microservice-chassis-grupo2 0.1.5rc10__tar.gz

microservice_chassis_grupo2-0.1.5rc10/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: microservice_chassis_grupo2
+Version: 0.1.5rc10
+Summary: A reusable library for microservices
+Home-page: https://github.com/Grupo-MACC/Chassis
+Author: Grupo 2
+Author-email: 
+Dynamic: author
+Dynamic: home-page
+Dynamic: summary

microservice_chassis_grupo2-0.1.5rc10/README.md

@@ -0,0 +1,44 @@
+# 🧩 Microservice Chassis Grupo 2
+
+**Repository link:** https://github.com/Grupo-MACC/Chassis
+
+---
+
+## Functionalities
+
+This repository provides a **shared chassis** for microservices, containing configuration, database management, authentication, messaging, and helper utilities.  
+It allows microservices to reuse common functionalities such as database connections, JWT validation, RabbitMQ communication, and standardized base models.
+
+Below is a detailed list of the available functionalities:
+
+| **Module** | **Functionality** | **Description** |
+|-------------|------------------|-----------------|
+| `core/config.py` | **Settings Management** | Centralized configuration for the chassis. Defines constants like the encryption algorithm (`RS256`), RabbitMQ connection parameters (`RABBITMQ_HOST`), and exchange name (`broker`). |
+| `core/security.py` | **Token Decoding and Verification** | Handles JWT decoding using a public RSA key. Validates tokens and raises appropriate HTTP errors if invalid or missing. |
+| `core/dependencies.py` | **Database Session & Authentication Dependency** | Provides FastAPI dependencies to manage asynchronous database sessions (`get_db`) and current user retrieval (`get_current_user`) from a JWT token. |
+| `core/rabbitmq.py` | **RabbitMQ Channel & Exchange Management** | Creates asynchronous connections to RabbitMQ using `aio_pika`. Declares durable topic exchanges for inter-service communication. |
+| `core/utils.py` | **Helper Functions and Service URLs** | Defines service URLs (order, machine, delivery, payment, auth) and provides error handling utilities with standardized logging (`raise_and_log_error`). |
+| `sql/database.py` | **Database Engine & Session Configuration** | Configures SQLAlchemy’s asynchronous engine and sessionmaker. Supports `SQLALCHEMY_DATABASE_URL` via environment variable (defaults to SQLite). |
+| `sql/base_class.py` | **Base Model for ORM Classes** | Provides a reusable abstract base class (`BaseModel`) for all database models, including timestamp columns (`creation_date`, `update_date`) and helper methods for converting models to dictionaries. |
+
+---
+
+## Functionalities per Microservice
+
+| **Microservice** | **Used Functionalities** |
+|------------------|--------------------------|
+| `payment` | `core/config`, `core/security`, `core/dependencies`, `core/rabbitmq`, `core/utils`, `sql/database`, `sql/base_class` |
+
+---
+
+## Summary
+
+This chassis allows the `payment` microservice (and potentially others in the future) to operate with consistent patterns for:
+- Secure token validation.
+- Standardized database access and sessions.
+- Centralized configuration.
+- RabbitMQ-based inter-service communication.
+- Common helper utilities and error management.
+- Unified base ORM models.
+
+It provides a robust foundation for building scalable and maintainable microservices within the system.

microservice_chassis_grupo2-0.1.5rc10/microservice_chassis_grupo2/core/config.py

