t-sql 4.4.2__tar.gz → 4.5.0__tar.gz

{t_sql-4.4.2 → t_sql-4.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: t-sql
-Version: 4.4.2
+Version: 4.5.0
 Summary: Safe SQL. SQL queries for python t-strings (PEP 750)
 Project-URL: Homepage, https://github.com/nhumrich/t-sql
 License-File: LICENSE

{t_sql-4.4.2 → t_sql-4.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "t-sql"
-version = "4.4.2"
+version = "4.5.0"
 description = "Safe SQL. SQL queries for python t-strings (PEP 750)"
 readme = "README.md"
 requires-python = ">=3.14"

{t_sql-4.4.2 → t_sql-4.5.0}/tests/test_type_processor.py

@@ -291,12 +291,14 @@ def test_map_results_with_joins_and_aliases():
         }
     ]
 
-    query.map_results(rows)
+    results = query.map_results(rows)
 
     # Check aliased column was decrypted
-    assert rows[0]["social"] == "123-45-6789"
+    assert results[0]["social"] == "123-45-6789"
+    assert results[0].social == "123-45-6789"  # Test attribute access
     # Check joined table column was deserialized
-    assert rows[0]["metadata_col"] == {"key": "value"}
+    assert results[0]["metadata_col"] == {"key": "value"}
+    assert results[0].metadata_col == {"key": "value"}  # Test attribute access
 
     # Test with SELECT * (should process all columns from all tables)
     query_star = User.select().join(Profile, on=User.id == Profile.user_id)
@@ -311,8 +313,10 @@ def test_map_results_with_joins_and_aliases():
         }
     ]
 
-    query_star.map_results(rows_star)
+    results_star = query_star.map_results(rows_star)
 
     # Both processors should be applied
-    assert rows_star[0]["ssn"] == "987-65-4321"
-    assert rows_star[0]["metadata_col"] == {"foo": "bar"}
+    assert results_star[0]["ssn"] == "987-65-4321"
+    assert results_star[0].ssn == "987-65-4321"  # Test attribute access
+    assert results_star[0]["metadata_col"] == {"foo": "bar"}
+    assert results_star[0].metadata_col == {"foo": "bar"}  # Test attribute access

{t_sql-4.4.2 → t_sql-4.5.0}/tsql/__init__.py

@@ -362,6 +362,7 @@ def delete(table: str, id: str | int) -> TSQL:
 
 from tsql.query_builder import UnsafeQueryError
 from tsql.type_processor import TypeProcessor
+from tsql.row import Row
 
 __all__ = [
     'TSQL',
@@ -375,5 +376,6 @@ __all__ = [
     'set_style',
     'UnsafeQueryError',
     'TypeProcessor',
+    'Row',
 ]
 

{t_sql-4.4.2 → t_sql-4.5.0}/tsql/query_builder.py

@@ -4,6 +4,7 @@ from datetime import datetime
 from abc import ABC, abstractmethod
 
 from tsql import TSQL, t_join
+from tsql.row import Row
 
 
 class UnsafeQueryError(Exception):
@@ -559,26 +560,28 @@ class QueryBuilder(ABC):
         """
         return self.to_tsql().render(style)
 
-    def map_results(self, rows: List[Dict[str, Any]]) -> List[Dict[str, Any]]:
+    def map_results(self, rows: List[Dict[str, Any]]) -> List[Row]:
         """Transform database rows with type processors applied.
 
         This method applies process_result_value from type processors to convert
         database values back to Python values (e.g., decrypt encrypted fields,
         deserialize JSON, etc.).
 
-        Modifies row objects in place to preserve driver-specific row types
-        (e.g., asyncpg Record objects).
+        Returns Row objects (dict subclass with attribute access) for consistent
+        API regardless of input type (dict, asyncpg Record, etc.).
 
         Args:
             rows: List of row objects from database query results
 
         Returns:
-            The same list of rows with transformed values (mutated in place)
+            List of Row objects with transformed values
 
         Example:
             query = User.select().where(User.id == 1)
             rows = await conn.fetch(*query.render())
-            query.map_results(rows)  # ssn decrypted, metadata deserialized (in place)
+            results = query.map_results(rows)
+            print(results[0].name)  # Attribute access
+            print(results[0]['name'])  # Dict access
         """
         if not hasattr(self, 'base_table'):
             raise AttributeError("map_results requires a base_table attribute")
@@ -602,13 +605,16 @@ class QueryBuilder(ABC):
             for table in tables:
                 processors.update(table._type_processors)
 
-        # Apply processors to rows in place
+        # Convert to Row objects and apply processors
+        results = []
         for row in rows:
-            for col_name in list(row.keys()):
+            row_dict = Row(row)  # Converts dict/Record to Row
+            for col_name in list(row_dict.keys()):
                 if col_name in processors:
-                    row[col_name] = processors[col_name].process_result_value(row[col_name])
+                    row_dict[col_name] = processors[col_name].process_result_value(row_dict[col_name])
+            results.append(row_dict)
 
-        return rows
+        return results
 
 
 class InsertBuilder(QueryBuilder):

t_sql-4.5.0/tsql/row.py

@@ -0,0 +1,39 @@
+"""Row object - dict with attribute access support."""
+
+
+class Row(dict):
+    """A dict subclass that supports attribute-style access.
+
+    Provides a nicer API for accessing row data while maintaining
+    full dict compatibility.
+
+    Example:
+        row = Row({'id': 1, 'name': 'Alice'})
+        print(row.id)        # 1 (attribute access)
+        print(row['name'])   # Alice (dict access)
+        row.age = 30         # Set via attribute
+        print(row['age'])    # 30
+    """
+
+    def __getattr__(self, key: str):
+        """Allow attribute-style access to dict keys."""
+        try:
+            return self[key]
+        except KeyError:
+            raise AttributeError(f"Row has no attribute {key!r}") from None
+
+    def __setattr__(self, key: str, value):
+        """Allow attribute-style setting of dict keys."""
+        self[key] = value
+
+    def __delattr__(self, key: str):
+        """Allow attribute-style deletion of dict keys."""
+        try:
+            del self[key]
+        except KeyError:
+            raise AttributeError(f"Row has no attribute {key!r}") from None
+
+    def __repr__(self) -> str:
+        """Nice repr for debugging."""
+        items = ', '.join(f'{k}={v!r}' for k, v in self.items())
+        return f"Row({items})"