chuopycore-cli 1.0.0__tar.gz

chuopycore_cli-1.0.0/MANIFEST.in

@@ -0,0 +1 @@
+recursive-include pycore/templates *

chuopycore_cli-1.0.0/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: chuopycore-cli
+Version: 1.0.0
+Requires-Dist: typer[all]
+Requires-Dist: jinja2
+Requires-Dist: rich
+Dynamic: requires-dist

chuopycore_cli-1.0.0/README.md

@@ -0,0 +1,75 @@
+# chuopycore-cli 🚀
+
+`chuopycore-cli` es una potente herramienta de interfaz de línea de comandos (CLI) escrita en Python, diseñada para acelerar el desarrollo de microservicios basados en **FastAPI**. Genera automáticamente una arquitectura profesional, escalable y lista para producción en segundos.
+
+## ✨ Características
+
+- **Scaffolding Profesional**: Estructura de carpetas optimizada para mantenibilidad.
+- **FastAPI Core**: Configuración avanzada con soporte para `lifespan` y middlewares.
+- **Docker-Ready**: Orquestación completa con Docker Compose.
+- **Arquitectura de DB Avanzada**:
+  - PostgreSQL con replicación **Master/Replica**.
+  - **PGBouncer** integrado para gestión eficiente de pool de conexiones.
+- **Migraciones**: Configuración de **Alembic** lista para usar.
+- **Gestión de Configuración**: Basada en `pydantic-settings` para manejo robusto de variables de entorno.
+- **Scripts de Automatización**: Script `startup.sh` que gestiona esperas de DB y ejecuciones de migraciones automáticas.
+
+## 🛠️ Instalación
+
+Para instalar la herramienta localmente en modo desarrollo:
+
+```bash
+pip install -e .
+```
+
+Esto registrará el comando `chuopycore` en tu sistema.
+
+## 🚀 Uso Académico y Práctico
+
+Para generar un nuevo microservicio, simplemente ejecuta:
+
+```bash
+chuopycore init mi-nuevo-servicio
+```
+
+### Opciones
+
+- `--db`, `-d`: Incluye toda la infraestructura de base de datos (PostgreSQL, PGBouncer, SQLAlchemy, Alembic).
+
+**Ejemplo de creación con base de datos:**
+
+```bash
+chuopycore init facturacion-service --db
+```
+
+## 📂 Estructura del Proyecto Generado
+
+El microservicio resultante seguirá este estándar:
+
+```text
+facturacion-service/
+├── app/
+│   ├── api/          # Routers y controladores
+│   ├── core/         # Configuración, excepciones y logs
+│   ├── db/           # Modelos y conexión a base de datos
+│   ├── schemas/      # Modelos Pydantic
+│   └── services/     # Lógica de negocio
+├── alembic/          # Historial de migraciones
+├── scripts/          # Scripts de utilidad
+├── tests/            # Pruebas unitarias e integración
+├── .env              # Variables de entorno
+├── dockerfile        # Construcción de imagen Docker
+├── docker-compose.yml # Orquestación de servicios
+└── startup.sh        # Script de inicialización
+```
+
+## 📝 Requisitos
+
+- Python 3.10+
+- Jinja2
+- Typer
+- Rich
+
+---
+
+Desarrollado con ❤️ para la estandarización de microservicios.

chuopycore_cli-1.0.0/chuopycore_cli.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: chuopycore-cli
+Version: 1.0.0
+Requires-Dist: typer[all]
+Requires-Dist: jinja2
+Requires-Dist: rich
+Dynamic: requires-dist

chuopycore_cli-1.0.0/chuopycore_cli.egg-info/SOURCES.txt

@@ -0,0 +1,30 @@
+MANIFEST.in
+README.md
+setup.py
+chuopycore_cli.egg-info/PKG-INFO
+chuopycore_cli.egg-info/SOURCES.txt
+chuopycore_cli.egg-info/dependency_links.txt
+chuopycore_cli.egg-info/entry_points.txt
+chuopycore_cli.egg-info/requires.txt
+chuopycore_cli.egg-info/top_level.txt
+pycore/__init__.py
+pycore/cli.py
+pycore/templates/.env.jinja
+pycore/templates/.gitignore.jinja
+pycore/templates/Dockerfile.jinja
+pycore/templates/alembic.ini.jinja
+pycore/templates/docker-compose.yml.jinja
+pycore/templates/requirements.txt.jinja
+pycore/templates/startup.sh.jinja
+pycore/templates/structure.json
+pycore/templates/app/main.py.jinja
+pycore/templates/app/api/routers.py.jinja
+pycore/templates/app/core/exceptions.py.jinja
+pycore/templates/app/core/logging.py.jinja
+pycore/templates/app/core/security.py.jinja
+pycore/templates/app/core/settings.py.jinja
+pycore/templates/app/db/database.py.jinja
+pycore/templates/app/db/models/models.py.jinja
+pycore/templates/app/schemas/schema.py.jinja
+pycore/templates/app/services/service.py.jinja
+pycore/templates/tests/test_main.py.jinja

chuopycore_cli-1.0.0/chuopycore_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

chuopycore_cli-1.0.0/chuopycore_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+chuopycore = pycore.cli:app

chuopycore_cli-1.0.0/chuopycore_cli.egg-info/requires.txt

@@ -0,0 +1,3 @@
+typer[all]
+jinja2
+rich

chuopycore_cli-1.0.0/chuopycore_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+pycore

chuopycore_cli-1.0.0/pycore/cli.py

@@ -0,0 +1,106 @@
+import typer
+import os
+from jinja2 import Environment, FileSystemLoader
+from rich.console import Console
+
+app = typer.Typer()
+console = Console()
+
+# Configuración de Jinja
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+TEMPLATE_DIR = os.path.join(BASE_DIR, 'templates')
+env = Environment(loader=FileSystemLoader(TEMPLATE_DIR))
+
+def create_file(template_path, context, output_path):
+    """Renderiza el template y lo guarda."""
+    try:
+        # Si el template está en subcarpeta, jinja lo busca relativo al root de templates
+        template = env.get_template(template_path)
+        content = template.render(context)
+        
+        dir_name = os.path.dirname(output_path)
+        if dir_name:
+            os.makedirs(dir_name, exist_ok=True)
+            
+        with open(output_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+    except Exception as e:
+        console.print(f"[red]Error procesando {template_path}: {e}[/red]")
+
+@app.command()
+def init(
+    name: str = typer.Argument(..., help="Nombre del proyecto"),
+    db: bool = typer.Option(False, "--db", "-d", help="Incluir Base de Datos (SQLAlchemy/Alembic)")
+):
+    """Genera la arquitectura base."""
+    base_path = os.path.join(os.getcwd(), name)
+    
+    if os.path.exists(base_path):
+        console.print(f"[bold red]❌ La carpeta {name} ya existe.[/bold red]")
+        raise typer.Exit()
+
+    console.print(f"🚀 Creando arquitectura en: [bold cyan]{name}[/bold cyan]")
+
+    # 1. Crear directorios vacíos necesarios (Estructura Base)
+    dirs = [
+        "alembic",
+        "app/api",
+        "app/core",
+        "app/db/models",
+        "app/schemas",
+        "app/services",
+        "scripts",
+        "tests",
+    ]
+    
+    for d in dirs:
+        os.makedirs(os.path.join(base_path, d), exist_ok=True)
+
+    # 2. Contexto para las plantillas
+    context = {
+        "project_name": name,
+        "with_db": db
+    }
+
+    # 3. Mapeo de Templates -> Archivo Destino
+    files_map = {
+        ".gitignore.jinja": ".gitignore",
+        ".env.jinja": ".env",
+        "requirements.txt.jinja": "requirements.txt",
+        "Dockerfile.jinja": "dockerfile",
+        "docker-compose.yml.jinja": "docker-compose.yml",
+        "startup.sh.jinja": "startup.sh",
+        "alembic.ini.jinja": "alembic.ini",
+        
+        # App Code
+        "app/main.py.jinja": "app/main.py",
+        "app/api/routers.py.jinja": "app/api/routers.py",
+        "app/core/settings.py.jinja": "app/core/settings.py",
+        "app/core/exceptions.py.jinja": "app/core/exceptions.py",
+        "app/core/logging.py.jinja": "app/core/logging.py",
+        "app/core/security.py.jinja": "app/core/security.py",
+        "app/db/models/models.py.jinja": "app/db/models/models.py",
+        "app/schemas/schema.py.jinja": "app/schemas/schema.py",
+        "app/services/service.py.jinja": "app/services/service.py",
+        "tests/test_main.py.jinja": "tests/test_main.py",
+    }
+
+    if db:
+        files_map["app/db/database.py.jinja"] = "app/db/database.py"
+
+    # 4. Generación
+    for template, dest in files_map.items():
+        create_file(template, context, os.path.join(base_path, dest))
+
+    # Crear __init__.py necesarios
+    init_dirs = ["app", "app/api", "app/core", "app/db", "app/db/models", "app/schemas", "app/services"]
+    for d in init_dirs:
+        with open(os.path.join(base_path, d, "__init__.py"), 'w') as f:
+            pass
+
+    console.print(f"\n✅ [green]Microservicio {name} creado con éxito.[/green]")
+    if db:
+        console.print("   📦 Incluye configuración de SQLAlchemy y Alembic.")
+
+if __name__ == "__main__":
+    app()

chuopycore_cli-1.0.0/pycore/templates/.env.jinja

@@ -0,0 +1,35 @@
+ENV=DEV
+
+PROJECT_FLAG=Project: {{ project_name }}
+ADMIN_KEY=GENERIC_ADMIN_KEY_CHANGE_ME
+{{ project_name | upper | replace('-', '_') }}_API_KEY=GENERIC_API_KEY_CHANGE_ME
+
+API_HOST=0.0.0.0
+API_PORT=8000
+API_DEBUG=True
+API_WORKERS=1
+ALGORITHM=HS256
+ACCESS_TOKEN_EXPIRE_MINUTES=30
+SECRET_KEY=CHANGE_THIS_TO_A_SECURE_SECRET_KEY
+
+# Security Settings
+ENABLE_RATE_LIMITING=True
+MAX_LOGIN_ATTEMPTS=5
+RATE_LIMIT_WINDOW=60
+
+# Logging Settings
+LOG_LEVEL=INFO
+ENABLE_SECURITY_LOGGING=True
+
+# Database Settings
+POSTGRES_USER=postgres
+POSTGRES_PASSWORD=postgres
+POSTGRES_DB={{ project_name | replace('-', '_') }}_db
+POSTGRES_PORT=5432
+POSTGRES_HOST=localhost
+
+# CQRS (Opcional, apuntan a master por defecto)
+POSTGRES_WRITER_HOST=localhost
+POSTGRES_WRITER_PORT=5432
+POSTGRES_READER_HOST=localhost
+POSTGRES_READER_PORT=5432

chuopycore_cli-1.0.0/pycore/templates/.gitignore.jinja

@@ -0,0 +1,44 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Microservice specific
+.env
+.venv
+venv/
+ENV/
+security.log
+*.db
+*.sqlite3
+
+# Docker
+.docker
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db

chuopycore_cli-1.0.0/pycore/templates/Dockerfile.jinja

@@ -0,0 +1,21 @@
+FROM python:3.11-slim
+WORKDIR /code
+
+RUN apt-get update && apt-get install -y \
+    curl \
+    postgresql-client \
+    && apt-get clean
+
+COPY ./requirements.txt /code/requirements.txt
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r /code/requirements.txt
+
+COPY ./app /code/app
+COPY ./alembic /code/alembic
+COPY ./alembic.ini /code/alembic.ini
+COPY ./startup.sh /code/startup.sh
+
+RUN sed -i 's/\r$//' /code/startup.sh && chmod +x /code/startup.sh
+
+EXPOSE 8000
+ENTRYPOINT ["/code/startup.sh"]

chuopycore_cli-1.0.0/pycore/templates/alembic.ini.jinja

@@ -0,0 +1,40 @@
+[alembic]
+script_location = alembic
+prepend_sys_path = .
+version_path_separator = os
+
+sqlalchemy.url = postgresql://%(POSTGRES_USER)s:%(POSTGRES_PASSWORD)s@%(POSTGRES_HOST)s:%(POSTGRES_PORT)s/%(POSTGRES_DB)s
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

chuopycore_cli-1.0.0/pycore/templates/app/api/routers.py.jinja

@@ -0,0 +1,29 @@
+from fastapi import APIRouter, Depends, HTTPException, status
+from sqlalchemy.ext.asyncio import AsyncSession
+from typing import List, Any
+
+from app.db.database import get_db, get_read_db
+from app.core.security import get_api_key
+
+router = APIRouter(
+    prefix="/items", 
+    tags=["Items"],
+    dependencies=[Depends(get_api_key)]
+)
+
+@router.get("", response_model=List[Any])
+async def list_items(
+    skip: int = 0,
+    limit: int = 100,
+    db: AsyncSession = Depends(get_read_db)
+):
+    """Obtiene la lista de elementos (Ejemplo)."""
+    return []
+
+@router.post("", status_code=status.HTTP_201_CREATED)
+async def create_item(
+    item_data: Any,
+    db: AsyncSession = Depends(get_db)
+):
+    """Crea un nuevo elemento (Ejemplo)."""
+    return {"message": "Item creado"}

chuopycore_cli-1.0.0/pycore/templates/app/core/exceptions.py.jinja

@@ -0,0 +1,30 @@
+class ServiceError(Exception):
+    """Excepción base para los errores del microservicio {{ project_name }}."""
+    pass
+
+class AuthenticationError(ServiceError):
+    """Lanzada cuando la autenticación falla."""
+    pass
+
+class TokenError(AuthenticationError):
+    """Lanzada cuando hay problemas con los tokens."""
+    pass
+
+class DatabaseError(ServiceError):
+    """Lanzada cuando las operaciones de base de datos fallan."""
+    pass
+
+class APIError(ServiceError):
+    """Lanzada cuando las llamadas a la API fallan."""
+    def __init__(self, status_code: int, message: str):
+        self.status_code = status_code
+        self.message = message
+        super().__init__(f"API Error {status_code}: {message}")
+
+class DataValidationError(ServiceError):
+    """Lanzada cuando la validación de datos falla."""
+    pass
+
+class ResourceNotFoundError(ServiceError):
+    """Lanzada cuando un recurso solicitado no se encuentra."""
+    pass

chuopycore_cli-1.0.0/pycore/templates/app/core/logging.py.jinja

@@ -0,0 +1,91 @@
+import html
+import logging
+import requests
+import traceback
+from datetime import datetime
+
+from .settings import settings
+
+class TelegramHandler(logging.Handler):
+    def __init__(self) -> None:
+        self.token = settings.TELEGRAM_TOKEN
+        self.chat_ids = settings.ADMINISTRATOR_IDS
+        self.project_flag = settings.PROJECT_FLAG
+        self.api_url = f"https://api.telegram.org/bot{self.token}/sendMessage"
+        super().__init__()
+
+    def send_message(self, message: str):
+        try:
+            project_flag_text = f"[{self.project_flag}]\n" if self.project_flag else ""
+            full_message = project_flag_text + message
+            for chat_id in self.chat_ids:
+                payload = {
+                    "chat_id": chat_id,
+                    "text": html.escape(full_message),
+                    "parse_mode": "HTML", 
+                }
+                response = requests.post(self.api_url, data=payload, timeout=5)
+                if not response.ok:
+                    print(f"ERROR: No se pudo enviar log a Telegram chat_id {chat_id}. Response: {response.text}")
+        except Exception as e:
+            print(f"CRITICAL: Excepción al enviar log a Telegram: {str(e)}")
+
+    def emit(self, record: logging.LogRecord):
+        try:
+            text = self.format(record)
+            if record.exc_info:
+                exc_type, exc_value, exc_traceback = record.exc_info
+                stack_trace = ''.join(traceback.format_exception(exc_type, exc_value, exc_traceback))
+                text += f"\n\n<b>Stack Trace:</b>\n<pre>{html.escape(stack_trace)}</pre>"
+            timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+            text = f"<b>[{record.levelname}]</b> {timestamp}\n{text}"
+            self.send_message(text)
+        except Exception:
+            self.handleError(record)
+
+def init_logger() -> None:
+    app_logger = logging.getLogger()
+    app_logger.setLevel(logging.DEBUG)
+
+    if app_logger.hasHandlers():
+        app_logger.handlers.clear()
+
+    standard_formatter = logging.Formatter(
+        "%(asctime)s [%(levelname)s] %(name)s: %(message)s"
+    )
+
+    basic_handler = logging.StreamHandler()
+    basic_handler.setLevel(logging.INFO)
+    basic_handler.setFormatter(standard_formatter)
+    app_logger.addHandler(basic_handler)
+
+    if settings.TELEGRAM_TOKEN and settings.ADMINISTRATOR_IDS:
+        telegram_handler = TelegramHandler()
+        telegram_handler.setLevel(logging.ERROR)  
+        telegram_handler.setFormatter(standard_formatter)
+        app_logger.addHandler(telegram_handler)
+        app_logger.info("Handler de Telegram configurado correctamente.")
+
+    app_logger.propagate = False
+    app_logger.info("Logger inicializado correctamente.")
+    
+    setup_security_logger()
+    return app_logger
+
+def setup_security_logger():
+    security_logger = logging.getLogger("security")
+    security_logger.setLevel(logging.INFO)
+    security_handler = logging.FileHandler("security.log")
+    security_handler.setLevel(logging.INFO)
+    security_formatter = logging.Formatter(
+        '%(asctime)s - SECURITY - %(levelname)s - %(message)s'
+    )
+    security_handler.setFormatter(security_formatter)
+    security_logger.addHandler(security_handler)
+    security_logger.propagate = False
+    return security_logger
+
+# Funciones de utilidad para logging de seguridad
+def log_security_event(event_type: str, details: str, ip: str = "unknown"):
+    security_logger = logging.getLogger("security")
+    security_logger.info(f"{event_type} - {details} - IP: {ip}")

chuopycore_cli-1.0.0/pycore/templates/app/core/security.py.jinja

@@ -0,0 +1,23 @@
+from fastapi import Security, HTTPException, status
+from fastapi.security.api_key import APIKeyHeader
+from app.core.settings import settings
+
+# Definir el nombre del header donde se espera el API Key
+API_KEY_NAME = "X-API-Key"
+api_key_header = APIKeyHeader(name=API_KEY_NAME, auto_error=False)
+
+async def get_api_key(api_key: str = Security(api_key_header)):
+    """
+    Dependencia para validar el API Key en los headers de la solicitud.
+    """
+    # Se espera una variable de entorno con el nombre del proyecto en mayúsculas + _API_KEY
+    expected_api_key = getattr(settings, "{{ project_name | upper | replace('-', '_') }}_API_KEY", None)
+    
+    if api_key and api_key == expected_api_key:
+        return api_key
+    
+    raise HTTPException(
+        status_code=status.HTTP_401_UNAUTHORIZED,
+        detail="API Key inválida o ausente",
+        headers={"WWW-Authenticate": "ApiKey"},
+    )

chuopycore_cli-1.0.0/pycore/templates/app/core/settings.py.jinja

@@ -0,0 +1,142 @@
+import enum
+import os
+from typing import Union, Any, List
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from pydantic import field_validator
+import json
+from datetime import datetime
+
+class Enviroments(enum.IntEnum):
+    """Enumeración de los entornos de ejecución disponibles."""
+    DEV = 1
+    TESTING = 2
+    PROD = 3
+
+    @classmethod
+    def from_str(cls, value: Union[str, int]) -> 'Enviroments':
+        if isinstance(value, int) or (isinstance(value, str) and value.isdigit()):
+            return cls(int(value))
+        value_map = {
+            'DEV': cls.DEV,
+            'TESTING': cls.TESTING,
+            'PROD': cls.PROD
+        }
+        return value_map[value.upper()]
+
+class Settings(BaseSettings):
+    """Configuración base de la aplicación."""
+    # Configuración del entorno
+    ENV: Enviroments = Enviroments.DEV
+    
+    # Configuración de Telegram para logging (Opcional)
+    TELEGRAM_TOKEN: str = ""
+    ADMINISTRATOR_IDS: List[str] = []
+    PROJECT_FLAG: str = ""
+    ADMIN_KEY: str = ""
+
+    # Seguridad: API Key
+    {{ project_name | upper | replace('-', '_') }}_API_KEY: str = ""
+    
+    # Configuración del servidor API
+    API_HOST: str = ""
+    API_PORT: int = 8000    
+    API_DEBUG: bool = True
+    API_WORKERS: int = 1
+    
+    # Configuraciones de seguridad de la API
+    ALGORITHM: str = "HS256"
+    ACCESS_TOKEN_EXPIRE_MINUTES: int = 30
+    SECRET_KEY: str = ""
+    
+    # Configuraciones de seguridad adicionales
+    ENABLE_RATE_LIMITING: bool = True
+    MAX_LOGIN_ATTEMPTS: int = 5
+    RATE_LIMIT_WINDOW: int = 60
+    
+    # Configuraciones de logging
+    LOG_LEVEL: str = "INFO"
+    ENABLE_SECURITY_LOGGING: bool = True
+    
+    # Configuración de la base de datos PostgreSQL
+    POSTGRES_USER: str = "postgres"
+    POSTGRES_PASSWORD: str = "postgres"
+    POSTGRES_DB: str = "{{ project_name | replace('-', '_') }}_db"
+    POSTGRES_HOST: str = "db"
+    POSTGRES_PORT: int = 5432
+
+    # CQRS: Hosts específicos para lectura y escritura
+    POSTGRES_WRITER_HOST: str = ""
+    POSTGRES_WRITER_PORT: int = 0
+    POSTGRES_READER_HOST: str = ""
+    POSTGRES_READER_PORT: int = 0
+
+    DATABASE_URL: str = ""
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_file_encoding="utf-8",
+        extra="allow",
+        env_nested_delimiter="__",
+        case_sensitive=False
+    )
+
+    def __init__(self, **values):
+        super().__init__(**values)
+        
+        if not self.POSTGRES_WRITER_HOST:
+            self.POSTGRES_WRITER_HOST = self.POSTGRES_HOST
+        if not self.POSTGRES_WRITER_PORT:
+            self.POSTGRES_WRITER_PORT = self.POSTGRES_PORT
+            
+        if not self.POSTGRES_READER_HOST:
+            self.POSTGRES_READER_HOST = self.POSTGRES_HOST
+        if not self.POSTGRES_READER_PORT:
+            self.POSTGRES_READER_PORT = self.POSTGRES_PORT
+
+        self.DATABASE_URL = self.get_writer_database_url()
+
+    @field_validator('ENV', mode='before')
+    @classmethod
+    def validate_env(cls, value):
+        if value is None:
+            return Enviroments.DEV
+        try:
+            return Enviroments.from_str(value)
+        except (KeyError, ValueError):
+            return Enviroments.DEV
+    
+    @field_validator('ADMINISTRATOR_IDS', mode='before')
+    @classmethod
+    def validate_admin_ids(cls, value):
+        if isinstance(value, str):
+            try:
+                return json.loads(value)
+            except json.JSONDecodeError:
+                return [value]
+        return value
+    
+    def get_database_url(self) -> str:
+        return self.DATABASE_URL
+    
+    def get_writer_database_url(self) -> str:
+        return (
+            "postgresql+asyncpg://"
+            f"{self.POSTGRES_USER}:{self.POSTGRES_PASSWORD}@"
+            f"{self.POSTGRES_WRITER_HOST}:{self.POSTGRES_WRITER_PORT}/{self.POSTGRES_DB}"
+        )
+
+    def get_reader_database_url(self) -> str:
+        return (
+            "postgresql+asyncpg://"
+            f"{self.POSTGRES_USER}:{self.POSTGRES_PASSWORD}@"
+            f"{self.POSTGRES_READER_HOST}:{self.POSTGRES_READER_PORT}/{self.POSTGRES_DB}"
+        )
+    
+    def get_sync_database_url(self) -> str:
+        return (
+            "postgresql://"
+            f"{self.POSTGRES_USER}:{self.POSTGRES_PASSWORD}@"
+            f"{self.POSTGRES_HOST}:{self.POSTGRES_PORT}/{self.POSTGRES_DB}"
+        )
+
+settings = Settings()

chuopycore_cli-1.0.0/pycore/templates/app/db/database.py.jinja

@@ -0,0 +1,71 @@
+from sqlalchemy.ext.asyncio import create_async_engine, async_sessionmaker
+from sqlalchemy.orm import declarative_base
+from app.core.settings import settings
+
+Base = declarative_base()
+
+# -----------------------------------------------------------------------------
+# Configuración de Motores (Master/Replica)
+# -----------------------------------------------------------------------------
+
+# Motor de Escritura (Master)
+writer_engine = create_async_engine(
+    settings.get_writer_database_url(),
+    echo=settings.DB_ECHO,
+    pool_size=20,
+    max_overflow=10,
+    pool_timeout=30,
+    pool_recycle=1800,
+    pool_pre_ping=True
+)
+
+# Motor de Lectura (Replica)
+# Si no hay replica configurada, settings devolverá la misma URL del master
+reader_engine = create_async_engine(
+    settings.get_reader_database_url(),
+    echo=settings.DB_ECHO,
+    pool_size=20,
+    max_overflow=10,
+    pool_timeout=30,
+    pool_recycle=1800,
+    pool_pre_ping=True
+)
+
+# -----------------------------------------------------------------------------
+# Sesiones Asíncronas
+# -----------------------------------------------------------------------------
+
+AsyncWriterSession = async_sessionmaker(writer_engine, expire_on_commit=False)
+AsyncReaderSession = async_sessionmaker(reader_engine, expire_on_commit=False)
+
+# Alias para compatibilidad
+AsyncSessionLocal = AsyncWriterSession
+engine = writer_engine
+
+# -----------------------------------------------------------------------------
+# Dependencias (Dependency Injection)
+# -----------------------------------------------------------------------------
+
+async def get_db():
+    """Dependencia por defecto (Escritura/Master)."""
+    async with AsyncWriterSession() as session:
+        try:
+            yield session
+        finally:
+            await session.close()
+
+async def get_write_db():
+    """Dependencia explícita para escritura."""
+    async with AsyncWriterSession() as session:
+        try:
+            yield session
+        finally:
+            await session.close()
+
+async def get_read_db():
+    """Dependencia explícita para lectura."""
+    async with AsyncReaderSession() as session:
+        try:
+            yield session
+        finally:
+            await session.close()

chuopycore_cli-1.0.0/pycore/templates/app/db/models/models.py.jinja

@@ -0,0 +1,16 @@
+from sqlalchemy import Column, Integer, String, DateTime, Boolean
+from sqlalchemy.sql import func
+from app.db.database import Base
+
+class BaseModel(Base):
+    __abstract__ = True
+    id = Column(Integer, primary_key=True, index=True)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+    updated_at = Column(DateTime(timezone=True), onupdate=func.now())
+    is_active = Column(Boolean, default=True)
+
+class Item(BaseModel):
+    __tablename__ = "items"
+    
+    name = Column(String, index=True)
+    description = Column(String, nullable=True)

chuopycore_cli-1.0.0/pycore/templates/app/main.py.jinja

@@ -0,0 +1,58 @@
+from contextlib import asynccontextmanager
+from fastapi import Depends, FastAPI
+from fastapi.responses import ORJSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+import logging
+
+from app.core.settings import settings
+from app.core.logging import init_logger
+from app.api.routers import router as api_router
+{% if with_db %}
+from app.db.database import engine, Base
+{% endif %}
+
+# Inicializar logger profesional
+logger = init_logger()
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    # Startup
+    logger.info(f"Iniciando microservicio {settings.PROJECT_FLAG}...")
+    
+    {% if with_db %}
+    # Crear tablas (Solo para desarrollo/testing - en prod usar Alembic)
+    async with engine.begin() as conn:
+        await conn.run_sync(Base.metadata.create_all)
+    {% endif %}
+    
+    yield
+    
+    # Shutdown
+    logger.info(f"Apagando microservicio {settings.PROJECT_FLAG}...")
+
+app = FastAPI(
+    title="{{ project_name }} API",
+    description="API generada por chuopycore-cli",
+    version="1.0.0",
+    lifespan=lifespan,
+    debug=settings.API_DEBUG,
+    default_response_class=ORJSONResponse
+)
+
+# CORS config
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+app.include_router(
+    api_router,
+    prefix="/api/v1"
+)
+
+@app.get("/health")
+async def health_check():
+    return {"status": "ok", "service": settings.PROJECT_FLAG}

chuopycore_cli-1.0.0/pycore/templates/app/schemas/schema.py.jinja

@@ -0,0 +1,21 @@
+from pydantic import BaseModel, ConfigDict
+from typing import Optional
+from datetime import datetime
+
+class ItemBase(BaseModel):
+    name: str
+    description: Optional[str] = None
+
+class ItemCreate(ItemBase):
+    pass
+
+class ItemUpdate(ItemBase):
+    name: Optional[str] = None
+
+class ItemResponse(ItemBase):
+    id: int
+    created_at: datetime
+    updated_at: Optional[datetime] = None
+    is_active: bool
+
+    model_config = ConfigDict(from_attributes=True)

chuopycore_cli-1.0.0/pycore/templates/app/services/service.py.jinja

@@ -0,0 +1,25 @@
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.future import select
+from typing import List, Optional
+
+from app.db.models.models import Item
+from app.schemas.schema import ItemCreate, ItemUpdate
+
+class ItemService:
+    @staticmethod
+    async def get_all(db: AsyncSession, skip: int = 0, limit: int = 100) -> List[Item]:
+        result = await db.execute(select(Item).offset(skip).limit(limit))
+        return result.scalars().all()
+
+    @staticmethod
+    async def get_by_id(db: AsyncSession, item_id: int) -> Optional[Item]:
+        result = await db.execute(select(Item).filter(Item.id == item_id))
+        return result.scalars().first()
+
+    @staticmethod
+    async def create(db: AsyncSession, item_data: ItemCreate) -> Item:
+        db_item = Item(**item_data.model_dump())
+        db.add(db_item)
+        await db.commit()
+        await db.refresh(db_item)
+        return db_item

