tai-sql 0.6.2__tar.gz → 0.6.4__tar.gz

{tai_sql-0.6.2 → tai_sql-0.6.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tai-sql
-Version: 0.6.2
+Version: 0.6.4
 Summary: SQL database management and code generation tool
 License: MIT
 License-File: LICENSE
@@ -133,6 +133,7 @@ users = public_sync_api.usuario.find_many(limit=10)
     - [Función `relation()`](#-función-relation---definición-de-relaciones)
     - [Encriptación de Columnas](#-encriptación-de-columnas)
     - [Columnas Vector](#-columnas-vector-pgvector)
+    - [Columnas Calculadas](#-columnas-calculadas-calculated_column)
   - [`View` — Definición de Vistas](#️-view---definición-de-vistas)
   - [`Enum` — Definición de Enumeraciones](#-enum---definición-de-enumeraciones)
   - [Triggers — Lógica de Negocio en Modelos](#-triggers---lógica-de-negocio-en-modelos)
@@ -757,6 +758,112 @@ embedding: vector = vector_column(
 - ✅ Si se omite `dimensions` y el encoder es conocido → se resuelve automáticamente
 
 
+#### 🧮 Columnas Calculadas (`calculated_column`)
+
+Las **columnas calculadas** son columnas físicas en la base de datos cuyo valor se computa automáticamente a partir de otras columnas. Se definen con el decorador `@calculated_column` directamente en el modelo y se recomputan en cada INSERT y UPDATE mediante event listeners de SQLAlchemy.
+
+**Definición básica:**
+
+```python
+from tai_sql import Table, column, calculated_column
+
+class Usuario(Table):
+    __tablename__ = "usuario"
+    
+    id: int = column(primary_key=True, autoincrement=True)
+    first_name: str
+    last_name: str
+    
+    @calculated_column
+    def full_name(self) -> str:
+        """Nombre completo del usuario"""
+        return f"{self.first_name} {self.last_name}"
+```
+
+Esto genera una columna física `full_name` de tipo `str` en la base de datos. El valor se calcula automáticamente al crear o actualizar el registro.
+
+**Cuerpo multi-statement con imports externos:**
+
+El cuerpo del método puede contener múltiples sentencias y usar imports del módulo donde se define el schema:
+
+```python
+from unidecode import unidecode
+
+class Producto(Table):
+    __tablename__ = "producto"
+    
+    id: int = column(primary_key=True, autoincrement=True)
+    nombre: str
+    categoria: str
+    
+    @calculated_column
+    def slug(self) -> str:
+        """Genera un slug SEO-friendly a partir del nombre y categoría"""
+        base = f"{self.nombre}-{self.categoria}"
+        normalized = unidecode(base).lower()
+        return normalized.replace(" ", "-")
+```
+
+TAI-SQL extrae automáticamente los imports necesarios (en este caso `from unidecode import unidecode`) y los incluye en el modelo generado.
+
+**Reglas:**
+
+- El método debe tener anotación de tipo de retorno (`-> str`, `-> int`, `-> float`, etc.)
+- El decorador `@calculated_column` debe ser el único decorador del método
+- Las dependencias (`self.campo`) se detectan automáticamente vía AST
+- Soporta tipos opcionales: `-> Optional[str]` genera una columna nullable
+
+**Cómo funciona internamente:**
+
+El modelo SQLAlchemy generado usa el mismo patrón que las columnas encriptadas:
+
+1. **Columna física** `_full_name` (con prefijo `_`) almacena el valor en la BD
+2. **`hybrid_property`** `full_name` expone lectura/escritura transparente
+3. **Event listeners** `before_insert` y `before_update` recomputan el valor automáticamente
+
+```python
+# Código generado (simplificado)
+class Usuario(Base):
+    _full_name = Column('full_name', String, nullable=False)
+    
+    @hybrid_property
+    def full_name(self):
+        return self._full_name
+    
+    @full_name.setter
+    def full_name(self, value):
+        self._full_name = value
+    
+    def _recompute_full_name(self):
+        self._full_name = f"{self.first_name} {self.last_name}"
+
+@event.listens_for(Usuario, 'before_insert')
+def _usuario_before_insert(mapper, connection, target):
+    target._recompute_full_name()
+
+@event.listens_for(Usuario, 'before_update')
+def _usuario_before_update(mapper, connection, target):
+    target._recompute_full_name()
+```
+
+**Comportamiento en DTOs generados:**
+
+| DTO | Incluye columna calculada | Motivo |
+|-----|--------------------------|--------|
+| `Create` | ❌ No | Se computa automáticamente |
+| `UpdateValues` | ❌ No | Se recomputa en cada update |
+| `Read` | ✅ Sí | El valor almacenado es legible |
+| `Filter` | ✅ Sí | Se puede filtrar por el valor almacenado |
+
+**Características:**
+
+- ✅ **Columna física**: El valor se almacena en la BD, indexable y filtrable
+- ✅ **Recompute automático**: Se recalcula en cada INSERT y UPDATE via event listeners
+- ✅ **Multi-statement**: Soporta cuerpos con múltiples sentencias
+- ✅ **Import extraction**: Detecta y extrae imports externos usados en el cuerpo
+- ✅ **Detección de dependencias**: Identifica qué columnas usa (`self.X`) vía análisis AST
+- ✅ **Transparente**: El CRUD generado maneja todo automáticamente — el usuario no necesita calcular nada
+
 ### 👁️ `View` - Definición de Vistas
 
 Las vistas permiten crear consultas complejas reutilizables:

{tai_sql-0.6.2 → tai_sql-0.6.4}/README.md

@@ -82,6 +82,7 @@ users = public_sync_api.usuario.find_many(limit=10)
     - [Función `relation()`](#-función-relation---definición-de-relaciones)
     - [Encriptación de Columnas](#-encriptación-de-columnas)
     - [Columnas Vector](#-columnas-vector-pgvector)
+    - [Columnas Calculadas](#-columnas-calculadas-calculated_column)
   - [`View` — Definición de Vistas](#️-view---definición-de-vistas)
   - [`Enum` — Definición de Enumeraciones](#-enum---definición-de-enumeraciones)
   - [Triggers — Lógica de Negocio en Modelos](#-triggers---lógica-de-negocio-en-modelos)
@@ -706,6 +707,112 @@ embedding: vector = vector_column(
 - ✅ Si se omite `dimensions` y el encoder es conocido → se resuelve automáticamente
 
 
+#### 🧮 Columnas Calculadas (`calculated_column`)
+
+Las **columnas calculadas** son columnas físicas en la base de datos cuyo valor se computa automáticamente a partir de otras columnas. Se definen con el decorador `@calculated_column` directamente en el modelo y se recomputan en cada INSERT y UPDATE mediante event listeners de SQLAlchemy.
+
+**Definición básica:**
+
+```python
+from tai_sql import Table, column, calculated_column
+
+class Usuario(Table):
+    __tablename__ = "usuario"
+    
+    id: int = column(primary_key=True, autoincrement=True)
+    first_name: str
+    last_name: str
+    
+    @calculated_column
+    def full_name(self) -> str:
+        """Nombre completo del usuario"""
+        return f"{self.first_name} {self.last_name}"
+```
+
+Esto genera una columna física `full_name` de tipo `str` en la base de datos. El valor se calcula automáticamente al crear o actualizar el registro.
+
+**Cuerpo multi-statement con imports externos:**
+
+El cuerpo del método puede contener múltiples sentencias y usar imports del módulo donde se define el schema:
+
+```python
+from unidecode import unidecode
+
+class Producto(Table):
+    __tablename__ = "producto"
+    
+    id: int = column(primary_key=True, autoincrement=True)
+    nombre: str
+    categoria: str
+    
+    @calculated_column
+    def slug(self) -> str:
+        """Genera un slug SEO-friendly a partir del nombre y categoría"""
+        base = f"{self.nombre}-{self.categoria}"
+        normalized = unidecode(base).lower()
+        return normalized.replace(" ", "-")
+```
+
+TAI-SQL extrae automáticamente los imports necesarios (en este caso `from unidecode import unidecode`) y los incluye en el modelo generado.
+
+**Reglas:**
+
+- El método debe tener anotación de tipo de retorno (`-> str`, `-> int`, `-> float`, etc.)
+- El decorador `@calculated_column` debe ser el único decorador del método
+- Las dependencias (`self.campo`) se detectan automáticamente vía AST
+- Soporta tipos opcionales: `-> Optional[str]` genera una columna nullable
+
+**Cómo funciona internamente:**
+
+El modelo SQLAlchemy generado usa el mismo patrón que las columnas encriptadas:
+
+1. **Columna física** `_full_name` (con prefijo `_`) almacena el valor en la BD
+2. **`hybrid_property`** `full_name` expone lectura/escritura transparente
+3. **Event listeners** `before_insert` y `before_update` recomputan el valor automáticamente
+
+```python
+# Código generado (simplificado)
+class Usuario(Base):
+    _full_name = Column('full_name', String, nullable=False)
+    
+    @hybrid_property
+    def full_name(self):
+        return self._full_name
+    
+    @full_name.setter
+    def full_name(self, value):
+        self._full_name = value
+    
+    def _recompute_full_name(self):
+        self._full_name = f"{self.first_name} {self.last_name}"
+
+@event.listens_for(Usuario, 'before_insert')
+def _usuario_before_insert(mapper, connection, target):
+    target._recompute_full_name()
+
+@event.listens_for(Usuario, 'before_update')
+def _usuario_before_update(mapper, connection, target):
+    target._recompute_full_name()
+```
+
+**Comportamiento en DTOs generados:**
+
+| DTO | Incluye columna calculada | Motivo |
+|-----|--------------------------|--------|
+| `Create` | ❌ No | Se computa automáticamente |
+| `UpdateValues` | ❌ No | Se recomputa en cada update |
+| `Read` | ✅ Sí | El valor almacenado es legible |
+| `Filter` | ✅ Sí | Se puede filtrar por el valor almacenado |
+
+**Características:**
+
+- ✅ **Columna física**: El valor se almacena en la BD, indexable y filtrable
+- ✅ **Recompute automático**: Se recalcula en cada INSERT y UPDATE via event listeners
+- ✅ **Multi-statement**: Soporta cuerpos con múltiples sentencias
+- ✅ **Import extraction**: Detecta y extrae imports externos usados en el cuerpo
+- ✅ **Detección de dependencias**: Identifica qué columnas usa (`self.X`) vía análisis AST
+- ✅ **Transparente**: El CRUD generado maneja todo automáticamente — el usuario no necesita calcular nada
+
 ### 👁️ `View` - Definición de Vistas
 
 Las vistas permiten crear consultas complejas reutilizables:

{tai_sql-0.6.2 → tai_sql-0.6.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tai-sql"
-version = "0.6.2"
+version = "0.6.4"
 description = "SQL database management and code generation tool"
 license = {text = "MIT"}
 authors = [

{tai_sql-0.6.2 → tai_sql-0.6.4}/tai_sql/__init__.py

@@ -21,7 +21,8 @@ from .orm import (
     Table, View, Enum, column, vector, vector_column, VectorColumn,
     relation, TriggerAPI, on_create, on_update, on_delete,
     trigger_api, col, onetomany, manytoone, onetoone, get_type_registry,
-    register_type, TypeDescriptor, BaseEncoder, SentenceTransformerEncoder
+    register_type, TypeDescriptor, BaseEncoder, SentenceTransformerEncoder,
+    calculated_column,
 )
 
 from .drivers import postgresql, mysql, sqlserver
@@ -50,6 +51,7 @@ __all__ = [
     'on_update',
     'on_delete',
     'trigger_api',
+    'calculated_column',
     'query',
     'View',
     'Enum',

{tai_sql-0.6.2 → tai_sql-0.6.4}/tai_sql/generators/python_client/__init__.py

@@ -32,10 +32,12 @@ class PythonClientGenerator(BaseGenerator):
         pool_recycle: Optional[int] = None,
         ssl: Optional[bool] = None,
         sqlalchemy_logs: Optional[bool] = None,
+        import_prefix: str = '..',
     ):
         super().__init__(output_dir)
         self.max_depth = max_depth
         self.logger_name = logger_name
+        self.import_prefix = import_prefix
         self._pool_size = pool_size
         self._max_overflow = max_overflow
         self._pool_timeout = pool_timeout
@@ -142,6 +144,12 @@ class PythonClientGenerator(BaseGenerator):
             for col in model.columns.values()
         )
 
+    def _model_has_calculated(self, model: Table | View) -> bool:
+        return any(
+            hasattr(col, 'is_calculated') and col.is_calculated
+            for col in model.columns.values()
+        )
+
     def _all_models_data(self, mode: str = 'sync') -> List[Dict[str, Any]]:
         return [model.info(mode) for model in self.models]
 
@@ -258,6 +266,7 @@ class PythonClientGenerator(BaseGenerator):
             schema_name=pm.db.schema_name,
             models=all_models_data,
             model_imports=model_imports,
+            shared_import_prefix='.' + self.import_prefix,
         )
         (utils_dir / 'funcs.py').write_text(funcs_code, encoding='utf-8')
 
@@ -293,6 +302,8 @@ class PythonClientGenerator(BaseGenerator):
             is_postgres=pm.db.provider.drivername == 'postgresql',
             schema_name=pm.db.schema_name,
             encrypt=self._model_has_encrypt(model),
+            has_calculated=self._model_has_calculated(model),
+            import_prefix=self.import_prefix,
         )
         (domain / 'model.py').write_text(code, encoding='utf-8')
 
@@ -305,6 +316,7 @@ class PythonClientGenerator(BaseGenerator):
             models=all_models,
             schema_name=pm.db.schema_name,
             max_depth=self.max_depth,
+            import_prefix=self.import_prefix,
         )
         (domain / 'dtos.py').write_text(code, encoding='utf-8')
 
@@ -332,6 +344,7 @@ class PythonClientGenerator(BaseGenerator):
             await_keyword='await ' if is_async else '',
             with_keyword='async with' if is_async else 'with',
             error_handler_name='async_error_handler' if is_async else 'sync_error_handler',
+            import_prefix=self.import_prefix,
         )
         filename = 'dao_async.py' if is_async else 'dao_sync.py'
         (domain / filename).write_text(code, encoding='utf-8')

{tai_sql-0.6.2 → tai_sql-0.6.4}/tai_sql/generators/python_client/templates/domain/dao.py.jinja2

@@ -48,7 +48,7 @@ from sqlalchemy.orm import defer
 {% endif %}
 from .model import {{ model.name }}
 from .dtos import *
-from .._shared import (
+from {{ import_prefix }}_shared import (
     {{ error_handler_name }},
     get_loading_options,
     get_included_relations,
@@ -67,7 +67,7 @@ from .._shared import (
     AggField,
     GroupByField
 )
-from .._session import {{ session_manager_var }}
+from {{ import_prefix }}_session import {{ session_manager_var }}
 {# ── Collect cross-DAO targets (relations + trigger cross-table ops) ── #}
 {% set _cross_dao_targets = [] %}
 {% for rel in model.relations | default([]) %}
@@ -84,7 +84,7 @@ from .._session import {{ session_manager_var }}
 {% set _ = _cross_dao_targets.append({'name': target_name, 'tablename': target_tablename}) %}
 {% endif %}
 {# DTO imports for cross-table trigger operations #}
-from ..{{ target_tablename }}.dtos import *  # trigger cross-table: {{ target_name }}
+from {{ import_prefix }}{{ target_tablename }}.dtos import *  # trigger cross-table: {{ target_name }}
 {% endif %}
 {% endif %}
 {% endfor %}
@@ -101,7 +101,7 @@ logger = Alphi.get_logger_by_name("{{ logger_name }}")
 # ── Vector encoders ──────────────────────────────────────────────────────
 {% for vcol in vector_cols_with_encoder %}
 {% if vcol.encoder_config %}
-from .._shared.utils.encoders import {{ model.tablename }}_{{ vcol.name }}_encoder as _{{ vcol.name }}_encoder
+from {{ import_prefix }}_shared.utils.encoders import {{ model.tablename }}_{{ vcol.name }}_encoder as _{{ vcol.name }}_encoder
 {% endif %}
 {% endfor %}
 {% if is_async %}

{tai_sql-0.6.2 → tai_sql-0.6.4}/tai_sql/generators/python_client/templates/domain/dtos.py.jinja2

@@ -49,7 +49,7 @@ from pydantic import (
 )
 
 from .model import {{ model.name }}
-from .._shared import (
+from {{ import_prefix }}_shared import (
     PrettyModel,
     should_include_relation,
     get_nested_includes
@@ -63,7 +63,7 @@ if TYPE_CHECKING:
 # ── Vector encoders ──────────────────────────────────────────────────────
 {% for vcol in _dto_encoder_cols %}
 {% if vcol.encoder_config %}
-from .._shared.utils.encoders import {{ model.tablename }}_{{ vcol.name }}_encoder as _{{ vcol.name }}_encoder
+from {{ import_prefix }}_shared.utils.encoders import {{ model.tablename }}_{{ vcol.name }}_encoder as _{{ vcol.name }}_encoder
 {% endif %}
 {% endfor %}
 {% endif %}
@@ -214,12 +214,12 @@ class {{ model.name }}Read(PrettyModel):
 class {{ model.name }}Create(PrettyModel):
     """DTO de escritura para {{ model.name }}."""
     {% for column in model.columns -%}
-    {% if not column.constraints.get('autoincrement', False) and column.default is none and not column.nullable and not column.is_foreign_key and not column.is_operative and not column.has_encoder|default(false) %}
+    {% if not column.constraints.get('autoincrement', False) and column.default is none and not column.nullable and not column.is_foreign_key and not column.is_operative and not column.has_encoder|default(false) and not column.is_calculated %}
     {{ column.name }}: {{ column.pydantic_type }}
     {% endif %}
     {% endfor %}
     {% for column in model.columns -%}
-    {% if not column.is_operative %}
+    {% if not column.is_operative and not column.is_calculated %}
     {% if column.has_encoder|default(false) %}
     {{ column.name }}: Optional[{{ column.pydantic_type }}] = None
     {% elif column.is_foreign_key %}
@@ -261,7 +261,7 @@ class {{ model.name }}Create(PrettyModel):
     def to_instance(self) -> {{ model.name }}:
         model = {{ model.name }}(
             {% for column in model.columns %}
-            {% if not column.constraints.get('autoincrement', False) and not column.is_operative %}
+            {% if not column.constraints.get('autoincrement', False) and not column.is_operative and not column.is_calculated %}
             {{ column.name }}=self.{{ column.name }},
             {% endif %}
             {% endfor %}
@@ -373,7 +373,7 @@ class {{ model.name }}UpdateNested(PrettyModel):
 class {{ model.name }}UpdateValues(PrettyModel):
     """DTO de actualización para {{ model.name }}."""
     {% for column in model.columns -%}
-    {% if not column.constraints.get('autoincrement', False) and not column.is_operative %}
+    {% if not column.constraints.get('autoincrement', False) and not column.is_operative and not column.is_calculated %}
     {% if not column.nullable %}
     {{ column.name }}: {{ column.pydantic_type }} = None
     {% else %}
@@ -426,7 +426,7 @@ class {{ model.name }}Update(PrettyModel):
 {% set target_info = models | selectattr('name', 'equalto', rel.target) | first %}
 {% if target_info and rel.target != model.name and rel.target not in related_targets %}
 {% set _ = related_targets.append(rel.target) %}
-from ..{{ target_info.tablename }}.dtos import (
+from {{ import_prefix }}{{ target_info.tablename }}.dtos import (
     {{ rel.target }}Read,
 {% if not model.is_view %}
     {{ rel.target }}Create,

{tai_sql-0.6.2 → tai_sql-0.6.4}/tai_sql/generators/python_client/templates/domain/model.py.jinja2

@@ -10,16 +10,20 @@
      is_postgres    bool   — True if the target database is PostgreSQL
      schema_name    str    — Database schema name (e.g. 'public')
      encrypt        bool   — True if the model has encrypted columns
+     has_calculated bool   — True if the model has calculated columns
+     import_prefix  str    — Relative import prefix to reach schema root (default '..')
    
    Template sections:
      1. Imports         — stdlib, typing, SQLAlchemy, cross-domain models
      2. Class header    — __tablename__, is_view flag
-     3. Encrypted init  — Custom __init__ for encrypted column interception
+     3. Custom init     — __init__ for encrypted/calculated column interception
      4. Columns         — Mapped[] declarations with mapped_column() args
      5. Encrypted props — hybrid_property get/set for encrypted columns
-     6. Relationships   — SQLAlchemy relationship() declarations
-     7. Table args      — ForeignKeyConstraint + schema config
-     8. Mapper args     — primary_key override for views
+     6. Calculated props— hybrid_property + recompute for calculated columns
+     7. Relationships   — SQLAlchemy relationship() declarations
+     8. Table args      — ForeignKeyConstraint + schema config
+     9. Mapper args     — primary_key override for views
+    10. Event listeners — before_insert/before_update for calculated columns
    ───────────────────────────────────────────────────────────────────────── #}
 # Este archivo ha sido generado automáticamente por tai-sql
 # No modifiques este archivo directamente
@@ -30,9 +34,9 @@ from __future__ import annotations
 from typing import Optional{% if is_postgres %}, List{% endif %}{% if model.relations | default([]) | list %}, TYPE_CHECKING{% endif %}
 
 {% if is_view %}
-from .._base import Base
+from {{ import_prefix }}_base import Base
 {% else %}
-from .._base import Base{% if encrypt %}, encrypt_value, decrypt_value{% endif %}
+from {{ import_prefix }}_base import Base{% if encrypt %}, encrypt_value, decrypt_value{% endif %}
 
 {% endif %}
 from sqlalchemy.orm import Mapped, mapped_column{% if model.relations | default([]) | list %}, relationship{% endif %}
@@ -71,16 +75,26 @@ from pgvector.sqlalchemy import Vector
 {% if sa_imports %}
 from sqlalchemy import {{ sa_imports | sort | join(', ') }}
 {% endif %}
-{% if encrypt %}
+{% if encrypt or has_calculated %}
 from sqlalchemy.ext.hybrid import hybrid_property
 {% endif %}
+{% if has_calculated %}
+from sqlalchemy import event
+{% endif %}
+
+{# Imports required by calculated column computations #}
+{% for calc_col in model.calculated_columns | default([]) %}
+{% for imp in calc_col.imports | default([]) %}
+{{ imp }}
+{% endfor %}
+{% endfor %}
 
 {# Cross-domain model imports — TYPE_CHECKING only (annotations are lazy via __future__) #}
 {% if model.relations | default([]) | selectattr('target', 'ne', model.name) | list %}
 if TYPE_CHECKING:
 {% for rel in model.relations | default([]) %}
 {% if rel.target != model.name %}
-    from ..{{ rel.target_tablename }}.model import {{ rel.target }}
+    from {{ import_prefix }}{{ rel.target_tablename }}.model import {{ rel.target }}
 {% endif %}
 {% endfor %}
 {% endif %}
@@ -96,18 +110,26 @@ class {{ model.name }}(Base):
     is_view = True
     {% endif %}
 
-{# ── 3. Encrypted __init__ ───────────────────────────────────────────── #}
+{# ── 3. Custom __init__ ───────────────────────────────────────────────── #}
 {# Intercepts encrypted column values before SQLAlchemy sets the raw column,
-   routing them through the hybrid_property setter that encrypts on write. #}
+   routing them through the hybrid_property setter that encrypts on write.
+   Also pops calculated column kwargs (they are auto-computed). #}
 {% set encrypted_columns = model.columns | selectattr('encrypt') | list %}
-{% if encrypted_columns %}
+{% set calculated_columns = model.calculated_columns | default([]) %}
+{% if encrypted_columns or calculated_columns %}
     def __init__(self, **kwargs):
         {% for column in encrypted_columns %}
         if '{{ column.name }}' in kwargs:
             {{ column.name }}_value = kwargs.pop('{{ column.name }}')
             self.{{ column.name }} = {{ column.name }}_value
         {% endfor %}
+        {% for calc_col in calculated_columns %}
+        kwargs.pop('{{ calc_col.name }}', None)
+        {% endfor %}
         super().__init__(**kwargs)
+        {% for calc_col in calculated_columns %}
+        self._recompute_{{ calc_col.name }}()
+        {% endfor %}
 {% endif %}
 
 {# ── 4. Columns ──────────────────────────────────────────────────────── #}
@@ -123,14 +145,14 @@ class {{ model.name }}(Base):
      3. name= override when the column is encrypted (_name vs name in DB)
    - Columns without any SA type or constraints use bare Mapped[T]. #}
 {% for column in model.columns %}
-    {# Encrypted columns use a private attribute; the public name becomes a hybrid_property #}
-    {% set col_attr = '_' + column.name if column.encrypt else column.name %}
+    {# Encrypted and calculated columns use a private attribute; the public name becomes a hybrid_property #}
+    {% set col_attr = '_' + column.name if (column.encrypt or column.is_calculated) else column.name %}
     {# Python type for the Mapped[] annotation — always a native Python type #}
     {% set py_type = 'Dict[str, Any]' if column.python_type == 'dict' else ('List[float]' if column.type == 'vector' else column.python_type) %}
     {% set mapped_type = 'Optional[' + py_type + ']' if column.nullable else py_type %}
     {# Determine if mapped_column() call is needed #}
     {% set has_constraints = column.constraints.values() | select | list | length > 0 %}
-    {% set needs_mapped_column = has_constraints or column.encrypt or column.sa_type is not none or column.type == 'vector' %}
+    {% set needs_mapped_column = has_constraints or column.encrypt or column.is_calculated or column.sa_type is not none or column.type == 'vector' %}
     {% if needs_mapped_column %}
     {% set mc_args = [] %}
     {% if column.type == 'vector' %}{% set _ = mc_args.append('Vector(' + column.dimensions|string + ')') %}
@@ -150,6 +172,7 @@ class {{ model.name }}(Base):
     {% endfor %}
     {% endif %}
     {% if column.encrypt %}{% set _ = mc_args.append('name="' + column.name + '"') %}{% endif %}
+    {% if column.is_calculated %}{% set _ = mc_args.append('name="' + column.name + '"') %}{% endif %}
     {{ col_attr }}: Mapped[{{ mapped_type }}] = mapped_column({{ mc_args | join(', ') }})
     {% else %}
     {{ col_attr }}: Mapped[{{ mapped_type }}]
@@ -178,7 +201,34 @@ class {{ model.name }}(Base):
 {% endif %}
 {% endfor %}
 
-{# ── 6. Relationships ────────────────────────────────────────────────── #}
+{# ── 6. Calculated hybrid properties ─────────────────────────────────── #}
+{# For each calculated column, expose a hybrid_property that reads the
+   stored value.  The setter allows direct assignment; the expression
+   clause maps to the physical _<name> column for SQL-level queries.
+   A _recompute_<name>() helper contains the user-defined computation. #}
+{% for calc_col in model.calculated_columns | default([]) %}
+    {% set prop_type = 'Optional[' + calc_col.python_type + ']' if calc_col.nullable else calc_col.python_type %}
+
+    @hybrid_property
+    def {{ calc_col.name }}(self) -> {{ prop_type }}:
+        return self._{{ calc_col.name }}
+
+    @{{ calc_col.name }}.setter
+    def {{ calc_col.name }}(self, value: {{ prop_type }}):
+        self._{{ calc_col.name }} = value
+
+    @{{ calc_col.name }}.expression
+    def {{ calc_col.name }}(cls):
+        return cls._{{ calc_col.name }}
+
+    def _recompute_{{ calc_col.name }}(self):
+        """Recompute calculated column ``{{ calc_col.name }}``."""
+        {% for line in calc_col.body_lines %}
+        {{ line }}
+        {% endfor %}
+{% endfor %}
+
+{# ── 7. Relationships ────────────────────────────────────────────────── #}
 {# SQLAlchemy relationship() with:
    - back_populates for bidirectional navigation
    - foreign_keys as string expression to avoid circular import issues
@@ -217,7 +267,7 @@ class {{ model.name }}(Base):
     __table_args__ = {'schema': '{{ schema_name }}'}
 {% endif %}
 
-{# ── 8. Mapper args — synthetic PK for views ────────────────────────── #}
+{# ── 9. Mapper args — synthetic PK for views ────────────────────────── #}
 {% if model.is_view %}
     __mapper_args__ = {'primary_key': [
         {% for column in model.columns %}
@@ -225,3 +275,15 @@ class {{ model.name }}(Base):
         {% endfor %}
     ]}
 {% endif %}
+
+{# ── 10. Event listeners — auto-recompute calculated columns ─────────── #}
+{% if model.calculated_columns | default([]) %}
+
+@event.listens_for({{ model.name }}, 'before_insert')
+@event.listens_for({{ model.name }}, 'before_update')
+def _recompute_{{ model.tablename }}_calculated(mapper, connection, target: {{ model.name }}):
+    """Recompute all calculated columns before insert/update."""
+    {% for calc_col in model.calculated_columns %}
+    target._recompute_{{ calc_col.name }}()
+    {% endfor %}
+{% endif %}

{tai_sql-0.6.2 → tai_sql-0.6.4}/tai_sql/generators/python_client/templates/macros/triggers.jinja2

@@ -23,7 +23,7 @@
         {% endfor %}
         {% if _dao_targets %}
         {% for t in _dao_targets %}
-        from ..{{ t.tablename }}.dao_{{ "async" if is_async else "sync" }} import {{ t.name }}{{ prefix }}DAO
+        from {{ import_prefix }}{{ t.tablename }}.dao_{{ "async" if is_async else "sync" }} import {{ t.name }}{{ prefix }}DAO
         {% endfor %}
         {% set ns_hook.has_content = true %}
         {% endif %}
@@ -83,7 +83,7 @@
         {% endfor %}
         {% if _dao_targets %}
         {% for t in _dao_targets %}
-        from ..{{ t.tablename }}.dao_{{ "async" if is_async else "sync" }} import {{ t.name }}{{ prefix }}DAO
+        from {{ import_prefix }}{{ t.tablename }}.dao_{{ "async" if is_async else "sync" }} import {{ t.name }}{{ prefix }}DAO
         {% endfor %}
         {% set ns_hook.has_content = true %}
         {% endif %}
@@ -136,7 +136,7 @@
         {% endfor %}
         {% if _dao_targets %}
         {% for t in _dao_targets %}
-        from ..{{ t.tablename }}.dao_{{ "async" if is_async else "sync" }} import {{ t.name }}{{ prefix }}DAO
+        from {{ import_prefix }}{{ t.tablename }}.dao_{{ "async" if is_async else "sync" }} import {{ t.name }}{{ prefix }}DAO
         {% endfor %}
         {% set ns_hook.has_content = true %}
         {% endif %}
@@ -179,7 +179,7 @@
         {% endfor %}
         {% if _dao_targets %}
         {% for t in _dao_targets %}
-        from ..{{ t.tablename }}.dao_{{ "async" if is_async else "sync" }} import {{ t.name }}{{ prefix }}DAO
+        from {{ import_prefix }}{{ t.tablename }}.dao_{{ "async" if is_async else "sync" }} import {{ t.name }}{{ prefix }}DAO
         {% endfor %}
         {% set ns_hook.has_content = true %}
         {% endif %}
@@ -222,7 +222,7 @@
         {% endfor %}
         {% if _dao_targets %}
         {% for t in _dao_targets %}
-        from ..{{ t.tablename }}.dao_{{ "async" if is_async else "sync" }} import {{ t.name }}{{ prefix }}DAO
+        from {{ import_prefix }}{{ t.tablename }}.dao_{{ "async" if is_async else "sync" }} import {{ t.name }}{{ prefix }}DAO
         {% endfor %}
         {% set ns_hook.has_content = true %}
         {% endif %}
@@ -257,7 +257,7 @@
         {% endfor %}
         {% if _dao_targets %}
         {% for t in _dao_targets %}
-        from ..{{ t.tablename }}.dao_{{ "async" if is_async else "sync" }} import {{ t.name }}{{ prefix }}DAO
+        from {{ import_prefix }}{{ t.tablename }}.dao_{{ "async" if is_async else "sync" }} import {{ t.name }}{{ prefix }}DAO
         {% endfor %}
         {% set ns_hook.has_content = true %}
         {% endif %}