@@ -0,0 +1,70 @@
+# -*- coding: utf-8 -*-
+"""
+Configuración del Chassis.
+
+Objetivo:
+    - Mantener compatibilidad con el sistema actual (AMQP sin TLS por defecto).
+    - Permitir activar TLS (AMQPS) sin tocar el código de los microservicios:
+        * RABBITMQ_USE_TLS=1
+        * RABBITMQ_PORT=5671
+        * RABBITMQ_TLS_CA_FILE=/certs/ca.pem
+"""
+
+from __future__ import annotations
+
+import os
+
+
+def _env_bool(name: str, default: str = "0") -> bool:
+    """
+    Convierte una variable de entorno a bool de forma tolerante.
+
+    Acepta: 1/true/yes/on/y (case-insensitive).
+    """
+    val = os.getenv(name, default)
+    return str(val).strip().lower() in {"1", "true", "yes", "on", "y"}
+
+
+class Settings:
+    """
+    Settings centralizados.
+
+    Nota:
+        Mantengo el nombre `RABBITMQ_HOST` porque ya lo usa todo el proyecto.
+        Aquí pasa a ser una URL completa (amqp/amqps) con puerto.
+    """
+
+    ALGORITHM: str = "RS256"
+
+    EXCHANGE_NAME = "broker"
+    EXCHANGE_NAME_COMMAND = "command"
+    EXCHANGE_NAME_SAGA = "saga"
+    EXCHANGE_NAME_LOGS = "logs"
+
+    # --- RabbitMQ base ---
+    RABBITMQ_USER = os.getenv("RABBITMQ_USER", "guest")
+    RABBITMQ_PASSWORD = os.getenv("RABBITMQ_PASSWORD", "guest")
+    RABBITMQ_HOSTNAME = os.getenv("RABBITMQ_HOST", "localhost")
+
+    # --- TLS switch ---
+    RABBITMQ_USE_TLS: bool = _env_bool("RABBITMQ_USE_TLS", "0")
+
+    # Puerto por defecto según TLS
+    _default_port = "5671" if RABBITMQ_USE_TLS else "5672"
+    RABBITMQ_PORT = int(os.getenv("RABBITMQ_PORT", _default_port))
+
+    # Override opcional por si alguien quiere pasar una URL completa
+    RABBITMQ_URL = os.getenv("RABBITMQ_URL", "").strip()
+
+    # URL final (compatibilidad con el resto del código)
+    if RABBITMQ_URL:
+        RABBITMQ_HOST = RABBITMQ_URL
+    else:
+        scheme = "amqps" if RABBITMQ_USE_TLS else "amqp"
+        RABBITMQ_HOST = (
+            f"{scheme}://{RABBITMQ_USER}:{RABBITMQ_PASSWORD}"
+            f"@{RABBITMQ_HOSTNAME}:{RABBITMQ_PORT}/"
+        )
+
+
+settings = Settings()

microservice_chassis_grupo2-0.1.5rc10/microservice_chassis_grupo2/core/consul.py

@@ -0,0 +1,80 @@
+import os
+import asyncio
+import httpx
+
+class ConsulClient:
+    def __init__(self, host: str, port: str):
+        self.host = host
+        self.port = port
+        self.base_url = f"http://{host}:{port}/v1"
+
+    async def deregister_service(
+        self,
+        service_id: str
+    ) -> bool:
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.put(
+                    f"{self.base_url}/agent/service/deregister/{service_id}",
+                    timeout=10.0,
+                )
+                if response.status_code == 200:
+                    return True
+                else:
+                    return False
+        except Exception as e:
+            return False
+    
+    async def discover_service(
+        self,
+        service_name: str
+    ) -> dict:
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(
+                    f"{self.base_url}/catalog/service/{service_name}",
+                    timeout=10.0,
+                )
+                if response.status_code == 200:
+                    services = response.json()
+                    if services:
+                        service = services[0]
+                        return {
+                            "address": service.get("ServiceAddress") or service.get("Address"),
+                            "port": service.get("ServicePort"),
+                        }
+        except Exception as e:
+            return None
+
+_consul_client = None
+
+def create_consul_client() -> ConsulClient:
+    global _consul_client
+    if _consul_client is None:
+        host = os.getenv("CONSUL_HOST", "localhost")
+        port = int(os.getenv("CONSUL_PORT", 8500))
+        _consul_client = ConsulClient(host, port)
+    return _consul_client
+
+async def get_service_url(service_name: str, default_url: str = None) -> str:
+    """Get service URL from Consul with retry and fallback."""
+    consul_client = create_consul_client()
+    max_retries = 5
+    retry_delay = 1
+
+    for attempt in range(max_retries):
+        try:
+            service_info = await consul_client.discover_service(service_name)
+            if service_info:
+                url = f"http://{service_info['address']}:{service_info['port']}"
+                return url
+        except Exception as e:
+            pass
+        if attempt < max_retries - 1:
+            await asyncio.sleep(retry_delay)
+
+    # Fallback to default
+    if default_url:
+        return default_url
+
+    raise Exception(f"Could not discover service: {service_name}")

