tai-sql 0.7.8__tar.gz → 0.7.9__tar.gz

{tai_sql-0.7.8 → tai_sql-0.7.9}/PKG-INFO

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

{tai_sql-0.7.8 → tai_sql-0.7.9}/pyproject.toml

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

{tai_sql-0.7.8 → tai_sql-0.7.9}/tai_sql/cli/commands/cmd_schema/schemas/auth.py

@@ -35,7 +35,7 @@ class AuthSchema(SchemaTemplate):
                 provider=env('MAIN_DATABASE_URL'),
                 schema='auth',
                 syntax='v2',
-                operative_fields=False,
+                operative_fields=True, # Añade created_at, updated_at, created_by, updated_by a todas las tablas
             )
 
             # Configurar los generadores

tai_sql-0.7.9/tai_sql/cli/commands/cmd_schema/schemas/chatbot.py

@@ -0,0 +1,637 @@
+from __future__ import annotations
+from pathlib import Path
+from textwrap import dedent
+
+from .base import SchemaTemplate
+
+
+class ChatbotSchema(SchemaTemplate):
+    """Plantilla chatbot: Chat, Mensaje, TokenUsage, ToolCall, Modelo, Tarifa, Bolsa,
+    LimitePresupuesto y vistas"""
+
+    def get_content(self) -> str:
+        return dedent(f'''
+            # -*- coding: utf-8 -*-
+            """
+            Esquema de base de datos para un chatbot con soporte de mensajes, tokens y herramientas.
+            Usa tai_sql para definir tablas, relaciones, vistas y generar automáticamente modelos y CRUDs.
+            Ejecuta por consola tai-sql generate para generar los recursos definidos en este esquema.
+            """
+            from __future__ import annotations
+            import os
+            from tai_sql import *
+            from tai_sql.generators import *
+
+
+            # Configurar el datasource
+            datasource(
+                provider=env('MAIN_DATABASE_URL'), # Además de env, también puedes usar (para testing) connection_string y params
+                schema='{self.schema_name}', # Esquema del datasource
+                syntax='v2', # Sintaxis V2: col[type], onetomany[Model], manytoone[Model]
+                operative_fields=True, # Añade created_at, updated_at, created_by, updated_by a todas las tablas
+            )
+
+            # Configurar los generadores
+            generate(
+                PythonClientGenerator(
+                    output_dir=[
+                        '{self.namespace}/{self.subnamespace}', # Directorio donde se generará el cliente python
+                        # Añade más directorios aquí
+                    ]
+                ),
+                ERDiagramGenerator(
+                    output_dir=[
+                        '{self.namespace}/diagrams', # Directorio donde se generará el diagrama
+                        # Añade más directorios aquí
+                    ],
+                    theme='classic',
+                    format='html'
+                )
+            )
+
+            # Definición de tablas y relaciones
+
+            class Chat(Table):
+                """Tabla que almacena las conversaciones del chatbot"""
+                __tablename__ = "chat"
+
+                id: col[bigint] = column(primary_key=True, autoincrement=True, description='UUID del chat')
+                title: col[str] = column(description='Título de la conversación')
+                username: col[str] = column(description='ID del usuario propietario del chat')
+                is_active: col[bool] = column(default=True, description='Estado activo del chat')
+                last_message_timestamp: col[datetime | None] = column(description='Timestamp del último mensaje del chat')
+
+                messages: onetomany[Mensaje] # Relación one-to-many con la tabla Mensaje
+
+
+            class Feedback(Enum):
+                """Enum para el feedback de los mensajes"""
+                GOOD = 'good'
+                BAD = 'bad'
+
+
+            class MessageRole(Enum):
+                """Roles de los mensajes en el chat"""
+                USER = 'usuario'
+                ASSISTANT = 'asistente'
+                SYSTEM = 'sistema'
+
+
+            class Mensaje(Table):
+                """Tabla que almacena los mensajes individuales de cada chat"""
+                __tablename__ = "mensaje"
+
+                id: col[bigint] = column(primary_key=True, autoincrement=True, description='UUID del mensaje')
+                content: col[str] = column(description='Contenido del mensaje')
+                role: col[MessageRole] = column(description='Rol del mensaje (user, assistant, system)')
+                timestamp: col[datetime] = column(default=datetime.now, description='Timestamp del mensaje')
+                feedback: col[Feedback] = column(default=Feedback.GOOD, description='Feedback del mensaje')
+                feedback_comment: col[str | None] = column(description='Comentario adicional del feedback')
+                reasoning: col[str | None] = column(description='Texto de razonamiento del agente antes de usar herramientas')
+                agent_iterations: col[int] = column(default=0, description='Número de iteraciones del agente')
+                total_duration_ms: col[int | None] = column(description='Duración total de la respuesta en ms')
+                model_name: col[str | None] = column(description='Modelo con el que se respondió')
+                provider: col[str | None] = column(description='Proveedor del modelo con el que se respondió')
+
+                chat_id: col[bigint] = column(description='ID del chat al que pertenece el mensaje')
+
+                token_usage: onetomany[TokenUsage] # Relación one-to-many con la tabla TokenUsage
+                tool_calls: onetomany[ToolCall] # Relación one-to-many con la tabla ToolCall
+
+                chat: manytoone[Chat] = relation(fields=['chat_id'], references=['id'], backref='messages') # Relación many-to-one con Chat
+
+                @on_create(timing='after')
+                def update_last_message_timestamp(self, t: TriggerAPI):
+                    """Actualiza el timestamp del último mensaje en el chat"""
+                    t.update(Chat, self.chat_id, last_message_timestamp=self.timestamp)
+
+
+            class TokenUsage(Table):
+                """Tabla que almacena el consumo de tokens de cada respuesta"""
+                __tablename__ = "token_usage"
+
+                id: col[bigint] = column(primary_key=True, autoincrement=True)
+                prompt_tokens: col[int] = column(default=0, description='Tokens consumidos en el prompt')
+                completion_tokens: col[int] = column(default=0, description='Tokens consumidos en la respuesta')
+                total_tokens: col[int] = column(default=0, description='Total de tokens consumidos')
+                timestamp: col[datetime] = column(default=datetime.now, description='Timestamp del consumo')
+
+                username: col[str] = column(index=True, description='Usuario que consumió')
+                message_id: col[bigint | None] = column(description='Mensaje que lo generó; vacío si se borró la conversación')
+
+                tarifa_id: col[bigint | None] = column(index=True, description='Tarifa con la que se valora')
+                bolsa_id: col[bigint | None] = column(index=True, description='Bolsa a la que se carga; vacío si no hay bolsas')
+
+                message: manytoone[Mensaje] = relation(fields=['message_id'], references=['id'], backref='token_usage', onDelete='set null')
+
+
+            class ToolCall(Table):
+                """Tabla que almacena las llamadas a herramientas realizadas por el agente durante la generación de respuestas"""
+                __tablename__ = "tool_call"
+
+                id: col[bigint] = column(primary_key=True, autoincrement=True, description='ID de la llamada a herramienta')
+                tool_name: col[str] = column(description='Nombre de la herramienta invocada')
+                tool_args: col[dict | None] = column(description='Argumentos de entrada en formato JSON')
+                tool_result: col[dict | None] = column(description='Resultado de la herramienta en formato JSON')
+                duration_ms: col[int | None] = column(description='Duración de la ejecución en milisegundos')
+                success: col[bool] = column(default=True, description='Si la llamada fue exitosa')
+                timestamp: col[datetime] = column(default=datetime.now, description='Timestamp de la llamada')
+                message_id: col[bigint] = column(description='ID del mensaje asociado')
+
+                message: manytoone[Mensaje] = relation(fields=['message_id'], references=['id'], backref='tool_calls') # Relación many-to-one con Mensaje
+
+
+            class Modelo(Table):
+                """Tabla que almacena los modelos con los que puede responder el agente"""
+                __tablename__ = "modelo"
+
+                id: col[bigint] = column(primary_key=True, autoincrement=True)
+                alias: col[str] = column(unique=True, description='Nombre corto con el que se pide el modelo')
+                etiqueta: col[str | None] = column(description='Nombre con el que se ve en el chat; sin él se usa el del modelo')
+                provider: col[str] = column(description='Proveedor: openai, azure-openai, anthropic o google')
+                model_name: col[str] = column(description='Nombre del modelo o del despliegue')
+                endpoint: col[str | None] = column(description='Endpoint del proveedor cloud')
+                # Solo el nombre de la variable: la clave no se guarda en la base de datos
+                api_key_env: col[str | None] = column(description='Variable de entorno que guarda la clave')
+                credentials_path: col[str | None] = column(description='Ruta del fichero de credenciales de Google')
+                google_cloud_project: col[str | None] = column(description='Proyecto de Google Cloud')
+                location: col[str | None] = column(description='Región del modelo en Google Cloud')
+                max_tokens: col[int] = column(default=2048, description='Máximo de tokens de la respuesta')
+                temperature: col[float] = column(default=0.7, description='Temperatura de generación')
+                thinking_budget: col[int | None] = column(description='Presupuesto de razonamiento')
+                activo: col[bool] = column(default=True, description='Si no está activo, no se puede pedir')
+                por_defecto: col[bool] = column(default=False, description='Con el que se responde si no se pide otro')
+
+                tarifas: onetomany[Tarifa] # Relación one-to-many con la tabla Tarifa
+
+
+            class Tarifa(Table):
+                """Tabla que almacena el precio y el margen de un modelo a partir de una fecha"""
+                __tablename__ = "tarifa"
+
+                id: col[bigint] = column(primary_key=True, autoincrement=True)
+                modelo_id: col[bigint] = column(description='Modelo al que pone precio')
+                precio_input_eur_millon: col[float] = column(default=0.0, description='Euros por millón de tokens de entrada, al precio del proveedor')
+                precio_output_eur_millon: col[float] = column(default=0.0, description='Euros por millón de tokens de salida, al precio del proveedor')
+                margen: col[float] = column(default=1.0, description='Multiplicador comercial sobre el precio del proveedor')
+                desde: col[date] = column(description='Primer día en que rige')
+                # Una tarifa no se edita ni se borra: se da de alta la siguiente con su `desde` y la
+                # vista cierra la anterior. Es lo que permite saber con qué precio y con qué margen se
+                # valoró un consumo de hace meses. `hasta` solo se rellena para retirar un modelo
+                hasta: col[date | None] = column(description='Cierre explícito, para dejar de poder usar el modelo')
+
+                modelo: manytoone[Modelo] = relation(fields=['modelo_id'], references=['id'], backref='tarifas', onDelete='restrict')
+
+
+            class Bolsa(Table):
+                """Tabla que almacena las bolsas de consumo contratadas"""
+                __tablename__ = "bolsa"
+
+                # El id marca el orden de la cadena: se gasta la más antigua que quede con saldo.
+                # La fecha de alta es `created_at`, que ya ponen los campos operativos
+                id: col[bigint] = column(primary_key=True, autoincrement=True)
+                nombre: col[str] = column(description='Nombre con el que se ve en facturación')
+                importe_eur: col[float] = column(default=0.0, description='Euros contratados')
+
+
+            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 el límite por defecto del mes, el que se le pone a quien
+                # llega nuevo; el límite general es la suma de los individuales
+                username: col[str] = column(primary_key=True, description="Usuario al que aplica, o '*' para el límite por defecto")
+                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):
+                """Vista que muestra estadísticas de usuarios y sus chats"""
+                __tablename__ = "user_stats"
+                __query__ = query('user_stats.sql') # Esto es necesario para usar tai-sql push
+
+                username: col[str]
+                total_chats: col[int]
+                active_chats: col[int]
+                total_messages: col[int]
+                last_activity: col[datetime | None]
+
+                most_used_model: col[str | None]
+                most_used_model_total_tokens: col[int]
+                most_used_model_active_days: col[int]
+
+
+            class ConsumoDiario(View):
+                """Vista que muestra el consumo por usuario, día y modelo"""
+                __tablename__ = "consumo_diario"
+                __query__ = query('consumo_diario.sql')
+
+                username: col[str]
+                date: col[datetime]
+                provider: col[str]
+                model_name: col[str]
+                total_prompt_tokens: col[int]
+                total_completion_tokens: col[int]
+                total_tokens: col[int]
+                total_cost_eur: col[float]
+                chat_count: col[int]
+                message_count: col[int]
+
+
+            class ChatActivity(View):
+                """Vista que muestra la actividad reciente de chats"""
+                __tablename__ = "chat_activity"
+                __query__ = query('chat_activity.sql')
+
+                chat_id: col[str]
+                chat_title: col[str]
+                username: col[str]
+                message_count: col[int]
+                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_eur: col[float]
+                message_count: col[int]
+
+
+            class TokensMensaje(View):
+                """Vista que muestra los tokens de cada mensaje, sin importes"""
+                __tablename__ = "tokens_mensaje"
+                __query__ = query('tokens_mensaje.sql')
+
+                message_id: col[bigint]
+                chat_id: col[bigint]
+                model_name: col[str | None]
+                provider: col[str | None]
+                prompt_tokens: col[int]
+                completion_tokens: col[int]
+                total_tokens: col[int]
+
+
+            class BolsaEstado(View):
+                """Vista que muestra cuánto lleva gastado cada bolsa de consumo"""
+                __tablename__ = "bolsa_estado"
+                __query__ = query('bolsa_estado.sql')
+
+                bolsa_id: col[bigint]
+                nombre: col[str]
+                importe_eur: col[float]
+                alta: col[datetime]
+                consumido_eur: col[float]
+                restante_eur: col[float]
+                primer_consumo: col[datetime | None]
+                ultimo_consumo: col[datetime | None]
+                estado: col[str]
+
+
+            class TarifaVigente(View):
+                """Vista que muestra la tarifa que rige hoy para cada modelo, a precio de venta"""
+                __tablename__ = "tarifa_vigente"
+                __query__ = query('tarifa_vigente.sql')
+
+                tarifa_id: col[bigint]
+                modelo_id: col[bigint]
+                alias: col[str]
+                provider: col[str]
+                model_name: col[str]
+                precio_input_eur_millon: col[float]
+                precio_output_eur_millon: col[float]
+                desde: col[date]
+                hasta: col[date | None]
+
+
+            class TarifaHistorico(View):
+                """Vista que muestra todas las tarifas de cada modelo, a precio de venta"""
+                __tablename__ = "tarifa_historico"
+                __query__ = query('tarifa_historico.sql')
+
+                tarifa_id: col[bigint]
+                modelo_id: col[bigint]
+                alias: col[str]
+                provider: col[str]
+                model_name: col[str]
+                precio_input_eur_millon: col[float]
+                precio_output_eur_millon: col[float]
+                desde: col[date]
+                hasta: col[date | None]
+                vigente: col[bool]
+
+
+            class ModeloDisponible(View):
+                """Vista que muestra el catálogo de modelos, sin sus datos de conexión"""
+                __tablename__ = "modelo_disponible"
+                __query__ = query('modelo_disponible.sql')
+
+                modelo_id: col[bigint]
+                alias: col[str]
+                etiqueta: col[str]
+                provider: col[str]
+                model_name: col[str]
+                activo: col[bool]
+                por_defecto: col[bool]
+                con_tarifa: col[bool]
+
+
+            class UsuarioFacturacion(View):
+                """Vista que muestra los usuarios a los que se factura"""
+                __tablename__ = "usuario_facturacion"
+                __query__ = query('usuario_facturacion.sql')
+
+                username: col[str]
+                realm_name: col[str]
+                first_name: col[str | None]
+                last_name: col[str | None]
+                full_name: col[str | None]
+                email: col[str | None]
+                is_active: col[bool]
+                alta: col[datetime]
+        ''').strip()
+
+    def create_views(self, views_dir: Path) -> None:
+        bolsa_estado_sql = dedent('''\
+            -- Vista con lo que lleva gastado cada bolsa de consumo. Las bolsas se encadenan por orden
+            -- de alta: se gasta la más antigua hasta agotarla y entonces entra la siguiente
+            WITH gasto AS (
+                SELECT
+                    b.id,
+                    b.nombre,
+                    b.importe_eur,
+                    b.created_at,
+                    COALESCE(SUM(ROUND(((tu.prompt_tokens * t.precio_input_eur_millon
+                                       + tu.completion_tokens * t.precio_output_eur_millon)
+                                       * t.margen / 1000000)::numeric, 8)), 0)::double precision as consumido_eur,
+                    MIN(tu.timestamp) as primer_consumo,
+                    MAX(tu.timestamp) as ultimo_consumo
+                FROM bolsa b
+                LEFT JOIN token_usage tu ON tu.bolsa_id = b.id
+                LEFT JOIN tarifa t ON t.id = tu.tarifa_id
+                GROUP BY b.id, b.nombre, b.importe_eur, b.created_at
+            )
+            SELECT
+                g.id as bolsa_id,
+                g.nombre,
+                g.importe_eur,
+                g.created_at as alta,
+                g.consumido_eur,
+                GREATEST(g.importe_eur - g.consumido_eur, 0) as restante_eur,
+                g.primer_consumo,
+                g.ultimo_consumo,
+                CASE
+                    WHEN g.consumido_eur >= g.importe_eur THEN 'agotada'
+                    WHEN g.id = (SELECT MIN(h.id) FROM gasto h WHERE h.consumido_eur < h.importe_eur) THEN 'en uso'
+                    ELSE 'en espera'
+                END as estado
+            FROM gasto g
+            ORDER BY g.id;
+        ''').rstrip()
+
+        chat_activity_sql = dedent('''\
+            -- Vista para actividad de chats
+            SELECT 
+                c.id as chat_id,
+                c.title as chat_title,
+                c.username,
+                COUNT(m.id) as message_count,
+                MAX(m.timestamp) as last_message_timestamp,
+                COALESCE(SUM(tu.total_tokens), 0) as total_tokens_consumed,
+                c.is_active
+            FROM chat c
+            LEFT JOIN mensaje m ON c.id = m.chat_id
+            LEFT JOIN token_usage tu ON m.id = tu.message_id
+            GROUP BY c.id, c.title, c.username, c.is_active
+            ORDER BY last_message_timestamp DESC NULLS LAST;
+        ''').rstrip()
+
+        consumo_diario_sql = dedent('''\
+            -- Vista para el consumo por usuario, día y modelo
+            SELECT
+                tu.username,
+                DATE(tu.timestamp) as date,
+                m.provider,
+                m.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(ROUND(((tu.prompt_tokens * t.precio_input_eur_millon
+                          + tu.completion_tokens * t.precio_output_eur_millon)
+                          * t.margen / 1000000)::numeric, 8))::double precision as total_cost_eur,
+                COUNT(DISTINCT me.chat_id) as chat_count,
+                COUNT(*) as message_count
+            FROM token_usage tu
+            JOIN tarifa t ON t.id = tu.tarifa_id
+            JOIN modelo m ON m.id = t.modelo_id
+            LEFT JOIN mensaje me ON me.id = tu.message_id
+            GROUP BY tu.username, DATE(tu.timestamp), m.provider, m.model_name
+            ORDER BY date DESC, total_tokens DESC;
+        ''').rstrip()
+
+        consumo_mensual_sql = dedent('''\
+            -- Vista para el consumo y el coste por usuario, mes y modelo. El importe se calcula aquí:
+            -- el apunte guarda con qué tarifa se valora y el margen no sale de la tabla `tarifa`
+            SELECT
+                tu.username,
+                DATE_TRUNC('month', tu.timestamp)::date as mes,
+                m.provider,
+                m.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(ROUND(((tu.prompt_tokens * t.precio_input_eur_millon
+                          + tu.completion_tokens * t.precio_output_eur_millon)
+                          * t.margen / 1000000)::numeric, 8))::double precision as coste_eur,
+                COUNT(*) as message_count
+            FROM token_usage tu
+            JOIN tarifa t ON t.id = tu.tarifa_id
+            JOIN modelo m ON m.id = t.modelo_id
+            GROUP BY tu.username, DATE_TRUNC('month', tu.timestamp), m.provider, m.model_name
+            ORDER BY mes DESC, tu.username, total_tokens DESC;
+        ''').rstrip()
+
+        modelo_disponible_sql = dedent('''\
+            -- Vista con el catálogo de modelos; el endpoint y la variable de la clave no salen de aquí
+            WITH ventana AS (
+                SELECT
+                    t.modelo_id,
+                    t.id,
+                    t.desde,
+                    COALESCE(
+                        t.hasta,
+                        LEAD(t.desde) OVER (PARTITION BY t.modelo_id ORDER BY t.desde) - 1
+                    ) as hasta_efectivo
+                FROM tarifa t
+            ),
+            vigente AS (
+                SELECT v.modelo_id, v.id
+                FROM ventana v
+                WHERE v.desde <= CURRENT_DATE
+                  AND (v.hasta_efectivo IS NULL OR v.hasta_efectivo >= CURRENT_DATE)
+            )
+            SELECT
+                m.id as modelo_id,
+                m.alias,
+                COALESCE(m.etiqueta, m.model_name) as etiqueta,
+                m.provider,
+                m.model_name,
+                m.activo,
+                m.por_defecto,
+                (vi.id IS NOT NULL) as con_tarifa
+            FROM modelo m
+            LEFT JOIN vigente vi ON vi.modelo_id = m.id
+            ORDER BY m.alias;
+        ''').rstrip()
+
+        tarifa_historico_sql = dedent('''\
+            -- Vista con todas las tarifas de cada modelo y el periodo en que rigieron, a precio de venta
+            WITH ventana AS (
+                SELECT
+                    t.*,
+                    COALESCE(
+                        t.hasta,
+                        LEAD(t.desde) OVER (PARTITION BY t.modelo_id ORDER BY t.desde) - 1
+                    ) as hasta_efectivo
+                FROM tarifa t
+            )
+            SELECT
+                v.id as tarifa_id,
+                v.modelo_id,
+                m.alias,
+                m.provider,
+                m.model_name,
+                (v.precio_input_eur_millon * v.margen)::double precision as precio_input_eur_millon,
+                (v.precio_output_eur_millon * v.margen)::double precision as precio_output_eur_millon,
+                v.desde,
+                v.hasta_efectivo as hasta,
+                (v.desde <= CURRENT_DATE
+                 AND (v.hasta_efectivo IS NULL OR v.hasta_efectivo >= CURRENT_DATE)) as vigente
+            FROM ventana v
+            JOIN modelo m ON m.id = v.modelo_id
+            ORDER BY m.alias, v.desde DESC;
+        ''').rstrip()
+
+        tarifa_vigente_sql = dedent('''\
+            -- Vista con la tarifa que rige hoy para cada modelo, ya a precio de venta: el precio del
+            -- proveedor y el margen no salen de la tabla. La ventana se deriva de la tarifa siguiente,
+            -- así que dar de alta una tarifa nueva no obliga a cerrar la anterior
+            WITH ventana AS (
+                SELECT
+                    t.*,
+                    COALESCE(
+                        t.hasta,
+                        LEAD(t.desde) OVER (PARTITION BY t.modelo_id ORDER BY t.desde) - 1
+                    ) as hasta_efectivo
+                FROM tarifa t
+            )
+            SELECT
+                v.id as tarifa_id,
+                v.modelo_id,
+                m.alias,
+                m.provider,
+                m.model_name,
+                (v.precio_input_eur_millon * v.margen)::double precision as precio_input_eur_millon,
+                (v.precio_output_eur_millon * v.margen)::double precision as precio_output_eur_millon,
+                v.desde,
+                v.hasta_efectivo as hasta
+            FROM ventana v
+            JOIN modelo m ON m.id = v.modelo_id
+            WHERE v.desde <= CURRENT_DATE
+              AND (v.hasta_efectivo IS NULL OR v.hasta_efectivo >= CURRENT_DATE)
+            ORDER BY m.alias;
+        ''').rstrip()
+
+        tokens_mensaje_sql = dedent('''\
+            -- Vista con los tokens de cada mensaje; no lleva importes a propósito: es la única que
+            -- puede leer cualquier usuario
+            SELECT
+                tu.message_id,
+                m.chat_id,
+                m.model_name,
+                m.provider,
+                SUM(tu.prompt_tokens) as prompt_tokens,
+                SUM(tu.completion_tokens) as completion_tokens,
+                SUM(tu.total_tokens) as total_tokens
+            FROM token_usage tu
+            JOIN mensaje m ON m.id = tu.message_id
+            GROUP BY tu.message_id, m.chat_id, m.model_name, m.provider;
+        ''').rstrip()
+
+        user_stats_sql = dedent('''\
+            -- Vista para estadísticas de usuarios
+            WITH top_model AS (
+                SELECT DISTINCT ON (c.username)
+                    c.username,
+                    m.model_name,
+                    SUM(tu.total_tokens) AS total_tokens,
+                    COUNT(DISTINCT DATE(tu.timestamp)) AS active_days
+                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, m.model_name
+                ORDER BY c.username, SUM(tu.total_tokens) DESC
+            )
+
+            SELECT
+                c.username,
+                COUNT(DISTINCT c.id) AS total_chats,
+                COUNT(DISTINCT CASE WHEN c.is_active THEN c.id END) AS active_chats,
+                COUNT(DISTINCT m.id) AS total_messages,
+                MAX(m.timestamp) AS last_activity,
+
+                tm.model_name AS most_used_model,
+                tm.total_tokens AS most_used_model_total_tokens,
+                tm.active_days AS most_used_model_active_days
+
+            FROM chat c
+            LEFT JOIN mensaje m ON c.id = m.chat_id
+            LEFT JOIN top_model tm ON c.username = tm.username
+            GROUP BY
+                c.username,
+                tm.model_name,
+                tm.total_tokens,
+                tm.active_days;
+        ''').rstrip()
+
+        usuario_facturacion_sql = dedent('''\
+            -- Vista con los usuarios a los que se factura. Es la que leen las pantallas de facturación:
+            -- /rbac/{realm}/user pide administración del realm y la contraseña no sale de aquí
+            SELECT
+                u.username,
+                u.realm_name,
+                u.first_name,
+                u.last_name,
+                u.full_name,
+                u.email,
+                u.is_active,
+                u.created_at as alta
+            FROM auth."user" u
+            ORDER BY u.username;
+        ''').rstrip()
+
+        (views_dir / 'bolsa_estado.sql').write_text(bolsa_estado_sql, encoding='utf-8')
+        (views_dir / 'chat_activity.sql').write_text(chat_activity_sql, encoding='utf-8')
+        (views_dir / 'consumo_diario.sql').write_text(consumo_diario_sql, encoding='utf-8')
+        (views_dir / 'consumo_mensual.sql').write_text(consumo_mensual_sql, encoding='utf-8')
+        (views_dir / 'modelo_disponible.sql').write_text(modelo_disponible_sql, encoding='utf-8')
+        (views_dir / 'tarifa_historico.sql').write_text(tarifa_historico_sql, encoding='utf-8')
+        (views_dir / 'tarifa_vigente.sql').write_text(tarifa_vigente_sql, encoding='utf-8')
+        (views_dir / 'tokens_mensaje.sql').write_text(tokens_mensaje_sql, encoding='utf-8')
+        (views_dir / 'user_stats.sql').write_text(user_stats_sql, encoding='utf-8')
+        (views_dir / 'usuario_facturacion.sql').write_text(usuario_facturacion_sql, encoding='utf-8')