Este site usa cookies e tecnologias afins que nos ajudam a oferecer uma melhor experiência. Ao clicar no botão "Aceitar" ou continuar sua navegação você concorda com o uso de cookies.

Aceitar

Conquiste Sua Primeira Vaga Remota Com Estratégias Testadas Que Garantem Resultados!

Saiba mais
Pro Simples
Como Criar Um Pacote Django Privado

django

Como Criar Um Pacote Django Privado

Elias
Escrito por Elias
Junte-se a mais de X pessoas

Entre para nossa lista e receba conteúdos exclusivos e com prioridade

Neste material, detalharei como você pode criar seu próprio pacote Django privado para ser reutilizado entre diferentes projetos.

Portanto, para acompanhar, usaremos um aplicativo chamado cart que tem a função de manipular pedidos personalizados enviando-os para checkout. Este aplicativo será transformado em um pacote para ser usado por outros projetos Django, onde todos os passos serão explicados para você.

Diretorio Inicial

seu_pacote_django/
    └───cart/
        │   admin.py
        │   apps.py
        │   contexts.py
        │   models.py
        │   urls.py
        │   views.py
        │   __init__.py
        │   
        ├───migrations/
        │       __init__.py
        │       
        ├───templates/
        │       cart.html
        │       header2.html
        │
        └───tests/
                test_urls.py
                test_views.py
                __init__.py
Bash

Como você pode ver, o diretório inicial tem apenas o aplicativo do carrinho dentro dele. Portanto, para iniciar seu pacote, você precisará criar mais arquivos que lidarão com o processo de construção do pacote, bem como alguns requisitos que você precisará caso, algum dia, queira torná-lo público, talvez adicionando-o ao PYPI.org.

Arquivos Importantes Para Construir o Pacote Django:

Nesta seção serão detalhados os arquivos necessários para construir o pacote do carrinho. Portanto, para facilitar o acompanhamento, a instrução será seguida como nome do arquivo + instrução + código.

1. Arquivo Setup.py

Este é o arquivo mais importante. setup.py representa main quando você chama as funções de instalação. Basicamente, dentro do setup.py você deve adicionar todas as informações necessárias para criar seu pacote. Como o nome do pacote, versão, licença e etc:

# setup.py

import os
from setuptools import find_packages, setup

with open(os.path.join(os.path.dirname(__file__), 'README.rst')) as readme:
    README = readme.read()

# allow setup.py to be run from any path
os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))

setup(
    name='cart',
    version='0.0.1',
    packages=find_packages(),
    include_package_data=True,
    license='Your license', 
    description='A cart package that handles payments with stripe.',
    long_description=README,
    url='yoursite.com',
    author='you',
    author_email='your@email.com',
    classifiers=[
        'Environment :: Web Environment',
        'Framework :: Django',
        'Framework :: Django :: 3.2',  
        'Intended Audience :: For my own or company usage',
        'License :: OSI Approved :: Your License',  
        'Operating System :: OS Independent',
        'Programming Language :: Python',
        'Programming Language :: Python :: 3',
        'Programming Language :: Python :: 3.6',
        'Programming Language :: Python :: 3.8',
        'Programming Language :: Python :: 3.9',
        'Topic :: Internet :: WWW/HTTP',
        'Topic :: Internet :: WWW/HTTP :: Dynamic Content',
    ],
)
Python

Existem outras maneiras de configurar o arquivo setup.py com abordagens diferentes. No entanto, eu sugeriria que esta é a melhor e mais fácil maneira de criar seu arquivo setup.py.

2. README.rst file

De acordo com fileinfo.com, a extensão .rst ou linguagem de marcação reStructuredText é um arquivo de texto que contém e suporta código escrito e estilizado. No site Sphinx, é detalhado que a extensão .rst é a principal linguagem de marcação para a criação e design de documentação de código. No entanto, este não é um arquivo realmente necessário para criar seu pacote privado, mas é essencial se um dia você quiser torná-lo público no pypi.org.

clique em view raw para ver o formato de marcação.

Your Django Package
To install:

pip install git+https://github.com/your_name/your_cart_package.git
In your_project.settings.py add:

INSTALLED_APPS = [
    ...
    'cart',
    ...
]
Migrate the changes from the underwriting_manual app:

$ python manage.py makemigrations cart

$ python manage.py migrate cart
In your_project.urls.py add:

from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('api/', include('core.urls')),
    path('cart/', include('cart.urls')), # <=====
]
RST

3. Arquivo LICENSE.

De acordo com a esri, um arquivo de licença é um arquivo de texto simples que fornece automaticamente as informações necessárias — como nome do produto, número de autorização e informações de contato do usuário — Software Authorization Wizard.

Dependendo do nível de informação que você tem em seu aplicativo, eu aconselho você a ter um arquivo LICENSE bem adaptado para evitar qualquer problema no futuro. No entanto, o arquivo LICENSE também é essencial ao carregar seu pacote para pypi.org.