chuopycore_cli-1.0.0/pycore/templates/docker-compose.yml.jinja

@@ -0,0 +1,108 @@
+services:
+  {{ project_name }}-api:
+    build: .
+    container_name: {{ project_name }}-api
+    command: /code/startup.sh
+    volumes:
+      - ./app:/code/app
+      - ./alembic:/code/alembic
+      - ./alembic.ini:/code/alembic.ini
+    ports:
+      - "8000:8000"
+    env_file:
+      - .env
+    environment:
+      - POSTGRES_WRITER_HOST=pgbouncer-writer
+      - POSTGRES_WRITER_PORT=6432
+      - POSTGRES_READER_HOST=pgbouncer-reader
+      - POSTGRES_READER_PORT=6433
+      - POSTGRES_HOST={{ project_name }}-db-master
+      - POSTGRES_PORT=5432
+    depends_on:
+      pgbouncer-writer:
+        condition: service_started
+      pgbouncer-reader:
+        condition: service_started
+      {{ project_name }}-db-master:
+        condition: service_healthy
+    restart: on-failure
+    networks:
+      - {{ project_name }}_network
+
+  pgbouncer-writer:
+    image: edoburu/pgbouncer:latest
+    container_name: {{ project_name }}-pgbouncer-writer
+    environment:
+      - DATABASE_URL=postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@{{ project_name }}-db-master:5432/${POSTGRES_DB}
+      - POOL_MODE=transaction
+      - MAX_CLIENT_CONN=100
+      - DEFAULT_POOL_SIZE=20
+      - LISTEN_PORT=6432
+      - AUTH_TYPE=scram-sha-256
+    depends_on:
+      {{ project_name }}-db-master:
+        condition: service_healthy
+    networks:
+      - {{ project_name }}_network
+
+  pgbouncer-reader:
+    image: edoburu/pgbouncer:latest
+    container_name: {{ project_name }}-pgbouncer-reader
+    environment:
+      - DATABASE_URL=postgres://${POSTGRES_USER}:${POSTGRES_PASSWORD}@{{ project_name }}-db-replica:5432/${POSTGRES_DB}
+      - POOL_MODE=transaction
+      - MAX_CLIENT_CONN=200
+      - DEFAULT_POOL_SIZE=40
+      - LISTEN_PORT=6433
+      - AUTH_TYPE=scram-sha-256
+    depends_on:
+      {{ project_name }}-db-replica:
+        condition: service_started
+    networks:
+      - {{ project_name }}_network
+
+  {{ project_name }}-db-master:
+    image: bitnami/postgresql:latest
+    container_name: {{ project_name }}-db-master
+    volumes:
+      - {{ project_name }}_postgres_master_data:/bitnami/postgresql
+    environment:
+      - POSTGRESQL_USERNAME=${POSTGRES_USER}
+      - POSTGRESQL_PASSWORD=${POSTGRES_PASSWORD}
+      - POSTGRESQL_DATABASE=${POSTGRES_DB}
+      - POSTGRESQL_REPLICATION_MODE=master
+      - POSTGRESQL_REPLICATION_USER=repl_user
+      - POSTGRESQL_REPLICATION_PASSWORD=repl_password
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER} -d ${POSTGRES_DB}"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+    networks:
+      - {{ project_name }}_network
+
+  {{ project_name }}-db-replica:
+    image: bitnami/postgresql:latest
+    container_name: {{ project_name }}-db-replica
+    volumes:
+      - {{ project_name }}_postgres_replica_data:/bitnami/postgresql
+    environment:
+      - POSTGRESQL_MASTER_HOST={{ project_name }}-db-master
+      - POSTGRESQL_MASTER_PORT_NUMBER=5432
+      - POSTGRESQL_REPLICATION_MODE=slave
+      - POSTGRESQL_REPLICATION_USER=repl_user
+      - POSTGRESQL_REPLICATION_PASSWORD=repl_password
+      - POSTGRESQL_PASSWORD=${POSTGRES_PASSWORD}
+    depends_on:
+      {{ project_name }}-db-master:
+        condition: service_healthy
+    networks:
+      - {{ project_name }}_network
+
+networks:
+  {{ project_name }}_network:
+    driver: bridge
+
+volumes:
+  {{ project_name }}_postgres_master_data:
+  {{ project_name }}_postgres_replica_data:

chuopycore_cli-1.0.0/pycore/templates/requirements.txt.jinja

@@ -0,0 +1,31 @@
+# --- FastAPI Core ---
+fastapi==0.111.0
+uvicorn[standard]==0.30.1
+gunicorn==22.0.0
+orjson==3.10.5
+
+# --- Database ---
+sqlalchemy==2.0.31
+alembic==1.13.1
+asyncpg==0.29.0
+psycopg[binary]>=3.1.18
+psycopg2-binary==2.9.9
+backoff==2.2.1
+
+# --- Settings and .env ---
+pydantic-settings==2.3.4
+python-dotenv==1.0.1
+
+# --- Security ---
+passlib[bcrypt]==1.7.4
+bcrypt==3.2.0
+python-jose[cryptography]==3.3.0
+slowapi==0.1.9
+requests==2.31.0
+
+# --- Testing ---
+pytest==8.2.2
+httpx==0.27.0
+pytest-asyncio==0.23.6
+aiosqlite==0.19.0
+tenacity==8.2.3

chuopycore_cli-1.0.0/pycore/templates/startup.sh.jinja

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+# Esperar a que la base de datos esté lista
+postgres_ready() {
+    pg_isready -h "$POSTGRES_HOST" -p "$POSTGRES_PORT" -U "$POSTGRES_USER"
+}
+
+until postgres_ready; do
+  >&2 echo "PostgreSQL no está listo - esperando..."
+  sleep 1
+done
+
+>&2 echo "PostgreSQL está listo."
+
+# Ejecutar migraciones si existe el directorio alembic
+if [ -d "/code/alembic" ]; then
+    echo "Ejecutando migraciones de base de datos..."
+    alembic upgrade head
+fi
+
+# Iniciar la aplicación
+echo "Iniciando {{ project_name }}..."
+exec uvicorn app.main:app --host 0.0.0.0 --port 8000 --reload

chuopycore_cli-1.0.0/pycore/templates/tests/test_main.py.jinja

@@ -0,0 +1,9 @@
+from fastapi.testclient import TestClient
+from app.main import app
+
+client = TestClient(app)
+
+def test_health_check():
+    response = client.get("/health")
+    assert response.status_code == 200
+    assert response.json()["status"] == "ok"

chuopycore_cli-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

chuopycore_cli-1.0.0/setup.py

@@ -0,0 +1,18 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="chuopycore-cli",
+    version="1.0.0",
+    packages=find_packages(),
+    include_package_data=True,
+    install_requires=[
+        "typer[all]",
+        "jinja2",
+        "rich"
+    ],
+    entry_points={
+        'console_scripts': [
+            'chuopycore=pycore.cli:app',
+        ],
+    },
+)