quipus-generate 0.1.0__tar.gz

quipus_generate-0.1.0/PKG-INFO

@@ -0,0 +1,8 @@
+Metadata-Version: 2.1
+Name: quipus-generate
+Version: 0.1.0
+Summary: Generador de proyectos FastAPI con arquitectura Hexagonal.
+Author: Juan Corrales
+Author-email: sistemas@amauttasistems.com
+License-File: LICENSE
+Requires-Dist: inflection

quipus_generate-0.1.0/project/cli.py

@@ -0,0 +1,49 @@
+import argparse
+
+from microservice_generator import create as microservice
+from docker_modified import modify as docker_modify
+from migration_generator import create as migration
+from readme_modified import modify as readme_modify
+from main_modified import modify as main_modify
+from proyect_generator import create as project
+from entity_generator import create as entity
+from site_generator import create as site
+
+def main():
+    parser = argparse.ArgumentParser(description="Generador de proyectos FastAPI con docker-compose y base de datos postgres.")
+    subparsers = parser.add_subparsers(dest="accion", required=True, help="Acciones disponibles.")
+    # Comando para inicializar un nuevo proyecto
+    init_parser = subparsers.add_parser("init", help="Iniciar un nuevo proyecto.")
+    init_parser.add_argument("name", help="Nombre del proyecto.")
+
+    # Comando para crear un microservicio
+    microservice_parser = subparsers.add_parser("microservice", help="Crear un microservicio con Arquitectura Hexagonal.")
+    microservice_parser.add_argument("name", help="Nombre del microservicio.")
+    microservice_parser.add_argument("entity", help="Nombre de la entidad.")
+
+    # Comando para crear una entity
+    entity_parser = subparsers.add_parser("entity", help="Crear una entity con Arquitecura Hexagonal.")
+    entity_parser.add_argument("name", help="Nombre de la entity.")
+
+    args = parser.parse_args()
+
+    if args.accion == "init":
+        project(args.name)
+
+    elif args.accion == "microservice":
+        microservice(args.name)
+        docker_modify(args.name)
+        site(args.name)
+        entity(args.entity, args.name)
+        migration(args.entity, args.name)
+        main_modify(args.entity, args.name)
+        readme_modify(args.entity, args.name)
+
+    elif args.accion == "entity":
+        entity(args.name)
+        migration(args.name)
+        main_modify(args.name)
+        readme_modify(args.name)
+
+if __name__ == "__main__":
+    main()

quipus_generate-0.1.0/project/docker_modified.py

@@ -0,0 +1,44 @@
+import os
+
+def modify(name):
+    compose_file = "docker-compose.yaml"
+
+    block = (
+        f"  {name}:\n"
+        "    build:\n"
+        f"      context: ./{name}\n"
+        "      dockerfile: Dockerfile\n"
+        f"    container_name: {name}-service\n"
+        "    volumes:\n"
+        f"      - ./{name}:/app\n"
+        "    command: uvicorn app.main:run --host 0.0.0.0 --port ${SERVICE_PORT} --reload\n"
+        "    networks:\n"
+        "      - quipus-network\n"
+        "    expose:\n"
+        "      - ${SERVICE_PORT}\n"
+        "    depends_on:\n"
+        "      - db\n"
+    )
+
+    # Leer el contenido actual
+    with open(compose_file, "r") as f:
+        lines = f.readlines()
+
+    # Buscar el índice de la línea que contiene el servicio nginx
+    insert_index = None
+    for i, line in enumerate(lines):
+        if line.strip().startswith("nginx:") and line.startswith("  "):  # indentación 2 espacios
+            insert_index = i
+            break
+
+    # Insertar el bloque antes de nginx si no está presente
+    if insert_index is not None:
+        if f"{name}:" not in "".join(lines):  # Evitar insertar duplicado
+            lines.insert(insert_index, block)
+            with open(compose_file, "w") as f:
+                f.writelines(lines)
+            print(f"✅ Servicio '{name}' insertado correctamente antes de 'nginx'")
+        else:
+            print(f"ℹ️ El servicio '{name}' ya existe en el archivo docker-compose.yaml")
+    else:
+        print("❌ No se encontró el servicio 'nginx:' en el archivo")

quipus_generate-0.1.0/project/entity_generator.py

@@ -0,0 +1,425 @@
+import inflection
+import os
+
+def create(name, microservice = None):
+
+    estructura = [
+        "application/services",
+        "application/use_cases",
+        "domain/entities",
+        "domain/repositories",
+        "domain/value_objects",
+        "infrastructure/dto",
+        "infrastructure/models",
+        "infrastructure/repositories",
+        "infrastructure/routers",
+    ]
+
+    archivos = {
+        f"application/services/{name}_service.py":(
+            "from typing import List, Optional, Dict, Any\n"
+            "\n"
+            f"from app.{name}.domain.repositories.{name}_repository import {name.capitalize()}Repository\n"
+            f"from app.{name}.domain.entities.{name} import {name.capitalize()}\n"
+            "\n"
+            f"class {name.capitalize()}Service:\n"
+            f"    def __init__(self, repository: {name.capitalize()}Repository):\n"
+            "        self.repository = repository\n"
+            "\n"
+            "    def list(self,\n"
+            "            trashed: int,\n"
+            "            paginate: int,\n"
+            "            page: int,\n"
+            "            rows: int,\n"
+            "            filters: Optional[Dict[str, Any]] = None\n"
+            f"        ) -> List[{name.capitalize()}]:\n"
+            "        return self.repository.all(trashed, paginate, page, rows, filters)\n"
+            "\n"
+            f"    def search(self, id: str) -> Optional[{name.capitalize()}]:\n"
+            "        return self.repository.find(id)\n"
+            "\n"
+            f"    def save(self, {name}: {name.capitalize()}) -> {name.capitalize()}:\n"
+            f"        return self.repository.create({name})\n"
+            "\n"
+            f"    def modify(self, id: str, {name}: {name.capitalize()}) -> Optional[{name.capitalize()}]:\n"
+            f"        return self.repository.update(id, {name})\n"
+            "\n"
+            f"    def remove(self, id: str) -> Optional[{name.capitalize()}]:\n"
+            "        return self.repository.delete(id)\n"
+        ),
+        f"application/use_cases/create_{name}.py":(
+            f"from app.{name}.application.services.{name}_service import {name.capitalize()}Service\n"
+            f"from app.{name}.domain.entities.{name} import {name.capitalize()}\n"
+            "\n"
+            f"class Create{name.capitalize()}:\n"
+            f"    def __init__(self, service: {name.capitalize()}Service):\n"
+            "        self.service = service\n"
+            "\n"
+            f"    def execute(self, {name}: {name.capitalize()}) -> {name.capitalize()}:\n"
+            f"        return self.service.save({name})\n"
+        ),
+        f"application/use_cases/delete_{name}.py":(
+            "from typing import Optional\n"
+            "\n"
+            f"from app.{name}.application.services.{name}_service import {name.capitalize()}Service\n"
+            f"from app.{name}.domain.entities.{name} import {name.capitalize()}\n"
+            "\n"
+            f"class Delete{name.capitalize()}:\n"
+            f"    def __init__(self, service: {name.capitalize()}Service):\n"
+            "        self.service = service\n"
+            "\n"
+            f"    def execute(self, id: str) -> Optional[{name.capitalize()}]:\n"
+            "        return self.service.remove(id)\n"
+        ),
+        f"application/use_cases/get_{inflection.pluralize(name)}.py":(
+            "from typing import List, Optional, Dict, Any\n"
+            "\n"
+            f"from app.{name}.application.services.{name}_service import {name.capitalize()}Service\n"
+            f"from app.{name}.domain.entities.{name} import {name.capitalize()}\n"
+            "\n"
+            f"class Get{ inflection.pluralize(name).capitalize()}:\n"
+            f"    def __init__(self, service: {name.capitalize()}Service):\n"
+            "        self.service = service\n"
+            "\n"
+            "    def execute(self,\n"
+            "                trashed: int,\n"
+            "                paginate: int,\n"
+            "                page: int,\n"
+            "                rows: int,\n"
+            "                filters: Optional[Dict[str, Any]] = None\n"
+            f"        ) -> List[{name.capitalize()}]:\n"
+            "        return self.service.list(trashed, paginate, page, rows, filters)\n"
+        ),
+        f"application/use_cases/get_{name}_by_id.py":(
+            "from typing import Optional\n"
+            "\n"
+            f"from app.{name}.application.services.{name}_service import {name.capitalize()}Service\n"
+            f"from app.{name}.domain.entities.{name} import {name.capitalize()}\n"
+            "\n"
+            f"class Get{name.capitalize()}ById:\n"
+            f"    def __init__(self, service: {name.capitalize()}Service):\n"
+            "        self.service = service\n"
+            "\n"
+            f"    def execute(self, id: str) -> Optional[{name.capitalize()}]:\n"
+            "        return self.service.search(id)\n"
+        ),
+        f"application/use_cases/update_{name}.py":(
+            "from typing import Optional\n"
+            "\n"
+            f"from app.{name}.application.services.{name}_service import {name.capitalize()}Service\n"
+            f"from app.{name}.domain.entities.{name} import {name.capitalize()}\n"
+            "\n"
+            f"class Update{name.capitalize()}:\n"
+            f"    def __init__(self, service: {name.capitalize()}Service):\n"
+            "        self.service = service\n"
+            "\n"
+            f"    def execute(self, id: str, {name}: {name.capitalize()}) -> Optional[{name.capitalize()}]:\n"
+            f"        return self.service.modify(id, {name})\n"
+
+        ),
+        f"domain/entities/{name}.py":(
+            "from pydantic import BaseModel, Field\n"
+            "\n"
+            "# import value objects\n"
+            f"from app.{name}.domain.value_objects.datetime import DateTime\n"
+            "\n"
+            f"class {name.capitalize()}(BaseModel):\n"
+            f"    id: str = Field(..., description=\"Unique identifier for the {name}\")\n"
+            f"    # field: str = Field(..., description=\"field of the {name}\")\n"
+            f"    example: str = Field(..., description=\"Example field\")\n"
+            f"    created_at: DateTime = Field(..., description=\"Timestamp when the {name} was created\")\n"
+            f"    updated_at: DateTime = Field(..., description=\"Timestamp when the {name} was last updated\")\n"
+            f"    deleted_at: DateTime = Field(None, description=\"Timestamp when the {name} was deleted\")\n"
+        ),
+        f"domain/repositories/{name}_repository.py":(
+            "from typing import List, Optional, Dict, Any\n"
+            "from abc import ABC, abstractmethod\n"
+            "\n"
+            f"from app.{name}.domain.entities.{name} import {name.capitalize()}\n"
+            "\n"
+            f"class {name.capitalize()}Repository(ABC):\n"
+            "    @abstractmethod\n"
+            "    def all(self,\n"
+            "            trashed: int,\n"
+            "            paginate: int,\n"
+            "            page: int,\n"
+            "            rows: int,\n"
+            "            filters: Optional[Dict[str, Any]] = None\n"
+            f"        ) -> List[{name.capitalize()}]:\n"
+            "        pass\n"
+            "\n"
+            "    @abstractmethod\n"
+            f"    def find(self, id: str) -> Optional[{name.capitalize()}]:\n"
+            "        pass\n"
+            "\n"
+            "    @abstractmethod\n"
+            f"    def create(self, {name}: {name.capitalize()}) -> {name.capitalize()}:\n"
+            "        pass\n"
+            "\n"
+            "    @abstractmethod\n"
+            f"    def update(self, id:str, {name}: {name.capitalize()}) -> Optional[{name.capitalize()}]:\n"
+            "        pass\n"
+            "\n"
+            "    @abstractmethod\n"
+            f"    def delete(self, id: str) -> Optional[{name.capitalize()}]:\n"
+            "        pass\n"
+        ),
+        f"domain/value_objects/datetime.py":(
+            "from pydantic import BaseModel, Field, field_validator\n"
+            "from datetime import datetime\n"
+            "\n"
+            "class DateTime(BaseModel):\n"
+            "    \"\"\"\n"
+            "    DateTime represents a date and time value in the system.\n"
+            "    It is a value object that encapsulates the date and time information.\n"
+            "    \"\"\"\n"
+            "\n"
+            "    datetime: str = Field(..., description=\"Date and time value\")\n"
+            "\n"
+            "    @field_validator(\"datetime\")\n"
+            "    def validate_datetime(cls, value: str) -> None:\n"
+            "        \"\"\"\n"
+            "        Validar que el formato de la feha y hora se Y-m-d H:M:S. o vacio.\n"
+            "        \"\"\"\n"
+            "        try:\n"
+            "            if value != \"\":\n"
+            "                datetime.strptime(value, \"%Y-%m-%dT%H:%M:%S.%fZ\")\n"
+            "        except ValueError:\n"
+            "            raise ValueError(\"El formato de fecha y hora no es válido. Debe ser YYYY-MM-DDTHH:MM:SSZ.\")\n"
+            "\n"
+            "    def __eq__(self, other: object) -> bool:\n"
+            "        return isinstance(other, DateTime) and self.datetime == other.datetime\n"
+            "\n"
+            "    def __str__(self) -> str:\n"
+            "        return self.datetime.isoformat()  # Returns the ISO format of the datetime\n"
+            "\n"
+            "    class Config:\n"
+            "        json_schema_extra = {\n"
+            "            \"example\": {\n"
+            "                \"datetime\": \"2023-10-01 12:00:00\"\n"
+            "            }\n"
+            "        }\n"
+        ),
+        f"infrastructure/dto/input_{name}.py":(
+            "from pydantic import BaseModel, Field\n"
+            "\n"
+            "# import value objects\n"
+            "\n"
+            f"class Input{name.capitalize()}(BaseModel):\n"
+            "    example: str = Field(..., description=\"Example field\")\n"
+        ),
+        f"infrastructure/models/{name}_model.py":(
+            "from typing import Optional, List\n"
+            "import uuid\n"
+            "\n"
+            "from sqlalchemy import Column, String, DateTime\n"
+            "from sqlalchemy.dialects.postgresql import UUID\n"
+            "from sqlalchemy.sql import func\n"
+            "import uuid\n"
+            "\n"
+            "from config.database import Base\n"
+            "\n"
+            f"class {name.capitalize()}Model(Base):\n"
+            f"    __tablename__ = \"{inflection.pluralize(name)}\"\n"
+            "\n"
+            "    # id es de tipo uuid\n"
+            "    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, index=True)\n"
+            "    example = Column(String, unique=True, index=True, nullable=False)\n"
+            "    created_at = Column(DateTime, server_default=func.now(), nullable=False)\n"
+            "    updated_at = Column(DateTime(timezone=True), default=func.now(), onupdate=func.now(), nullable=False)\n"
+            "    deleted_at = Column(DateTime, nullable=True)\n"
+            "\n"
+            "    def to_dict(self, include: Optional[List[str]] = None) -> dict:\n"
+            "        data = {\n"
+            "            \"id\": str(self.id),\n"
+            "            \"example\": self.example,\n"
+            "            \"deleted_at\": self.deleted_at\n"
+            "        }\n"
+            "\n"
+            "        if include:\n"
+            "            return {k: v for k, v in data.items() if k in include}\n"
+            "        return data\n"
+        ),f"infrastructure/repositories/{name}_repository_impl.py":(
+            "from typing import List, Optional, Dict, Any\n"
+            "from datetime import datetime\n"
+            "\n"
+            "from app.Traits.filters import Filterable\n"
+            "\n"
+            f"from app.{name}.domain.repositories.{name}_repository import {name.capitalize()}Repository\n"
+            f"from app.{name}.infrastructure.models.{name}_model import {name.capitalize()}Model\n"
+            f"from app.{name}.domain.entities.{name} import {name.capitalize()}\n"
+            "\n"
+            f"class {name.capitalize()}RepositoryImpl({name.capitalize()}Repository):\n"
+            "    def __init__(self, db):\n"
+            "        self.db = db\n"
+            "        self.filterable = Filterable()\n"
+            "\n"
+            "    def all(self,\n"
+            "            trashed: int,\n"
+            "            paginate: int,\n"
+            "            page: int,\n"
+            "            rows: int,\n"
+            "            filters: Optional[Dict[str, Any]] = None\n"
+            f"        ) -> List[{name.capitalize()}]:\n"
+            "\n"
+            f"        query = self.db.query({name.capitalize()}Model)\n"
+            "\n"
+            "        columns_change = {\n"
+            f"            'example': {name.capitalize()}Model.example,\n"
+            "        }\n"
+            "\n"
+            "        if trashed == 0:\n"
+            f"            query = query.filter({name.capitalize()}Model.deleted_at.is_(None))\n"
+            "\n"
+            "        if filters:\n"
+            "            query = self.filterable.apply_filters(query, filters, columns_change)\n"
+            "\n"
+            "        if paginate == 1:\n"
+            "            total = query.count()\n"
+            "            ofset = (page - 1) * rows\n"
+            "            items = query.ofset(ofset).limit(rows).all()\n"
+            "        else:\n"
+            "            items = query.all()\n"
+            "            total = len(items)\n"
+            "\n"
+            "        data = [item.to_dict() for item in items]\n"
+            "\n"
+            "        return {\n"
+            "            'total': total,\n"
+            "            'data':  data,\n"
+            "        }\n"
+            "\n"
+            f"    def find(self, id: str) -> Optional[{name.capitalize()}]:\n"
+            f"        return self.db.query({name.capitalize()}Model).filter_by(id=id).first()\n"
+            "\n"
+            f"    def create(self, {name}: {name.capitalize()}) -> {name.capitalize()}:\n"
+            "        try:\n"
+            f"            {name}_model = {name.capitalize()}Model(**{name}.model_dump())\n"
+            f"            self.db.add({name}_model)\n"
+            "            self.db.commit()\n"
+            f"            self.db.refresh({name}_model)\n"
+            f"            return {name}_model\n"
+            "        except Exception as e:\n"
+            "            self.db.rollback()\n"
+            "            raise e\n"
+            "\n"
+            f"    def update(self, id: str, {name}: {name.capitalize()}) -> Optional[{name.capitalize()}]:\n"
+            f"        existing_{name} = self.find(id)\n"
+            f"        if existing_{name}:\n"
+            f"            for key, value in {name}.model_dump(exclude_unset=True).items():\n"
+            f"                setattr(existing_{name}, key, value)\n"
+            "            self.db.commit()\n"
+            f"            self.db.refresh(existing_{name})\n"
+            f"            return existing_{name}\n"
+            "        return None\n"
+            "\n"
+            f"    def delete(self, id: str) -> Optional[{name.capitalize()}]:\n"
+            f"        {name} = self.find(id)\n"
+            "\n"
+            f"        if {name} and {name}.deleted_at is None:\n"
+            f"            {name}.deleted_at = datetime.now()\n"
+            "            self.db.commit()\n"
+            f"            self.db.refresh({name})\n"
+            f"        elif {name} and {name}.deleted_at is not None:\n"
+            f"            {name}.deleted_at = None\n"
+            "            self.db.commit()\n"
+            f"            self.db.refresh({name})\n"
+            "\n"
+            f"        return {name}\n"
+        ),
+        f"infrastructure/routers/{name}_router.py":(
+            "from fastapi import APIRouter, Depends\n"
+            "from sqlalchemy.orm import Session\n"
+            "from uuid import UUID\n"
+            "\n"
+            f"from app.{name}.infrastructure.repositories.{name}_repository_impl import {name.capitalize()}RepositoryImpl\n"
+            f"from app.{name}.application.services.{name}_service import {name.capitalize()}Service\n"
+            "\n"
+            f"from app.{name}.application.use_cases.get_{name}_by_id import Get{name.capitalize()}ById\n"
+            f"from app.{name}.application.use_cases.create_{name} import Create{name.capitalize()}\n"
+            f"from app.{name}.application.use_cases.delete_{name} import Delete{name.capitalize()}\n"
+            f"from app.{name}.application.use_cases.update_{name} import Update{name.capitalize()}\n"
+            f"from app.{name}.application.use_cases.get_{inflection.pluralize(name)} import Get{inflection.pluralize(name).capitalize()}\n"
+            "\n"
+            "from app.components.filter.infrastructure.dto.input_filter import InputFilter\n"
+            f"from app.{name}.infrastructure.dto.input_{name} import Input{name.capitalize()}\n"
+            "\n"
+            "from config.database import database\n"
+            "\n"
+            f"class {name.capitalize()}API:\n"
+            "    def __init__(self):\n"
+            f"        self.router = APIRouter(prefix=\"/{name}\", tags=[\"{name.capitalize()}\"])\n"
+            "        self._setup_routes()\n"
+            "\n"
+            "    def _setup_routes(self):\n"
+            f"        self.router.get(\"\")(self.get_{name})\n"
+            f"        self.router.get(\"/{{id}}\")(self.get_{name}_by_id)\n"
+            f"        self.router.post(\"\")(self.create_{name})\n"
+            f"        self.router.put(\"/{{id}}\")(self.update_{name})\n"
+            f"        self.router.delete(\"/{{id}}\")(self.delete_{name})\n"
+            "\n"
+            f"    async def get_{name}(self, payload: InputFilter = Depends(InputFilter.from_request_body), db: Session = Depends(database.get_db)):\n"
+            f"        repository = {name.capitalize()}RepositoryImpl(db)\n"
+            f"        service = {name.capitalize()}Service(repository)\n"
+            f"        use_case = Get{inflection.pluralize(name).capitalize()}(service)\n"
+            "        categories = use_case.execute(**payload.model_dump())\n"
+            "        return categories\n"
+            "\n"
+            f"    def get_{name}_by_id(self, id: UUID, db: Session = Depends(database.get_db)):\n"
+            f"        repository = {name.capitalize()}RepositoryImpl(db)\n"
+            f"        service = {name.capitalize()}Service(repository)\n"
+            f"        use_case = Get{name.capitalize()}ById(service)\n"
+            f"        {name} = use_case.execute(id)\n"
+            f"        return {name}\n"
+            "\n"
+            f"    def create_{name}(self, {name}: Input{name.capitalize()}, db: Session = Depends(database.get_db)):\n"
+            f"        repository = {name.capitalize()}RepositoryImpl(db)\n"
+            f"        service = {name.capitalize()}Service(repository)\n"
+            f"        use_case = Create{name.capitalize()}(service)\n"
+            f"        created_{name} = use_case.execute({name})\n"
+            f"        return created_{name}\n"
+            "\n"
+            f"    def update_{name}(self, id: UUID, {name}: Input{name.capitalize()}, db: Session = Depends(database.get_db)):\n"
+            f"        repository = {name.capitalize()}RepositoryImpl(db)\n"
+            f"        service = {name.capitalize()}Service(repository)\n"
+            f"        use_case = Update{name.capitalize()}(service)\n"
+            f"        updated_{name} = use_case.execute(id, {name})\n"
+            f"        return updated_{name}\n"
+            "\n"
+            f"    def delete_{name}(self, id: UUID, db: Session = Depends(database.get_db)):\n"
+            f"        repository = {name.capitalize()}RepositoryImpl(db)\n"
+            f"        service = {name.capitalize()}Service(repository)\n"
+            f"        use_case = Delete{name.capitalize()}(service)\n"
+            f"        deleted_{name} = use_case.execute(id)\n"
+            f"        return deleted_{name}\n"
+            "\n"
+            f"router = {name.capitalize()}API().router\n"
+        )
+    }
+
+    if microservice is not None:
+        path = f"{microservice}/app/{name}"
+    else:
+        path = f"app/{name}"
+
+    # Si la entidad ya existe, no la crea
+    if os.path.exists(path):
+        print(f"ℹ️ La entidad {name} ya existe.")
+        return
+
+    if microservice is not None:
+        os.makedirs(microservice + '/app/' + name, exist_ok=True)
+    else:
+        os.makedirs(path, exist_ok=True)
+
+    # Crear subdirectorios
+    for carpeta in estructura:
+        os.makedirs(os.path.join(path, carpeta), exist_ok=True)
+
+    # Crear archivos vacíos
+    for archivo, content in archivos.items():
+        ruta_archivo = os.path.join(path, archivo)
+        with open(ruta_archivo, "w") as f:
+            f.write(content)
+
+    print(f"✅ Entidad {name} creada con éxito.")

