tai-sql 0.7.18__tar.gz → 0.7.19__tar.gz

{tai_sql-0.7.18 → tai_sql-0.7.19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tai-sql
-Version: 0.7.18
+Version: 0.7.19
 Summary: SQL database management and code generation tool
 License-Expression: LicenseRef-Proprietary
 License-File: LICENSE

{tai_sql-0.7.18 → tai_sql-0.7.19}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tai-sql"
-version = "0.7.18"
+version = "0.7.19"
 description = "SQL database management and code generation tool"
 license = "LicenseRef-Proprietary"
 license-files = ["LICENSE"]

{tai_sql-0.7.18 → tai_sql-0.7.19}/tai_sql/cli/commands/cmd_generate/funcs.py

@@ -1,7 +1,7 @@
 import click
 
 from tai_sql import pm
-from tai_sql.errors import ErrorCode, GenerationError, render_warning
+from tai_sql.errors import ErrorCode, GenerationError, TaiSqlError, render_warning
 from tai_sql.rules import warn_if_outdated
 
 from ...preamble import load_schema
@@ -49,6 +49,21 @@ def run_generate(schema_name: str = None):
             )
             generator.generate()
 
+        except TaiSqlError as e:
+            # El generador ya sabe qué ha fallado y cómo se arregla —un trigger que no se
+            # puede transpilar dice cuál y por qué—: su solución vale más que la genérica.
+            # Se conserva el tipo y se añade el schema y el generador delante del sitio
+            # que traía (el trigger), en vez de pisarlo.
+            raise type(e)(
+                message=f"{generator_name} falló al generar: {e.message}",
+                solution=e.solution,
+                location=' · '.join(filter(None, (
+                    f"Schema '{schema_name}'", generator_name, e.diagnostic.location,
+                ))),
+                code=e.diagnostic.code,
+                **e.diagnostic.context,
+            ) from e
+
         except Exception as e:
             raise GenerationError(
                 message=f"{generator_name} falló al generar: {e}",

{tai_sql-0.7.18 → tai_sql-0.7.19}/tai_sql/cli/commands/cmd_schema/schemas/chatbot.py

@@ -62,6 +62,11 @@ class ChatbotSchema(SchemaTemplate):
 
                 visible: col[bool] = column(default=True, index=True, description='Si no, la conversación no se lista')
                 last_message_timestamp: col[datetime | None] = column(description='Timestamp del último mensaje del chat')
+                # Por alias y no como FK a modelo.id, a propósito: el alias es con lo que el catálogo y
+                # el front piden un modelo, y uno desactivado no tiene por qué romper la conversación
+                # (cae al de por defecto). Opcional y sin default: un push la añade a una base de
+                # datos existente sin tocar sus filas
+                modelo: col[str | None] = column(description='Alias del modelo con el que responde esta conversación; sin él, el de por defecto')
 
                 messages: onetomany[Mensaje] # Relación one-to-many con la tabla Mensaje
                 token_usage: onetomany[TokenUsage] # El consumo de la conversación, tenga mensaje o no

{tai_sql-0.7.18 → tai_sql-0.7.19}/tai_sql/generators/python_client/triggers/__init__.py

@@ -12,6 +12,9 @@ ninguna capa de despacho — el coste es cero.
        (metadato puro)     →  transformer  →  AST reescrito
                            →  renderer  →  dict de contexto para Jinja2
 
+`scopes` lo usan los dos primeros: dice qué `t` es el parámetro y cuál es otra variable
+con el mismo nombre en un ámbito interno.
+
 Este código vivía en `orm/triggers.py` (1.300 de sus 2.092 líneas). Está aquí porque
 conoce los nombres de los artefactos generados (`{Model}SyncDAO`, `{Model}Create`…),
 que son conocimiento del generador, no de la definición del schema.

{tai_sql-0.7.18 → tai_sql-0.7.19}/tai_sql/generators/python_client/triggers/analyzer.py

@@ -15,9 +15,10 @@ NO le corresponde: validar que el trigger sea legal (eso ocurre en tiempo de imp
 schema, en `orm.triggers`), ni conocer la sintaxis del DSL.
 """
 from __future__ import annotations
-from typing import List, Optional
+from typing import Dict, List, Optional, Set
 import ast
 
+from . import scopes
 from .steps import TriggerStep
 
 
@@ -31,14 +32,34 @@ class TriggerAnalyzer(ast.NodeVisitor):
     - Operaciones de mutación de datos
     """
     
-    def __init__(self, source_lines: List[str]):
+    def __init__(self, source_lines: List[str], trigger_var: str = 't'):
         """
         Args:
             source_lines: Líneas del código fuente para obtener el texto original
+            trigger_var: Nombre del parámetro TriggerAPI del trigger. Con uno fijo a `'t'`,
+                un trigger que lo llamara de otra forma no registraba ninguna operación, y
+                el DAO generado no importaba los DAOs de los modelos que toca.
         """
         self.steps: List[TriggerStep] = []
         self.source_lines = source_lines
-        self.trigger_var = 't'  # Nombre del parámetro TriggerAPI (por defecto 't')
+        self.trigger_var = trigger_var
+        # Llamadas ya registradas por `visit_Assign`, para que `visit_Call` no las repita
+        self._registered: Set[int] = set()
+        # Qué `Name` son de verdad el parámetro: los calcula la primera llamada a `visit`
+        self._refs: Optional[Dict[ast.Name, Optional[str]]] = None
+
+    def visit(self, node: ast.AST):
+        """
+        Recorre `node`, resolviendo antes los ámbitos si es la primera vez.
+
+        `node` es la función del trigger (lo que pasa `analyze_steps`) o un bloque de su
+        cuerpo. De la función cuentan el cuerpo y la `lambda` de `when=`, cada uno con su
+        parámetro; un `t` re-ligado en un ámbito interno (`[x for t in ...]`) no es una
+        operación, aunque se llame `t.count(...)`.
+        """
+        if self._refs is None:
+            self._refs = _trigger_refs(node, self.trigger_var)
+        return super().visit(node)
     
     def visit_Assign(self, node: ast.Assign) -> None:
         """Visita asignaciones para detectar mutaciones de datos"""
@@ -67,10 +88,7 @@ class TriggerAnalyzer(ast.NodeVisitor):
             if self._is_crud_method(node.value.func):
                 crud_operation = node.value.func.attr
                 
-                # El primer argumento debe ser el modelo
-                model_name = None
-                if len(node.value.args) > 0 and isinstance(node.value.args[0], ast.Name):
-                    model_name = node.value.args[0].id
+                model_name = _model_name(node.value)
                 
                 # Los demás argumentos
                 args = [self._ast_to_repr(arg) for arg in node.value.args[1:]]
@@ -92,13 +110,21 @@ class TriggerAnalyzer(ast.NodeVisitor):
                     ast_node=node,
                     trigger_refs=trigger_refs
                 ))
