tina4-python 3.13.124__tar.gz → 3.13.126__tar.gz

{tina4_python-3.13.124 → tina4_python-3.13.126}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: tina4-python
-Version: 3.13.124
+Version: 3.13.126
 Summary: Tina4 Python v3 — Zero-dependency, lightweight web framework
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.13.124 → tina4_python-3.13.126}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.13.124"
+version = "3.13.126"
 description = "Tina4 Python v3 — Zero-dependency, lightweight web framework"
 authors = [
     {name = "Andre van Zuydam", email = "andrevanzuydam@gmail.com"}

{tina4_python-3.13.124 → tina4_python-3.13.126}/tina4_python/__init__.py

@@ -51,7 +51,7 @@ def _resolve_version() -> str:
     #
     # test_version_constant.py now asserts this literal equals the pyproject
     # version, so the release bump cannot leave it behind again.
-    return "3.13.124"
+    return "3.13.125"
 
 
 __version__ = _resolve_version()

{tina4_python-3.13.124 → tina4_python-3.13.126}/tina4_python/cli/__init__.py

@@ -31,8 +31,8 @@ from pathlib import Path
 
 # ── Field type mapping ────────────────────────────────────────────────
 FIELD_TYPE_MAP = {
-    "string":   {"orm": "StringField",   "sql": "TEXT",    "default": "''"},
-    "str":      {"orm": "StringField",   "sql": "TEXT",    "default": "''"},
+    "string":   {"orm": "StringField",   "sql": "VARCHAR(255)", "default": "''"},
+    "str":      {"orm": "StringField",   "sql": "VARCHAR(255)", "default": "''"},
     "int":      {"orm": "IntegerField",  "sql": "INTEGER", "default": "0"},
     "integer":  {"orm": "IntegerField",  "sql": "INTEGER", "default": "0"},
     "float":    {"orm": "NumericField",  "sql": "REAL",    "default": "0"},
@@ -41,7 +41,7 @@ FIELD_TYPE_MAP = {
     "bool":     {"orm": "BooleanField",  "sql": "INTEGER", "default": "0"},
     "boolean":  {"orm": "BooleanField",  "sql": "INTEGER", "default": "0"},
     "text":     {"orm": "TextField",     "sql": "TEXT",    "default": "''"},
-    "datetime": {"orm": "DateTimeField", "sql": "TEXT",    "default": "NULL"},
+    "datetime": {"orm": "DateTimeField", "sql": "TIMESTAMP", "default": "NULL"},
     "blob":     {"orm": "BlobField",     "sql": "BLOB",    "default": "NULL"},
 }
 
@@ -1941,7 +1941,7 @@ def _gen_migration(name: str, flags: dict = None, *,
             info = FIELD_TYPE_MAP.get(ftype, FIELD_TYPE_MAP["string"])
             default = f" DEFAULT {info['default']}" if info["default"] != "NULL" else ""
             col_lines.append(f"    {fname} {info['sql']}{default}")
-        col_lines.append("    created_at TEXT DEFAULT CURRENT_TIMESTAMP")
+        col_lines.append("    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP")
 
         # ADR-0063: `tina4:edit` marker between the last column and the closing
         # paren, placed OUTSIDE the comma-joined column list so the SQL stays

{tina4_python-3.13.124 → tina4_python-3.13.126}/tina4_python/database/firebird.py

@@ -646,6 +646,7 @@ class FirebirdAdapter(SqlCrudMixin, DatabaseAdapter):
         sql = SQLTranslator.ilike_to_like(sql)
         sql = SQLTranslator.boolean_to_int(sql)
         sql = SQLTranslator.auto_increment_syntax(sql, "firebird")
+        sql = SQLTranslator.ddl_types(sql, "firebird")
         return sql
 
     def _supports_returning(self) -> bool:

{tina4_python-3.13.124 → tina4_python-3.13.126}/tina4_python/database/mssql.py

@@ -350,6 +350,7 @@ class MSSQLAdapter(SqlCrudMixin, DatabaseAdapter):
         sql = SQLTranslator.ilike_to_like(sql)
         sql = SQLTranslator.auto_increment_syntax(sql, "mssql")
         sql = SQLTranslator.boolean_to_int(sql)
+        sql = SQLTranslator.ddl_types(sql, "mssql")
         return sql
 
     def _supports_returning(self) -> bool:

{tina4_python-3.13.124 → tina4_python-3.13.126}/tina4_python/database/mysql.py

@@ -321,6 +321,7 @@ class MySQLAdapter(SqlCrudMixin, DatabaseAdapter):
         sql = SQLTranslator.concat_pipes_to_func(sql)
         sql = SQLTranslator.ilike_to_like(sql)
         sql = SQLTranslator.auto_increment_syntax(sql, "mysql")
+        sql = SQLTranslator.ddl_types(sql, "mysql")
         return sql
 
     def _supports_returning(self) -> bool:

{tina4_python-3.13.124 → tina4_python-3.13.126}/tina4_python/database/sql_translator.py

@@ -347,6 +347,49 @@ class SQLTranslator:
             return re.sub(r"\s*AUTOINCREMENT\b", "", sql, flags=re.IGNORECASE)
         return sql
 
+    @staticmethod
+    def ddl_types(sql: str, engine: str) -> str:
+        """Translate SQLite-canonical DDL column TYPES + CREATE-TABLE options to
+        the target engine.
+
+        ONLY acts on ``CREATE TABLE`` / ``ALTER TABLE`` statements, so a query or
+        INSERT that happens to contain the word ``TEXT`` (a column name, a string
+        literal) is never rewritten. Complements ``auto_increment_syntax`` (which
+        maps the id keyword) so ONE portable migration — and every
+        ``ORM.create_table()`` DDL, which is also SQLite-canonical — applies on
+        every engine instead of failing on Firebird/MSSQL.
+
+        * Firebird has no ``TEXT`` (-607), no ``REAL``, and no
+          ``CREATE TABLE IF NOT EXISTS``.
+        * MSSQL has no ``CREATE TABLE IF NOT EXISTS`` and its ``TIMESTAMP`` is a
+          rowversion, not a datetime — a ``created_at TIMESTAMP`` there is wrong.
+        * MySQL's ``TIMESTAMP`` carries auto-update / 2038 surprises, so a
+          datetime column maps to ``DATETIME`` (matching ORM.create_table()).
+        """
+        # Gate to DDL only, tolerating leading `-- ...` comment lines / blank
+        # lines that a migration file carries before its CREATE TABLE. A SELECT
+        # or INSERT that merely mentions a type keyword is never rewritten.
+        head = re.sub(r"^(?:\s*--[^\n]*\n)+", "", sql)
+        if not re.match(r"\s*(CREATE\s+TABLE|ALTER\s+TABLE)\b", head, re.IGNORECASE):
+            return sql
+        e = (engine or "").lower()
+        if e == "firebird":
+            sql = re.sub(r"\bIF\s+NOT\s+EXISTS\b", "", sql, flags=re.IGNORECASE)
+            # Map bare TEXT -> BLOB SUB_TYPE TEXT, but leave an existing
+            # "BLOB SUB_TYPE TEXT" intact (it already contains the word TEXT).
+            sql = re.sub(
+                r"\bBLOB\s+SUB_TYPE\s+TEXT\b", "\x00FBTEXT\x00", sql, flags=re.IGNORECASE
+            )
+            sql = re.sub(r"\bTEXT\b", "BLOB SUB_TYPE TEXT", sql, flags=re.IGNORECASE)
+            sql = sql.replace("\x00FBTEXT\x00", "BLOB SUB_TYPE TEXT")
+            sql = re.sub(r"\bREAL\b", "DOUBLE PRECISION", sql, flags=re.IGNORECASE)
+        elif e == "mssql":
+            sql = re.sub(r"\bIF\s+NOT\s+EXISTS\b", "", sql, flags=re.IGNORECASE)
+            sql = re.sub(r"\bTIMESTAMP\b", "DATETIME2", sql, flags=re.IGNORECASE)
+        elif e == "mysql":
+            sql = re.sub(r"\bTIMESTAMP\b", "DATETIME", sql, flags=re.IGNORECASE)
+        return sql
+
     @staticmethod
     def placeholder_style(sql: str, style: str = "?") -> str:
         """Convert ? placeholders to engine-specific style.

{tina4_python-3.13.124 → tina4_python-3.13.126}/tina4_python/seeder/__init__.py

@@ -66,6 +66,35 @@ _JOB_TITLES = [
 ]
 _CURRENCIES = ["USD", "EUR", "GBP", "JPY", "CAD", "AUD", "CHF", "ZAR", "INR", "CNY"]
 _CREDIT_CARD_PREFIXES = ["4111", "4242", "5500", "5105"]
+# Product-name vocabulary (adjective + noun). Seeds a `name` column on a
+# product-ish table with "Wireless Keyboard" instead of a person name.
+_PRODUCT_ADJECTIVES = [
+    "Wireless", "Organic", "Premium", "Classic", "Eco", "Smart", "Portable",
+    "Deluxe", "Compact", "Rustic", "Handcrafted", "Vintage", "Modern",
+    "Ergonomic", "Stainless", "Bamboo", "Recycled", "Artisan", "Professional",
+    "Ultra", "Insulated", "Lightweight", "Adjustable", "Foldable",
+]
+_PRODUCT_NOUNS = [
+    "Keyboard", "Coffee Beans", "Backpack", "Water Bottle", "Desk Lamp",
+    "Headphones", "Notebook", "Sneakers", "Sunglasses", "Wallet", "Mug",
+    "Chair", "Blender", "Speaker", "Charger", "Umbrella", "Toothbrush",
+    "Jacket", "Watch", "Kettle", "Picture Frame", "Planter", "Cutlery Set",
+    "Yoga Mat", "Phone Case",
+]
+# A table/model whose name contains any of these gets product names on its
+# generic `name`/`full_name` column instead of a person name.
+_PRODUCT_TABLE_HINTS = (
+    "product", "item", "catalog", "inventory", "goods", "merchandise",
+    "sku", "listing", "stock", "ware",
+)
+
+
+def _is_product_table(table: str) -> bool:
+    """True when the table/model name looks like a product catalogue, so a
+    generic ``name`` column should seed a product name, not a person name.
+    With no table context this is False, so the person-name default is kept
+    (back-compat)."""
+    return any(hint in (table or "").lower() for hint in _PRODUCT_TABLE_HINTS)
 
 
 class FakeData:
@@ -227,7 +256,7 @@ class FakeData:
         d = start + timedelta(seconds=self._rng.randint(0, delta))
         return d.strftime("%Y-%m-%dT%H:%M:%SZ")
 
-    def for_field(self, field_def: dict, column_name: str = None):
+    def for_field(self, field_def: dict, column_name: str = None, table: str = None):
         """Generate a fake value from a field definition dict and optional column name.
 
         Args:
@@ -249,7 +278,7 @@ class FakeData:
             if "phone" in col or "tel" in col or "mobile" in col:
                 return self.phone()
             if col in ("full_name", "fullname", "name"):
-                return self.name()
+                return self.product() if _is_product_table(table) else self.name()
             if "first_name" in col or ("first" in col and "name" in col):
                 return self.first_name()
             if "last_name" in col or ("last" in col and "name" in col):
@@ -297,6 +326,11 @@ class FakeData:
     def job_title(self) -> str:
         return self._rng.choice(_JOB_TITLES)
 
+    def product(self) -> str:
+        """A plausible product name, e.g. "Wireless Keyboard" or "Organic Coffee
+        Beans". Deterministic under a seed like every other generator."""
+        return f"{self._rng.choice(_PRODUCT_ADJECTIVES)} {self._rng.choice(_PRODUCT_NOUNS)}"
+
     def currency(self) -> str:
         return self._rng.choice(_CURRENCIES)
 
@@ -362,7 +396,7 @@ class SeedSummary(int):
         return f"SeedSummary(seeded={self.seeded}, failed={self.failed}, errors={self.errors!r})"
 
 
-def _generator_for_column(fake: "FakeData", name: str, col_type: str):
+def _generator_for_column(fake: "FakeData", name: str, col_type: str, table: str = None):
     """Pick a FakeData generator for one column from its name + type.
 
     The shared heuristic behind :func:`auto_field_map`, so the dev-admin
@@ -380,7 +414,7 @@ def _generator_for_column(fake: "FakeData", name: str, col_type: str):
     if "last" in name_lower and "name" in name_lower:
         return fake.last_name
     if "name" in name_lower:
-        return fake.name
+        return fake.product if _is_product_table(table) else fake.name
     if "phone" in name_lower or "tel" in name_lower:
         return fake.phone
     if "url" in name_lower or "link" in name_lower:
@@ -424,7 +458,7 @@ def auto_field_map(db, table: str, fake: "FakeData" = None) -> dict:
         is_pk = col.get("primary_key", col.get("pk", False))
         if is_pk and ("AUTO" in col_type or "SERIAL" in col_type or name.lower() == "id"):
             continue
-        field_map[name] = _generator_for_column(fake, name, col_type)
+        field_map[name] = _generator_for_column(fake, name, col_type, table)
     return field_map
 
 
@@ -584,7 +618,8 @@ def seed_orm(orm_class, count: int = 10,
                 elif name in fk_pools and fk_pools[name]:
                     attrs[name] = fake.choice(fk_pools[name])
                 else:
-                    attrs[name] = _generate_for_field(fake, _field_meta(field), name)
+                    attrs[name] = _generate_for_field(fake, _field_meta(field), name,
+                                                      table=orm_class.__name__)
             _validate_types(fields, attrs, orm_class.__name__, Log)
             obj = orm_class(attrs)
             if obj.save():
@@ -813,7 +848,7 @@ def _topo_sort_models(orm_classes: list) -> list:
     return ordered
 
 
-def _generate_for_field(fake: FakeData, field_def: dict, col: str):
+def _generate_for_field(fake: FakeData, field_def: dict, col: str, table: str = None):
     """Generate a fake value for an ORM field definition + column name."""
     col = col.lower()
     ftype = field_def.get("type", "string")
@@ -842,7 +877,7 @@ def _generate_for_field(fake: FakeData, field_def: dict, col: str):
         if "email" in col:
             return fake.email()
         if col in ("name", "full_name", "fullname"):
-            return fake.name()
+            return fake.product() if _is_product_table(table) else fake.name()
         if "first" in col and "name" in col:
             return fake.first_name()
         if "last" in col and "name" in col: