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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tai-sql
-Version: 0.7.18
+Version: 0.7.20
 Summary: SQL database management and code generation tool
 License-Expression: LicenseRef-Proprietary
 License-File: LICENSE
@@ -211,9 +211,10 @@ poetry run pytest -m mysql                   # el ciclo completo contra MySQL
 Los tests marcados `db` necesitan un PostgreSQL alcanzable y se **saltan** si no lo hay; los
 marcados `mysql`, un MySQL en `TAI_SQL_MYSQL_URL`. Sus schemas salen de `tests/fixtures/project/`.
 
-El CI tiene tres workflows: `tests.yaml` ejecuta la suite en cada push y PR a `main` y `dev` —un
-trabajo con PostgreSQL y otro con MySQL—, `docs.yaml` publica el manual y `publish.yaml` publica
-a PyPI en push a `main`. La rama de trabajo habitual es `dev`, y la versión se bumpea a mano en
+El CI tiene tres workflows: `tests.yaml` ejecuta la suite en cada PR a `main` y `dev` —un trabajo
+con PostgreSQL y otro con MySQL—, `docs.yaml` publica el manual y `publish.yaml` publica a PyPI en
+push a `main`, después de volver a pasar la suite. En los push no se ejecuta aparte, ni en una PR
+que solo cambia documentación (`docs/`, `specs/`, `.claude/`). La rama de trabajo habitual es `dev`, y la versión se bumpea a mano en
 `pyproject.toml`.
 
 ### El manual, en local

{tai_sql-0.7.18 → tai_sql-0.7.20}/README.md

@@ -148,9 +148,10 @@ poetry run pytest -m mysql                   # el ciclo completo contra MySQL
 Los tests marcados `db` necesitan un PostgreSQL alcanzable y se **saltan** si no lo hay; los
 marcados `mysql`, un MySQL en `TAI_SQL_MYSQL_URL`. Sus schemas salen de `tests/fixtures/project/`.
 
-El CI tiene tres workflows: `tests.yaml` ejecuta la suite en cada push y PR a `main` y `dev` —un
-trabajo con PostgreSQL y otro con MySQL—, `docs.yaml` publica el manual y `publish.yaml` publica
-a PyPI en push a `main`. La rama de trabajo habitual es `dev`, y la versión se bumpea a mano en
+El CI tiene tres workflows: `tests.yaml` ejecuta la suite en cada PR a `main` y `dev` —un trabajo
+con PostgreSQL y otro con MySQL—, `docs.yaml` publica el manual y `publish.yaml` publica a PyPI en
+push a `main`, después de volver a pasar la suite. En los push no se ejecuta aparte, ni en una PR
+que solo cambia documentación (`docs/`, `specs/`, `.claude/`). La rama de trabajo habitual es `dev`, y la versión se bumpea a mano en
 `pyproject.toml`.
 
 ### El manual, en local

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

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

{tai_sql-0.7.18 → tai_sql-0.7.20}/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.20}/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.20}/tai_sql/errors/render.py

@@ -49,6 +49,19 @@ def _console(stream: Optional[TextIO] = None):
     return Console(file=stream or sys.stderr, soft_wrap=True)
 
 
+def _escape(text) -> str:
+    """
+    El texto de un diagnóstico, a salvo del marcado de `rich`.
+
+    Lo que se interpola en `console.print()` se interpreta como marcado, y un corchete se
+    toma por una etiqueta de estilo: `pip install 'tai-sql[vectors]'` salía como
+    `pip install 'tai-sql'`, justo la solución que no funciona.
+    """
+    from rich.markup import escape
+
+    return escape(str(text))
+
+
 def shorten_path(path) -> str:
     """
     Deja una ruta relativa al directorio actual, si cuelga de él.
@@ -111,17 +124,17 @@ def render_diagnostics(
 def _render_one_rich(console, diagnostic: Diagnostic, context: Optional[str]) -> None:
     """Un problema: tres líneas, sin marco."""
     console.print()
-    console.print(f"[bold red]❌ {diagnostic.message}[/bold red]")
+    console.print(f"[bold red]❌ {_escape(diagnostic.message)}[/bold red]")
 
     detail = _detail_line(diagnostic, context)
     if detail:
-        console.print(f"   [dim]📍 {detail}[/dim]")
+        console.print(f"   [dim]📍 {_escape(detail)}[/dim]")
 
-    console.print(f"   [yellow]💡 {diagnostic.solution}[/yellow]")
+    console.print(f"   [yellow]💡 {_escape(diagnostic.solution)}[/yellow]")
 
     if diagnostic.context:
         extra = ', '.join(f'{k}={v}' for k, v in diagnostic.context.items())
-        console.print(f"   [dim]ℹ️  {extra}[/dim]")
+        console.print(f"   [dim]ℹ️  {_escape(extra)}[/dim]")
 
     console.print()
 
@@ -134,7 +147,7 @@ def _render_many_rich(
     from rich.text import Text
 
     total = len(diagnostics)
-    where = f' en {context}' if context else ''
+    where = f' en {_escape(context)}' if context else ''
     console.print(f"\n[bold red]❌ Se encontraron {total} errores{where}[/bold red]\n")
 
     for i, diagnostic in enumerate(diagnostics, 1):
@@ -235,11 +248,11 @@ def render_warning(
             print(f"   💡 {hint}", file=out)
         return
 
-    console.print(f"[bold yellow]⚠️  {message}[/bold yellow]")
+    console.print(f"[bold yellow]⚠️  {_escape(message)}[/bold yellow]")
     if location:
-        console.print(f"   [dim]📍 {location}[/dim]")
+        console.print(f"   [dim]📍 {_escape(location)}[/dim]")
     if hint:
-        console.print(f"   [yellow]💡 {hint}[/yellow]")
+        console.print(f"   [yellow]💡 {_escape(hint)}[/yellow]")
 
 
 __all__ = ['render_diagnostics', 'render_warning']

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

@@ -307,6 +307,22 @@ class PythonClientGenerator(BaseGenerator):
     def _all_models_data(self, mode: str = 'sync') -> List[Dict[str, Any]]:
         return self.context.entities(mode)
 
+    @staticmethod
+    def _writes_vectors(all_models: List[Dict[str, Any]]) -> bool:
+        """
+        Whether some table of the schema computes a vector on write (`vector_column` with
+        an encoder and a `source`).
+
+        It is schema-wide, not per table: a DAO also writes the nested rows of other
+        tables, and those can carry a vector.
+        """
+        return any(
+            col.get('type') == 'vector' and col.get('has_encoder')
+            and col.get('encoder_config') and col.get('source')
+            for m in all_models
+            for col in m.get('columns', [])
+        )
+
     # ── Generate ──────────────────────────────────────────────────────────
 
     def generate(self) -> str:
@@ -525,6 +541,7 @@ class PythonClientGenerator(BaseGenerator):
             schema_name=self.schema.name,
             max_depth=self.max_depth,
             logger_name=self.logger_name,
+            writes_vectors=self._writes_vectors(all_models),
             is_async=is_async,
             prefix=prefix,
             dao_module_name=dao_module_name,

{tai_sql-0.7.18 → tai_sql-0.7.20}/tai_sql/generators/python_client/templates/domain/dao.py.jinja2

@@ -153,6 +153,11 @@ from {{ import_prefix }}_shared.utils.encoders import {{ model.tablename }}_{{ v
 import asyncio
 {% endif %}
 {% endif %}
+{% if writes_vectors and not model.is_view %}
+{# Los vectores se calculan al escribir, sobre todo lo pendiente de la sesión: una fila
+   anidada de otra tabla también puede llevar uno, así que no depende de esta tabla. #}
+from {{ import_prefix }}_shared.utils.encoders import {{ 'aencode_pending' if is_async else 'encode_pending' }} as _encode_pending
+{% endif %}
 
 {# `natural_key` es la respuesta del modelo a «por qué columnas se reconoce una fila»:
    la clave primaria si quien escribe la trae, si no la primera columna única, y si no la

{tai_sql-0.7.18 → tai_sql-0.7.20}/tai_sql/generators/python_client/templates/domain/dtos.py.jinja2

@@ -67,15 +67,6 @@ from {{ import_prefix }}_shared import (
 if TYPE_CHECKING:
     from pandas import DataFrame, Series  # type: ignore[import-untyped]
 
-{% set _dto_encoder_cols = model.columns | selectattr('type', 'equalto', 'vector') | selectattr('has_encoder') | list %}
-{% if _dto_encoder_cols %}
-# ── Vector encoders ──────────────────────────────────────────────────────
-{% for vcol in _dto_encoder_cols %}
-{% if vcol.encoder_config %}
-from {{ import_prefix }}_shared.utils.encoders import {{ model.tablename }}_{{ vcol.name }}_encoder as _{{ vcol.name }}_encoder
-{% endif %}
-{% endfor %}
-{% endif %}
 
 {# ── Read DTO ─────────────────────────────────────────────────────────── #}
 
@@ -332,28 +323,16 @@ class {{ model.name }}Create(PrettyModel):
         return self.model_dump(exclude_none=True)
 
     {% if vector_cols_create_encoder %}
-    def model_post_init(self, __context: Any) -> None:
-        {% for vcol in vector_cols_create_encoder %}
-        {% if vcol.source %}
-        if self.{{ vcol.name }} is None and self.{{ vcol.source }} is not None:
-            self.{{ vcol.name }} = _{{ vcol.name }}_encoder.encode(self.{{ vcol.source }})
-        {% endif %}
-        {% endfor %}
-
     @classmethod
     def deferred(cls, **kwargs) -> '{{ model.name }}Create':
         """
