tai-sql 0.7.0__tar.gz → 0.7.2__tar.gz

{tai_sql-0.7.0 → tai_sql-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tai-sql
-Version: 0.7.0
+Version: 0.7.2
 Summary: SQL database management and code generation tool
 License-Expression: MIT
 License-File: LICENSE

{tai_sql-0.7.0 → tai_sql-0.7.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tai-sql"
-version = "0.7.0"
+version = "0.7.2"
 description = "SQL database management and code generation tool"
 license = "MIT"
 license-files = ["LICENSE"]

{tai_sql-0.7.0 → tai_sql-0.7.2}/tai_sql/cli/commands/cmd_schema/schemas/chatbot.py

@@ -6,7 +6,7 @@ from .base import SchemaTemplate
 
 
 class ChatbotSchema(SchemaTemplate):
-    """Plantilla chatbot: Usuario, Chat, Mensaje, TokenUsage, ToolCall, vistas"""
+    """Plantilla chatbot: Chat, Mensaje, TokenUsage, ToolCall, LimitePresupuesto y vistas"""
 
     def get_content(self) -> str:
         return dedent(f'''
@@ -113,7 +113,11 @@ class ChatbotSchema(SchemaTemplate):
                 total_tokens: col[int] = column(default=0, description='Total de tokens consumidos')
                 model_name: col[str] = column(description='Nombre del modelo utilizado')
                 provider: col[str] = column(description='Proveedor del modelo (OpenAI, Anthropic, etc.)')
-                cost_usd: col[float | None] = column(description='Costo estimado en USD')
+                cost_usd: col[float | None] = column(description='Costo estimado en USD, con el margen ya aplicado')
+                # Los precios con los que se calculó: una factura antigua se reconstruye aunque el
+                # catálogo de .config.json valga hoy otra cosa
+                input_usd_millon: col[float | None] = column(description='USD por millón de tokens de entrada aplicados')
+                output_usd_millon: col[float | None] = column(description='USD por millón de tokens de salida aplicados')
                 timestamp: col[datetime] = column(default=datetime.now, description='Timestamp del consumo')
                 message_id: col[bigint] = column(description='ID del mensaje asociado')
 
@@ -136,6 +140,19 @@ class ChatbotSchema(SchemaTemplate):
                 message: manytoone[Mensaje] = relation(fields=['message_id'], references=['id'], backref='tool_calls') # Relación many-to-one con Mensaje
 
 
+            class LimitePresupuesto(Table):
+                """Tabla que almacena el límite de gasto de cada usuario en cada mes"""
+                __tablename__ = "limite_presupuesto"
+
+                # Una fila por mes: al cerrarse el mes su límite queda congelado y las facturas
+                # antiguas no cambian aunque se reparta otra bolsa
+                mes: col[str] = column(primary_key=True, description="Mes al que se aplica, como 'YYYY-MM'")
+                # La fila con username '*' es la bolsa general, que se reparte entre los usuarios
+                username: col[str] = column(primary_key=True, description="Usuario al que aplica, o '*' para la bolsa general")
+                limite_eur: col[float] = column(default=10.0, description='Límite de gasto mensual en euros')
+                personalizado: col[bool] = column(default=False, description='True si lo fijó el administrador a mano, False si sale del reparto')
+
+
             # Definición de vistas
 
             class UserStats(View):
@@ -183,6 +200,22 @@ class ChatbotSchema(SchemaTemplate):
                 last_message_timestamp: col[datetime]
                 total_tokens_consumed: col[int]
                 is_active: col[bool]
+
+
+            class ConsumoMensual(View):
+                """Vista que muestra el consumo y el coste por usuario, mes y modelo"""
+                __tablename__ = "consumo_mensual"
+                __query__ = query('consumo_mensual.sql')
+
+                username: col[str]
+                mes: col[datetime]
+                provider: col[str]
+                model_name: col[str]
+                total_prompt_tokens: col[int]
+                total_completion_tokens: col[int]
+                total_tokens: col[int]
+                coste_usd: col[float | None]
+                message_count: col[int]
         ''').strip()
 
     def create_views(self, views_dir: Path) -> None:
@@ -260,6 +293,26 @@ class ChatbotSchema(SchemaTemplate):
             ORDER BY last_message_timestamp DESC NULLS LAST;
         ''').rstrip()
 
+        consumo_mensual_sql = dedent('''\
+            -- Vista para el consumo y el coste por usuario, mes y modelo
+            SELECT
+                c.username,
+                DATE_TRUNC('month', tu.timestamp)::date as mes,
+                tu.provider,
+                tu.model_name,
+                SUM(tu.prompt_tokens) as total_prompt_tokens,
+                SUM(tu.completion_tokens) as total_completion_tokens,
+                SUM(tu.total_tokens) as total_tokens,
+                SUM(tu.cost_usd) as coste_usd,
+                COUNT(DISTINCT m.id) as message_count
+            FROM chat c
+            JOIN mensaje m ON c.id = m.chat_id
+            JOIN token_usage tu ON m.id = tu.message_id
+            GROUP BY c.username, DATE_TRUNC('month', tu.timestamp), tu.provider, tu.model_name
+            ORDER BY mes DESC, c.username, total_tokens DESC;
+        ''').rstrip()
+
         (views_dir / 'user_stats.sql').write_text(user_stats_sql, encoding='utf-8')
         (views_dir / 'token_consumption_stats.sql').write_text(token_consumption_sql, encoding='utf-8')
         (views_dir / 'chat_activity.sql').write_text(chat_activity_sql, encoding='utf-8')
+        (views_dir / 'consumo_mensual.sql').write_text(consumo_mensual_sql, encoding='utf-8')

tai_sql-0.7.2/tai_sql/generators/__init__.py

@@ -0,0 +1,13 @@
+from .base import BaseGenerator
+from .diagram import ERDiagramGenerator
+from .python_client import PythonClientGenerator
+from .python_client import ImportLayout
+from .python_client.context import TemplateContextBuilder
+
+__all__ = [
+    'BaseGenerator',
+    'ERDiagramGenerator',
+    'PythonClientGenerator',
+    'ImportLayout',
+    'TemplateContextBuilder',
+]

{tai_sql-0.7.0 → tai_sql-0.7.2}/tai_sql/generators/python_client/context.py

@@ -18,9 +18,13 @@ NO le corresponde: analizar el schema (eso es `orm/analysis/`), decidir rutas de
 salida ni imports (eso es `PythonClientGenerator` con su `ImportLayout`), ni transpilar
 el AST de un trigger (eso es `triggers/transformer.py`).
 
-Sobre la forma de los dicts: es un contrato con las plantillas, no una API pública.
-`tests/golden/*.json` lo congela entero y `tests/test_golden_output.py` compara el
-resultado final fichero a fichero, que es la comprobación que de verdad importa.
+Qué es público y qué no: **la clase y sus métodos** (`entities`, `entity`, `table`,
+`view`, `column`, `enum`) se exportan desde `tai_sql.generators` y son contrato — los
+usa tai-api para generar sus endpoints a partir del mismo schema, y romperlos rompe la
+librería de al lado. **La forma exacta de los dicts** no lo es: la congela
+`tests/golden/*.json` y la revisa `tests/test_golden_output.py` fichero a fichero, así
+que evoluciona con las plantillas, y ese diff es donde se ve. Añadir una clave es
+seguro; quitar o renombrar una exige mirar también quién más la consume.
 """
 from __future__ import annotations
 from enum import Enum as PyEnum

{tai_sql-0.7.0 → tai_sql-0.7.2}/tai_sql/generators/python_client/templates/shared/utils/rls.py.jinja2

@@ -6,7 +6,10 @@
 import functools
 from collections import deque
 from dataclasses import dataclass
+from datetime import date, datetime, time
+from decimal import Decimal, InvalidOperation
 from enum import Enum
+from uuid import UUID
 from typing import (
     Any,
     List,
@@ -110,15 +113,10 @@ class RLS:
             else:
                 self.values = [self.values]
 
-        # Convertir strings numéricas a enteros silenciosamente
-        converted_values = []
-        for value in self.values:
-            if isinstance(value, str) and value.isdigit():
-                converted_values.append(int(value))
-            else:
-                converted_values.append(value)
-        self.values = converted_values
-        
+        # NOTA: los valores NO se convierten aquí. La coerción de tipos se hace en
+        # RLSPredicateBuilder, donde ya se conoce el tipo real de la columna objetivo.
+        # Convertir a ciegas rompía valores como "01" sobre columnas de texto.
+
     def applies_to(self, model_cls: Type[ModelType]) -> bool:
         """Determina si esta regla se aplica al modelo dado."""
         path = RelationshipPathFinder.find_path(model_cls, self.target_model)
@@ -262,7 +260,10 @@ class RLSPredicateBuilder:
         except AttributeError:
             logger.error(f"[{{ schema_name }}] Column {target_column} not found in {target_model.__name__}")
             return None
-        
+
+        # Adaptar los valores al tipo real de la columna
+        values = RLSPredicateBuilder._coerce_values(target_col, values)
+
         # Construir predicado base según el operador
         base_predicate = RLSPredicateBuilder._build_base_predicate(
             target_col, values, operator
@@ -279,10 +280,80 @@ class RLSPredicateBuilder:
             source_model, path.path, base_predicate
         )
     
+    @staticmethod
+    def _column_python_type(column: ColumnElement) -> Optional[type]:
+        """Obtiene el tipo Python de la columna, o None si no se puede determinar."""
+        try:
+            return column.type.python_type
+        except (AttributeError, NotImplementedError):
+            return None
+
+    @staticmethod
+    def _coerce_values(column: ColumnElement, values: List[Any]) -> List[Any]:
+        """
+        Adapta los valores al tipo Python de la columna objetivo.
+
+        Los valores suelen llegar como strings (atributos del token), así que una
+        columna Integer necesita "1" → 1. Lo que no debe ocurrir es la conversión a la
+        inversa: sobre una columna de texto, "01" tiene que seguir siendo "01".
+        """
+        python_type = RLSPredicateBuilder._column_python_type(column)
+        if python_type is None:
+            return values
+
+        coerced = [RLSPredicateBuilder._coerce_value(value, python_type) for value in values]
+        if coerced != values:
+            logger.debug(f"[{{ schema_name }}] RLS values coerced to {python_type.__name__}: {values} → {coerced}")
+        return coerced
+
+    @staticmethod
+    def _coerce_value(value: Any, python_type: type) -> Any:
+        """Convierte un valor al tipo Python indicado; lo deja intacto si no es posible."""
+        if value is None:
+            return value
+
+        try:
+            if python_type is bool:
+                if isinstance(value, bool):
+                    return value
+                if isinstance(value, str):
+                    normalized = value.strip().lower()
+                    if normalized in ("true", "t", "yes", "y", "1"):
+                        return True
+                    if normalized in ("false", "f", "no", "n", "0"):
+                        return False
+                    return value
+                return bool(value) if isinstance(value, int) else value
+
+            # Ya es del tipo esperado: no tocar (p.ej. "01" sobre una columna de texto)
+            if isinstance(value, python_type):
+                return value
+
+            if python_type is str:
+                return str(value)
+            if python_type is int:
+                return int(str(value).strip())
+            if python_type is float:
+                return float(str(value).strip())
+            if python_type is Decimal:
+                return Decimal(str(value).strip())
+            if python_type is UUID:
+                return UUID(str(value).strip())
+            if python_type is datetime:
+                return datetime.fromisoformat(str(value).strip())
+            if python_type is date:
+                return date.fromisoformat(str(value).strip())
+            if python_type is time:
+                return time.fromisoformat(str(value).strip())
+        except (TypeError, ValueError, InvalidOperation):
+            logger.warning(f"[{{ schema_name }}] Could not coerce RLS value {value!r} to {python_type.__name__}")
+
+        return value
+
     @staticmethod
     def _build_base_predicate(
-        column: ColumnElement, 
-        values: List[Any], 
+        column: ColumnElement,
+        values: List[Any],
         operator: RLSOperator
     ) -> Optional[ColumnElement]:
         """Construye el predicado base según el operador."""

tai_sql-0.7.0/tai_sql/generators/__init__.py

@@ -1,6 +0,0 @@
-from .base import BaseGenerator
-from .diagram import ERDiagramGenerator
-from .python_client import PythonClientGenerator
-from .python_client import ImportLayout
-
-__all__ = ['BaseGenerator','ERDiagramGenerator', 'PythonClientGenerator', 'ImportLayout']