tai-sql 0.6.26__tar.gz → 0.6.28__tar.gz

{tai_sql-0.6.26 → tai_sql-0.6.28}/PKG-INFO

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

{tai_sql-0.6.26 → tai_sql-0.6.28}/pyproject.toml

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

{tai_sql-0.6.26 → tai_sql-0.6.28}/tai_sql/cli/commands/cmd_generate/funcs.py

@@ -15,7 +15,7 @@ def run_generate(schema_name: str=None):
     for generator in pm.db.generators:
         try:
             generator_name = generator.__class__.__name__
-            click.echo(f"   • {click.style(generator_name, bold=True)} → {generator.config.output_dir}")
+            click.echo(f"   • {click.style(generator_name, bold=True)} → {' | '.join(generator.config.output_dirs)}")
             
             # El generador se encargará de descubrir los modelos internamente
             result = generator.generate()

{tai_sql-0.6.26 → tai_sql-0.6.28}/tai_sql/generators/python_client/templates/domain/dtos.py.jinja2

@@ -596,7 +596,9 @@ class {{ model.name }}DataFrameValidator:
         for record in records_data:
             cleaned_record = {}
             for key, value in record.items():
-                if pd.isna(value):
+                if isinstance(value, list):
+                    cleaned_record[key] = value
+                elif pd.isna(value):
                     cleaned_record[key] = None
                 elif hasattr(value, 'item'):
                     cleaned_record[key] = value.item()

{tai_sql-0.6.26 → tai_sql-0.6.28}/tai_sql/generators/python_client/templates/domain/model.py.jinja2

@@ -223,9 +223,9 @@ class {{ model.name }}(Base):
 
     def _recompute_{{ calc_col.name }}(self):
         """Recompute calculated column ``{{ calc_col.name }}``."""
-        {% for line in calc_col.body_lines %}
+{% for line in calc_col.body_lines %}
         {{ line }}
-        {% endfor %}
+{% endfor %}
 {% endfor %}
 
 {# ── 7. Relationships ────────────────────────────────────────────────── #}

{tai_sql-0.6.26 → tai_sql-0.6.28}/tai_sql/generators/python_client/templates/shared/utils/encoders.py.jinja2

@@ -255,10 +255,18 @@ class GoogleEncoder(BaseEncoder):
     Env: GOOGLE_API_KEY
     """
 
-    def __init__(self, model: str = 'gemini-embedding-2-preview', dimensions: int | None = None):
+    def __init__(
+        self,
+        model: str = 'gemini-embedding-2-preview',
+        dimensions: int | None = None,
+        location: str | None = None,
+        project_id: str | None = None,
+    ):
         self._model_name = model
         self._client = None
         self._dimensions: int | None = dimensions
+        self._location = location
+        self._project_id = project_id
 
     @property
     def dimensions(self) -> int:
@@ -280,6 +288,10 @@ class GoogleEncoder(BaseEncoder):
         kwargs = {"model": self._model_name}
         if self._dimensions is not None:
             kwargs["output_dimensionality"] = self._dimensions
+        if self._location:
+            kwargs["location"] = self._location
+        if self._project_id:
+            kwargs["project_id"] = self._project_id
         self._client = GoogleGenerativeAIEmbeddings(**kwargs)
         logger.info(f"[encoder] Google '{self._model_name}' ready ({self._dimensions} dims)")
 
@@ -323,7 +335,7 @@ class GoogleEncoder(BaseEncoder):
 {% elif col.encoder_config.get('class') == 'AzureOpenAIEncoder' %}
 {{ model.tablename }}_{{ col.name }}_encoder = AzureOpenAIEncoder(model='{{ col.encoder_config.model }}', dimensions={{ col.dimensions }}{{ ', azure_endpoint="' + col.encoder_config.azure_endpoint + '"' if col.encoder_config.get('azure_endpoint') else '' }}{{ ', api_version="' + col.encoder_config.api_version + '"' if col.encoder_config.get('api_version') else '' }})
 {% elif col.encoder_config.get('class') == 'GoogleEncoder' %}
-{{ model.tablename }}_{{ col.name }}_encoder = GoogleEncoder(model='{{ col.encoder_config.model }}', dimensions={{ col.dimensions }})
+{{ model.tablename }}_{{ col.name }}_encoder = GoogleEncoder(model='{{ col.encoder_config.model }}', dimensions={{ col.dimensions }}{{ ', location="' + col.encoder_config.location + '"' if col.encoder_config.get('location') else '' }}{{ ', project_id="' + col.encoder_config.project_id + '"' if col.encoder_config.get('project_id') else '' }})
 {% endif %}
 {% endif %}
 {% endfor %}

{tai_sql-0.6.26 → tai_sql-0.6.28}/tai_sql/orm/calculated.py

@@ -66,6 +66,27 @@ class _ExternalNameExtractor(ast.NodeVisitor):
         self.generic_visit(node)
 
 
+class _ReturnToAssignmentTransformer(ast.NodeTransformer):
+    """AST transformer that converts all ``return`` statements to assignments."""
+
+    def __init__(self, column_name: str) -> None:
+        self.column_name = column_name
+
+    def visit_Return(self, node: ast.Return) -> ast.Assign:
+        """Replace ``return expr`` with ``self._<name> = expr``."""
+        assign = ast.Assign(
+            targets=[ast.Attribute(
+                value=ast.Name(id='self', ctx=ast.Load()),
+                attr=f'_{self.column_name}',
+                ctx=ast.Store(),
+            )],
+            value=node.value if node.value is not None else ast.Constant(value=None),
+            lineno=node.lineno,
+            col_offset=node.col_offset,
+        )
+        return ast.copy_location(assign, node)
+
+
 class CalculatedColumn(AutoRegisterDescriptor):
     """
     Descriptor for calculated columns that auto-register on their owner Table.
@@ -139,14 +160,18 @@ class CalculatedColumn(AutoRegisterDescriptor):
         """
         Return the full function body as a list of Python source lines.
 
-        The docstring is stripped.  The last ``return`` statement is converted
-        to ``self._<name> = <expr>`` so the body can be rendered directly
-        inside ``_recompute_<name>(self)``.
+        The docstring is stripped. All ``return`` statements (including nested ones)
+        are converted to ``self._<name> = <expr>`` so the body can be rendered
+        directly inside ``_recompute_<name>(self)``.
 
         Returns:
-            List of source lines (without leading indentation).
+            List of source lines (with proper relative indentation).
         """
-        body = list(self.ast_tree.body)
+        import copy
+        
+        # Make a deep copy to avoid mutating the original AST
+        body = [copy.deepcopy(stmt) for stmt in self.ast_tree.body]
+        
         # Skip docstring
         if (body and isinstance(body[0], ast.Expr)
                 and isinstance(getattr(body[0], 'value', None), ast.Constant)
@@ -156,26 +181,30 @@ class CalculatedColumn(AutoRegisterDescriptor):
         if not body:
             return [f'self._{self.name} = None']
 
-        # Convert the last return statement to an assignment
-        last = body[-1]
-        if isinstance(last, ast.Return) and last.value is not None:
-            assign = ast.Assign(
-                targets=[ast.Attribute(
-                    value=ast.Name(id='self', ctx=ast.Load()),
-                    attr=f'_{self.name}',
-                    ctx=ast.Store(),
-                )],
-                value=last.value,
-                lineno=last.lineno,
-            )
-            body[-1] = assign
-        elif isinstance(last, ast.Return):
-            # return with no value → assign None
-            body[-1] = ast.parse(f'self._{self.name} = None').body[0]
-
-        module = ast.Module(body=body, type_ignores=[])
+        # Transform all return statements to assignments recursively
+        transformer = _ReturnToAssignmentTransformer(self.name)
+        transformed_body = [transformer.visit(stmt) for stmt in body]
+
+        # Optimize pattern: if <cond>: assignment + unconditional assignment → if/else
+        # Common pattern from: if x: return val; return None
+        if (len(transformed_body) >= 2 
+            and isinstance(transformed_body[-2], ast.If)
+            and isinstance(transformed_body[-1], ast.Assign)
+            and not transformed_body[-2].orelse):  # No else clause yet
+            
+            if_stmt = transformed_body[-2]
+            final_assign = transformed_body[-1]
+            
+            # Move final assignment into else clause
+            if_stmt.orelse = [final_assign]
+            transformed_body = transformed_body[:-1]
+
+        module = ast.Module(body=transformed_body, type_ignores=[])
         ast.fix_missing_locations(module)
-        return [ast.unparse(stmt) for stmt in module.body]
+        
+        # Unparse the entire body and split into lines
+        code = ast.unparse(module)
+        return code.splitlines()
 
     # ── SQL expression generation ────────────────────────────────────────
 

{tai_sql-0.6.26 → tai_sql-0.6.28}/tai_sql/orm/encoders.py

@@ -277,9 +277,13 @@ class GoogleEncoder(BaseEncoder):
         self,
         model: GoogleModelTypes = 'gemini-embedding-2-preview',
         dimensions: Optional[int] = None,
+        location: Optional[str] = None,
+        project_id: Optional[str] = None,
     ):
         self._model_name = model
         self._dimensions = dimensions or self.KNOWN_MODELS.get(model)
+        self._location = location
+        self._project_id = project_id
 
     @property
     def dimensions(self) -> int:
@@ -290,9 +294,14 @@ class GoogleEncoder(BaseEncoder):
         )
 
     def get_config(self) -> dict:
-        return {
+        config = {
             'class': 'GoogleEncoder',
             'model': self._model_name,
             'dimensions': self._dimensions,
         }
+        if self._location:
+            config['location'] = self._location
+        if self._project_id:
+            config['project_id'] = self._project_id
+        return config