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.
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.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 Codex | Module 06 bis — Code Nexus | |
|---|---|---|
| Tema | El sistema de imports | ABC, polimorfismo, Protocol, factoría abstracta, estrategia |
| Versión | 2.0 | 1.0 |
| Imports permitidos | Solo los módulos que crees tú | abc y typing |
| Prohibición especial | Modificar sys.path | Librerías externas |
| Estructura | Un paquete alchemy/ y 13 scripts de prueba | Tres 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.
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
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:
ft_alembic_0 y _1: el elements.py de la raíz, con
import … y con from … import ….ft_alembic_2 y _3: alchemy/elements.py
directamente, con las mismas dos formas.ft_alembic_4: solo import alchemy. Desde ahí
create_air tiene que funcionar, pero create_earth
no debe estar expuesto: llamarla tiene que lanzar un AttributeError
(puedes capturarlo o dejar que salga) y mypy también protestará, a propósito.ft_alembic_5: from alchemy import … para crear aire.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»
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).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.
ft_distillation_0 accede a alchemy/potions.py con
from … import … y prepara las dos pociones.ft_distillation_1 solo hace import alchemy y usa
strength_potion y un heal() que es un alias de paquete
de la poción curativa: hay que ampliar __init__.py para que exista ese
nombre.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.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
alchemy no hace aparecer
alchemy.transmutation salvo que algún __init__.py lo traiga.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».
ft_kaboom_0 usa el módulo grimoire y registra un hechizo de
luz sin problemas: tú eliges cómo evitar la dependencia circular, y en la
evaluación tendrás que explicar las distintas formas de hacerlo.ft_kaboom_1 accede directamente a dark_spellbook.py y
debe explotar con un ImportError por import circular (capturado o
no, a tu elección).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.python3 ft_x.py desde ahí; esa carpeta es la que entra en
sys.path. Probar a ejecutar un módulo interno suelto es la forma más rápida de
ver por qué falla un import relativo.elements.py. El de la raíz y el de
alchemy/ se llaman igual; la ruta del import decide cuál se carga. Conviene
tener claro cuál ve cada fichero.__init__.py expone. En ft_alembic_4
el fallo de create_earth es parte del enunciado: si la exportas «por
comodidad», el ejercicio deja de demostrar lo que pide.__init__.py. El enunciado ya avisa
de que aparecerán avisos y pide resolverlos «según las convenciones habituales»; saber
explicar cuál usas y por qué forma parte de la defensa. El error de mypy de
ft_alembic_4, en cambio, es intencionado.sys.path. Está prohibido modificarlo, y solo se
pueden importar módulos creados en el propio proyecto.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.
Una clase abstracta DataProcessor (hereda de ABC) con dos
métodos abstractos y uno normal, y tres subclases: NumericProcessor,
TextProcessor y LogProcessor.
validate(self, data: Any) -> bool: dice si el procesador puede con ese
dato. Las subclases mantienen la misma firma, porque no saben qué les llegará.ingest(self, data: Any) -> None: procesa el dato. Aquí las subclases
sí cambian la firma para reflejar los tipos que aceptan, y si alguien llama a
ingest con un dato inválido sin validar antes, se lanza una excepción.output(self) -> tuple[int, str]: método común, sin redefinir, que saca
el dato más antiguo almacenado junto con su número de orden en ese procesador, y lo
elimina.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: ...
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.Partiendo del ex0, una clase DataStream con tres métodos de firma
impuesta:
register_processor(self, proc: DataProcessor) -> None: añade un
procesador.process_stream(self, stream: list[typing.Any]) -> None: recorre la
lista y manda cada elemento al procesador registrado que pueda con él; si ninguno puede,
imprime un mensaje de error.print_processors_stats(self) -> None: total procesado y pendiente por
procesador.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.
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.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
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.Dentro de ex3/:
Creature (ABC) con nombre y tipo, un método abstracto
attack y un método concreto describe que devuelve un mensaje
estándar con nombre y tipo.Flameling y Pyrodon.TransformCapability (ABC) con transform y
revert abstractos, que no hereda de Creature. Un
atributo guarda si está transformada y cambia lo que devuelve attack.Shiftling y
Morphagon.CreatureFactory (ABC) con create_base y
create_evolved, y dos factorías concretas: FlameFactory
(Flameling/Pyrodon) y TransformCreatureFactory (Shiftling/Morphagon).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.
transform y revert estuvieran en Creature?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.
validate, ingest, output,
register_processor, process_stream,
print_processors_stats, process_output y
output_pipeline.bool es un int. isinstance(True,
int) da True; al validar datos numéricos merece la pena decidir qué
hacer con los booleanos y saber explicarlo.int y float; conviene pensar qué pasa con una lista vacía o con
una que trae un elemento de otro tipo.ex3 solo debe ofrecer factorías;
es justo lo que el Module 06 clásico enseña con __init__.py.packs/cursus/M2/208_Python_Module_06/en.subject.pdf (texto en
subject.txt).packs/cursus/M2/208_Python_Module_06/bis.en.subject.pdf
(texto en subject_bis.txt).Los dos enunciados solo existen en inglés. Slugs de la intra:
python-module-06 y python-module-06-bis.