-        Create a DTO with vector encoding deferred.
-
-        Use when building lists for ``create_many()``: encoding will be done
-        in a single ``encode_batch`` call inside the DAO instead of once per record.
-
-        Example::
+        Lo mismo que el constructor. Se conserva por compatibilidad.
 
-            records = [{{ model.name }}Create.deferred({% for vcol in vector_cols_create_encoder %}{% if vcol.source %}{{ vcol.source }}=text{% endif %}{% endfor %}) for text in texts]
-            {{ model.name }}SyncDAO.create_many(records)
+        Construir un DTO no calcula ningún vector: lo calcula el DAO al escribir, en lote y,
+        en el DAO asíncrono, sin bloquear el bucle de eventos. Antes el constructor lo
+        calculaba en el acto, y `deferred()` existía para evitarlo.
         """
-        return cls.model_construct(**kwargs)
+        return cls(**kwargs)
     {% endif %}
 {% endif %}
 

{tai_sql-0.7.18 → tai_sql-0.7.20}/tai_sql/generators/python_client/templates/macros/hierarchy.jinja2

@@ -86,40 +86,11 @@ tree_depth: Optional[int] = None,
 
         {{ def_keyword }} execute_query(session: {{ session_type }}) -> List[{{ model.name }}Read]:
             if _hierarchy_mode == TreeMode.FLAT:
-                # Standard flat query
-                results = {{ await_keyword -}} session.execute(query)
 {% if vector_cols_with_encoder %}
-
-                if _has_vector_search:
-                    rows = results.all()
-                    _log_commit(session, f"[{{ schema_name }}] ✅ Encontrados {len(rows)} registros {{ model.name }} (similitud)")
-                    return [
-                        {{ model.name }}Read.from_instance(
-                            row[0],
-                            {% if not model.is_view %}
-                            includes=includes,
-                            max_depth={{ max_depth }},
-                            {% endif %}
-                            include_vectors=include_vectors,
-                            vector_search=_build_vector_search_result(row, _active_vectors)
-                        )
-                        for row in rows
-                    ]
-                else:
-                    instances = results.scalars().all()
-                    _log_commit(session, f"[{{ schema_name }}] ✅ Encontrados {len(instances)} registros {{ model.name }}")
-                    return [
-                        {{ model.name }}Read.from_instance(
-                            instance,
-                            {% if not model.is_view %}
-                            includes=includes,
-                            max_depth={{ max_depth }},
-                            {% endif %}
-                            include_vectors=include_vectors,
-                        )
-                        for instance in instances
-                    ]
+                # Sin recursión es la consulta normal, con o sin similitud
+                return {{ await_keyword -}} _execute_flat(session)
 {% else %}
+                results = {{ await_keyword -}} session.execute(query)
                 instances = results.scalars().all()
 
                 _log_commit(session, f"[{{ schema_name }}] ✅ Encontrados {len(instances)} registros {{ model.name }}")
@@ -129,7 +100,10 @@ tree_depth: Optional[int] = None,
                         instance,
                         {% if not model.is_view %}
                         includes=includes,
-                        max_depth={{ max_depth }}
+                        max_depth={{ max_depth }},
+                        {% endif %}
+                        {% if model.columns | selectattr('type', 'equalto', 'vector') | list %}
+                        include_vectors=include_vectors,
                         {% endif %}
                     )
                     for instance in instances

{tai_sql-0.7.18 → tai_sql-0.7.20}/tai_sql/generators/python_client/templates/macros/read.jinja2

@@ -270,6 +270,11 @@
 
         # Ejecutar query
 {% if model.has_self_reference %}
+{% if vector_cols_with_encoder %}
+{# El modo `flat` de la jerarquía es la consulta vectorial de siempre: se emite con otro
+   nombre y el bloque jerárquico la llama, en vez de repetirla a medias. #}
+{{ vector_macros.generate_vector_execute(model, max_depth, '_execute_flat') }}
+{% endif %}
 {{ hierarchy_macros.generate_hierarchy_execute(model, max_depth) }}
 {% elif vector_cols_with_encoder %}
 {{ vector_macros.generate_vector_execute(model, max_depth) }}
@@ -285,7 +290,11 @@
                     instance, 
                     {% if not model.is_view %}
                     includes=includes, 
-                    max_depth={{ max_depth }}
+                    max_depth={{ max_depth }}{% if _find_many_vector_cols %},{% endif %}
+
+                    {% endif %}
+                    {% if _find_many_vector_cols %}
+                    include_vectors=include_vectors,
                     {% endif %}
                 ) 
                 for instance in instances

{tai_sql-0.7.18 → tai_sql-0.7.20}/tai_sql/generators/python_client/templates/macros/upsert.jinja2

@@ -197,6 +197,11 @@
         if not match_fields:
             raise ValueError("match_fields no puede estar vacío. Debe contener al menos un campo para identificar registros.")
 
+{% if model.columns | selectattr('type', 'equalto', 'vector') | selectattr('has_encoder') | selectattr('source') | list %}
+        # El camino masivo escribe diccionarios por Core, sin pasar por el modelo: los vectores
+        # se calculan antes, sobre los DTOs
+        {{ await_keyword -}} _encode_pending(records, '{{ model.name }}')
+{% endif %}
         records_data = [record.to_dict() for record in records]
 {% if derived_columns %}
         records_data = cls._as_row_values(records_data)

{tai_sql-0.7.18 → tai_sql-0.7.20}/tai_sql/generators/python_client/templates/macros/vector.jinja2

@@ -110,7 +110,7 @@ vector_weights: Optional[Dict[str, float]] = None,
 {# Replaces the default scalars().all() block  #}
 {# ============================================ #}
 
-{% macro generate_vector_execute(model, max_depth) -%}
+{% macro generate_vector_execute(model, max_depth, fn_name='execute_query') -%}
 {% set vector_cols_with_encoder = [] -%}
 {% for vcol in model.columns | selectattr('type', 'equalto', 'vector') | list -%}
   {% if vcol.get('has_encoder') -%}
@@ -154,7 +154,7 @@ vector_weights: Optional[Dict[str, float]] = None,
             )
 {% endif %}
 
-        {{ def_keyword }} execute_query(session: {{ session_type }}) -> List[{{ model.name }}Read]:
+        {{ def_keyword }} {{ fn_name }}(session: {{ session_type }}) -> List[{{ model.name }}Read]:
             results = {{ await_keyword -}} session.execute(query)
 
             if _has_vector_search:

{tai_sql-0.7.18 → tai_sql-0.7.20}/tai_sql/generators/python_client/templates/macros/write.jinja2

@@ -153,6 +153,10 @@
             included = get_included_relations(new_instance, {{ model.tablename }})
             {{ await_keyword -}} cls._on_create_before(new_instance, included, session)
             session.add(new_instance)
+{% if writes_vectors %}
+            # Después de los triggers `before`, que pueden cambiar el texto del que sale el vector
+            {{ await_keyword -}} _encode_pending(session.new)
+{% endif %}
             {{ await_keyword -}} session.flush()
             {{ await_keyword -}} cls._on_create_after(new_instance, included, session)
             return {{ model.name }}Read.from_created_instance(new_instance, included)
@@ -196,22 +200,6 @@
         """
         _log_tx(session, f"[{{ schema_name }}] 🔢 Creando {len(records)} registros {{ model.name }}")
 
