Metadata-Version: 2.3
Name: config-mounter
Version: 1.0.0
Summary: Proyecto de carga de configuraciones base a partir de un fichero YAML
Author: Damian Gonzalez
Author-email: damian@mail.com
Requires-Python: >=3.13
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.13
Requires-Dist: PyYAML (>=6.0)
Requires-Dist: logger-tracker (>=1.0.10)
Description-Content-Type: text/markdown

# Config Mounter

Una librería de Python para cargar configuraciones base desde un archivo YAML plano, proporcionando acceso centralizado a variables de configuración para aplicaciones.

## Descripción

Config Mounter es un módulo diseñado para simplificar la gestión de configuraciones en aplicaciones Python. Prioriza las variables de entorno (útiles en despliegues con contenedores/orquestadores como AWS ECS, Kubernetes o Docker Compose) y usa un archivo YAML plano como fallback para desarrollo local.

Proporciona:

- **Prioridad a variables de entorno**: Si una variable ya existe en `os.environ` (ej. desde task definition), no la sobrescribe
- **Fallback a YAML plano**: Carga `config.yml` para variables no definidas, ideal para desarrollo
- **Carga automática**: Al importar el módulo, carga configuraciones automáticamente
- **Acceso vía os.environ**: Las variables se acceden usando `os.environ.get('VARIABLE', 'default')`
- **Configuraciones para múltiples servicios**: Soporte para AWS, Jira, bases de datos y más
- **Logging integrado**: Usa logger-tracker para trazabilidad
- **Función manual de carga**: `load_config()` para recargar si es necesario

## Instalación

Instala desde PyPI:

```bash
pip install config-mounter
```

O desde el código fuente:

```bash
git clone https://github.com/tu-usuario/config-mounter.git
cd config-mounter
pip install -e .
```

## Uso

### Archivo de configuración

Crea un archivo `config.yml` en la raíz de tu proyecto. Puede ser plano o anidado; el módulo lo aplana automáticamente. Ejemplo anidado:

```yaml
debug: true
host: 0.0.0.0
port: 8080
environment: dev
connectors:
  database:
    driver: postgresql+psycopg2
    host: localhost
    port: 5432
    database: kerverus
    user: postgres
    password: admin
  jira:
    server: https://jira.example.com
    email: user@example.com
    token: token123
aws:
  region: us-east-1
  capabilities: ["CAPABILITY_IAM"]
  parameters: []
```

Esto se aplana a variables como `DEBUG`, `HOST`, `PORT`, `CONNECTORS_DATABASE_DRIVER`, `CONNECTORS_DATABASE_HOST`, etc.

### Carga automática

Al importar `config_mounter`, las variables se cargan automáticamente en `os.environ`:

```python
import config_mounter  # Carga config.yml automáticamente

# Usar las variables
import os
print(f"Entorno: {os.environ.get('ENVIRONMENT', 'dev')}")
print(f"Debug: {os.environ.get('DEBUG', 'False').lower() == 'true'}")
print(f"Región AWS: {os.environ.get('AWS_REGION')}")
print(f"Servidor Jira: {os.environ.get('JIRA_SERVER')}")
print(f"Host DB: {os.environ.get('DB_HOST')}")
```

### Carga manual

Si necesitas recargar el YAML manualmente:

```python
from config_mounter import load_config

load_config()  # Recarga las variables
```

### Configuración de ruta del archivo

Puedes especificar una ruta personalizada para el archivo de configuración usando la variable de entorno `APP_CONFIG_PATH`:

```bash
export APP_CONFIG_PATH=/path/to/my/config.yml
python tu_aplicacion.py
```

## Despliegues en contenedores

El módulo es compatible con entornos de despliegue como AWS ECS Task Definitions, Kubernetes y Docker Compose, donde las variables de entorno se pasan desde el orquestador.

### AWS ECS Task Definition
En tu `task-definition.json`, define las variables de entorno:

```json
{
  "containerDefinitions": [
    {
      "name": "my-app",
      "environment": [
        {"name": "ENVIRONMENT", "value": "prod"},
        {"name": "DB_HOST", "value": "my-db-host"}
      ]
    }
  ]
}
```

### Kubernetes
Usa ConfigMaps o Secrets para las variables:

```yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: my-config
data:
  ENVIRONMENT: "prod"
  DB_HOST: "my-db-host"
```

Y en el Deployment:

```yaml
envFrom:
- configMapRef:
    name: my-config
```

### Docker Compose
En `docker-compose.yml`:

```yaml
services:
  app:
    environment:
      - ENVIRONMENT=prod
      - DB_HOST=my-db-host
```

En todos estos casos, las variables del orquestador tienen prioridad sobre el `config.yml`. Si no se definen en el orquestador, se usan los valores del YAML como fallback.

### Definir constantes en tu proyecto

Como la librería solo carga variables en `os.environ`, define tus propias constantes en tu aplicación:

```python
import os
import config_mounter  # Carga las variables

# Definir constantes personalizadas
DEBUG = os.environ.get('DEBUG', 'True').lower() == 'true'
HOST = os.environ.get('HOST', '0.0.0.0')
PORT = int(os.environ.get('PORT', '5000'))
ENVIRONMENT = os.environ.get('ENVIRONMENT', 'dev')
DB_DRIVER = os.environ.get('CONNECTORS_DATABASE_DRIVER')
DB_HOST = os.environ.get('CONNECTORS_DATABASE_HOST')
DB_PORT = int(os.environ.get('CONNECTORS_DATABASE_PORT', '5432'))
DB_NAME = os.environ.get('CONNECTORS_DATABASE_DATABASE')
DB_USER = os.environ.get('CONNECTORS_DATABASE_USER')
DB_PASSWORD = os.environ.get('CONNECTORS_DATABASE_PASSWORD')
JIRA_SERVER = os.environ.get('CONNECTORS_JIRA_SERVER')
AWS_REGION = os.environ.get('AWS_REGION')
AWS_CAPABILITIES = os.environ.get('AWS_CAPABILITIES', '').split(',') if os.environ.get('AWS_CAPABILITIES') else []
```

Esto te da flexibilidad para definir solo las constantes que necesitas en tu proyecto.

## Dependencias

- `logger-tracker >=1.0.10`
- `PyYAML >=6.0`