quipus_generate-0.1.0/project/main_modified.py

@@ -0,0 +1,46 @@
+import os
+
+def modify(name, microservice=None):
+
+    if microservice is not None:
+        main_file = f"{microservice}/app/main.py"
+    else:
+        main_file = "app/main.py"
+
+    import_line = f"from app.{name}.infrastructure.routers.{name}_router import router as {name}_router\n"
+    router_line = f"run.include_router({name}_router, prefix=\"/api/v1\", tags=[\"{name.capitalize()}\"])\n"
+
+    # Leer contenido actual
+    with open(main_file, "r") as f:
+        lines = f.readlines()
+
+    # Verificar si ya existe
+    if import_line in lines and router_line in lines:
+        print("ℹ️ Las líneas ya están en main.py")
+    else:
+        # === 1. Insertar IMPORT si no existe ===
+        if import_line not in lines:
+            import_indices = [i for i, line in enumerate(lines) if line.startswith("import") or line.startswith("from")]
+            last_import_idx = import_indices[-1] if import_indices else 0
+            lines.insert(last_import_idx + 2, import_line + "\n")
+
+        # === 2. Insertar include_router en el lugar correcto ===
+        # Buscar todas las líneas que incluyen run.include_router
+        router_indices = [i for i, line in enumerate(lines) if "run.include_router" in line]
+
+        if router_indices:
+            # Insertar justo después del último include_router
+            last_router_idx = router_indices[-1]
+            if router_line not in lines:
+                lines.insert(last_router_idx + 1, router_line)
+        else:
+             # Si no hay ningún run.include_router, insertar al final del archivo
+            if not lines[-1].endswith("\n"):
+                lines[-1] += "\n"
+            lines.append("\n" + router_line)
+
+        # Guardar archivo actualizado
+        with open(main_file, "w") as f:
+            f.writelines(lines)
+
+        print("✅ main.py actualizado exitosamente.")