Cursus — Python Module 06 pendiente

Un módulo del rank 02 con dos enunciados a elegir: «The Codex», sobre cómo funciona de verdad import (paquetes, __init__.py, rutas absolutas y relativas, dependencias circulares), y su alternativa «Code Nexus» (06 bis), sobre clases abstractas, polimorfismo y patrones de diseño.

Dos caminos por el mismo tramo — Los módulos de Python del rank 02 existen en dos versiones. El recorrido «clásico» va así: Module 05 (Code Nexus, polimorfismo), Module 06 (The Codex, imports), Module 07 (DataDeck, patrones de diseño) y Module 08 (The Matrix, entornos virtuales y dependencias). El recorrido «bis» comprime lo mismo en dos: el 05 bis es otro «The Codex» que junta los imports del 06 con los entornos y la configuración del 08, y el 06 bis es otro «Code Nexus» que junta el polimorfismo del 05 con las factorías y estrategias del 07. Por eso Python Module 09 pide literalmente 1 of python-module-06-bis and python-module-08: basta con haber llegado al final de cualquiera de los dos caminos. Esta ficha cubre los dos enunciados del pack: el 06 y el 06 bis; solo se entrega uno.

Qué pide

Rank: 02Python: 3.10 o posteriorObligatorio: flake8, mypy (anotaciones de tipo completas)Prohibido: eval(), exec()

Los dos enunciados comparten las reglas generales de todos los módulos de Python: código que pase flake8, anotaciones de tipo en todo y comprobadas con mypy, colecciones y funciones integradas permitidas salvo eval y exec. A partir de ahí divergen:

Module 06 — The CodexModule 06 bis — Code Nexus
TemaEl sistema de importsABC, polimorfismo, Protocol, factoría abstracta, estrategia
Versión2.01.0
Imports permitidosSolo los módulos que crees túabc y typing
Prohibición especialModificar sys.pathLibrerías externas
EstructuraUn paquete alchemy/ y 13 scripts de pruebaTres ficheros sueltos y dos paquetes (ex3/, ex4/)

El propio 06 bis avisa de que sus ejercicios 3 y 4 son paquetes que se importan entre sí, y recomienda hacer antes «el proyecto de empaquetado» si no te manejas con __init__.py y con lo que un paquete decide exponer.

Bloque 1 — Module 06: The Codex

Por qué un módulo entero sobre import — En C, «importar» era el preprocesador pegando el texto de un .h y el enlazador juntando .o. En Python, import es una instrucción que se ejecuta: busca el módulo en las rutas de sys.path (la primera es la carpeta del script que lanzas), ejecuta su código de arriba abajo una sola vez, guarda el objeto módulo resultante en sys.modules y enlaza un nombre en tu espacio de nombres. Casi todos los misterios del enunciado —qué se ve desde dónde, por qué un import relativo falla, por qué dos módulos que se importan mutuamente revientan— salen de ahí. Un paquete es una carpeta de módulos; el fichero __init__.py es el código que se ejecuta al importar la carpeta, y decide qué nombres ofrece el paquete hacia fuera. El enunciado lo ambienta en un laboratorio de alquimia y te prohíbe tocar sys.path: tienes que conseguirlo todo con la estructura de carpetas y los imports correctos.

Al final hay que tener exactamente este árbol en la raíz del repositorio (todas las funciones son simples y devuelven cadenas; lo que se evalúa son los imports, no la lógica):

.
|-- alchemy
|   |-- __init__.py
|   |-- elements.py
|   |-- grimoire
|   |   |-- __init__.py
|   |   |-- dark_spellbook.py
|   |   |-- dark_validator.py
|   |   |-- light_spellbook.py
|   |   `-- light_validator.py
|   |-- potions.py
|   `-- transmutation
|       |-- __init__.py
|       `-- recipes.py
|-- elements.py
|-- ft_alembic_0.py … ft_alembic_5.py
|-- ft_distillation_0.py, ft_distillation_1.py
|-- ft_kaboom_0.py, ft_kaboom_1.py
`-- ft_transmutation_0.py … ft_transmutation_2.py