microservice_chassis_grupo2-0.1.5rc10/microservice_chassis_grupo2/core/dependencies.py

@@ -0,0 +1,64 @@
+import logging
+from fastapi import Depends, HTTPException, status
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from microservice_chassis_grupo2.core.security import decode_token, PUBLIC_KEY_PATH
+import os
+
+logger = logging.getLogger(__name__)
+auth_scheme = HTTPBearer()
+
+# Database #########################################################################################
+async def get_db():
+    """Genera sesiones de BD y las cierra al terminar.
+
+    Nota:
+        - init_database() es idempotente: si ya se inicializó, no repite trabajo.
+        - Se mantiene commit/rollback automático como en tu implementación original.
+    """
+    from microservice_chassis_grupo2.sql.database import init_database, SessionLocal
+
+    # ✅ Asegura engine y SessionLocal listos antes de usarlos
+    await init_database()
+
+    if SessionLocal is None:
+        raise RuntimeError(
+            "SessionLocal no inicializada tras init_database(). "
+            "Revisa microservice_chassis_grupo2/sql/database.py"
+        )
+
+    db = SessionLocal()
+    try:
+        yield db
+        await db.commit()
+    except Exception:
+        await db.rollback()
+        raise
+    finally:
+        await db.close()
+
+async def get_current_user(
+    credentials: HTTPAuthorizationCredentials = Depends(auth_scheme)
+):
+    """
+    Decodifica el JWT y obtiene el usuario actual desde la base de datos.
+    """
+    token = credentials.credentials
+
+    try:
+        payload = decode_token(token) 
+    except ValueError:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Token inválido")
+
+    user_id = payload.get("user_id")
+    if not user_id:
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Token inválido")
+    
+    return user_id
+
+def check_public_key():
+    if os.path.exists(PUBLIC_KEY_PATH):
+        with open(PUBLIC_KEY_PATH, "r", encoding="utf-8") as f:
+            f.read()
+        return True
+    else:
+        return False

microservice_chassis_grupo2-0.1.5rc10/microservice_chassis_grupo2/core/rabbitmq_core.py

