Как связать приложения django
Я стараюсь писать многоразовые приложения Django. Теперь я озадачен тем, как собрать все вместе, чтобы получить окончательный проект.
Чтобы сделать это, я мог бы помещать поля внешнего ключа в блоге, чтобы указывать на фотографии. Но тогда блог не мог использоваться без приложения для картинок. Также я мог бы создать третье приложение, которое отвечает за подключение обоих.
Какова наилучшая практика?
EDIT: Спасибо за ваши очень хорошие ответы, но я все еще ищу более практичный пример того, как решить эту проблему. Чтобы завершить мой пример: иногда было бы неплохо использовать приложение для блога без приложения для картинок. Но если я жестко кодирую зависимость, это уже невозможно. Итак, как насчет 3-го приложения объединить оба?
Вступительный разговор в нижней части ответа (более прямой ответ). Я предполагаю, что у вас есть одно приложение для обработки текста под названием "Текст" и одно приложение для обработки изображений "Картинки" и третье приложение для ведения блога под названием "Блог".
Большое изображение
Вам нужно будет изучить руководство по языку шаблона для программистов python. Идея состоит в том, что каждая вещь находится в собственном приложении и что у вас есть третье приложение, которое соединяет все. Затем приложения должны предоставлять свои модели и представления, как вам нравится (просто не забудьте сосредоточиться на том, что должно делать приложение), а также предоставить набор templatetags.
Как сделать теги включения
Сделайте теги включения, и это очень просто! Это напомнит вам о написании нормальных представлений.
Создайте каталог templatetags в папке приложения. Также создайте файл __init__.py в этом templatetags (поэтому каталог становится пакетом python).
Затем создайте файл python. Имя важно, вы будете использовать его в в шаблонах, которые будут использовать ваше приложение. Например, если вы вызываете файл picturestags.py , вы вызываете во всех шаблонах, которые будут использовать его.
Сначала в файле добавьте некоторую политику, о которой вам не нужно много думать, просто включите ее прежде всего:
Затем добавьте теги, определив функции с тем же именем, что и ваш тег. Я назову его display_picture в примере, и это займет один аргумент url. Функция должна создать словарь, который вы будете использовать в шаблоне. В моем примере будет отображаться только изображение, на которое указывает URL.
Создайте шаблоны/рисунки пути в своем приложении и создайте файл display_picture.html внутри, содержащий:
Как вы, вероятно, понимаете, @register делает это тегом, то, что находится внутри словаря display_picture, - это то, что вы можете использовать в display_picture.html. Очень похож на обычные функции просмотра.
В итоге вы получите эти файлы:
Это все, что вам нужно добавить в приложение для картинок. Чтобы использовать это в своем приложении в блоге, вам нужно добавить Картинки на ваш INSTALLED_APPS. Затем в шаблонах, где вам нужно использовать свой собственный недавно испеченный тег, сначала загрузите его: , затем просто добавьте тег следующим образом:
Результаты
Обратите внимание, что только у Blog есть зависимости, и это зависимости, которые он должен иметь (без блога без текста и изображений. но картинки могут жить без текста). Взгляд и размещение должны контролироваться CSS и DIV/SPAN-тегами. Таким образом, вы можете принять приложение "Картинка" и передать его тому, кто понятия не имеет о приложении "Текст", и использовать его, отображая изображения по-разному, возможно, даже не прикасаясь к вашему коду!
Теги включения - это единственное, что я знаю, так как я только что узнал об этом вчера. Я думаю, что это удобство Django, чтобы сделать жизнь простой. На странице документации есть намного больше (в том числе, как сделать "реальные" теги трудным путем без "ярлыков" ). Поэтому, если вы обнаружите, что этот метод ограничен, прочитайте документацию. в нем много примеров. В нем также обсуждается, как создавать фильтры, simple_tags, обсуждения потоков и другие продвинутые материалы.
Введение
У меня была эта именно эта проблема, так как вы и я также хотели что-то другое, чем ответы, которые я читал (я не говорю, что ответы были плохими, они помогли мне многому научиться и дали мне идеи, но я хотел этого, я писать сейчас). Мне удалось понять что-то, что не очень очевидно, благодаря вашему вопросу и, безусловно, благодаря Stack Overflow, так что это мой вклад обратно даже на полтора года вопрос, который, вероятно, заброшен (может помочь googler или два)!
Я также получил много вдохновения от Google Tech Talk многоразовых приложений. В конце (43 минуты) он упоминает несколько хороших примеров, таких как django-tagging, что он говорит о модели для написания многоразовых приложений. Это дало мне идею для всего этого, потому что это то, как django-tagging решает эту проблему, которую мы имели/имели.
Теперь, после того как я написал все это (занял час), я впервые чувствую, что могу внести вклад, а не просто google и следить за тем, что делают другие, или жалуются, что другие не пишут, как мне нужно что-то делать. Впервые я беру на себя ответственность писать свое мнение, чтобы другие могли это сделать (просто нужно было написать этот абзац:-), потому что он чувствует себя действительно здорово, даже если его можно разбить на части или игнорировать и забыть).
Я стараюсь изо всех сил писать многоразовые приложения Django. Теперь я озадачен, как собрать их всех вместе, чтобы получить окончательный проект.
для этого я мог бы поместить поля внешнего ключа в блог, чтобы указать на фотографии. Но тогда блог не мог быть используется без приложения изображения. Также я мог бы создать третье приложение, которое отвечает за подключение обоих.
каков наилучший способ сделать это ?
EDIT: Спасибо за ваши очень хорошие ответы, но я все еще ищу более практический пример того, как решить эту проблему. Чтобы завершить мой пример: иногда было бы неплохо использовать приложение без приложения Фото. Но если я жестко закодирую зависимость, это больше невозможно. Так как насчет 3rd app объединить оба ?
введение разговор в нижней части ответа (более прямо к ответу). Я предположу, что у вас есть одно приложение для обработки текста под названием Text и одно приложение для обработки изображений под названием Pictures и третье приложение для ведения блога под названием Blog.
большая картинка
вам нужно будет учиться руководство по языку шаблонов для программистов python. Идея заключается в том, что каждая вещь находится в своем собственном приложении и что у вас есть третье приложение, которое подключается всё. Затем приложения должны предоставить свои модели и представления, как вам нравится (просто не забудьте сосредоточиться на том, что должно делать приложение), а также предоставить набор шаблонов.
как сделать теги включения
сделайте теги включения, и это действительно легко! Это напомнит вам о написании нормальных представлений.
создайте каталог templatetags в папке приложения. Также создайте __init__.py файл в этом templatetags (так что каталог становится python пакет.)
создайте файл python. Имя важно, вы будете использовать это в в шаблонах, которые будут использовать ваше приложение. Например, если вызвать файл picturestags.py , вы будете называть
во всех шаблонах, которые будут использовать его.
сначала в файл добавьте некоторые политики, о которых вам не нужно много думать, просто включите это прежде всего:
затем добавьте теги, определив функции с тем же именем, что и ваш тег. Я позвоню это display_picture в Примере, и он будет принимать один аргумент url. Функция должна создать словарь,который будет использоваться в шаблоне. Мой пример просто отобразит изображение, на которое указывает url.
создайте шаблоны/изображения пути в вашем приложении и создайте файл display_picture.html внутри содержит:
как вы, вероятно, понимаете, @register делает этот тег, что внутри словаря display_picture возвращает то, что вы можно использовать в display_picture.формат html. Очень похоже на ваши обычные функции просмотра.
в конце концов вы получите эти файлы:
это все, что вам нужно добавить в приложение фотографию. Чтобы использовать это в своем блоге, вам нужно добавить фотографии в INSTALLED_APPS. Затем в шаблонах, где вам нужно использовать свой собственный недавно испеченный тег, сначала загрузите его: тогда просто добавьте тег как это:
результаты
обратите внимание, что только блог имеет зависимости, и это зависимости, которые он должен иметь (без блога текст и картинки. но картинки могут жить и без текста). Внешний вид и размещение должны и могут контролироваться CSS и DIV/SPAN-тегами. Таким образом, вы можете взять свое приложение для фотографий и дать его кому-то, кто понятия не имеет о текстовом приложении и использовать его, отображая изображения по-разному, вероятно, даже не касаясь кода!
включения теги-это единственное, что я знаю, так как я только вчера узнал. Я думаю, что это удобство, предоставляемое Django, чтобы сделать жизнь простой. На на странице документации есть намного больше (включая то, как сделать "реальные" теги сложным способом без "ярлыков"). Поэтому, если вы найдете этот метод ограниченным, прочитайте документацию. у него есть много примеров. В нем также обсуждается, как сделать фильтры, simple_tags, соображения потока и другие продвинутые вещи.
введение
у меня была именно эта проблема, поскольку вы и я также хотели чего-то другого, чем ответы, которые я читал (я не говорю, что ответы были плохими, они помогли мне многому научиться и дали мне понимание, но я хотел, чтобы это я пишу сейчас). Мне удалось выяснить что-то, что не очень очевидно, благодаря вашему вопросу и, безусловно, благодаря переполнению стека, так что это мой вклад даже в вопрос полугодовой давности, который, вероятно, заброшен (может помочь гуглеру или двум)!
я также получил много вдохновения от Google Tech Talk Многоразовые Приложения. В конце (43 минуты) он упоминает некоторые хорошие примеры, такие как django-пометка что он говорит модель для того, как писать многоразовые приложения. Это дало мне идею для всего этого, потому что именно так django-tagging решает эту самую проблему, которую мы имели/имеем.
подумайте об этом так же, как вы использовали бы любое стороннее приложение в своем проекте. "Повторно использовать "не означает"без зависимостей". Напротив, вам будет сложно найти приложение, которое не имеет хотя бы одной зависимости, даже если оно зависит только от библиотек Django или core Python. (В то время как основные библиотеки Python обычно рассматриваются как "безопасные" зависимости, т. е. все будут иметь его, вещи иногда меняются между версиями Python, поэтому вы все еще блокируете свое приложение в конкретный момент времени).
цель повторного использования такая же, как и у DRY: вы не хотите писать один и тот же код снова и снова. В результате имеет смысл вырваться из функциональности, такой как приложение picture, потому что вы можете использовать его снова и снова в других приложениях и проектах, но ваше приложение picture будет иметь зависимости, и другие пакеты будут зависеть от него, пока нет круговых зависимостей, вы хороши (круговая зависимость будет означать, что у вас нет фактически разделили функциональность).
Это хороший вопрос, и что-то я нахожу довольно трудно управлять также. Но-вы представляете, что эти приложения будут выпущены публично, или вы используете их только сами? Если вы не выпускаете, я бы не волновался слишком об этом.
другое дело, что зависимости хорошо иметь. Приложение pictures в вашем примере звучит как хороший кандидат на "многоразовое" приложение. Он прост, делает одно, и может быть использован другим приложения.
приложение для блога, с другой стороны, обычно должно потреблять другие приложения, такие как приложение для изображений или приложение для тегов. Я нахожу эту зависимость прекрасной. Вы можете попытаться немного абстрагировать его, просто связавшись с медиа-ресурсом, который был помещен туда вашим приложением picture.
Это все просто немного здравого смысла. Можете ли вы сделать свои приложения тонкими? Если да, то попробуйте создать их, чтобы их можно было использовать повторно. Но не бойтесь принимать зависимости, когда они имеют смысл. Также пробовать разрешить точки расширения, чтобы вы могли потенциально поменять зависимости на другие. Прямой внешний ключ здесь не поможет, но, возможно, что-то вроде сигналов или Restful APIs может.
я новичок в Django и я столкнулся с той же проблемой. Позорно, как много шума о многоразовых приложениях в сообществе Django, но ни одной авторитетной ссылки на то, как их подключить в проект без жестких зависимостей.
я работал над новым проектом Django, и я хотел настроить свои модели, чтобы избежать жесткого кодирования как можно больше. Это шаблон, который я использовал.
планировка
модели приложения
base.py : этот модуль реализует только "причину существования" этого приложения в абстрактных классах. Правила таковы:
этот модуль обычно импортируется только из core app. Обычно он ничего не импортирует из других приложений в том же проекте.
исключение к вышеуказанному правилу когда " причина для существование предполагает существование другого приложения. Например, group приложение предполагает, что есть user приложение где-то. В этом случае способ связать их:
, а затем с помощью параметров.AUTH_USER_MODEL для ссылки на user модель
используйте этот шаблон для всех приложений, а не только user app. Например, вы также должны сделать
если вы используете вышеуказанный шаблон, только предполагайте функциональность предоставлено base.py другое приложение с которой вы связаны. Не предполагайте функциональность сложных конкретных классов (я буду обсуждать, где поставить конкретные классы в ближайшее время)
конечно, импорт из django, сторонних приложений и пакетов python разрешен.
убедитесь, что предположения, которые вы делаете в base.py любого приложения является твердым камнем и не будет многое изменится в будущем. Хороший пример - django-registration Джеймс Беннетт. Его старое приложение, но его привлекательность не ослабла, потому что он сделал твердые предположения. Поскольку хорошие многоразовые приложения делают одну вещь хорошо, нетрудно найти этот набор предположений.
basemixins.py : этот модуль должен реализовывать вилки для конкретных моделей этого приложения. "Вилка" к модели M-это любая модель, содержащая внешний ключ к модели M. Например:
BaseOwnedByGroup является "вилкой" для group модель. Правила здесь следующие: так же, как base.py`
- при определении "подключается" в basemixins.py , только предполагают функциональность, предоставляемую base.py .
- импорт только из core , django, сторонние приложения и пакеты python.
mixins.py : этот модуль должен использоваться для двух целей
чтобы определить сложные "вилки", который предполагает функциональность сложных конкретных классов, но не отношения с другими приложениями. Сложный штепсельные вилки должны в идеале наследовать один из "базовых разъемов", определенных в basemixins.py .
чтобы определить модели mixin (которые не являются "вилками"), которые могут использоваться конкретными классами этого приложения.
concrete.py : этот модуль должен использоваться для определения (вы догадались) конкретных классов этих приложений и для настройки отношений с другими приложениями. Короче говоря, этот модуль предполагает ваш проект и все функциональность, которую вы хотите предоставить в он.
взаимоотношения с другими приложениями должны быть настроены следующим образом:
создать one to one или many to one отношения с моделью M приложения another_app сделайте следующее:
создать many to many отношения, рекомендуемый способ-использовать through модель. Наследовать правильный плагин в through модель точно так же (как мы сделали в ConcreteGroup модель)
Создаём проект Django в виртуальном окружении Python
Создайте новую папку и перейдите в неё:
mkdir django-react && cd $_
Потом активируйте виртуальное окружение Python:
Примечание все следующие команды нужно выполнять из папки django-react и с активированным виртуальным окружением.
Установите зависимости Django и Django REST Framework:
pip install django djangorestframework
После установки создайте новый проект Django:
django-admin startproject django_react
Теперь сделаем простое API на Django для создания и хранения контактов.
Создаём приложение на Django
В каждом проекте Django может быть много приложений. Приложения можно делать переиспользуемыми: такими, что их можно добавить в менеджер пакетов Python и установить через него в другой проект, в котором нужно такое приложение.
3–4 декабря, Онлайн, Беcплатно
Для создания нового приложения Django используется команда:
django-admin startapp app_name
где app_name — название приложения.
В нашем случае команда будет выглядеть так:
django-admin startapp leads
Она создаст приложение leads в папке django-react . Теперь структура папок в проекте должна выглядеть так:
Теперь сделаем так, чтобы Django проект использовал новое приложение. Откройте файл django_react/settings.py и добавьте приложение в INSTALLED_APPS :
Создаём модель в базе данных с помощью Django
Модель — это объект, представляющий собой данные из таблицы. Почти каждый веб-фреймворк использует модели, и Django — не исключение.
Модель Django может иметь одно или больше полей. Каждое поле соответствует полю в таблице.
Мы собираемся хранить контакты, поэтому модель Lead может состоять из этих полей:
(Можно добавлять и другие поля, например телефон). Добавим ещё поле с временем создания модели, потому что по умолчанию Django этого не делает.
Откроем leads/models.py и опишем модель Lead :
Примечание изучите документацию Django о полях. Когда придумываете структуру модели, выбирайте самые подходящие для вашего случая поля.
Создадим миграции командой:
python manage.py makemigrations leads
и применим их к базе данных:
python manage.py migrate
Займёмся тестированием
Вы могли подумать «А как же тестирование?».
Мнение: разработка через тестирование — это тупо. Обсуждаем TDDСуществует масса туториалов по Django, начинающихся примерно так:
Не надо так. Нет никакого смысла ни в тестировании стандартной модели Django, ни в тестировании Django ORM. Что точно не нужно тестировать при создании приложения на Django:
- встроенный код Django (модели, представления);
- встроенные функции Python.
Не тестируйте то, что уже протестировано! Так что же тогда тестировать?
Добавили свой метод в модель Django — протестируйте его. Дополнили стандартное представление — протестируйте его. Но как узнать, что именно нужно протестировать?
Узнать это поможет библиотека coverage. Установите её:
pip install coverage
Теперь после каждого добавления или изменения кода запускайте coverage :
coverage run --source='.' manage.py test
и создавайте отчёт:
Вы увидите, что именно нужно протестировать. Если предпочитаете увидеть отчёт в командной строке, запустите команду:
Сериализаторы Django
Сериализация — это конвертация объекта Python в другой формат. После сериализации можно сохранить объект в файл или послать его через сеть.
Как оценить профессионализм программиста за 5 вопросов — отвечают экспертыПочему сериализация необходима? Модель Django — это класс Python. Чтобы превратить её в данные в формате JSON, нужна сериализация.
Сериализаторы работают и в обратном направлении: они конвертируют JSON в объекты. Это позволяет:
Суммируя: сериализаторы в Django можно использовать для совершения операций с моделями Django через API.
Создайте новый файл leads/serializers.py . Сериализатор LeadSerializer содержит нашу модель и поля:
Созданный дочерний класс от класса serializers.ModelSerializer . ModelSerializer в Django похож на ModelForm . Он подходит, когда нужно, чтобы сериализатор соответствовал модели.
Создаём представления
Если вы раньше работали с другими фреймворками, то можете удивиться, что в Django нет контроллеров.
Веб-фреймворки для начинающих: простое объяснение с примерамиDjango — это фреймворк MVT. MVT — это модель, представление и шаблон (Template). В Django есть много типов представлений: функции-представления, представления, основанные на классах, и обобщённые представления.
Используйте функции-представления только если изменение обобщенных представлений займет больше, чем написание представления заново.
Мы будем использовать обобщённые представления. Наше простое приложение будет:
- возвращать выборку моделей;
- создавать новые объекты в базе данных.
С помощью документации можно узнать, что есть представление для возвращения выборки и создания моделей: ListCreateAPIView . Это представление содержит queryset и serializer_class .
queryset — это выборка данных, которую приложение будет возвращать. В нашем случае — все модели Lead . serializer_class — класс сериализатора для модели.
Добавьте в файл django_react/views.py следующий код:
С помощью трёх строк кода мы создали представление для обработки GET и POST запросов.
Чего ещё не хватает? Маршрутизации URL. Другими словами, нам нужно соединить URL и представления.
Настраиваем маршрутизацию url
Нам нужно сделать так, чтобы GET и POST запросы к api/lead/ обрабатывались представлением LeadListCreate , которое будет возвращать и создавать модели.
Чтобы настроить маршрутизацию URL, отредактируйте файл django_react/urls.py , добавив туда url приложения:
Так мы указываем Django, что нужно использовать url, которые есть в приложения leads .
Теперь создайте файл leads/urls.py . В нём мы соединим представление LeadListCreate и url api/lead/ :
И наконец, включим rest_framework в INSTALLED_APPS . Откройте django_react/settings.py и добавьте приложение в INSTALLED_APPS :
Запустим сервер Django:
python manage.py runserver
Примечание в продакшене лучше отключить возможность просмотра API. Это можно сделать в конфигурации:
Соединяем Django и React
У многих разработчиков возникают вопросы по поводу того, как правильно соединить Django и React.
React: практики, которые помогут стать продвинутым разработчикомДолжен ли роутер React взять на себя маршрутизацию? Нужно ли монтировать компоненты React в каждом шаблоне Django?
Ответ зависит от случая.
Есть следующие способы создания проекта на Django и React (они похожи почти для любого веб-фреймворка):
- React в собственном приложении Django для фронтенда. Загружаем один HTML шаблон и даём React управление фронтендом (сложность: средняя).
- Django REST как отдельное API + React как отдельное SPA (сложность: высокая, нужна будет авторизация по JWT).
- Смешанный вариант: мини-приложения React в шаблонах Django (сложность: просто, но сложно будет поддерживать).
Если вы только начали работать с Django REST и React, избегайте варианта 2. Вместо этого выберите 1 (React в собственном приложении Django для фронтенда), если:
- вы создаёте приложение, похожее на веб-сайт;
- в интерфейсе будет много пользовательских действий, используется AJAX;
- вас устраивает авторизация, основанная на сессиях;
- вас не очень волнуют вопросы SEO;
- вас устраивает роутер React.
Если будете держать React близко к Django, то будет проще с авторизацией. Можно будет использовать встроенную систему авторизации Django для регистрации и входа пользователей. Используйте старую добрую авторизацию с помощью сессий и не беспокойтесь о токенах и JWT.
Выберите вариант 3 (смешанный вариант: мини-приложения React в шаблонах Django), если:
- на сайте не нужно использовать много JavaScript;
- вам важно SEO и вы не можете использовать Node.js для рендеринга серверной части.
В данной статье мы будем использовать вариант 1.
Устанавливаем React и webpack
Создадим новое приложение Django для фронтенда:
django-admin startapp frontend
Вы увидите новую папку с названием frontend в вашей структуре папок:
Подготовим папки для хранения компонентов React:
mkdir -p ./frontend/src/components
Дальше установим React, webpack и babel. Перейдите в папку frontend и создайте окружение:
cd ./frontend && npm init -y
Установите webpack и webpack CLI:
npm i webpack webpack-cli --save-dev
Откройте package.json и запишите 2 скрипта для продакшна и для разработки:
Сохраните и закройте файл.
Установим babel, чтобы код был совместим со старыми браузерами, которые не поддерживают последние стандарты JavaScript:
npm i @babel/core babel-loader @babel/preset-env @babel/preset-react --save-dev
npm i react react-dom --save-dev
Настроим Babel (по-прежнему находясь в папке frontend ):
Создадим файл webpack.config.js для настройки загрузчика babel:
Готовим приложение Django для фронтенда
Создадим представление в ./frontend/views.py :
Создадим шаблон в ./frontend/templates/frontend/index.html :
В шаблоне вызывается ./frontend/main.js — файл, который будет генерировать webpack, содержащий весь код на React.
Настроим маршрутизатор Django: включим туда url приложения frontend. Отредактируем файл ./project/urls.py :
Создадим файл ./frontend/urls.py :
Включим приложение фронтенда в список используемых приложений в файле ./project/settings.py :
Фронтенд на React
Сделаем простой компонент React, который будет отображать наши данные. Если ваша база данных пуста, то самое время наполнить приложение какими-нибудь данными.
Создадим файл ./frontend/src/components/App.js . В нём будет компонент React, запрашивающий и отображающий данные.
Примечание можно написать тот же компонент в виде функции с хуком useEffect .
Сохраните и закройте файл. Теперь создайте точку входа для webpack — файл ./frontend/src/index.js и импортируйте компонент:
import App from "./components/App" ;
Теперь можно протестировать результат. Запустите webpack:
Запустите сервер Django:
python manage.py runserver
Выглядит просто. И работает!
Заключение
В этом материале мы сделали простой проект на Django REST API и React. Мы научились:
- создавать простое REST API на Django;
- добавлять React в проект Django;
- соединять Django REST API и React.
Если этот проект показался сложным, попробуйте другой туториал. В нём мы показали, как создать первое веб-приложение на Django.
Этот учебник продолжает знакомить нас с Джанго, после Части 7 . Мы превратим наш Web-опрос в автономный пакет Python, который вы сможете использовать в новых проектах и делиться с другими людьми.
Если вы еще не завершили ознакомление с учебными пособиями 1–7, рекомендуем вам просмотреть их, чтобы ваш пример проекта соответствовал описанному ниже.
Возможность повторного использования имеет значение¶
Это большая работа по проектированию, созданию, тестированию и поддержке веб-приложения. Многие проекты Python и Django имеют общие проблемы. Разве не было бы здорово, если бы мы могли спасти часть этой повторяющейся работы?
Повторное использование - это образ жизни в Python. Индекс пакетов Python (PyPI) содержит широкий спектр пакетов, которые вы можете использовать в своих собственных программах Python. Проверьте Django Packages для существующих приложений многократного использования, которые вы можете включить в свой проект. Сам Django также является обычным пакетом Python. Это означает, что вы можете взять существующие пакеты Python или приложения Django и объединить их в свой собственный веб-проект. Вам нужно только написать части, которые делают ваш проект уникальным.
Допустим, вы начинаете новый проект, для которого нужно приложение для опросов, такое как то, над которым мы работали. Как вы делаете это приложение многоразовым? К счастью, у вас уэн почти все готово. В Части 1 мы увидели, как можно отделить опросы от URLconf уровня проекта, используя include . В этом руководстве мы предпримем дальнейшие шаги, чтобы сделать приложение простым в использовании в новых проектах и готовым к публикации для установки и использования другими пользователями.
В Python package предоставляет способ группировки кода Python для легкого повторного использования. Пакет содержит один или несколько файлов кода Python (также называемых «модулями»).
Пакет может быть импортирован с помощью import foo.bar или from foo import bar . Чтобы каталог (например, polls ) сформировал пакет, он должен содержать специальный файл __init__.py , даже если этот файл пуст.
Приложение Django - это пакет Python, который специально предназначен для использования в проекте Django. Приложение может использовать общие соглашения Django, такие как субмодули models , tests , urls и views .
Позже мы будем использовать термин «упаковка», чтобы описать процесс создания пакета Python, который другие могут легко установить. Это может немного сбивать с толку, мы знаем.
Ваш проект и ваше повторно используемое приложение¶
После предыдущих уроков наш проект должен выглядеть следующим образом:
Вы создали mysite/templates в Части 7 и polls/templates в Части 3 . Теперь, возможно, стало понятнее, почему мы выбрали отдельные каталоги шаблонов для проекта и приложения: все, что является частью приложения polls, находится в polls . Это делает приложение самодостаточным и позволяет легко перейти в новый проект.
Каталог polls теперь может быть скопирован в новый проект Django и немедленно использован повторно. Но он еще не совсем готов к публикации. Для этого нам нужно упаковать приложение, чтобы другим было легко его установить.
Установка некоторых предварительных условий¶
Текущее состояние упаковки Python немного запутано различными инструментами. Для этого урока мы будем использовать setuptools для сборки нашего пакета. Это рекомендуемый инструмент для упаковки (объединен с веткой distribute ). Мы также будем использовать pip для его установки и удаления. Вы должны установить эти два пакета сейчас. Если вам нужна помощь, вы можете обратиться к как установить Django с помощью pip . Вы можете установить setuptools таким же образом.
Упаковка вашего приложения¶
Упаковка Python означает подготовку вашего приложения в определенном формате, который можно легко установить и использовать. Сам Django упакован таким образом. Для небольших приложений, таких как опросы, этот процесс не слишком сложен.
Сначала создайте родительский каталог для polls , вне вашего проекта Django. Назовите этот каталог django-polls .
Выбор названия вашего приложения
При выборе имени для вашего пакета, проверьте ресурсы, такие как PyPI, чтобы избежать конфликтов имен с существующими пакетами. Часто полезно добавлять django- к имени вашего модуля при создании пакета для распространения. Это помогает другим, ищущим приложения Django, идентифицировать ваше приложение как специфическое для Django.
Метки приложений (то есть конечная часть пунктирного пути к пакетам приложений) должны быть уникальными в INSTALLED_APPS . Избегайте использования того же ярлыка, что и любой из Django contrib пакетов , например auth , admin или messages .
Переместите каталог polls в каталог django-polls .
Создайте файл django-polls/README.rst со следующим содержимым:
Создайте файл django-polls/LICENSE . Выбор лицензии выходит за рамки данного руководства, но достаточно сказать, что код, выпущенный публично без лицензии, бесполезен. Django и многие Django-совместимые приложения распространяются по лицензии BSD; однако вы можете выбрать собственную лицензию. Просто знайте, что ваш выбор лицензии повлияет на то, кто может использовать ваш код.
Далее мы создадим файлы setup.cfg и setup.py , в которых подробно описано, как создать и установить приложение. Полное объяснение этих файлов выходит за рамки данного руководства, но хорошее описание приведено в документации setuptools. Создайте файлы django-polls/setup.cfg и django-polls/setup.py со следующим содержимым:
По умолчанию в пакет включены только модули и пакеты Python. Чтобы включить дополнительные файлы, нам нужно создать файл MANIFEST.in . Документация setuptools, упомянутая в предыдущем шаге, описывает этот файл более подробно. Чтобы включить шаблоны, README.rst и наш файл LICENSE , создайте файл django-polls/MANIFEST.in со следующим содержимым:
Необязательно, но рекомендуется включать подробную документацию в ваше приложение. Создайте пустой каталог django-polls/docs для будущей документации. Добавьте дополнительную строку в django-polls/MANIFEST.in :
Попробуйте собрать свой пакет с помощью python setup.py sdist (запустите изнутри django-polls ). Это создаст каталог с именем dist и соберет ваш новый пакет, django-polls-0.1.tar.gz .
Для получения дополнительной информации о пакетировании см. Учебное пособие Python по упаковке и распространению проектов.
Используя свой собственный пакет¶
Поскольку мы удалили каталог polls из проекта, он больше не работает. Теперь мы исправим это, установив наш новый пакет django-polls .
Установка в качестве пользовательской библиотеки
Следующие шаги устанавливают django-polls в качестве пользовательской библиотеки. Индивидуальная установка имеет много преимуществ по сравнению с установкой пакета в масштабе всей системы, например, возможность использования в системах, где у вас нет прав администратора, а также предотвращение влияния пакета на системные службы и других пользователей компьютера.
Обратите внимание, что индивидуальные установки могут по-прежнему влиять на поведение системных инструментов, которые запускаются от имени этого пользователя, поэтому использование виртуальной среды является более надежным решением (смотрите ниже).
Чтобы установить пакет, используйте pip (вы уже установили его , верно?)
Если повезет, ваш проект Django теперь снова должен работать правильно. Запустите сервер еще раз, чтобы подтвердить это.
Чтобы удалить пакет, используйте pip:
Публикация вашего приложения¶
Теперь, когда мы упаковали и протестировали django-polls , он готов поделиться с миром! Если бы это был не просто пример, вы могли бы сейчас:
Установка пакетов Python с помощью виртуального окружения¶
Ранее мы установили приложение polls как пользовательскую библиотеку. Это имеет некоторые недостатки:
- Изменение пользовательских библиотек может повлиять на другое программное обеспечение Python в вашей системе.
- Вы не сможете запустить несколько версий этого пакета (или других с одинаковым именем).
Как правило, такие ситуации возникают только после того, как вы поддерживаете несколько проектов Django. Когда они это сделают, лучшим решением будет использование venv . Этот инструмент позволяет поддерживать несколько изолированных сред Python, каждая из которых имеет свою собственную копию библиотек и пространства имен пакетов.
Читайте также: