GuíaAvanzado
Guía de Empaquetado y Herramientas CLI
Un script que "funciona en mi máquina" y un paquete instalable que otra persona puede usar son dos cosas muy distintas, y esta guía te lleva de uno al otro paso a paso. Trabajas empaquetando un solo caso realista —`reservo`, un sistema de reservas de salas de coworking cuyo modelo de objetos ya existe— y lo conviertes en una librería instalable con una herramienta de línea de comandos propia. Aprendes qué es un módulo y un paquete, cómo funciona `import` y el `sys.path`, el estándar moderno `pyproject.toml` (PEP 621) y cómo construir un wheel y un sdist reales con `uv build`, a aislar el proyecto en entornos virtuales y manejar dependencias con `pip` y `uv`, a construir una CLI completa con `argparse` (sin dependencias externas), a exponerla como comando instalado con un entry point en `[project.scripts]`, a estructurar un paquete real con submódulos, imports relativos y una API pública deliberada, y a configurar el toolchain de calidad (`ruff`, `mypy`, `pytest`, `pre-commit`). Todo lo ejecutable se corre de verdad —el comando `reservo price --tier basic --hours 3` imprime `7500` desde tu terminal—; lo único que se enseña como contenido sin ejecutar es la publicación en PyPI, porque es una acción pública e irreversible. El proyecto final integra las siete piezas en un paquete completo, construido, instalado y corriendo de punta a punta.
- 64
- lecciones
- 8
- módulos
- Inglés · Español
- disponible en
- Sí
- certificado
- Gratis
- acceso
Resultados
Lo que vas a poder hacer
- Distinguir un módulo de un paquete, entender qué hace `__init__.py` y cómo Python resuelve un `import` a través de `sys.path`
- Escribir un `pyproject.toml` completo según PEP 621 (metadata, dependencias, build backend) y construir un wheel y un sdist reales con `uv build`
- Aislar un proyecto en un entorno virtual, manejar dependencias con `pip` y `uv`, fijar versiones para reproducibilidad e instalar en modo editable
- Construir una interfaz de línea de comandos completa con `argparse`: subcomandos, argumentos posicionales y opciones, ayuda autogenerada y códigos de salida
- Exponer una función `main()` como comando instalado en el PATH mediante un entry point (`[project.scripts]`), y entender cómo funciona el script wrapper que genera
- Aplicar versionado semántico y conocer el flujo completo de distribución a PyPI/TestPyPI con `twine`
- Estructurar un paquete real en submódulos con responsabilidades claras, imports relativos, `__main__.py` y dependencia en un solo sentido (la CLI llama a la librería, nunca al revés)
- Declarar una API pública deliberada con `__all__` y re-exportar en `__init__.py`, y darle a `__version__` una única fuente de verdad
- Configurar un toolchain de calidad moderno (`ruff` para lint y formato, `mypy` para tipos, `pytest` cableado, `pre-commit` para automatizar)
- Integrar todas las piezas en un paquete distribuible completo, construido, instalado y verificado con la CLI corriendo desde el PATH
Antes de empezar
Qué necesitas traer
Es para ti si...
- Desarrolladores Python de nivel intermedio que solo han escrito scripts sueltos y nunca convirtieron su código en un paquete instalable
- Devs que quieren darle a una herramienta propia una interfaz de línea de comandos profesional, con subcomandos y ayuda autogenerada
- Personas que necesitan entender `pyproject.toml` a fondo porque lo ven en todos los proyectos modernos pero nunca lo escribieron desde cero
- Cualquiera que quiera publicar su primera librería en PyPI y quiera conocer el flujo completo antes de hacerlo de verdad
- Quien mantiene un paquete de un solo archivo que ya creció demasiado y necesita un criterio claro para estructurarlo en submódulos
Requisitos y materiales
- Sintaxis básica de Python: variables, funciones, diccionarios, listas, control de flujo, y saber escribir y correr un archivo `.py`
- Nociones mínimas de clases (no se requiere dominar diseño orientado a objetos)
- Python 3.14 instalado y una terminal
- No es necesario haber usado `pip`, `venv`, `uv` ni ninguna herramienta de empaquetado antes: todo se explica desde cero
Contenido
El temario, módulo por módulo
Abre cualquiera para ver sus lecciones.
- 1. Introducción: De script a paquete
- 2. Por qué empaquetar — el script suelto no escala
- 3. Módulo vs paquete y `__init__.py`
- 4. Cómo funciona `import` y `sys.path`
- 5. Imports absolutos vs relativos
- 6. El src layout y el bug que evita
- 7. El primer paquete `reservo` importable
- 8. Mini-proyecto: tu primer paquete
- 1. Presentación del módulo: del paquete importable al paquete construible
- 2. `pyproject.toml`: el archivo único
- 3. La tabla `[project]` y su metadata
- 4. Dependencias y `requires-python`
- 5. El build backend: `[build-system]`
- 6. Construir con `uv build`: wheel + sdist
- 7. Qué es un wheel vs un sdist (e inspeccionarlo)
- 8. Mini-proyecto: construye el wheel de `reservo`
- 1. Presentación del módulo: del paquete construible al entorno reproducible
- 2. Por qué aislar: el entorno virtual
- 3. Crear y activar un entorno virtual
- 4. pip: instalar, `freeze` y `requirements.txt`
- 5. Fijar versiones y reproducibilidad
- 6. El install editable: `pip install -e .`
- 7. uv: el gestor moderno (venv, install, lock)
- 8. Mini-proyecto: un entorno de desarrollo reproducible
- 1. Presentación del módulo: dale una interfaz a `reservo`
- 2. Qué es una CLI y el `ArgumentParser` básico
- 3. Subcomandos con `add_subparsers`
- 4. Argumentos posicionales vs opciones
- 5. El `--help` autogenerado y los códigos de error de argparse
- 6. La función `main()` y el exit code
- 7. Separar la CLI de la lógica; `click` y `typer` como concepto
- 8. Mini-proyecto: la CLI de `reservo`
- 1. Introducción: Entry points y distribución
- 2. Qué es un entry point y la tabla `[project.scripts]`
- 3. Instala y corre el comando `reservo`
- 4. El wrapper generado y cómo funciona
- 5. Versionado semántico
- 6. Publicar en PyPI y TestPyPI con `twine` (contenido)
- 7. Qué exige PyPI: metadata, README y license
- 8. Mini-proyecto: publica `reservo` como comando
- 1. Introducción: Estructurar un paquete real
- 2. Partir el código en submódulos
- 3. Imports relativos dentro del paquete
- 4. `__main__.py` y `python -m reservo`
- 5. Separar la librería de la CLI
- 6. La API pública con `__all__` y re-exportar en `__init__.py`
- 7. `__version__` y la fuente única de verdad
- 8. Mini-proyecto: un `reservo` bien estructurado
- 1. Introducción al módulo: el toolchain de calidad
- 2. Por qué un toolchain de calidad
- 3. `ruff`: lint vs format, y cómo configurarlo
- 4. Anotaciones de tipo y `mypy`
- 5. Configurar `mypy` en modo estricto en `pyproject.toml`
- 6. El gancho a `pytest`: cablearlo con `[tool.pytest.ini_options]`
- 7. `pre-commit`: automatizar el toolchain
- 8. Mini-proyecto: un toolchain de calidad para `reservo`
- 1. Introducción: Empaqueta y publica `reservo`
- 2. El src layout completo y la API pública
- 3. El `pyproject.toml`: metadata, entry point y toolchain
- 4. La CLI de `argparse` integrada
- 5. Construir el wheel con `uv build`
- 6. Instalar y correr el comando `reservo`
- 7. Dejar listo el `twine upload` (contenido)
- 8. Proyecto: arma, construye y publica `reservo`
Dudas frecuentes
Lo que suele preguntarse
Sin límite. Es una guía gratuita: entras cuando quieras, las veces que quieras.
No. Los módulos están ordenados de menos a más, pero puedes saltar al que necesites. Tu progreso se guarda por lección.
Lo que haga falta está en «Qué necesitas traer», arriba. Si no aparece nada ahí, puedes empezar desde cero.
En el grupo de WhatsApp del Club, y cada quince días hay un live con un instructor donde se resuelven dudas en vivo.
Sí. Al terminar todas las lecciones se emite automáticamente, con un código verificable que puedes compartir en LinkedIn.
Empieza cuando quieras
Lo que dicen los estudiantes
Estas reseñas son de estudiantes inscritos que completaron al menos el 50% del curso. Moderamos las reseñas solo por motivos de contenido (spam, lenguaje ofensivo, datos personales), nunca por ser críticas o negativas.
Aún no hay reseñas aprobadas.
¡Sé el primero en compartir tu experiencia!