+                self._registered.add(id(node.value))
         
         self.generic_visit(node)
     
-    def visit_Expr(self, node: ast.Expr) -> None:
-        """Visita expresiones para detectar llamadas a métodos del TriggerAPI"""
-        if isinstance(node.value, ast.Call):
-            self._visit_call(node.value)
+    def visit_Call(self, node: ast.Call) -> None:
+        """
+        Visita cualquier llamada a un método del TriggerAPI, esté donde esté.
+
+        Antes solo se miraban las sentencias sueltas y las asignaciones, así que una
+        operación en el iterable de un `for`, en un argumento o en una condición no se
+        registraba, y el DAO generado no importaba el DAO del modelo que tocaba. Las de
+        una asignación las registra `visit_Assign`, con la variable de destino.
+        """
+        if id(node) not in self._registered:
+            self._visit_call(node)
         self.generic_visit(node)
     
     def _visit_call(self, node: ast.Call) -> None:
@@ -137,10 +163,7 @@ class TriggerAnalyzer(ast.NodeVisitor):
         elif self._is_crud_method(node.func):
             crud_operation = node.func.attr  # find, create, count, etc.
             
-            # El primer argumento debe ser el modelo
-            model_name = None
-            if len(node.args) > 0 and isinstance(node.args[0], ast.Name):
-                model_name = node.args[0].id
+            model_name = _model_name(node)
             
             # Los demás argumentos son parámetros de la operación
             args = [self._ast_to_repr(arg) for arg in node.args[1:]]  # Saltar el modelo