@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+"""
+RabbitMQ core del Chassis (aio-pika).
+
+Objetivo:
+    - Si TLS está activo, usar AMQPS con verificación del servidor por CA.
+    - SIN mTLS: no cargamos certificado/clave de cliente (no hace falta).
+"""
+
+from __future__ import annotations
+
+import os
+import ssl
+import inspect
+import logging
+from aio_pika.exceptions import AMQPConnectionError
+from aio_pika import connect_robust, ExchangeType
+
+from microservice_chassis_grupo2.core.config import settings
+
+logger = logging.getLogger(__name__)
+
+# Ruta al public key para verificar JWTs
+PUBLIC_KEY_PATH = os.getenv("PUBLIC_KEY_PATH", "auth_public.pem")
+
+
+def _env_bool(name: str, default: str = "0") -> bool:
+    """
+    Convierte una variable de entorno a bool de forma tolerante.
+
+    Acepta: 1/true/yes/on/y (case-insensitive).
+    """
+    val = os.getenv(name, default)
+    return str(val).strip().lower() in {"1", "true", "yes", "on", "y"}
+
+
+def _build_ssl_context() -> ssl.SSLContext:
+    """
+    Construye un SSLContext para TLS simple (server-auth).
+
+    Requisitos:
+        - RABBITMQ_TLS_CA_FILE debe apuntar al CA que firmó el cert del servidor RabbitMQ.
+        - No se carga cert/key de cliente (NO mTLS).
+
+    Decisiones:
+        - TLSv1.2+.
+        - check_hostname=False para evitar problemas típicos de CN/SAN en entornos docker.
+          (Si tus certs están bien con SAN, puedes ponerlo True sin problema.)
+    """
+    ca_file = os.getenv("RABBITMQ_TLS_CA_FILE", "/certs/ca.pem")
+
+    if not os.path.exists(ca_file):
+        raise FileNotFoundError(f"CA file no encontrado: {ca_file}")
+
+    ctx = ssl.create_default_context(purpose=ssl.Purpose.SERVER_AUTH, cafile=ca_file)
+    ctx.minimum_version = ssl.TLSVersion.TLSv1_2
+    ctx.check_hostname = False
+
+    # Verificación estricta del servidor (lo normal en TLS simple)
+    ctx.verify_mode = ssl.CERT_REQUIRED
+
+    return ctx
+
+
+async def _connect(url: str, ssl_ctx: ssl.SSLContext | None):
+    """
+    Conecta con aio-pika de forma robusta.
+
+    Estrategia:
+        - Si no hay TLS (ssl_ctx is None): conexión normal.
+        - Si hay TLS: pasar el SSLContext usando el parámetro correcto
+          para la versión de aio-pika instalada.
+
+    Compatibilidad:
+        - Algunas versiones soportan `ssl_context=SSLContext`.
+        - Otras usan `ssl=True` + `ssl_options` (dict u objeto SSLOptions).
+    """
+    if ssl_ctx is None:
+        return await connect_robust(url)
+
+    sig = inspect.signature(connect_robust)
+    params = sig.parameters
+
+    # Opción 1 (preferida): ssl_context=
+    if "ssl_context" in params:
+        return await connect_robust(url, ssl_context=ssl_ctx)
+
+    # Opción 2: ssl=True + ssl_options=dict(...)
+    if "ssl_options" in params:
+        # Para aiormq, suele funcionar pasando el contexto dentro de ssl_options.
+        # Si tu versión exige keys tipo cafile/certfile/keyfile,
+        # aquí también podrías pasar {"cafile": "..."} en vez de context.
+        return await connect_robust(url, ssl=True, ssl_options={"context": ssl_ctx})
+
+    # Último recurso: algunas versiones aceptan ssl como contexto
+    return await connect_robust(url, ssl=ssl_ctx)
+
+
+async def get_channel():
+    """
+    Devuelve (connection, channel) listo para usar.
+
+    Nota profesional:
+        - Abrir/cerrar conexión por cada publish es caro.
+          Para producción, lo suyo es pool o conexión global por proceso.
+        - Aquí mantengo tu contrato actual por compatibilidad.
+    """
+    use_tls = _env_bool("RABBITMQ_USE_TLS", "0")
+
+    ssl_ctx = _build_ssl_context() if use_tls else None
+
+    try:
+        connection = await _connect(settings.RABBITMQ_HOST, ssl_ctx)
+        channel = await connection.channel()
+        return connection, channel
+    except AMQPConnectionError as e:
+        # Re-lanzamos con contexto útil (no lo escondas con un fallback “mágico”).
+        raise RuntimeError(f"RabbitMQ connection failed (TLS={use_tls}) to {settings.RABBITMQ_HOST}: {e}") from e
+
+
+async def declare_exchange(channel):
+    """Declara el exchange general (broker)."""
+    return await channel.declare_exchange(
+        settings.EXCHANGE_NAME,
+        ExchangeType.TOPIC,
+        durable=True,
+    )
+
+
+async def declare_exchange_command(channel):
+    """Declara el exchange de comandos (command)."""
+    return await channel.declare_exchange(
+        settings.EXCHANGE_NAME_COMMAND,
+        ExchangeType.TOPIC,
+        durable=True,
+    )
+
+
+async def declare_exchange_saga(channel):
+    """Declara el exchange de saga (saga)."""
+    return await channel.declare_exchange(
+        settings.EXCHANGE_NAME_SAGA,
+        ExchangeType.TOPIC,
+        durable=True,
+    )
+
+
+async def declare_exchange_logs(channel):
+    """
+    Declara el exchange de logs (logs) y asegura la cola telegraf_metrics.
+    """
+    exchange = await channel.declare_exchange(
+        settings.EXCHANGE_NAME_LOGS,
+        ExchangeType.TOPIC,
+        durable=True,
+    )
+    queue = await channel.declare_queue("telegraf_metrics", durable=True)
+    await queue.bind(exchange, routing_key="#")
+    return exchange

microservice_chassis_grupo2-0.1.5rc10/microservice_chassis_grupo2/core/router_utils.py

@@ -0,0 +1,19 @@
+# -*- coding: utf-8 -*-
+"""Util/Helper functions for router definitions."""
+import logging
+import os
+from fastapi import HTTPException
+
+ORDER_SERVICE_URL = f"{os.getenv('ORDER_SERVICE', 'http://localhost')}:5000"
+MACHINE_SERVICE_URL = f"{os.getenv('MACHINE_SERVICE', 'http://localhost')}:5001"
+DELIVERY_SERVICE_URL = f"{os.getenv('DELIVERY_SERVICE', 'http://localhost')}:5002"
+PAYMENT_SERVICE_URL = f"{os.getenv('PAYMENT_SERVICE', 'http://localhost')}:5003"
+AUTH_SERVICE_URL = f"{os.getenv('AUTH_SERVICE', 'http://localhost')}:5004"
+
+logger = logging.getLogger(__name__)
+
+
+def raise_and_log_error(my_logger, status_code: int, message: str):
+    """Raises HTTPException and logs an error."""
+    my_logger.error(message)
+    raise HTTPException(status_code, message)

microservice_chassis_grupo2-0.1.5rc10/microservice_chassis_grupo2/core/security.py

@@ -0,0 +1,27 @@
+import jwt
+import os
+from fastapi import HTTPException
+from microservice_chassis_grupo2.core.config import settings
+
+#"/home/pyuser/code/auth_public.pem"
+PUBLIC_KEY_PATH = os.getenv("PUBLIC_KEY_PATH", "auth_public.pem")
+
+def read_public_pem():
+    if not os.path.exists(PUBLIC_KEY_PATH):
+        print("no hay")
+        print(PUBLIC_KEY_PATH)
+        raise ValueError(f"Public key not found at {PUBLIC_KEY_PATH}")
+    with open(PUBLIC_KEY_PATH, "r", encoding="utf-8") as f:
+        return f.read()
+
+def decode_token(token: str) -> dict:
+    try:
+        public_pem = read_public_pem()
+        payload = jwt.decode(token, public_pem, algorithms=[settings.ALGORITHM])
+        return payload
+    except FileNotFoundError as e:
+        raise HTTPException(status_code=500, detail="Public key file not found")
+    except ValueError as e:
+        raise HTTPException(status_code=401, detail=str(e))
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Unexpected error: {str(e)}")

microservice_chassis_grupo2-0.1.5rc10/microservice_chassis_grupo2/sql/database.py

@@ -0,0 +1,138 @@
+# -*- coding: utf-8 -*-
+"""microservice_chassis_grupo2.sql.database
+
+Inicialización de SQLAlchemy Async.
+
+Compatibilidad:
+    - Si existe SQLALCHEMY_DATABASE_URL, inicializa engine/SessionLocal al importar
+      (evita `engine=None` en microservicios que usan `database.engine` directamente).
+
+Modo “avanzado” (AWS/Consul):
+    - Si no existe SQLALCHEMY_DATABASE_URL, se puede usar `await init_database()`
+      para resolver RDS (por RDS_HOST o descubriendo servicio `rds` en Consul).
+"""
+from __future__ import annotations
+
+import os
+import asyncio
+import logging
+from typing import Optional
+
+from sqlalchemy.orm import sessionmaker, declarative_base
+from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, AsyncEngine
+
+from microservice_chassis_grupo2.core.consul import get_service_url
+
+logger = logging.getLogger(__name__)
+
+# Estado global
+engine: Optional[AsyncEngine] = None
+SessionLocal: Optional[sessionmaker] = None
+Base = declarative_base()
+
+_db_initialized: bool = False
+_init_lock = asyncio.Lock()
+
+
+def _safe_url_hint(url: str) -> str:
+    """Evita volcar credenciales en logs."""
+    try:
+        return url.split("://", 1)[0] + "://***"
+    except Exception:
+        return "***"
+
+
+def _create_engine_and_session(database_url: str) -> None:
+    """Crea engine y SessionLocal (sin I/O)."""
+    global engine, SessionLocal, _db_initialized
+
+    engine = create_async_engine(
+        database_url,
+        echo=False,
+        pool_pre_ping=True,
+        future=True,
+    )
+    SessionLocal = sessionmaker(
+        bind=engine,
+        class_=AsyncSession,
+        expire_on_commit=False,
+    )
+
+    _db_initialized = True
+    logger.info("[DATABASE] Engine creado (%s)", _safe_url_hint(database_url))
+
+
+async def get_database_url() -> str:
+    """Resuelve la URL de BD.
+
+    Prioridad:
+        1) SQLALCHEMY_DATABASE_URL
+        2) RDS_HOST + DB_USER/DB_PASSWORD + DB_NAME (MySQL)
+        3) DB_NAME + Consul(service=rds) + DB_USER/DB_PASSWORD (MySQL)
+        4) fallback sqlite default.db
+    """
+    env_url = os.getenv("SQLALCHEMY_DATABASE_URL")
+    if env_url:
+        return env_url
+
+    db_name = os.getenv("DB_NAME")
+    db_user = os.getenv("DB_USER")
+    db_password = os.getenv("DB_PASSWORD")
+
+    if not db_name:
+        return "sqlite+aiosqlite:///./default.db"
+
+    rds_host = os.getenv("RDS_HOST")
+    if rds_host:
+        rds_port = os.getenv("RDS_PORT", "3306")
+        if not db_user or not db_password:
+            raise RuntimeError("Faltan DB_USER/DB_PASSWORD para RDS_HOST.")
+        return f"mysql+aiomysql://{db_user}:{db_password}@{rds_host}:{rds_port}/{db_name}"
+
+    # Consul discovery
+    rds_info = await get_service_url(service_name="rds", default_url=None)
+    if rds_info.startswith("http://"):
+        rds_info = rds_info.replace("http://", "")
+    elif rds_info.startswith("https://"):
+        rds_info = rds_info.replace("https://", "")
+
+    if not db_user or not db_password:
+        raise RuntimeError("Faltan DB_USER/DB_PASSWORD para RDS via Consul.")
+
+    return f"mysql+aiomysql://{db_user}:{db_password}@{rds_info}/{db_name}"
+
+
+async def init_database() -> None:
+    """Inicializa engine y SessionLocal (idempotente y async-safe)."""
+    global _db_initialized
+
+    if _db_initialized:
+        return
+
+    async with _init_lock:
+        if _db_initialized:
+            return
+
+        database_url = await get_database_url()
+        _create_engine_and_session(database_url)
+
+
+async def dispose_database() -> None:
+    """Libera recursos de BD de forma segura."""
+    global engine, SessionLocal, _db_initialized
+
+    if engine is not None:
+        await engine.dispose()
+
+    engine = None
+    SessionLocal = None
+    _db_initialized = False
+
+
+# ✅ Compatibilidad: init eager si existe SQLALCHEMY_DATABASE_URL
+_env_url = os.getenv("SQLALCHEMY_DATABASE_URL")
+if _env_url:
+    try:
+        _create_engine_and_session(_env_url)
+    except Exception:
+        logger.exception("[DATABASE] Falló la inicialización eager desde SQLALCHEMY_DATABASE_URL.")

microservice_chassis_grupo2-0.1.5rc10/microservice_chassis_grupo2/sql/models.py

@@ -0,0 +1,30 @@
+from sqlalchemy import Column, DateTime
+from sqlalchemy.sql import func
+from microservice_chassis_grupo2.sql.database import Base
+
+class BaseModel(Base):
+    """Base database table representation to reuse."""
+    __abstract__ = True
+    creation_date = Column(DateTime(timezone=True), server_default=func.now())
+    update_date = Column(DateTime, nullable=False, server_default=func.now(), onupdate=func.now())
+
+    def __repr__(self):
+        fields = ""
+        for column in self.__table__.columns:
+            if fields == "":
+                fields = f"{column.name}='{getattr(self, column.name)}'"
+                # fields = "{}='{}'".format(column.name, getattr(self, column.name))
+            else:
+                fields = f"{fields}, {column.name}='{getattr(self, column.name)}'"
+                # fields = "{}, {}='{}'".format(fields, column.name, getattr(self, column.name))
+        return f"<{self.__class__.__name__}({fields})>"
+        # return "<{}({})>".format(self.__class__.__name__, fields)
+
+    @staticmethod
+    def list_as_dict(items):
+        """Returns list of items as dict."""
+        return [i.as_dict() for i in items]
+
+    def as_dict(self):
+        """Return the item as dict."""
+        return {c.name: getattr(self, c.name) for c in self.__table__.columns}

microservice_chassis_grupo2-0.1.5rc10/microservice_chassis_grupo2.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: microservice_chassis_grupo2
+Version: 0.1.5rc10
+Summary: A reusable library for microservices
+Home-page: https://github.com/Grupo-MACC/Chassis
+Author: Grupo 2
+Author-email: 
+Dynamic: author
+Dynamic: home-page
+Dynamic: summary

microservice_chassis_grupo2-0.1.5rc10/microservice_chassis_grupo2.egg-info/SOURCES.txt

@@ -0,0 +1,17 @@
+README.md
+setup.py
+microservice_chassis_grupo2/__init__.py
+microservice_chassis_grupo2.egg-info/PKG-INFO
+microservice_chassis_grupo2.egg-info/SOURCES.txt
+microservice_chassis_grupo2.egg-info/dependency_links.txt
+microservice_chassis_grupo2.egg-info/top_level.txt
+microservice_chassis_grupo2/core/__init__.py
+microservice_chassis_grupo2/core/config.py
+microservice_chassis_grupo2/core/consul.py
+microservice_chassis_grupo2/core/dependencies.py
+microservice_chassis_grupo2/core/rabbitmq_core.py
+microservice_chassis_grupo2/core/router_utils.py
+microservice_chassis_grupo2/core/security.py
+microservice_chassis_grupo2/sql/__init__.py
+microservice_chassis_grupo2/sql/database.py
+microservice_chassis_grupo2/sql/models.py

microservice_chassis_grupo2-0.1.5rc10/microservice_chassis_grupo2.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

microservice_chassis_grupo2-0.1.5rc10/microservice_chassis_grupo2.egg-info/top_level.txt

@@ -0,0 +1 @@
+microservice_chassis_grupo2

microservice_chassis_grupo2-0.1.5rc10/setup.cfg

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

microservice_chassis_grupo2-0.1.5rc10/setup.py

@@ -0,0 +1,12 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="microservice_chassis_grupo2",
+    version="0.1.5rc10",
+    packages=find_packages(),
+    install_requires=[],
+    author="Grupo 2",
+    author_email="",
+    description="A reusable library for microservices",
+    url="https://github.com/Grupo-MACC/Chassis",
+)