-{% set vcols_batch = model.columns | selectattr('type', 'equalto', 'vector') | selectattr('has_encoder') | selectattr('source') | list %}
-{% if vcols_batch %}
-        # Batch encode any records with deferred vector fields (created via model_construct)
-{% for vcol in vcols_batch %}
-        _batch_{{ vcol.name }}_idx = [i for i, r in enumerate(records) if r.{{ vcol.name }} is None and r.{{ vcol.source }} is not None]
-        if _batch_{{ vcol.name }}_idx:
-            _batch_{{ vcol.name }}_texts = [records[i].{{ vcol.source }} for i in _batch_{{ vcol.name }}_idx]
-{% if is_async %}
-            _batch_{{ vcol.name }}_vecs = await _{{ vcol.name }}_encoder.aencode_batch(_batch_{{ vcol.name }}_texts)
-{% else %}
-            _batch_{{ vcol.name }}_vecs = _{{ vcol.name }}_encoder.encode_batch(_batch_{{ vcol.name }}_texts)
-{% endif %}
-            for _i, _vec in zip(_batch_{{ vcol.name }}_idx, _batch_{{ vcol.name }}_vecs):
-                object.__setattr__(records[_i], '{{ vcol.name }}', _vec)
-{% endfor %}
-{% endif %}
         {% set operative_str_cols = model.columns | selectattr('is_operative') | selectattr('python_type', 'equalto', 'str') | list %}
         {{ def_keyword }} _execute_create_many(session: {{ session_type }}) -> int:
             instances = []
@@ -221,6 +209,10 @@
                 {{ await_keyword -}} cls._on_create_before(instance, included, session)
                 instances.append(instance)
             session.add_all(instances)
+{% if writes_vectors %}
+            # Todos los vectores pendientes en una llamada por columna, anidados incluidos
+            {{ await_keyword -}} _encode_pending(session.new)
+{% endif %}
             {{ await_keyword -}} session.flush()
             for instance in instances:
                 included = get_included_relations(instance, record)
@@ -322,11 +314,10 @@
 {% for vcol in model.columns | selectattr('type', 'equalto', 'vector') | list %}
 {% if vcol.source and vcol.has_encoder %}
             if '{{ vcol.source }}' in update_data and '{{ vcol.name }}' not in update_data:
-{% if is_async %}
-                update_data['{{ vcol.name }}'] = await _{{ vcol.name }}_encoder.aencode(update_data['{{ vcol.source }}'])
-{% else %}
-                update_data['{{ vcol.name }}'] = _{{ vcol.name }}_encoder.encode(update_data['{{ vcol.source }}'])
-{% endif %}
+                update_data['{{ vcol.name }}'] = (
+                    None if update_data['{{ vcol.source }}'] is None
+                    else {{ await_keyword }}_{{ vcol.name }}_encoder.{{ 'aencode' if is_async else 'encode' }}(update_data['{{ vcol.source }}'])
+                )
 {% endif %}
 {% endfor %}
             for key, value in update_data.items():
@@ -520,6 +511,18 @@
         
         if not filters and not values:  # Solo actualizar si hay filtros y valores
             return 0
+{% for vcol in model.columns | selectattr('type', 'equalto', 'vector') | list %}
+{% if vcol.source and vcol.has_encoder %}
+
+        # Un `UPDATE ... SET` no pasa por el modelo: si cambia el texto, el vector se calcula
+        # aquí. Es el mismo texto para todas las filas, así que es un solo vector.
+        if '{{ vcol.source }}' in values and '{{ vcol.name }}' not in values:
+            values['{{ vcol.name }}'] = (
+                None if values['{{ vcol.source }}'] is None
+                else {{ await_keyword }}_{{ vcol.name }}_encoder.{{ 'aencode' if is_async else 'encode' }}(values['{{ vcol.source }}'])
+            )
+{% endif %}
+{% endfor %}
 
         query = update({{ model.name }})
         query = payload.filter.apply_to_query(query)

{tai_sql-0.7.18 → tai_sql-0.7.20}/tai_sql/generators/python_client/templates/shared/utils/encoders.py.jinja2

@@ -2,14 +2,14 @@
 # No modifiques este archivo directamente
 #
 # _shared/utils/encoders.py
-# Encoder instances shared across all DAOs and DTOs in this schema.
+# Encoder instances shared across all DAOs in this schema.
 # Each instance is named {tablename}_{colname}_encoder.
 #
 # All encoders use langchain as the unified embedding interface.
 
 from __future__ import annotations
 from abc import ABC, abstractmethod
-from typing import List
+from typing import Any, Dict, Iterable, List, Optional, Tuple
 import asyncio
 import time
 import os
@@ -78,7 +78,7 @@ class HuggingFaceEncoder(BaseEncoder):
         except ImportError:
             raise ImportError(
                 "langchain-huggingface is required for HuggingFaceEncoder. "
-                "Install it with: pip install 'tai-sql[vectors]'"
+                "Install it in this project: pip install langchain-huggingface"
             )
         self._client = HuggingFaceEmbeddings(model_name=self._model_name)
         # Resolve dimensions from a test embedding if not provided
@@ -131,7 +131,7 @@ class OpenAIEncoder(BaseEncoder):
         except ImportError:
             raise ImportError(
                 "langchain-openai is required for OpenAIEncoder. "
-                "Install it with: pip install 'tai-sql[vectors]'"
+                "Install it in this project: pip install langchain-openai"
             )
         kwargs = {"model": self._model_name}
         if self._dimensions is not None:
@@ -205,7 +205,7 @@ class AzureOpenAIEncoder(BaseEncoder):
         except ImportError:
             raise ImportError(
                 "langchain-openai is required for AzureOpenAIEncoder. "
-                "Install it with: pip install 'tai-sql[vectors]'"
+                "Install it in this project: pip install langchain-openai"
             )
         kwargs = {"model": self._model_name}
         if self._dimensions is not None:
@@ -283,7 +283,7 @@ class GoogleEncoder(BaseEncoder):
         except ImportError:
             raise ImportError(
                 "langchain-google-genai is required for GoogleEncoder. "
-                "Install it with: pip install 'tai-sql[vectors]'"
+                "Install it in this project: pip install langchain-google-genai"
             )
         kwargs = {"model": self._model_name}
         if self._dimensions is not None:
@@ -340,3 +340,63 @@ class GoogleEncoder(BaseEncoder):
 {% endif %}
 {% endfor %}
 {% endfor %}
+
+
+# ── Vectors computed on write ─────────────────────────────────────────────────
+# Per model: (vector column, source column, encoder). Only the vector columns that
+# declare a `source` are computed on write; the rest are written as given.
+VECTOR_SOURCES: Dict[str, Tuple[Tuple[str, str, BaseEncoder], ...]] = {
+{% for model in models %}
+{% set _sources = [] %}
+{% for col in model.columns %}
+{% if col.type == 'vector' and col.has_encoder and col.encoder_config and col.source %}
+{% set _ = _sources.append(col) %}
+{% endif %}
+{% endfor %}
+{% if _sources %}
+    '{{ model.name }}': (
+{% for col in _sources %}
+        ('{{ col.name }}', '{{ col.source }}', {{ model.tablename }}_{{ col.name }}_encoder),
+{% endfor %}
+    ),
+{% endif %}
+{% endfor %}
+}
+
+
+def _pending(objects: Iterable[Any], model_name: Optional[str]) -> List[Tuple[BaseEncoder, str, str, List[Any]]]:
+    """
+    Groups the objects whose vector is missing but whose source has a value, by column.
+
+    `model_name` is for objects that are not instances of the model —the `Create`
+    DTOs that `upsert_many` writes as dicts—; without it, each object is looked up by
+    its class name, which is what `session.new` holds.
+    """
+    groups: Dict[Tuple[str, str], Tuple[BaseEncoder, str, str, List[Any]]] = {}
+    for obj in objects:
+        for column, source, encoder in VECTOR_SOURCES.get(model_name or type(obj).__name__, ()):
+            if getattr(obj, column, None) is None and getattr(obj, source, None) is not None:
+                key = (model_name or type(obj).__name__, column)
+                groups.setdefault(key, (encoder, column, source, []))[3].append(obj)
+    return list(groups.values())
+
+
+def encode_pending(objects: Iterable[Any], model_name: Optional[str] = None) -> None:
+    """
+    Computes the vectors that are missing, one `encode_batch` per column.
+
+    It is what the DAOs call right before writing —on `session.new` before the flush,
+    so nested rows are included—: a DTO does not encode when it is built.
+    """
+    for encoder, column, source, objs in _pending(list(objects), model_name):
+        vectors = encoder.encode_batch([getattr(o, source) for o in objs])
+        for obj, vector in zip(objs, vectors):
+            setattr(obj, column, vector)
+
+
+async def aencode_pending(objects: Iterable[Any], model_name: Optional[str] = None) -> None:
+    """`encode_pending` for the async DAOs: it awaits the encoder instead of blocking the loop."""
+    for encoder, column, source, objs in _pending(list(objects), model_name):
+        vectors = await encoder.aencode_batch([getattr(o, source) for o in objs])
+        for obj, vector in zip(objs, vectors):
+            setattr(obj, column, vector)

{tai_sql-0.7.18 → tai_sql-0.7.20}/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.