Publicación de Paquetes Python en PyPI

Resumen

¿Cómo publicar un paquete Python en PyPi?

Publicar un paquete en PyPi (Python Package Index) puede ser un proceso revelador y emocionante. Tener la capacidad de compartir con la comunidad mil millones de líneas de código de valor incalculable y facilitar las funcionalidades en tu flujo de trabajo es una experiencia sin igual. Aquí te guiaremos por todos los pasos necesarios para dar visibilidad a tus proyectos en el ecosistema Python.

¿Qué es PyPi?

PyPi es el repositorio oficial de paquetes de Python. Este vasto repositorio incluye más de medio millón de paquetes, cada uno proporcionando diferentes versiones que los desarrolladores pueden utilizar. El proceso de publicación es esencial para asegurar que el paquete no solo esté disponible, sino que también esté bien documentado y listo para su uso por cualquier persona. Ofrece las siguientes ventajas:

Distribución sencilla de paquetes y módulos gestionables.
Instalación fácil mediante pip install seguido del nombre del paquete.
Versionamiento para gestionar y compartir actualizaciones con toda la comunidad.
Documentación y metadatos manteniendo a la comunidad informada sobre cambios y actualizaciones.

¿Cómo estructurar tu paquete para PyPi?

Antes de publicar un paquete, es esencial seguir ciertas guías para estructurarlo correctamente:

Nombre y versiones del paquete: Comienza definiendo el nombre de tu paquete. Las versiones empiezan con 0.0.1 y deben incrementarse cada vez que realices actualizaciones.
Información del autor: Introduce los detalles del autor, utilizando el correo con el que te registraste en PyPi.
Archivo pyproject.toml: Este archivo es clave ya que incluye información esencial del paquete, desde el nombre y versiones compatibles hasta datos del autor.
Archivo README: Formato Markdown es ideal para este archivo, ya que proporciona instrucciones, ejemplos de uso y cualquier otro detalle que los usuarios deban conocer.
Licencia: Aborda los términos y condiciones para el uso de tu paquete, asegurando claridad y cumplimiento legal.
Creación de espacio en GitHub: Una presencia en GitHub es mínima para facilitar contribuciones y control de versiones efectivas.

¿Cuáles son los pasos para publicar un paquete?

Publicar tu paquete implica una serie de comandos y herramientas indispensables:

Actualizar PIP: Asegúrate de tener la última versión de PIP para facilitar conexiones con PyPi.
Estructurar el proyecto: Logos básicos como el archivo __init__ y módulos internos deben estar debidamente preparados.
Utilizar Twine para publicación: Esta librería es vital para completar el proceso de publicación:
```
python3 -m pip install --upgrade twine
python3 -m twine upload dist/*
```
Comandos para creación de archivos necesarios: Crear archivos adicionales necesarios para la publicación:
```
python3 setup.py sdist bdist_wheel
```

¿Por qué compartir tu código en PyPi?

Publicar tu código en PyPi no solo facilita su distribución, sino que también contribuye al crecimiento y fortaleza de la comunidad de Python. Al compartir tu trabajo:

Empoderas a otros desarrolladores que pueden beneficiarse de tu innovación.
Gestión y actualización centralizada de versiones sin complicaciones.
Reconocimiento y prestigio como contribuyente a la comunidad de Python.

El conocimiento adquirido al publicar en PyPi amplifica tu entendimiento y habilidad en el mundo del desarrollo de software. ¡Sigue adelante y comparte tu software con el mundo!

Julián Cárdenas

student•

Lo entendí perfectamente, pero la verdad espero en otra ampliación que creen un modulo de los cursos para hacer un packete y luego subirlo, para posterior a ello descargarlo y utilizarlo, es mucho más practico que leer solo la documentación y se recuerda más <3

Mario Alexander Vargas Celis

student•

Publicar un paquete en el **Python Package Index (PyPI)** permite que otros usuarios puedan instalarlo y utilizarlo fácilmente a través de pip. Aquí tienes una guía paso a paso para hacerlo.

### Paso 1: Preparar el Entorno y el Código

1. **Organiza tu proyecto**: Asegúrate de que tu paquete tiene la estructura correcta y un archivo \_\_init\_\_.py en cada carpeta de paquetes o subpaquetes.

2. **Crea setup.py**: Este archivo contiene la configuración para construir e instalar el paquete.

3. **Crea README.md** (opcional pero recomendado): Este archivo sirve como descripción detallada del paquete y se muestra en la página de PyPI.

### Paso 2: Crear el Archivo setup.py

En la raíz de tu proyecto, crea setup.py con la configuración básica del paquete.

Ejemplo de setup.py:


from setuptools import setup, find\_packages



setup(

&#x20;   name='mi\_paquete',  # Nombre único en PyPI

&#x20;   version='0.1.0',    # Versión inicial

&#x20;   packages=find\_packages(),  # Encuentra automáticamente submódulos y subpaquetes

&#x20;   description='Un paquete de ejemplo para operaciones matemáticas y de texto',

&#x20;   long\_description=open('README.md').read(),

&#x20;   long\_description\_content\_type='text/markdown',

&#x20;   author='Tu Nombre',

&#x20;   author\_email='tu\_email@example.com',

&#x20;   url='https://github.com/tu\_usuario/mi\_paquete',  # URL del repositorio

&#x20;   classifiers=\[

&#x20;       'Programming Language :: Python :: 3',

&#x20;       'License :: OSI Approved :: MIT License',

&#x20;       'Operating System :: OS Independent',

&#x20;   ],

&#x20;   python\_requires='>=3.6',

)

### Paso 3: Crear el Archivo pyproject.toml (opcional)

Para definir cómo construir el paquete, usa un archivo pyproject.toml, aunque no siempre es necesario. Este archivo define las dependencias de construcción, si tu proyecto tiene configuraciones específicas.

Ejemplo de pyproject.toml:


\[build-system]

requires = \["setuptools", "wheel"]

build-backend = "setuptools.build\_meta"

### Paso 4: Crear un Entorno Virtual y Empaquetar el Proyecto

1. **Instala setuptools y wheel** en tu entorno virtual:

```bash

pip install setuptools wheel

```

2. **Empaqueta el proyecto**: Esto creará los archivos necesarios en la carpeta dist/.

```bash

python setup.py sdist bdist_wheel

```

Esto generará un archivo .tar.gz y un archivo .whl dentro de la carpeta dist/, que son los archivos de distribución del paquete.

### Paso 5: Crear una Cuenta en PyPI

1. **Regístrate en PyPI**: Si aún no tienes cuenta, ve a [https://pypi.org/account/register/]\(https://pypi.org/account/register/) y crea una.

2. **Configura la autenticación**: Una vez registrado, guarda tu nombre de usuario y contraseña, o crea un **token de API** para autenticación.

### Paso 6: Subir el Paquete a PyPI

1. **Instala twine**: Es la herramienta para subir paquetes a PyPI.

```bash

pip install twine

```

2. **Sube el paquete a PyPI**:

```bash

twine upload dist/*

```

3. **Iniciar sesión**: Twine te pedirá tus credenciales de PyPI, o puedes usar un token de API.

### Paso 7: Verificar la Publicación

1. Visita tu página de PyPI en [https://pypi.org/project/mi\_paquete]\(https://pypi.org/project/mi\_paquete) (reemplaza mi\_paquete con el nombre de tu paquete).

2. Comprueba que la descripción, las dependencias y los archivos se hayan subido correctamente.

### Paso 8: Instalar el Paquete desde PyPI

Para probar el paquete recién publicado, instálalo con pip:


pip install mi\_paquete

### Ejemplo Completo de la Estructura Final

Estructura típica de un proyecto que se subirá a PyPI:


mi\_paquete/

│

├── mi\_paquete/              # Paquete principal

│   ├── \_\_init\_\_.py

│   ├── operaciones\_matematicas.py

│   └── operaciones\_texto.py

│

├── README.md                # Descripción del proyecto (Markdown)

├── setup.py                 # Configuración de empaquetado

└── pyproject.toml           # (opcional) Configuración de compilación

### Consejos para Publicaciones en PyPI

1. **Incrementa la versión**: Cada vez que subas una actualización, incrementa la versión en setup.py.

2. **Buena documentación**: Un README.md claro y detallado ayudará a los usuarios a entender cómo usar el paquete.

3. **Pruebas**: Asegúrate de probar el paquete localmente antes de publicarlo.

Este flujo garantiza que el paquete esté listo y sea accesible desde PyPI, permitiendo que otros usuarios puedan instalarlo y utilizarlo de manera sencilla.

Alexis Dorado Muñoz

student•

¡Gracias por compartir este resumen tan completo y bien estructurado!

Alejandro Ernesto Gómez Soria

student•

Paso 5: Publicar en PyPI

Para publicar tu paquete, usa twine. Primero, instala twine si no lo tienes:

pip install twine

Luego, sube tu paquete a PyPI:

twine upload dist/*

Se te pedirá tu nombre de usuario y contraseña de PyPI. Si no tienes una cuenta, puedes crearla en PyPI.

Alexis Dorado Muñoz

student•

Muchas gracias por tu aporte

Cristofer Vargas Morales

student•

Bueno, me tomó tiempo entender y ver que pasos son necesario y cuáles no. Me apoyé con apunte de esta clase con ChatGPT y con algunas consultas a la IA de Platzi.

Al final, les comparto el proyecto que realicé y los pasos:

El proyecto trata de un paquete que contiene un módulo Calculadora.py la cual contiene una clase del mismo nombre y contiene los método estáticos se suma, resta, division, multiplicación, potencia y radicación.

Iré enumerando los pasos, desde la estructura de la carpeta, la implementación de cada archivo y los pasos para la publicación, hasta finalmente cómo instalarlo y usarlo.

PRE-REQUISITOS:

Tener una cuenta en PyPI
Tener una cuenta en TestPYPI (esto.siempre y cuando quieras desplegar tu paquete en este entorno para pruebas).
Tener una cuenta GitHub para poder publicar tu proyecto y colocar la URL del Proyecto como parte de la metadata del archivo pyproject.toml
Recordar que el archivo setup.py ya no se usa en proyecctos modernos, esto es reemplazado por el archivo pyproject.toml

PASOS REALIZADOS:

PASO 1: ESTRUCTURA INICIAL

La carpeta inicial es del proyecto general, que se llama igual a la carpeta del paquete. Por estándar suelen nombrarse igual, pero no es necesario. La carpeta del proyecto contiene los archivos como pyproject.toml, LICENSE, README y el paquete que contendrá el Módulo que se importará y que tiene la lógica que nos interesa.

En el archivo pyproject.toml se incluye toda la metadata del proyecto, y entre sus atributos está el name = <mi_paquete> es el nombre que se da al paquete que es el que se distribuirá, publicará y posteriormente instalará.

PASO 2: IMPLEMENTACIÓN

Archivo /package_calculator/__init__.py

Esto se realiza para que a la hora de importar el paquete solo coloquemos "from package_calculator import Calculadora" (donde Calculadora es la clase que contiene la lógica) en lugar de colocar "from package_calculator.Calculadora import Calculadora"; es decir para no colocar el nombre del Módulo.

Módulo /package_calculator/Calculadora.py

import math

class Calculadora:
    
    @staticmethod
    # Función que suma dos números
    def sumar(a : int|float, b : int|float) -> int|float:
        if(isinstance(a,(int,float)) and isinstance(b,(int,float)) ):
            return a + b
        else:
            raise ValueError("Debe ingresar valores numéricos enteros o flotantes.")

    @staticmethod
    # Función que resta dos números
    def restar(a : int|float, b : int|float) -> int|float:
        if(isinstance(a,(int,float)) and isinstance(b,(int,float))):
            return a - b
        else:
            raise ValueError("Debe ingresar valores numéricos enteros o flotantes.")

    @staticmethod
    # Función que multiplica dos números
    def multiplicar(a : int|float, b : int|float) -> int|float:
        if(isinstance(a,(int,float)) and isinstance(b,(int,float)) ):
            return a * b
        else:
            raise ValueError("Debe ingresar valores numéricos enteros o flotantes.")

    @staticmethod
    # Función que divide dos números
    def dividir(a : int|float, b : int|float) -> int|float:
        if(isinstance(a,(int,float)) and isinstance(b,(int,float))):
            if b == 0:
                raise ValueError("No se puede dividir entre 0")
            return a / b
        else:
            raise ValueError("Debe ingresar valores numéricos enteros o flotantes.")
        
    @staticmethod
     # Función que divide dos números
    def exponenciar(a : int|float, b : int|float) -> int|float:
        if(isinstance(a,(int,float)) and isinstance(b,(int,float))):
            return math.pow(a,b)
        else:
            raise ValueError("Debe ingresar valores numéricos enteros o flotantes.")
        
    @staticmethod
     # Función que divide dos números
    def obtener_raiz(a : int|float, b : int|float) -> int|float:
        if(isinstance(a,(int,float)) and isinstance(b,(int,float))):
            return round(math.pow(a,1/b),4)
        else:
            raise ValueError("Debe ingresar valores numéricos enteros o flotantes.")

Archivo de LICENSE: Hay varios tipos de licencia, puedes optar por cualquier formato y personalizarlo. Yo elegí el tipo MIT.
Archivo pyproject.toml:

En el atributo "name" se le dado el nombre al paquete de "package_calculator_zriiman84" ya que este debe ser único y no debe existir en PYPI. Lo único que deberá cambiar en caso vuelva a publicarlo, sería la versión. La sección [build-system] es importante.
Archivo README.md

PASO 3: Subir a GITHUB

Este paso no es obligatorio para que se distribuya tu paquete en PYPI, pero se recomienda tener tu proyecto también subido a Github, ya que es parte de la metadata descrita en el archivo pyproject.toml.
Crear un repositorio remoto público y vacío (sin ramas, ni archivos por defecto) llamado “package_calculator”.
Desde git covertir la carpeta del proyecto “package_calculator” a un repositorio con el comando “git init”
Luego, agregar los archivos con el comando “git add .”
Realizar el commit con el comando “git commit -m <comentarios>”
Luego, realizar la conexión remota desde el repositorio remoto al repositorio local con el comando “git remote add origin <ruta_remota>”
Validar las conexiones con el comando “git remote -v”
Finalmente, hago envío los cambios al repoitorio remoto con el comando “git push --set-upstream origin main”

PASO 4: Actualizar PIP

No es necesario actualizarlo siempre que vayas a publicar un paquete, pero igual se recomienda ejecutar el siguiente comando, sobre todo si es la primera vez que publicas un paquete:

python3 -m pip install --upgrade pip

PASO 5: Generar la distribución de paquetes

Ejecutar el siguiente comando:

python3 -m pip install --upgrade build

PASO 6: Construir el paquete con build

Este paso es MUY IMPORTANTE. Esto crea un directorio dist/ con archivos .tar.gz y .whl; en la raíz del proyecto, fuera del paquete que contiene al módulo Calculadora.

PASO 7: Instalar TWINE o actualizarlo

Ejecutar el siguiente comando:

python3 -m pip install --upgrade twine

PASO 8: Subir el paquete a PYPI con Twine

Ejecutar el siguiente comando:

python3 -m twine upload dist/*

Pre-requisitos:

Tener un API TOKEN creado
Tener el API TOKEN almacenado en el archivo ~/.pypirc

PASO 9: Validar que exista el paquete en PIPY y/o en TESTPYPI

Recordar que PYPI y TestPyPI con dos ámbitos distintos.
TestPyPI requiere de su propio usuario y contraseña.
Si deseas publicar en TestPyPI se usa otro comando como: python3 -m twine upload --repository testpypi dist/*

PASO 10: Instalar el paquete

Ejecutar el siguiente comando:

pip install package-calculator-zriiman84

Nótese que el nombre del paquete para la instalación es el que se le asignó en el atributo "name" del archivo pyproject.toml. Si bien es cierto yo le puse con "_", (subguión), PYPI a la hora de publicarlo lo puso con "-" (guión).

PASO 11: Usar el paquete

Nótese que al realizar la importación: "from package_calculator import Calculadora" estamos colocando el nombre original del paquete, no el nombre o alias que se le puso en el archivo "pyproject.toml".

Esto lo comprobé tratando de colocar el nombre "from package_calculator_zriiman84 import Calculadora" o "from package-calculator-zriiman84 import Calculadora" pero no me reconocía.

FINALMENTE:

Hay muchos términos y consideraciones, pero los pasos realizados son los más básicos e importantes. Les sugiero apoyarse bastante de herramientas como CHATGPT o cualquier otra herramienta de IA y además leer la documentación oficial de PYPI para la publicación: https://packaging.python.org/en/latest/tutorials/packaging-projects/

Juan Camilo Suarez

student•

Muchas gracias por tu paso a paso Cristofer!

Hiciste un grandioso tutorial!!

Juan Diego

student•

Exelente aporte!

Daniel Ochoa

student•

El mejor curso de lectura del mundo.

Alejandro Ernesto Gómez Soria

student•

Paso 3: Crear un Archivo README.md

Este archivo proporciona una descripción detallada de tu paquete. Es recomendable usar Markdown para formatearlo.

Paso 4: Construir tu Paquete

Usa setuptools y wheel para construir tu paquete. Primero, asegúrate de tener estas herramientas instaladas:

pip install setuptools wheel

Luego, construye tu paquete

python setup.py sdist bdist_wheel

Alexis Dorado Muñoz

student•

Gracias

Alejandro Ernesto Gómez Soria

student•

Paso 6: Verificar la Publicación

Después de una carga exitosa, tu paquete estará disponible en PyPI y podrás instalarlo usando pip:

pip install mi_paquete

Fidel Ortega Guzman

student•

GRACIAS

José Manuel Robles Espinosa

student•

Ha caray!!! como es que de PyPI nos brincamos a la página oficial de Python???

Juan Diego

student•

Twine es una herramienta de línea de comandos utilizada para construir y empaquetar proyectos en Python. Permite crear archivos de distribución que contienen toda la información necesaria sobre el paquete, facilitando su publicación en repositorios como PyPI. En el contexto de la clase sobre publicación de paquetes, se menciona que Twine ayuda a enviar estos paquetes a PyPI, lo que permite que otros desarrolladores puedan instalar y utilizar tu código fácilmente.

Juan Diego

student•

Para actualizar pip, puedes usar el siguiente comando en tu terminal o línea de comandos:

python -m pip install --upgrade pip

Asegúrate de tener instalada la última versión de Python, ya que pip se actualiza junto con ella. Este comando descargará la última versión de pip desde PyPI. Recuerda que mantener pip actualizado es importante para gestionar tus paquetes de forma eficiente y segura.

Juan Diego

student•

El archivo README.md es un documento clave para cualquier proyecto que se publica, ya que proporciona una descripción del proyecto, instrucciones de instalación, ejemplos de uso y otra información relevante. Utiliza el formato Markdown, lo que permite que sea fácil de leer y editar. Este archivo es fundamental para que otros usuarios comprendan rápidamente de qué trata tu paquete y cómo utilizarlo, mejorando así la usabilidad y accesibilidad del proyecto que has publicado en PyPI.

Juan Diego

student•

Los metadatos del paquete se estructuran en el archivo pyproject.toml. Este archivo es fundamental, ya que debe contener información como el nombre del paquete, versión, autor, requisitos de Python y más. Además, es importante incluir un archivo README.md que sirva como documentación para los usuarios. Asegúrate de seguir las buenas prácticas de estructuración de proyectos al crear estos archivos.

Alvaro Rafael Guete Puello

student•

¿Qué medidas de seguridad se deben tomar al subir un paquete a PyPi para evitar vulnerabilidades o accesos no autorizados?

Alexander Ramirez

student•

Lo de instalar openai no lo sabía, tremendo aporte!

Daniel Ochoa

student•

Si estan subiendo el paquete y tienen problemas con el token en windows creen un archivo ".pypirc" en su raíz con la siguiente estructura:

[pypi]

username = __token__

password = <SU API_KEY>

De ahi ejecuten ```python twine upload dist/*

Alejandro Ernesto Gómez Soria

student•

Paso 2: Crear el Archivo setup.py

El archivo setup.py es crucial para definir los metadatos de tu paquete. Aquí tienes un ejemplo básico:

from setuptools import setup, find_packages

setup(
    name="mi_paquete",
    version="0.1.0",
    packages=find_packages(),
    install_requires=[
        # Lista de dependencias
    ],
    author="Tu Nombre",
    author_email="tu_email@example.com",
    description="Una breve descripción de tu paquete",
    long_description=open('README.md').read(),
    long_description_content_type='text/markdown',
    url="https://github.com/tu_usuario/mi_paquete",
    classifiers=[
        "Programming Language :: Python :: 3",
        "License :: OSI Approved :: MIT License",
        "Operating System :: OS Independent",
    ],
    python_requires='>=3.6',
)

Alejandro Ernesto Gómez Soria

student•

Paso 1: Preparar tu Paquete

Asegúrate de que tu paquete esté bien estructurado. Una estructura típica podría ser:

mi_paquete/

│

├── mi_paquete/

│ ├── __init__.py

│ ├── modulo1.py

│ └── modulo2.py

├── tests/

│ ├── __init__.py

│ └── test_modulo1.py

├── setup.py

└── README.md

Miguel Angel Otero Otero

student•

Estructura del Paquete para gestión de servicios minoristas

inventario.py
- Gestión de productos y stock
- Alertas de inventario bajo
- Clasificación por categorías
clientes.py
- Registro de clientes
- Historial de compras
- Actualización de datos
ventas.py
- Procesamiento de transacciones
- Cálculo de subtotales y totales
- Gestión del estado de ventas
proveedores.py
- Registro de proveedores
- Asociación con productos
- Información de contacto
reportes.py
- Análisis de ventas por período
- Productos más vendidos
- Valoración de inventario
exportacion.py
- Exportación a CSV
- Exportación a JSON

Características Principales

Sistema completo e integrado para tiendas minoristas
Gestión eficiente de inventario con alertas de stock bajo
Seguimiento detallado de clientes y sus historiales de compra
Procesamiento completo de ventas con actualización automática de inventario
Generación de reportes para análisis de negocio
Exportación de datos a formatos estándar