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.
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.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.abc y typing.La arquitectura base:
DataProcessor que hereda de ABC, con dos
métodos abstractos — validate(self, data: Any) -> bool, que dice si el dato
sirve a ese procesador, e ingest(self, data: Any) -> None, que lo procesa — y
un método normal, output(self) -> tuple[int, str].NumericProcessor, TextProcessor y
LogProcessor, que sobrescriben validate e ingest.
validate mantiene la misma firma (no puede saber qué le llegará); en cambio cada
ingest tiene una firma propia que refleja los tipos que acepta.NumericProcessor acepta int, float y listas de
ambos (también mezclados); TextProcessor, str y listas de cadenas;
LogProcessor, diccionarios de cadenas a cadenas y listas de ellos. Los tres guardan
internamente cada elemento por separado, como cadena.ingest con datos inválidos sin validar antes, debe
saltar una excepción.output no se sobrescribe: extrae el elemento más antiguo
guardado, junto con su número de orden dentro del procesador, y lo elimina.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:
...
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.Una clase DataStream que recibe un flujo con datos de tipos mezclados y envía
cada elemento al procesador adecuado mediante polimorfismo. Implementa:
register_processor(self, proc: DataProcessor) -> None, para registrar un
procesador nuevo;process_stream(self, stream: list[typing.Any]) -> None, que analiza cada
elemento y lo manda a un procesador registrado capaz de tratarlo, con un mensaje de error si
ninguno puede;print_processors_stats(self) -> None, que muestra estadísticas: por
procesador, cuántos elementos ha procesado en total y cuántos le quedan.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.
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.La parte de salida de la tubería, con un sistema de plugins de exportación compatibles por duck typing:
ExportPlugin que hereda de Protocol y define el método
que todo plugin debe tener:
process_output(self, data: list[tuple[int, str]]) -> None, cuyo parámetro
coincide con lo que devuelve output.DataStream,
output_pipeline(self, nb: int, plugin: ExportPlugin) -> None, que, tras
process_stream, consume nb elementos de cada procesador registrado y
los exporta con el plugin recibido.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).validate, ingest,
output, register_processor, process_stream,
print_processors_stats, process_output y
output_pipeline vienen dadas con sus tipos.[3.14, -1, 2.71] y
42 suman 4.int y
float mezclados, pero una lista de cadenas no es suya, y una de diccionarios
tampoco.bool es un int. En Python True pasa por
isinstance(x, int); conviene decidir qué hacer con él.item_3: el rango es la
posición de llegada dentro del procesador.ingest con un
dato inválido para comprobar que lanza la excepción.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.eval() y exec().sys.path en todo el proyecto.alchemy/, y varios scripts en la raíz del repositorio..env.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
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.
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.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
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.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.
__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?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
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.La misma funcionalidad escrita dos veces: una que funciona y otra que explota.
light_spellbook.py define
light_spell_allowed_ingredients() (devuelve «earth», «air», «fire», «water») y
light_spell_record(spell_name: str, ingredients: str), que dice si el hechizo se
registra o se rechaza según el validador. light_validator.py define
validate_ingredients(ingredients: str), que devuelve los ingredientes con «VALID»
o «INVALID»: son válidos si incluyen al menos uno de los permitidos por el libro, sin
distinguir mayúsculas. Cada fichero necesita al otro, y hay que hacer que eso no
explote.dark_spellbook.py y
dark_validator.py, con funciones con prefijo dark_ e ingredientes
oscuros («bats», «frogs», «arsenic», «eyeball»), con la dependencia mutua escrita de la forma
ingenua, arriba de los dos ficheros, y rota de verdad. El enunciado insiste en
no copiar los ficheros de luz y renombrar: el ciclo de imports tiene que ser lo único que
cambie a propósito.ft_kaboom_0.py registra un hechizo de luz sin problema;
ft_kaboom_1.py va directo a dark_spellbook.py y debe fallar con una
excepción (en el ejemplo, ImportError: «cannot import name … from partially
initialized module … (most likely due to a circular import)»).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?.env. En la evaluación pueden pedirte crear
un entorno nuevo desde cero, así que hay que saber hacerlo sin chuleta.construct.py, y ningún
fallo en loading.py si falta una librería.requirements.txt y en pyproject.toml, y la salida tiene que explicar
la diferencia..env. Las variables pasadas al lanzar el
programa deben ganar a las del fichero; la diferencia entre desarrollo y producción tiene que
verse en la salida..env en ex1/.gitignore, y saber explicar por qué.__init__.py. Un import que solo sirve
para reexportar parece «sin usar»; el enunciado dice que se sigan las convenciones habituales
para ese caso.create_earth a través de
alchemy y el grimorio oscuro tienen que fallar de verdad; el error de mypy de
ft_alembic_1.py es intencionado.sys.path, eval ni exec.Dos enunciados oficiales en inglés, en packs/cursus/M2/207_Python_Module_05/:
en.subject.pdf, con el texto extraído en
subject.txt.bis.en.subject.pdf, con el texto extraído en
subject_bis.txt.