IThe Alembic

Entrega: elements.py, alchemy/elements.py, alchemy/__init__.py, ft_alembic_0.py … ft_alembic_5.py

Dos ficheros con el mismo nombre en sitios distintos: elements.py en la raíz (con create_fire() y create_water()) y alchemy/elements.py (con create_earth() y create_air()). Cada función devuelve una frase fija del tipo «Fire element created». Luego seis scripts que llegan a ellas de seis formas:

La pieza clave es alchemy/__init__.py, que debe contener «lo que haga falta» para que el paquete exponga parcialmente su contenido. Las dos formas de import, en general:

import paquete.modulo          # enlaza el nombre «paquete»; se usa paquete.modulo.f()
from paquete.modulo import f   # enlaza directamente «f»
Qué te obliga a aprender — Que importar un paquete no importa sus submódulos: import alchemy ejecuta solo alchemy/__init__.py, y el objeto alchemy tiene únicamente los nombres que ese fichero define o trae. Por eso __init__.py es la «interfaz pública» del paquete: lo que no re-exporta, no se ve desde fuera. Y que un nombre importado en __init__.py que no se usa ahí es, para flake8, un aviso de «importado y no usado»; el enunciado te pide seguir las convenciones habituales para ese caso (la lista __all__, la re-exportación explícita o el comentario noqa, según lo que elijas y sepas justificar).

IIDistillation

Entrega: alchemy/potions.py, ft_distillation_0.py, ft_distillation_1.py (y mejoras en alchemy/__init__.py)

alchemy/potions.py tiene dos funciones cuyo texto se construye con los resultados de las de los elementos: healing_potion() usa tierra y aire, strength_potion() fuego y agua. O sea, un módulo dentro del paquete necesita código de su propio paquete y del elements.py de la raíz.

Qué te obliga a aprender — Que las rutas de import se resuelven desde sys.path, no desde el fichero que importa: cuando lanzas python3 ft_distillation_0.py desde la raíz, la raíz es lo que ve todo el mundo, también alchemy/potions.py. Y que en Python un alias no es más que otro nombre apuntando al mismo objeto función: import x as y o una simple asignación en __init__.py crean nombres nuevos sin copiar nada.

IIIThe Great Transmutation

Entrega: alchemy/transmutation/__init__.py, alchemy/transmutation/recipes.py, ft_transmutation_0.py … _2.py

Un subpaquete dentro del paquete. recipes.py define lead_to_gold(), que combina aire, la poción de fuerza y fuego, y el enunciado exige que contenga al menos un import absoluto y uno relativo. Los tres scripts llegan a la receta desde tres niveles: el fichero recipes.py directamente, el módulo transmutation y el paquete alchemy a secas. El enunciado avisa de que tendrás que crear o retocar algún fichero más para que funcionen.

La sintaxis de los dos tipos, en general:

from alchemy.potions import algo   # absoluto: desde la raíz de sys.path
from ..potions import algo         # relativo: un punto = este paquete, dos = el padre
Qué te obliga a aprender — La pregunta que deja el propio enunciado: ¿cuándo conviene cada ruta? El import absoluto es explícito y se lee igual desde cualquier sitio; el relativo no depende del nombre del paquete (puedes renombrarlo o moverlo sin tocar sus tripas), pero solo funciona dentro de un paquete: si ejecutas un módulo con imports relativos como script suelto, Python no sabe cuál es su «paquete padre» y falla. La PEP 8 recomienda los absolutos y acepta los relativos explícitos en paquetes complejos. También verás que importar alchemy no hace aparecer alchemy.transmutation salvo que algún __init__.py lo traiga.

IVAvoid the Explosion

Entrega: alchemy/grimoire/ (__init__.py, light_spellbook.py, light_validator.py, dark_spellbook.py, dark_validator.py), ft_kaboom_0.py, ft_kaboom_1.py

Dos módulos que se necesitan mutuamente. El spellbook tiene la lista de ingredientes permitidos y light_spell_record(spell_name: str, ingredients: str), que decide si registra o rechaza el hechizo según lo que diga el validador. El validator tiene validate_ingredients(ingredients: str), que devuelve los ingredientes y «VALID» o «INVALID»: válidos si incluyen al menos uno de los permitidos por el spellbook, sin distinguir mayúsculas. La magia de luz usa «earth», «air», «fire» y «water»; la oscura, en copias renombradas de los dos ficheros, «bats», «frogs», «arsenic» y «eyeball».

Qué te obliga a aprender — Por qué un import circular falla a veces y a veces no. Cuando A importa B y B importa A, Python no entra en bucle: al empezar a ejecutar A ya lo ha registrado en sys.modules, así que B recibe un módulo A a medio inicializar. Si B solo necesita el módulo, puede salir bien; si pide un nombre concreto con from A import nombre y ese nombre aún no se ha definido, salta ImportError: cannot import name … from partially initialized module. Las salidas habituales son conceptuales: reorganizar (sacar lo compartido a un tercer módulo del que dependan ambos), retrasar el import a dentro de la función que lo usa, o importar el módulo y acceder al atributo en el momento de usarlo. El enunciado te pide demostrar a la vez la versión que funciona y la que revienta.

Puntos delicados del Codex

Bloque 2 — Module 06 bis: Code Nexus

De las clases a la arquitectura — En 2087, en un Neo-Tokio de fibra cuántica, un sistema recibe flujos de datos de tipos muy distintos y tiene que tratarlos con el mismo código. El enunciado tiene dos movimientos. Los ejercicios 0–2 son los cimientos: una jerarquía abstracta con abc.ABC, un flujo que reparte cada dato a quien sepa procesarlo (polimorfismo de subtipos) y un sistema de plugins basado en typing.Protocol (tipado estructural, el «duck typing» comprobado por mypy). Los ejercicios 3–4 son la arquitectura: un arenero de combate donde se aprenden tres patrones del libro de la «Banda de los Cuatro» (Design Patterns, 1994) y de la práctica diaria: la factoría abstracta, las capacidades como clases abstractas aparte y la estrategia. Solo se pueden importar abc y typing, y el enunciado pide que la gestión de excepciones proteja los flujos de datos.

Árbol final: data_processor.py, data_stream.py y data_pipeline.py sueltos en la raíz (cada uno mejora el anterior); los paquetes ex3/ y ex4/, cada uno con su __init__.py obligatorio; y los scripts de prueba battle.py, capacitor.py y tournament.py, también en la raíz.

ex0data_processor

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

Una clase abstracta DataProcessor (hereda de ABC) con dos métodos abstractos y uno normal, y tres subclases: NumericProcessor, TextProcessor y LogProcessor.

El numérico acepta int, float y listas de ambos (mezclados incluidos); el de texto, str y listas de cadenas; el de logs, diccionarios de cadena a cadena y listas de ellos. Todos guardan cada elemento por separado, como texto. La prueba debe crear los tres, validar datos buenos y malos, forzar al menos una ingesta inválida sin validar (que deja un aviso de mypy a propósito) e ir extrayendo con output.

La sintaxis general de una clase abstracta:

from abc import ABC, abstractmethod

class Forma(ABC):
    @abstractmethod
    def area(self) -> float: ...
Qué te obliga a aprender — Qué impide de verdad una clase abstracta: no puedes instanciar DataProcessor ni una subclase que olvide implementar algún método abstracto; Python lo comprueba al crear el objeto. Y una sutileza de tipos que mypy vigila: estrechar los parámetros de un método redefinido (aceptar menos que el padre) rompe el principio de sustitución de Liskov. El enunciado te hace hacerlo a propósito en ingest y mantenerlo en validate, para que veas la diferencia. Y una cola FIFO: lo primero que entra es lo primero que sale.

ex1data_stream

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

Partiendo del ex0, una clase DataStream con tres métodos de firma impuesta:

La prueba registra al principio solo el numérico, de modo que textos y logs dan error; luego registra los demás, reenvía el lote, consume algunos elementos y vuelve a mostrar estadísticas.

Qué te obliga a aprender — La pregunta del enunciado: ¿cómo puede DataStream manejar tipos distintos sin conocer sus implementaciones? Porque solo habla con la interfaz de DataProcessor (validate, ingest, output) y cada objeto responde a su manera. Añadir un procesador nuevo no obliga a tocar DataStream: eso es el principio abierto/cerrado en la práctica.

ex2data_pipeline

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

Ahora la salida. Una clase ExportPlugin que hereda de Protocol y fija un único método: process_output(self, data: list[tuple[int, str]]) -> None (la lista de tuplas coincide con lo que devuelve output). DataStream gana output_pipeline(self, nb: int, plugin: ExportPlugin) -> None, que consume nb elementos de cada procesador registrado y los pasa al plugin. Hay que crear al menos un plugin CSV y uno JSON, generando el texto a mano, sin importar módulos para ello.

from typing import Protocol

class Volador(Protocol):
    def volar(self) -> None: ...   # cualquier clase con volar() encaja, sin heredar
Qué te obliga a aprender — La pregunta con la que cierra el ejercicio: DataProcessor es una ABC y ExportPlugin un Protocol; los dos imponen qué debe tener una clase, pero de forma distinta. La ABC es nominal: hay que heredar de ella explícitamente. El Protocol es estructural: cualquier clase con el método adecuado lo cumple, aunque no sepa que existe, y es mypy quien lo comprueba. Para un sistema de plugins eso es oro: un tercero puede escribir un exportador sin depender de tu código. Y de paso, que CSV y JSON tienen reglas de formato (comas, comillas, escapes) que conviene respetar cuando los generas a mano.

ex3Entity Factories and Capabilities

Entrega: battle.py, capacitor.py, ex3/ como paqueteAutorizado: builtins, tipos estándar, typing, abc

Dentro de ex3/:

Los nombres pueden cambiar si se mantienen los patrones. battle.py prueba cada factoría con una función que crea base y evolucionada, las describe y ataca, y otra que enfrenta las bases de dos factorías. capacitor.py recorre describir, atacar, transformar, atacar otra vez y revertir.

Qué te obliga a aprender — Dos preguntas que una jerarquía sola no responde. Quién crea los objetos: con una factoría abstracta el código que usa criaturas nunca nombra la clase concreta, solo pide «la base» o «la evolucionada» de una familia. Cómo dar una habilidad a algunos tipos sin imponérsela a todos: una clase abstracta aparte combinada por herencia múltiple (lo que en otros lenguajes sería una interfaz o un mixin). La pregunta del enunciado: ¿qué se rompería si transform y revert estuvieran en Creature?

ex4Abstract Strategy

Entrega: tournament.py, ex4/ como paqueteAutorizado: builtins, tipos estándar, typing, abc

En ex4/, una ABC BattleStrategy con act e is_valid abstractos (is_valid dice si una criatura sirve para esa estrategia; act lo llama el torneo) y al menos dos estrategias: NormalStrategy, válida para cualquiera, que solo ataca, y AggressiveStrategy, para criaturas con la capacidad de transformarse, que transforma, ataca y revierte. Si se llama a act con una criatura no válida, se lanza una excepción propia con un mensaje claro. Las estrategias comprueban capacidades con isinstance, nunca la familia concreta.

tournament.py crea factorías del ex3 y estrategias, y define una única función de combate que recibe una lista de rivales —tuplas de (CreatureFactory, BattleStrategy)—, enfrenta a cada uno con todos los demás una vez y aborta el torneo ante una pareja criatura-estrategia inválida.

Qué te obliga a aprender — El patrón estrategia: sacar el «cómo se comporta» a un objeto intercambiable. El torneo no pregunta nunca a qué familia pertenece cada criatura y aun así cada una pelea distinto: la decisión se ha mudado a la estrategia. El día que aparezca una capacidad nueva, se añade una estrategia y el torneo no cambia. También practica crear tu propia clase de excepción y recorrer todas las parejas de una lista sin repetir combates.

Puntos delicados del Code Nexus

Fuente

Los dos enunciados solo existen en inglés. Slugs de la intra: python-module-06 y python-module-06-bis.