Publicación de Paquetes Python en PyPI

Clase 62 de 64 • Curso de Python

Contenido del curso

Fundamentos de Programación y Python

Colección y Procesamiento de Datos en Python

Control de Flujo en Python

Funciones y Manejo de Excepciones en Python

Programación Orientada a Objetos en Python

Lectura y escritura de archivos

Biblioteca estándar de Python

Conceptos avanzados de Python

Decoradores

Métodos y estructura de clases en Python

Programación concurrente y asíncrona

Creación de módulos y paquetes

Proyecto final

Tomar examen

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!

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:

Juan Camilo Suarez

student•

Muchas gracias por tu paso a paso Cristofer!

Hiciste un grandioso tutorial!!

Juan Diego

student•

Exelente aporte!

Publicación de Paquetes Python en PyPI

Fundamentos de Programación y Python

Fundamentos de Programación con Python para Principiantes

Este curso tiene una nueva versión, link para continuar aprendiendo

Instalación y Uso Básico de Python en Windows y Mac

Semántica y Sintaxis en Programación Python

Práctica: Te doy la bienvenida a los ejercicios interactivos

Manejo de Cadenas y Operaciones Básicas en Python

Tipos de Datos en Python: Enteros, Flotantes y Booleanos

Dominio de la función `print` en Python: usos y formatos avanzados

Operaciones matemáticas avanzadas en Python: módulo, potencia y más

Entrada de información y manejo de tipos de datos en Python

Colección y Procesamiento de Datos en Python

Manipulación de Listas en Python: Creación, Indexación y Métodos Básicos

Copiar listas en Python sin compartir memoria con slicing

Manejo de Matrices y Tuplas en Python

Matrices en Juegos y Imágenes con Python

Diccionarios en Python: Uso y Manipulación de Datos

Control de Flujo en Python

Estructuras Condicionales en Programación: Uso de If, Else y Elif

Iteración y control de flujo con bucles en Python

Iteradores y Generadores en Python: Uso Eficiente de Memoria

Listas por comprensión en Python: creación y optimización de listas

Funciones y Manejo de Excepciones en Python

Funciones y Parámetros en Python: Crea una Calculadora Básica

Funciones Lambda en Python: Uso y Aplicaciones Prácticas

Recursividad en Python: Factoriales y Serie de Fibonacci

Manejo de Excepciones y Errores en Python

Programación Orientada a Objetos en Python

Programación Orientada a Objetos en Python: Clases y Métodos Básicos

Gestión de Biblioteca con Programación Orientada a Objetos

Herencia y Polimorfismo en Programación Orientada a Objetos

Programación Orientada a Objetos: Implementación de Clases y Herencia

Polimorfismo en Programación Orientada a Objetos

Herencia y Uso de la Función super() en Python

Programación Orientada a Objetos: Atributos, Métodos y `super()` en Python

Lectura y escritura de archivos

Manipulación de Archivos TXT y CSV en Python

Manipulación de archivos CSV con Python: lectura y escritura

Manejo de Archivos JSON en Python para Aplicaciones Web y APIs

Biblioteca estándar de Python

Uso Eficiente de la Biblioteca Estándar de Python

Uso de las librerías OS, Math y Random en Python

Análisis de Datos de Ventas con Python y Statistics

Desarrollo del juego Batalla Naval en Python

Conceptos avanzados de Python

Programación Avanzada en Python: POO, Excepciones y Proyectos

Escritura de Código Pytónico y Buenas Prácticas en Python

Comentarios y Docstrings: Buenas Prácticas en Programación

Tiempo de vida y alcance de variables en Python

Anotaciones de Tipo en Python para Código Más Legible

Validación de Tipos y Manejo de Excepciones en Python

Estructuras de Datos Avanzadas en Python: Collection y Enumeraciones

Decoradores

Decoradores en Python: Extiende Funcionalidades de Funciones

Uso de Decoradores Anidados y con Parámetros en Python

Decoradores en Programación Orientada a Objetos en Python

Métodos y estructura de clases en Python

Uso de Métodos Mágicos en Python

Sobrecarga de Operadores en Python: Personaliza Comportamiento de Clases

Ejecutar scripts Python con `if __name__ == '__main__'`

Metaprogramación en Python: Métodos `__new__` y `__init__`

Uso de *args y **kwargs en funciones de Python

Métodos y Atributos Privados y Protegidos en Python

Uso de Property en Python: Getter, Setter y Eliminación de Atributos

Métodos estáticos y de clase en Python

Programación concurrente y asíncrona

Concurrencia y Paralelismo en Python: Técnicas y Librerías Básicas

Concurrencia y Paralelismo en Python: `threading` y `multiprocessing`

Asincronismo en Python con AsyncIO y Corrutinas

Sincronía y Concurrencia en Python: Teoría y Práctica

Creación de módulos y paquetes

Módulos y Paquetes en Python: Reutilización y Organización de Código

Uso de Paquetes y Subpaquetes en Python con Visual Studio Code

Publicación de Paquetes Python en PyPI

Proyecto final

Sistema de Gestión de Reservas en Python Avanzado

Sistema de Gestión de Reservas en Python Avanzado

Ejecutar scripts Python con `if name == 'main'`

Metaprogramación en Python: Métodos `new` y `init`