Cursus — Python Module 05 pendiente

Dos proyectos alternativos del rank 02 para el mismo hueco: «Code Nexus» (Module 05: clases abstractas y polimorfismo) y «The Codex» (Module 05 bis: entornos virtuales, dependencias, configuración e imports). Se hace uno de los dos. Aún no está hecho: esta ficha explica ambos enunciados; el código llegará con el que se elija.

Uno de los dos — En la intra son dos proyectos distintos, python-module-05 y python-module-05-bis, y el bis es una alternativa al 05: basta con hacer uno para seguir con la rama de Python. Tiran en direcciones diferentes. Code Nexus continúa la línea de orientación a objetos del Module 01: clases abstractas, sobrescritura de métodos y polimorfismo, en tres ejercicios que hacen crecer un único programa. The Codex mira hacia fuera del código, a lo que rodea a un proyecto de Python real: el entorno virtual, las dependencias con pip y Poetry, los secretos en variables de entorno y, sobre todo, cómo funcionan los paquetes y los imports, en cinco ejercicios que construyen un árbol de ficheros en la raíz del repositorio.

Module 05 — Code Nexus

Muchos tipos, un solo flujo — Polimorfismo significa «muchas formas»: que un mismo código trate objetos de clases distintas a través de una interfaz común, sin preguntar de qué clase es cada uno. En C lo imitaste en la piscine con punteros a función y void * (C 11): una tabla de funciones por tipo, a mano. En Python lo da la herencia: una clase madre declara los métodos y cada hija los sobrescribe con su propio comportamiento. Una clase abstracta (módulo abc, desde Python 2.6 y 3.0) va un paso más allá: declara métodos sin implementarlos, no se puede instanciar y obliga a las hijas a completarlos. Y en el último ejercicio aparece la otra cara del polimorfismo en Python, el duck typing — «si camina como un pato y grazna como un pato, es un pato» —, formalizado para mypy con typing.Protocol (Python 3.8): un objeto vale si tiene los métodos adecuados, herede de quien herede.

Qué pide (Module 05)

Rank: 02Python: 3.10 o superiorObligatorio: flake8, mypyEjercicios: 3 (ex0–ex2)

ex0data_processor

Entrega: ex0/data_processor.pyAutorizado: builtins, tipos estándar, import typing, import abc

La arquitectura base:

Las pruebas: una instancia de cada hija, datos válidos e inválidos con validate, al menos un ingest inválido sin validar que lance la excepción (lo que deja un aviso de mypy a propósito) y varios datos ingeridos y luego extraídos con output.

La sintaxis de un método abstracto, con un ejemplo ajeno al ejercicio:

from abc import ABC, abstractmethod

class Figura(ABC):
    @abstractmethod
    def area(self) -> float:
        ...
Qué te obliga a aprender — Separar la interfaz (qué sabe hacer cualquier procesador) de la implementación (cómo lo hace cada uno), y que una clase abstracta es un contrato: Figura() lanza un TypeError, y una hija que olvide un método abstracto tampoco se puede instanciar. También una estructura de datos clásica: guardar y sacar «el más antiguo primero» es una cola (FIFO). Y un matiz de tipos: Any es compatible con todo en ambas direcciones, y eso es lo que permite que las hijas estrechen la firma de ingest sin que mypy proteste.

ex1data_stream

Entrega: ex1/data_stream.pyAutorizado: builtins, tipos estándar, import typing, import abc

Una clase DataStream que recibe un flujo con datos de tipos mezclados y envía cada elemento al procesador adecuado mediante polimorfismo. Implementa:

El escenario de prueba muestra las estadísticas, registra procesadores, procesa un flujo, consume elementos con output y vuelve a mostrarlas. En el ejemplo, con solo el procesador numérico registrado, el texto y los logs dan error; tras registrar los otros dos, el mismo lote ya se reparte entero.

Qué te obliga a aprender — El polimorfismo en acción: DataStream no sabe qué procesadores existen ni cómo trabaja cada uno; solo les pregunta a todos lo mismo (validate) y entrega el dato al que dice que sí. Añadir un procesador nuevo no obliga a tocar DataStream. Son justo las preguntas del enunciado: cómo permite el polimorfismo manejar tipos distintos sin conocer su implementación y qué ventajas tiene ese diseño.

ex2data_pipeline

Entrega: ex2/data_pipeline.pyAutorizado: builtins, tipos estándar, import typing, import abc

La parte de salida de la tubería, con un sistema de plugins de exportación compatibles por duck typing:

Qué te obliga a aprender — La diferencia entre tipado nominal (eres un DataProcessor porque heredas de él) y estructural (eres un ExportPlugin porque tienes process_output con esa firma). Un plugin no necesita heredar de ExportPlugin: mypy comprueba la forma. Y dos formatos de intercambio que vas a ver en todas partes: CSV, valores separados por comas, y JSON, la notación de objetos de JavaScript, con sus reglas estrictas (comillas dobles siempre).
Puntos delicados (Module 05)

Module 05 bis — The Codex

El laboratorio antes que la fórmula — Un programa de Python real casi nunca es un fichero suelto: depende de librerías de terceros, necesita configuración y se reparte en paquetes. Instalar las librerías en el Python del sistema acaba mal en cuanto dos proyectos piden versiones distintas; para eso existen los entornos virtuales (venv, en la biblioteca estándar desde Python 3.3): una carpeta con su propio intérprete enlazado y su propio site-packages. Las dependencias se declaran para que cualquiera reproduzca el entorno: con requirements.txt y pip, el método clásico, o con pyproject.toml y Poetry, que además fija las versiones exactas resueltas en poetry.lock. Los secretos se sacan del código a variables de entorno, una de las reglas de la metodología Twelve-Factor App. Y luego está el corazón del proyecto: el sistema de imports, que decide cómo encuentra Python un módulo, qué ejecuta al importarlo y por qué dos módulos que se importan entre sí pueden hacer saltar el laboratorio por los aires.

Qué pide (Module 05 bis)

Rank: 02Python: 3.10 o superiorObligatorio: flake8, mypyHerramientas: venv, pip, Poetry, python-dotenvEjercicios: 5 (ex0–ex4)

El árbol final que pide el enunciado (resumido en una línea por carpeta):

.
|-- ex0/  construct.py  loading.py  pyproject.toml  requirements.txt
|-- ex1/  .env.example  .gitignore  oracle.py  requirements.txt
|-- alchemy/
|   |-- __init__.py  elements.py  potions.py
|   |-- transmutation/  __init__.py  recipes.py
|   `-- grimoire/  __init__.py  dark_spellbook.py  dark_validator.py
|                  light_spellbook.py  light_validator.py
|-- elements.py
|-- ft_alembic_0.py  ft_alembic_1.py
|-- ft_distillation_0.py  ft_transmutation_0.py
`-- ft_kaboom_0.py  ft_kaboom_1.py

ex0The Sealed Laboratory

Entrega: ex0/construct.py, loading.py, requirements.txt, pyproject.tomlAutorizado: os, sys, site, importlib, pandas, numpy

Parte 1. construct.py detecta si se ejecuta dentro de un entorno virtual, muestra información del Python actual, da instrucciones para crear y activar uno si no lo hay, y enseña la diferencia entre la ubicación global de los paquetes y la del entorno. Tiene que funcionar dentro y fuera de un entorno con una salida claramente distinta en cada caso.

python3 -m venv lab_env
source lab_env/bin/activate

Parte 2. loading.py declara un par de librerías externas (como pandas y numpy) tanto en requirements.txt (para pip) como en pyproject.toml (para Poetry), importa cada una y muestra su versión instalada, y explica en su salida la diferencia entre pip y Poetry. Si falta alguna, no se rompe: muestra un mensaje con el comando de instalación para pip y para Poetry. Se prueba sin las librerías, tras pip install -r ex0/requirements.txt y con poetry install y poetry run.

Qué te obliga a aprender — Qué es de verdad un entorno virtual: una carpeta con un fichero pyvenv.cfg, un intérprete y un site-packages propio; «activarlo» solo cambia variables como PATH en tu shell. Python distingue entre el prefijo en que se está ejecutando y el de la instalación base, y la diferencia entre ambos es la huella del entorno. También importar algo que quizá no está instalado sin romperse (el ModuleNotFoundError es una excepción más) y las dos filosofías de dependencias. Las preguntas del enunciado: qué aísla un entorno virtual y qué no, y por qué elegir Poetry frente a un requirements.txt.

ex1The Oracle

Entrega: ex1/oracle.py, requirements.txt, .env.example, .gitignoreAutorizado: os, sys, python-dotenv, operaciones con ficheros

Un sistema de configuración basado en variables de entorno y un fichero .env, cargado con la librería python-dotenv (el objetivo es aprender a usar .env, no escribir un parser). oracle.py carga su configuración del entorno, usa el .env para desarrollo, se comporta de forma visiblemente distinta en desarrollo y en producción, y maneja la configuración que falte sin romperse. Las variables: MATRIX_MODE («development» o «production»), DATABASE_URL, API_KEY, LOG_LEVEL y ZION_ENDPOINT.

Tres pruebas: sin configuración (valores por defecto y aviso), con un .env copiado de .env.example, y con variables pasadas en la propia línea de comandos, que deben tener prioridad sobre el .env:

MATRIX_MODE=production API_KEY=secret123 python3 ex1/oracle.py
Qué te obliga a aprender — Que la configuración y los secretos no van en el código: un API_KEY escrito en un fichero está a un git push de ser público, y los bots que rastrean GitHub buscando claves son muy rápidos. Por eso .env va en .gitignore y lo que se versiona es .env.example, una plantilla sin valores reales. También el entorno de un proceso (el envp que en C llega como tercer argumento de main) y su orden de prioridad. La pregunta del enunciado: por qué una variable de entorno es mejor sitio para un secreto que una constante, y qué sigue sin ser seguro.

ex2The Alembic

Entrega: elements.py, alchemy/__init__.py, alchemy/elements.py, ft_alembic_0.py, ft_alembic_1.pyAutorizado: builtins, tipos estándar y solo módulos propios

Los primeros componentes: elements.py en la raíz, con create_fire() y create_water(); alchemy/elements.py, con create_earth() y create_air() (cada una devuelve una frase fija como «Fire element created»); y alchemy/__init__.py, con lo necesario para exponer create_air a través del paquete, y nada que exponga create_earth.

Dos scripts: ft_alembic_0.py usa import ... para llegar al elements.py de la raíz y crear fuego; ft_alembic_1.py usa import alchemy, crea aire y luego intenta alchemy.create_earth(), que tiene que fallar (con un AttributeError en el ejemplo) aunque la función exista en alchemy/elements.py. Ahí se espera un error de mypy a propósito.

Qué te obliga a aprender — Qué es un paquete: una carpeta con __init__.py, que se ejecuta al importarla y cuyo espacio de nombres es lo que ve quien escribe import alchemy. Los submódulos no aparecen solos: si __init__.py no los menciona, alchemy.create_earth no existe. La pregunta del enunciado lo plantea así: nada se ha ocultado ni se ha hecho privado, ¿qué ha cambiado entonces __init__.py?

ex3Distillation and Transmutation

Entrega: alchemy/potions.py, alchemy/transmutation/ (paquete), ft_distillation_0.py, ft_transmutation_0.pyAutorizado: builtins, tipos estándar y solo módulos propios

Destilación. alchemy/potions.py define healing_potion(), que combina los elementos tierra y aire, y strength_potion(), que combina fuego y agua, con el texto exacto del enunciado. Para eso tiene que llegar a los cuatro elementos, y dos de ellos viven fuera del paquete. ft_distillation_0.py accede a alchemy/potions.py con from ... import ... y prepara las dos pociones.

Transmutación. alchemy/transmutation/recipes.py, un nivel más abajo, define lead_to_gold(), que combina aire, la poción de fuerza y fuego, y debe contener al menos un import absoluto y uno relativo. ft_transmutation_0.py llega a esa receta con import ... y transmuta el plomo en oro.

Las dos formas, con nombres de ejemplo:

from paquete.modulo import funcion   # absoluto: desde la raíz de búsqueda
from .modulo import funcion           # relativo: desde el paquete actual
from ..otro import funcion            # relativo: un nivel más arriba
Qué te obliga a aprender — Dónde busca Python los módulos: sys.path, cuya primera entrada es la carpeta del script que ejecutas. Por eso los scripts van en la raíz y por eso un módulo de dentro del paquete puede alcanzar el elements.py de fuera sin tocar sys.path (que está prohibido). Y el viejo debate entre imports absolutos, explícitos y estables aunque muevas el fichero que importa, y relativos, cortos y estables aunque renombres el paquete, que solo funcionan dentro de un paquete. La pregunta del enunciado: cuándo usar cada uno.

ex4Avoid the Explosion

Entrega: alchemy/grimoire/ (paquete), ft_kaboom_0.py, ft_kaboom_1.pyAutorizado: builtins, tipos estándar y solo módulos propios

La misma funcionalidad escrita dos veces: una que funciona y otra que explota.

Qué te obliga a aprender — Qué pasa exactamente al importar: la primera vez, Python crea el módulo vacío, lo apunta en sys.modules y ejecuta su código de arriba abajo. Si a mitad de camino otro módulo lo importa, recibe ese módulo a medio construir, y pedirle un nombre que todavía no se ha definido falla. En C el equivalente eran dos cabeceras que se incluyen mutuamente, y lo resolvían los include guards y las declaraciones adelantadas. El enunciado pide elegir una forma de evitar la explosión y saber explicar las alternativas, porque la diferencia entre los dos grimorios es una decisión de diseño, no una línea de sintaxis. Su pregunta final: si los dos grimorios describen dos ficheros que se necesitan, ¿por qué solo explota uno?
Puntos delicados (Module 05 bis)

Fuente

Dos enunciados oficiales en inglés, en packs/cursus/M2/207_Python_Module_05/: