MetsuOS

Construyendo la plena inclusión a través del videojuego

Elegimos exactamente qué partes de Poetry vamos a usar en MetsuDepManager 🟡③

Elegimos exactamente qué partes de Poetry vamos a usar en MetsuDepManager

Curso sobre desarrollo de un gestor de paquetes python que use poetry como backend 🟡③

En este punto ya sabemos que no vamos a reinventar la rueda. Vamos a reutilizar lo mejor de Poetry, pero con control total: sin telemetría, con timeouts, con auditoría y funcionando en entornos air-gapped.

La decisión práctica que tomamos hoy (y que vamos a codificar ya mismo) es esta:

Necesidad Fuente elegida Motivo real (2025)
Resolver dependencias y generar lock poetry-core (API pura) Control total, timeout, objetos Python, sin stdout
Instalar paquetes en el venv poetry-core → Installer.run() Podemos inspeccionar cada paquete antes de instalarlo
Construir wheel/sdist poetry-core → Builder Inyectamos metadatos éticos y SBOM
Comandos rápidos que el usuario conoce binario poetry vía subprocess Estables y el usuario ya los sabe usar
Bloqueo de telemetría y auditoría automática plugin propio (metsudep-plugin-ethics) Se ejecuta solo, sin intervención del usuario

Hoy vamos a hacer tres cosas concretas (y las vamos a dejar funcionando):

1. El primer wrapper híbrido real (70 % poetry-core + 30 % subprocess)

Archivo: metsudep/core/backend.py

from __future__ import annotations
import subprocess
from pathlib import Path
from poetry.core.factory import Factory
from poetry.core.installation.installer import Installer
from poetry.core.execution.executor import Executor
from poetry.core.utils.env import VirtualEnv

class PoetryBackend:
    def __init__(self, cwd: Path | None = None):
        self.cwd = Path(cwd or Path.cwd())
        self.poetry = Factory().create_poetry(self.cwd)  # API pública y estable

    # 1. Operaciones rápidas → subprocess (más simple y estable)
    def lock_check(self) -> bool:
        result = subprocess.run(
            ["poetry", "lock", "--check"],
            cwd=self.cwd,
            capture_output=True,
            text=True,
            timeout=60,
        )
        return result.returncode == 0

    def export_requirements(self, output: Path, format: str = "requirements.txt") -> None:
        subprocess.run(
            ["poetry", "export", "-f", format, "-o", str(output), "--without-hashes"],
            check=True,
            cwd=self.cwd,
            timeout=120,
        )

    # 2. Operaciones críticas → poetry-core puro (control total)
    def install_with_audit(self, dry_run: bool = False) -> int:
        env = VirtualEnv(self.poetry.file.path.parent / ".venv")
        installer = Installer(
            io=self.poetry.io,          # puedes usar un IO custom para logs
            env=env,
            package=self.poetry.package,
            locker=self.poetry.locker,
            pool=self.poetry.pool,
            config=self.poetry.config,
            executor=Executor(env, self.poetry.pool, self.poetry.config),
        )
        installer.whitelist(["requests", "numpy"])  # ejemplo de política
        installer.verbose(True)
        return installer.run(dry_run=dry_run, timeout=300)

2. Clases públicas y estables de poetry-core en 2025

Estas son las que puedes importar sin miedo a que rompan en versiones menores (confirmado en el CHANGELOG oficial 2.2.0+):

Clase/Objeto Ruta de importación Uso recomendado en MetsuDepManager
Factory().create_poetry() poetry.core.factory.Factory Lectura de pyproject.toml y lock
Installer poetry.core.installation.installer.Installer Instalación con control total
Solver poetry.core.packages.dependency_solver.Solver Resolución personalizada
Builder poetry.core.masonry.api Build con SBOM y metadatos extra
Locker poetry.core.poetry.Locker Escritura/lectura segura del lock

3. La frontera definitiva que vas a usar desde hoy

Regla de oro (pégala en tu README interno):

┌─────────────────────────────────────────────────────────────────────────────────┐
│  ¿Necesitas timeout, cancelación o inspeccionar paquetes? → poetry-core         │
│  ¿Es un comando que el usuario final ya conoce y es idempotente? → subprocess   │
│  ¿Quieres que se ejecute siempre sin acordarte? → plugin                        │
└─────────────────────────────────────────────────────────────────────────────────┘

Con esto ya tienes el esqueleto funcional del backend híbrido que vas a ir enriqueciendo en los próximos módulos.

Referencias que apoyan este enfoque

  1. poetry-core API pública y estable 🟡③🌐 .- Implementación ligera y estable del backend de construcción PEP 517 para Poetry, versión 2.2.1 lanzada el 21 de septiembre de 2025, compatible con Python >=3.9.
  2. Real Python – Dependency Management with Poetry (2024, actualizado 2025) 🟡③🌐 .- Tutorial sobre gestión de dependencias con Poetry, cubriendo instalación, creación de proyectos, declaración de dependencias y entornos virtuales, actualizado en 2025.

Referencias que critican Poetry (para que tengas contraargumentos)

  1. “Why I stopped using Poetry” – ArjanCodes (2024) 🟡③🌐 .- Video explaining reasons for abandoning Poetry, including dependency conflicts, redundancy with pip and pip-tools, and loss of trust due to maintainer decisions on script deprecation.
  2. Comparativa 2025 uv vs Poetry – Medium (diciembre 2025) 🟡③🌐 .- Article comparing uv, Poetry, and pip-tools for Python dependency management in 2025, emphasizing tool selection based on workflow needs.

One More Thing

Un escenario de retrocomputación del siglo 24

¡Desbloquea el poder de MetsuOS y descubre que la privacidad y la seguridad son la clave para desencadenar tu verdadero potencial en línea!

Contenido registrado en Safe Creative

Logo Safe Creative
¡Usa el código de promocional 7ZYM4Z y ahorrate unos eurillos en tu suscripcion de Safe Creative!

MetsuOS Needs You!

Apoyanos en este proyecto difundiendolo en tus redes, o mejor, haznos una donación a la cuenta paypal para poder dedicar más tiempo y recursos a el. No olvides comentarnos que parete te interesa más junto con tu donación.

En este momento, además de mantener los servicios, estoy centrado en crear la siguiente iteración del software que me permite hacer todo esto y creando una biblioteca personal física para poder contrastar contenido.

Sobre el sistema de validez de un contenido en MetsuOS

Empezando a incorporar los niveles de validación de un contenido (también llamada sabiduría o niveles de conocimiento) ⚫🔴 🟡 🟢 🔵⚪ ¿Qué són?

Sobre la categorización de los tipos de conocimiento

La Metsukeología (de Metsuke vision global y logos conocimiento) es la ciencia que estudia el conocimiento como un conjunto potencial de conocimiento del que podemos obtener, procesar o percibir partes concretas dentro de un marco contextual específico, y cuyo contexto general real está muy por encima de lo que somos capaces, como especie, de percibir, procesar e integrar de forma completa (definición en progreso).

La Metsucología (de Metsu aniquilación - en este contexto en forma de colapso - , logos conocimiento) es la ciencia que estudia como extraemos verdades percibidas - colapsadas - como conocimiento desde nuestra perspectiva real (tanto epistemológico como gnoseológico) al tomar una parte específica del conocimiento metsukeológico potencial enmarcado en un contexto concreto, obligando a colapsar el conocimiento potencial en conocimiento específico (definición en progreso).

Mas sobre el contexto

DISCLAIMER: Mi consideración de anticientífico respecto al consenso científico es una hipotesis de trabajo propia, que supone que toda asignación de validez, incluso aquella derivada de la conclusión por acumulación de evidencia NO debe ser supeditada a debate, ni acuerdo, debe ser algo probabilistico sin intervención del ego humano. Podría estar equivocado y, en este punto, es donde se aplicaría entonces ese mismo consenso que ahora considero no valido (incluso dañino)

Existen indicadores para algunas cuestiones adicoinales como los siguientes:

Cuando hablamos de un contenido que incluye un texto que hace referencia a otro.

También aplicaremos el Sistema de fiabilidad de fuentes y credibilidad de contenidos de la OTAN 🔴②, este sistema incluye una valoración de la fiabilidad de la fuente de A a F (siendo A la de mayor fiabilidad) y una varloración de credibilidad del contenido de 1 a 6 (siendo 1 la mayor credibilidad).

En MetsuOS la agregaremos al final uniendo amos valores como si fuera una coordenada. Por ejemplo: ⚫①-D4 o 🟡③-B2. Esto ayudarña a contextualizar la información sobre la solidez del conocimiento al que se hace referencia en cada momento.

Hay que tener en cuenta que, cuando hay elementos subjetivos o parcialmente subjetivos, el punto de referencia seré yo mismo. Quizá más adelante pueda objetivizar esto más (seria lo deseable), pero en tanto no tenga herramientas que me lo permitan, debo ceñirme al principio de honestidar intelectual, y esperar que mis sesgos dañen lo menos posible la información (en parte este es el nudo gordiano que pretendo resolver, y por ello es dificil resolverlo a priori).

Así de forma resumida, podríamos decir que esta definición es nivel 🔴② (Rojo2 xD) ¿Crees que me dejo algo? Si es así por favor ayudame a mejorarlo contactándome a través de X (Twitter) en mi cuenta, @metsuke 🌐

Consulta la versión completa de la descripcion en ⚫🔴🟡🟢🔵⚪ (🔴②) Un poco más de detalle