@@ -158,18 +181,24 @@ class TriggerAnalyzer(ast.NodeVisitor):
                 trigger_refs=trigger_refs
             ))
     
+    def _is_trigger_ref(self, node: ast.AST) -> bool:
+        """Si `node` es el parámetro del trigger, y no otra variable con su nombre."""
+        if not isinstance(node, ast.Name):
+            return False
+        if self._refs is None:
+            return node.id == self.trigger_var
+        return node in self._refs
+
     def _is_trigger_attr(self, node: ast.AST, attr_name: str) -> bool:
         """Verifica si un nodo es un atributo del trigger (ej: t.data, t.old)"""
         return (isinstance(node, ast.Attribute) and 
-                isinstance(node.value, ast.Name) and 
-                node.value.id == self.trigger_var and 
+                self._is_trigger_ref(node.value) and 
                 node.attr == attr_name)
     
     def _is_trigger_method(self, node: ast.AST, method_name: str) -> bool:
         """Verifica si un nodo es una llamada a método del trigger (ej: t.log, t.abort)"""
         return (isinstance(node, ast.Attribute) and 
-                isinstance(node.value, ast.Name) and 
-                node.value.id == self.trigger_var and 
+                self._is_trigger_ref(node.value) and 
                 node.attr == method_name)
     
     def _is_crud_method(self, node: ast.AST) -> bool:
@@ -184,8 +213,7 @@ class TriggerAnalyzer(ast.NodeVisitor):
         }
         
         return (isinstance(node, ast.Attribute) and 
-                isinstance(node.value, ast.Name) and 
-                node.value.id == self.trigger_var and 
+                self._is_trigger_ref(node.value) and 
                 node.attr in crud_methods)
     
     def _extract_subscript_key(self, node: ast.Subscript) -> Optional[str]:
@@ -216,10 +244,11 @@ class TriggerAnalyzer(ast.NodeVisitor):
             Lista de referencias encontradas (ej: ['t.new', 't.old'])
         """
         references = []
+        is_trigger_ref = self._is_trigger_ref
         
         class ReferenceExtractor(ast.NodeVisitor):
             def visit_Attribute(self, node):
-                if isinstance(node.value, ast.Name) and node.value.id == 't':
+                if is_trigger_ref(node.value):
                     if node.attr in ['old', 'new']:
                         references.append(f't.{node.attr}')
                 self.generic_visit(node)
@@ -234,3 +263,34 @@ class TriggerAnalyzer(ast.NodeVisitor):
             # lineno es 1-indexed
             return self.source_lines[node.lineno - 1].strip()
         return None
+
+
+def _model_name(call: ast.Call) -> Optional[str]:
+    """El modelo de `t.<op>(Modelo, ...)`: el primer argumento, o `model=` como en `TriggerAPI`."""
+    if call.args:
+        return call.args[0].id if isinstance(call.args[0], ast.Name) else None
+    for kw in call.keywords:
+        if kw.arg == 'model' and isinstance(kw.value, ast.Name):
+            return kw.value.id
+    return None
+
+
+def _trigger_refs(node: ast.AST, trigger_var: str) -> Dict[ast.Name, Optional[str]]:
+    """
+    Las referencias al parámetro dentro de `node`, que es la función del trigger o un
+    bloque de su cuerpo.
+
+    De la función no se mira la firma —ahí `t` es el argumento, no un uso—: su cuerpo
+    con el parámetro del trigger, y la `lambda` de `when=` con el suyo, que puede
+    llamarse distinto.
+    """
+    if not isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)):
+        return scopes.param_refs([node], trigger_var)
+    refs = scopes.param_refs(node.body, trigger_var)
+    for decorator in node.decorator_list:
+        if not isinstance(decorator, ast.Call):
+            continue
+        for kw in decorator.keywords:
+            if kw.arg == 'when' and isinstance(kw.value, ast.Lambda) and kw.value.args.args:
+                refs.update(scopes.param_refs([kw.value.body], kw.value.args.args[0].arg))
+    return refs

{tai_sql-0.7.18 → tai_sql-0.7.19}/tai_sql/generators/python_client/triggers/renderer.py

@@ -20,6 +20,9 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional
 import ast
 import copy
 import re
+import textwrap
+
+from tai_sql.errors import GenerationError
 
 from .analyzer import TriggerAnalyzer
 from .transformer import TriggerCodeTransformer
@@ -57,7 +60,7 @@ def analyze_steps(trigger: Trigger) -> list:
     if not trigger.ast_tree or not trigger.source_code:
         return []
 
-    analyzer = TriggerAnalyzer(trigger.source_code.split('\n'))
+    analyzer = TriggerAnalyzer(trigger.source_code.split('\n'), _trigger_param(trigger))
     analyzer.visit(trigger.ast_tree)
     return analyzer.steps
 
@@ -71,6 +74,54 @@ def _trigger_param(trigger: Trigger) -> str:
     return 't'
 
 
+def _when_param(trigger: Trigger) -> str:
+    """
+    Nombre del parámetro de la `lambda` de `when=`.
+
+    No tiene por qué coincidir con el de la función: `when=lambda x: x.new.precio > 0`
+    sobre un `def f(self, t)` es válido. Con el de la función, el `x` se quedaba sin
+    transpilar y la condición fallaba al ejecutar con `NameError`.
+    """
+    if trigger.ast_tree:
+        for decorator in trigger.ast_tree.decorator_list:
+            if not isinstance(decorator, ast.Call):
+                continue
+            for kw in decorator.keywords:
+                if kw.arg == 'when' and isinstance(kw.value, ast.Lambda) and kw.value.args.args:
+                    return kw.value.args.args[0].arg
+    return _trigger_param(trigger)
+
+
+def _check_compiles(trigger: Trigger, code: str, mode: str, what: str) -> None:
+    """
+    Compila el código transpilado dentro de una función como la del hook que lo recibe.
+
+    Es la red de seguridad del transformer: lo que él no rechace y no sea Python válido
+    —un `await` donde no cabe, un argumento repetido— sale aquí, con el nombre del
+    trigger, y no como un DAO generado que no se puede importar.
+
+    Raises:
+        GenerationError: Si el código no compila.
+    """
+    header = 'async def _hook():' if mode == 'async' else 'def _hook():'
+    try:
+        compile(f"{header}\n{textwrap.indent(code, '    ')}\n", f'<trigger {trigger.name}>', 'exec')
+    except SyntaxError as e:
+        line = (e.text or '').strip()
+        raise GenerationError(
+            message=(
+                f"Trigger '{trigger.name}': su {what} transpilado para el cliente {mode} no "
+                f"compila: {e.msg}" + (f" (en `{line}`)" if line else "")
+            ),
+            solution=(
+                "Reescribe esa expresión de forma más sencilla —con una variable intermedia "
+                "o una comprensión de lista— y, si el trigger es Python válido, repórtalo: "
+                "es un fallo de la transpilación de tai-sql."
+            ),
+            location=trigger.name,
+        ) from e
+
+
 def render_body(
     trigger: Trigger,
     mode: str = 'sync',
@@ -115,11 +166,13 @@ def render_body(
         _trigger_param(trigger), trigger.event, mode,
         operative_str_fields if operative_str_fields is not None else [],
         tablename,
+        trigger_name=trigger.name,
     )
-    transformed = transformer.visit(module)
-    ast.fix_missing_locations(transformed)
+    transformed = transformer.transpile(module)
 
-    return '\n'.join(ast.unparse(stmt) for stmt in transformed.body)
+    code = '\n'.join(ast.unparse(stmt) for stmt in transformed.body)
+    _check_compiles(trigger, code, mode, 'cuerpo')
+    return code
 
 
 def render_when(
@@ -136,20 +189,24 @@ def render_when(
     if not trigger.when_source:
         return None
 
-    param = _trigger_param(trigger)
+    param = _when_param(trigger)
     when = trigger.when_source.strip()
 
     try:
         tree = ast.parse(when, mode='eval')
-        transformer = TriggerCodeTransformer(param, trigger.event, mode, tablename=tablename)
-        transformed = transformer.visit(tree)
-        ast.fix_missing_locations(transformed)
-        return ast.unparse(transformed.body)
     except SyntaxError:
         # Fallback: la fuente de la lambda no siempre se recupera como expresión
         # parseable (troceo de strings en el decorador). Quitar el prefijo `t.` deja
         # algo utilizable en la mayoría de casos.
-        return re.sub(rf'\b{re.escape(param)}\.', '', when)
+        code = re.sub(rf'\b{re.escape(param)}\.', '', when)
+    else:
+        transformer = TriggerCodeTransformer(
+            param, trigger.event, mode, tablename=tablename, trigger_name=trigger.name,
+        )
+        code = ast.unparse(transformer.transpile(tree).body)
+
+    _check_compiles(trigger, f"if {code}:\n    pass", mode, 'condición `when=`')
+    return code
 
 
 def render_trigger(

tai_sql-0.7.19/tai_sql/generators/python_client/triggers/scopes.py

@@ -0,0 +1,164 @@
+# -*- coding: utf-8 -*-
+"""
+Ámbitos del cuerpo de un trigger: qué apariciones de un nombre son el parámetro.
+
+CAPA: generador (`generators/python_client/triggers/`).
+
+El cuerpo de un trigger puede reutilizar el nombre del parámetro (`t`) en un ámbito
+interno —`[t.strip() for t in etiquetas]`, `lambda t: t.activo`, una función anidada
+con un argumento `t`—, y ahí `t` ya no es `TriggerAPI`. Sin distinguirlo, el
+transformer reescribía o rechazaba código que no le corresponde. Este módulo resuelve
+el ámbito una vez y devuelve qué nodos `Name` son de verdad el parámetro.
+
+De paso dice, de cada uno, si cae en un sitio donde el código generado no puede
+esperar a una corrutina: dentro de una `lambda`, de una expresión generadora o de una
+función anidada que no es `async`. En el DAO async, una operación ahí lleva un `await`
+que no compila (`lambda`, `def`) o que convierte la expresión generadora en un
+generador asíncrono que nadie sabe recorrer.
+
+Las reglas son las de Python: los argumentos por defecto, las anotaciones y los
+decoradores de una función o `lambda` se evalúan fuera; el iterable del **primer**
+`for` de una comprensión, también. Lo demás de una comprensión, el cuerpo de una
+`lambda` y el de una función anidada, dentro.
+
+NO le corresponde: reescribir nada (eso es `transformer.py`) ni registrar operaciones
+(eso es `analyzer.py`). Solo responde «¿este `t` es el parámetro?».
+"""
+from __future__ import annotations
+from typing import Dict, Iterable, Optional, Set
+import ast
+
+
+#: Dónde no se puede esperar a una corrutina, con cómo se nombra en los mensajes.
+LAMBDA = 'una `lambda`'
+GENERATOR = 'una expresión generadora'
+FUNCTION = 'una función anidada que no es `async`'
+
+_COMPREHENSIONS = (ast.ListComp, ast.SetComp, ast.DictComp, ast.GeneratorExp)
+_FUNCTIONS = (ast.FunctionDef, ast.AsyncFunctionDef)
+
+
+def param_refs(roots: Iterable[ast.AST], name: str) -> Dict[ast.Name, Optional[str]]:
+    """
+    Las apariciones de `name` que se refieren al parámetro del trigger.
+
+    Args:
+        roots: Nodos que están en el ámbito del propio trigger: las sentencias de su
+            cuerpo, un `ast.Module` con ellas o la expresión de su `when=`.
+        name: El nombre del parámetro (`t`, o el que use el trigger).
+
+    Returns:
+        Cada `ast.Name` que es el parámetro → dónde cae: `None` si se puede esperar
+        ahí, o `LAMBDA`, `GENERATOR` o `FUNCTION` si no. Las claves son los propios
+        nodos (un nodo AST se compara por identidad): quien reescribe el árbol puede
+        seguir preguntando por los que conserva.
+    """
+    refs: Dict[ast.Name, Optional[str]] = {}
+
+    def walk(node: ast.AST, shadowed: bool, deferred: Optional[str]) -> None:
+        if isinstance(node, ast.Name):
+            if node.id == name and not shadowed:
+                refs[node] = deferred
+            return
+
+        if isinstance(node, ast.Lambda):
+            _walk_all(_outer_parts(node.args), walk, shadowed, deferred)
+            walk(node.body, shadowed or name in _arg_names(node.args), LAMBDA)
+            return
+
+        if isinstance(node, _FUNCTIONS):
+            outer = [*node.decorator_list, *_outer_parts(node.args)]
+            if node.returns is not None:
+                outer.append(node.returns)
+            _walk_all(outer, walk, shadowed, deferred)
+            inner = shadowed or name in _arg_names(node.args) | local_names(node.body)
+            # Dentro de un `async def` se puede esperar, aunque esté en una lambda.
+            inner_deferred = None if isinstance(node, ast.AsyncFunctionDef) else FUNCTION
+            _walk_all(node.body, walk, inner, inner_deferred)
+            return
+
+        if isinstance(node, _COMPREHENSIONS):
+            first, *rest = node.generators
+            # El iterable del primer `for` se evalúa en el ámbito de fuera, y ya: en
+            # `[x for t in t.find_many(...)]` ese `t` sí es el parámetro.
+            walk(first.iter, shadowed, deferred)
+            bound = set()
+            for generator in node.generators:
+                bound |= _stored_names(generator.target)
+            inner = shadowed or name in bound
+            # Una comprensión de lista, conjunto o dict se evalúa en el sitio, y en un
+            # `async def` admite `await`; una expresión generadora, no.
+            inner_deferred = GENERATOR if isinstance(node, ast.GeneratorExp) else deferred
+            for i, generator in enumerate(node.generators):
+                walk(generator.target, inner, inner_deferred)
+                if i:
+                    walk(generator.iter, inner, inner_deferred)
+                _walk_all(generator.ifs, walk, inner, inner_deferred)
+            parts = [node.key, node.value] if isinstance(node, ast.DictComp) else [node.elt]
+            _walk_all(parts, walk, inner, inner_deferred)
+            return
+
+        _walk_all(ast.iter_child_nodes(node), walk, shadowed, deferred)
+
+    _walk_all(roots, walk, False, None)
+    return refs
+
+
+def local_names(body: Iterable[ast.stmt]) -> Set[str]:
+    """
+    Los nombres que liga un bloque en su propio ámbito, sin entrar en los internos.
+
+    Es lo que hace local un nombre en una función: un argumento, una asignación, el
+    destino de un `for` o de un `with`, un `import`, un `except ... as`, una `def`.
+    """
+    names: Set[str] = set()
+    declared: Set[str] = set()
+    pending = list(body)
+    while pending:
+        node = pending.pop()
+        if isinstance(node, (*_FUNCTIONS, ast.ClassDef)):
+            names.add(node.name)
+            continue
+        if isinstance(node, (ast.Lambda, *_COMPREHENSIONS)):
+            continue
+        if isinstance(node, (ast.Global, ast.Nonlocal)):
+            declared.update(node.names)
+            continue
+        if isinstance(node, ast.Name) and isinstance(node.ctx, (ast.Store, ast.Del)):
+            names.add(node.id)
+        elif isinstance(node, (ast.Import, ast.ImportFrom)):
+            names.update((alias.asname or alias.name).split('.')[0] for alias in node.names)
+        elif isinstance(node, ast.ExceptHandler) and node.name:
+            names.add(node.name)
+        pending.extend(ast.iter_child_nodes(node))
+    return names - declared
+
+
+def _walk_all(nodes, walk, shadowed: bool, deferred: Optional[str]) -> None:
+    for node in nodes:
+        if node is not None:
+            walk(node, shadowed, deferred)
+
+
+def _outer_parts(args: ast.arguments) -> list:
+    """Lo de una firma que se evalúa fuera de la función: defaults y anotaciones."""
+    parts = [*args.defaults, *args.kw_defaults]
+    for arg in (*args.posonlyargs, *args.args, args.vararg, *args.kwonlyargs, args.kwarg):
+        if arg is not None and arg.annotation is not None:
+            parts.append(arg.annotation)
+    return parts
+
+
+def _arg_names(args: ast.arguments) -> Set[str]:
+    return {
+        arg.arg
+        for arg in (*args.posonlyargs, *args.args, args.vararg, *args.kwonlyargs, args.kwarg)
+        if arg is not None
+    }
+
+
+def _stored_names(target: ast.AST) -> Set[str]:
+    return {
+        node.id for node in ast.walk(target)
+        if isinstance(node, ast.Name) and isinstance(node.ctx, ast.Store)
+    }