/* Copyright (C) Your Company Systems, Inc - All Rights Reserved
 * Unauthorized copying of this file, via any medium is strictly prohibited
 * Proprietary and confidential
 * Written by your company attorney <you@yourcompany.com>, December 2021
 */
Markdown

Neste exemplo, usarei um modelo personalizado que pode ser editado por você:

PS: Não sou advogado, portanto, o exemplo de licença não pode ser usado como um conselho ou exemplo do mundo real.

4. MANIFEST.in file

MANIFEST.in é um arquivo de texto que contém uma série de “comandos” em um formato definido pelo Distutils. Os comandos manifest permitem que você inclua ou exclua arquivos e diretórios específicos. Principalmente aqueles que não são reconhecidos pelo python como um diretório porque não contêm o init.py, como o diretório templates/ no Django. E arquivos que não têm a extensão .py e os arquivos que são usados ​​para construir o pacote, como LICENSE e README.rst.

No entanto, o MANIFEST.in é basicamente um conjunto de comandos para incluir no pacote que será reconhecido pelo sdist ao construir seu pacote. Portanto, quando o pacote for criado, se um diretório ou arquivo for especificado, eles estarão lá quando o pacote for construído 😉.

include LICENSE
include README.rst
recursive-include cart/templates *
recursive-include cart/tests *
INI

Buildando o Pacote Django

No momento em que você está seguindo este tutorial, no qual iniciamos apenas com o aplicativo cart , ele mudou. Portanto, se você fez tudo corretamente, seu diretório de trabalho deve ficar assim:

seu_pacote_django/
  │   LICENSE
  │   MANIFEST.in
  │   README.rst
  │   setup.py
  │
  └───cart/
      │   admin.py
      │   apps.py
      │   contexts.py
      │   models.py
      │   urls.py
      │   views.py
      │   __init__.py
      │
      ├───migrations/
      │       __init__.py
      │
      ├───templates/
      │       cart.html
      │       header2.html
      │
      └───tests/
              test_urls.py
              test_views.py
              __init__.py
Bash

Agora, há alguns passos que precisam ser seguidos para iniciar o processo de construção do seu pacote:

Instale os pacotes sdist (distribuição de origem) e whell:

pip install sdist && pip install wheel
Bash

nota: Eu consideraria criar um ambiente virtual e instalar os pacotes sdist e whell nele (não se esqueça de adicionar um arquivo .gitignore).

Build do pacote Em Ação:

No diretório raiz do pacote, adicione os seguintes comandos para finalmente compilar o pacote:

python setup.py sdist && python setup.py bdist_wheel
Bash

Dessa forma o pacote será finalmente construído deixando você com o seguinte diretório:

seu_pacote_django/
│   .gitignore
│   LICENSE
│   MANIFEST.in
│   README.rst
│   setup.py
│
├───build/
│   ├───bdist.win-amd64
│   └───lib
│       └───cart/
│           │   admin.py
│           │   apps.py
│           │   contexts.py
│           │   models.py
│           │   urls.py
│           │   views.py
│           │   __init__.py
│           │
│           ├───migrations/
│           │       __init__.py
│           │
│           ├───templates/
│           │       cart.html
│           │       header2.html
│           │
│           └───tests/
│                   test_urls.py
│                   test_views.py
│                   __init__.py
│
├───cart/
│   │   admin.py
│   │   apps.py
│   │   contexts.py
│   │   models.py
│   │   urls.py
│   │   views.py
│   │   __init__.py
│   │
│   ├───migrations/
│   │       __init__.py
│   │
│   ├───templates/
│   │       cart.html
│   │       header2.html
│   │
│   └───tests/
│           test_urls.py
│           test_views.py
│           __init__.py
│
├───cart.egg-info/
│       dependency_links.txt
│       PKG-INFO
│       SOURCES.txt
│       top_level.txt
│
└───dist/
        cart-0.0.1-py3-none-any.whl
        cart-0.0.1.tar.gz
Bash

Instalando Seu Proprio Pacote Django

O próximo passo para usar seu pacote é enviá-lo para um repositório do github para ser usado por você ou sua empresa.

Então, você pode instalar o pacote pelo seguinte comando:

Para repositório privado:

pip install git+ssh://git@github.com:sua_conta/seu_pacote_django.git
Bash

Para repositório público:

pip install git+https://github.com/sua_conta/seu_pacote_django.git
Bash

Faça uma pip list para verificar se o pacote do carrinho está instalado no seu ambiente virtual.

$ pip list
Package    Version
---------- -------
pip        21.2.4
cart        0.0.1   <-- Aqui
Bash

Portanto, seguindo este tutorial você aprendeu como construir seu próprio pacote Django que pode ser reutilizado entre diferentes projetos. Por último, mas não menos importante, embora este tutorial tenha exemplificado um aplicativo Django que foi transformado em um pacote, esta abordagem que você aprendeu tem o mesmo processo para criar qualquer pacote Python.