tina4-python 3.13.69__tar.gz → 3.13.70__tar.gz

{tina4_python-3.13.69 → tina4_python-3.13.70}/PKG-INFO

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

{tina4_python-3.13.69 → tina4_python-3.13.70}/pyproject.toml

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

{tina4_python-3.13.69 → tina4_python-3.13.70}/tina4_python/database/firebird.py

@@ -8,7 +8,7 @@ Requires: pip install firebird-driver  (or pip install fdb for legacy)
 """
 import os
 import re
-from urllib.parse import urlparse, unquote
+from urllib.parse import urlparse, unquote, parse_qs
 from tina4_python.database.adapter import DatabaseAdapter, DatabaseResult, SQLTranslator
 
 
@@ -68,6 +68,35 @@ def _normalize_firebird_db_identifier(raw_path: str) -> str:
     return decoded if decoded.startswith("/") else "/" + decoded
 
 
+def _resolve_firebird_charset(connection_string: str, kwarg_charset: str | None = None) -> str:
+    """Resolve the Firebird connection charset (php #160).
+
+    The adapter used to hardcode ``UTF8`` with no override, which
+    double-encodes UTF-8 bytes stored under a legacy ``NONE`` database. This
+    resolves the charset from, in precedence order:
+
+    1. the connection URL query — ``firebird://host:port/path?charset=NONE``
+    2. an explicit ``charset=`` keyword passed to :meth:`connect`
+    3. the ``TINA4_DATABASE_CHARSET`` environment variable
+    4. the ``UTF8`` default (unchanged — non-breaking for existing connections)
+
+    Pure config resolution over its inputs (URL string, kwarg, env) — no
+    connection is opened, so it is unit-testable without a live server.
+    """
+    url_charset = None
+    query = urlparse(connection_string).query
+    if query:
+        values = parse_qs(query).get("charset")
+        if values:
+            url_charset = values[0]
+    return (
+        url_charset
+        or kwarg_charset
+        or os.environ.get("TINA4_DATABASE_CHARSET")
+        or "UTF8"
+    )
+
+
 # Try modern firebird-driver first, fall back to legacy fdb
 _driver = None
 _driver_name = None
@@ -142,7 +171,11 @@ class FirebirdAdapter(DatabaseAdapter):
 
         user = parsed.username or username or "SYSDBA"
         password = parsed.password or password or "masterkey"
-        charset = kwargs.pop("charset", "UTF8")
+        # php #160: honour ?charset= in the URL and TINA4_DATABASE_CHARSET so a
+        # legacy NONE database isn't force-connected as UTF8 (double-encoding).
+        # Pop the kwarg first so it isn't also forwarded into the driver connect
+        # via **extra below (which would raise a duplicate-keyword error).
+        charset = _resolve_firebird_charset(connection_string, kwargs.pop("charset", None))
 
         # Cache for transparent reconnect — never logged, lives only in
         # adapter memory alongside the connection it owns.

{tina4_python-3.13.69 → tina4_python-3.13.70}/tina4_python/dev_admin/__init__.py

@@ -953,7 +953,7 @@ async def _api_seed_table(request, response):
     """Seed fake data into a database table from the admin UI."""
     try:
         from tina4_python.database import Database
-        from tina4_python.seeder import FakeData, seed_table
+        from tina4_python.seeder import FakeData, seed_table, auto_field_map
 
         body = request.body if hasattr(request, "body") and request.body else {}
         table = body.get("table", "")
@@ -985,54 +985,12 @@ async def _api_seed_table(request, response):
 
         fake = FakeData(seed=seed_val)
 
-        def _gen_for_column(col):
-            """Pick a FakeData generator for one column from its name + type."""
-            name = col.get("name", col.get("column_name", ""))
-            col_type = col.get("type", col.get("data_type", "")).upper()
-            name_lower = name.lower()
-            if "email" in name_lower:
-                return fake.email
-            if "name" in name_lower and "user" in name_lower:
-                return fake.name
-            if "first" in name_lower and "name" in name_lower:
-                return fake.first_name
-            if "last" in name_lower and "name" in name_lower:
-                return fake.last_name
-            if "name" in name_lower:
-                return 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:
-                return fake.url
-            if "address" in name_lower:
-                return fake.address
-            if "date" in name_lower or "time" in name_lower or "created" in name_lower:
-                return fake.datetime_iso
-            if "desc" in name_lower or "body" in name_lower or "content" in name_lower:
-                return fake.paragraph
-            if "title" in name_lower or "subject" in name_lower:
-                return fake.sentence
-            if "active" in name_lower or "enabled" in name_lower or "done" in name_lower:
-                return fake.boolean
-            if "INT" in col_type or "SERIAL" in col_type:
-                return lambda: fake.integer(1, 10000)
-            if any(t in col_type for t in ("REAL", "FLOAT", "DOUBLE", "NUMERIC", "DECIMAL")):
-                return lambda: fake.decimal(0, 1000)
-            if "BOOL" in col_type:
-                return fake.boolean
-            return fake.sentence
-
-        # Build a field_map skipping auto-increment / id PKs, then delegate to
-        # seed_table so this endpoint shares the exact same visible-but-resilient
-        # per-row error handling (P1/P4b) — no unhandled row failure crashes it.
-        field_map = {}
-        for col in columns:
-            name = col.get("name", col.get("column_name", ""))
-            col_type = col.get("type", col.get("data_type", "")).upper()
-            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] = _gen_for_column(col)
+        # Build a field_map (column -> generator, skipping auto-increment / id
+        # PKs) via the shared seeder helper, then delegate to seed_table so this
+        # endpoint shares the exact same visible-but-resilient per-row error
+        # handling (P1/P4b) — no unhandled row failure crashes it. The MCP
+        # seed_table dev tool uses the identical helper for parity.
+        field_map = auto_field_map(db, table, fake)
 
         try:
             summary = seed_table(db, table, count, field_map=field_map,

{tina4_python-3.13.69 → tina4_python-3.13.70}/tina4_python/dev_admin/metrics.py

@@ -129,7 +129,7 @@ def quick_metrics(root: str = "src") -> dict:
     orm_count = 0
     try:
         from tina4_python.core.router import Router
-        route_count = len(Router._routes) if hasattr(Router, "_routes") else 0
+        route_count = len(Router.get_routes())
     except Exception:
         pass
     try:

{tina4_python-3.13.69 → tina4_python-3.13.70}/tina4_python/mcp/tools.py

@@ -307,7 +307,11 @@ def register_dev_tools(server):
     def swagger_spec() -> dict:
         """Return the full OpenAPI 3.0.3 JSON specification."""
         from tina4_python.swagger import Swagger
-        return Swagger.generate()
+        from tina4_python.core.router import Router
+        # Swagger.generate is an INSTANCE method that takes the route table;
+        # build the spec from the live routes (same shape AutoCrud/the dev
+        # /swagger endpoint use). Canonical call: Swagger().generate(Router.get_routes()).
+        return Swagger().generate(Router.get_routes())
 
     # ── Template Tools ──────────────────────────────────────────
 
@@ -481,15 +485,15 @@ def register_dev_tools(server):
 
     # ── Migration Tools ─────────────────────────────────────────
 
-    def migration_status() -> list:
+    def migration_status() -> dict:
         """List pending and completed migrations."""
         from tina4_python.orm.model import ORM
-        from tina4_python.migration.runner import MigrationRunner
-        db = ORM._database
+        from tina4_python.migration import status
+        db = ORM._get_db() if hasattr(ORM, "_get_db") else None
         if db is None:
             return {"error": "No database connection"}
-        runner = MigrationRunner(db)
-        return runner.status() if hasattr(runner, "status") else {"info": "Migration status not available"}
+        # status(db) == Migration(db).status(); returns {"completed": [...], "pending": [...]}.
+        return status(db)
 
     def migration_create(description: str) -> dict:
         """Create a new migration file. Refuses to create a duplicate
@@ -541,12 +545,14 @@ def register_dev_tools(server):
     def migration_run() -> dict:
         """Run all pending migrations."""
         from tina4_python.orm.model import ORM
-        from tina4_python.migration import Migration
-        db = ORM._database
+        from tina4_python.migration import migrate
+        db = ORM._get_db() if hasattr(ORM, "_get_db") else None
         if db is None:
             return {"error": "No database connection"}
-        result = Migration(db).migrate()
-        return {"result": str(result)}
+        # migrate(db) == Migration(db).migrate(); returns the list of applied
+        # migration filenames (empty when nothing was pending).
+        applied = migrate(db)
+        return {"applied": applied, "count": len(applied)}
 
     # ── Queue Tools ─────────────────────────────────────────────
 
@@ -638,13 +644,20 @@ def register_dev_tools(server):
     def seed_table(table: str, count: int = 10) -> dict:
         """Seed a table with fake data."""
         try:
-            from tina4_python.seeder import seed_table as _seed
+            from tina4_python.seeder import seed_table as _seed, auto_field_map
             from tina4_python.orm.model import ORM
-            db = ORM._database
+            db = ORM._get_db() if hasattr(ORM, "_get_db") else None
             if db is None:
                 return {"error": "No database connection"}
-            inserted = _seed(db, table, count)
-            return {"table": table, "inserted": inserted}
+            # seed_table needs an explicit column->generator field_map (no map =
+            # no rows, by design). auto_field_map introspects the table columns
+            # and builds one — the same helper the dev-admin seeding endpoint
+            # uses — so the tool actually inserts fake rows.
+            field_map = auto_field_map(db, table)
+            if not field_map:
+                return {"error": f"Table '{table}' not found or has no seedable columns"}
+            summary = _seed(db, table, count, field_map=field_map)
+            return {"table": table, "inserted": summary.seeded, "failed": summary.failed}
         except Exception as e:
             return {"error": str(e)}
 

{tina4_python-3.13.69 → tina4_python-3.13.70}/tina4_python/orm/model.py

@@ -183,6 +183,15 @@ class ORM(metaclass=ORMMeta):
         # Initialize relationship cache
         self._rel_cache = {}
 
+        # #165: track which fields the caller EXPLICITLY assigned (via
+        # constructor data/kwargs, _populate, or ``model.field = x``). save()
+        # uses this to OMIT an unset column from an INSERT — so a NOT NULL
+        # DEFAULT column gets its DB default instead of an explicit NULL —
+        # while still writing NULL for a field the caller set to None. The
+        # defaults seeded below go through object.__setattr__ so they are NOT
+        # counted as caller assignments.
+        self._assigned_fields = set()
+
         # Set defaults from field definitions.
         # v3.13.11 (issue #50): callable defaults are evaluated *per
         # instance* so per-row timestamps (e.g. ``default=lambda:
@@ -190,7 +199,7 @@ class ORM(metaclass=ORMMeta):
         # object reached the driver verbatim and blew up with
         # ``can't adapt type 'function'``.
         for name, field in self._fields.items():
-            setattr(self, name, field._resolve_default())
+            object.__setattr__(self, name, field._resolve_default())
 
         # Accept JSON string or dict
         if isinstance(data, str):
@@ -213,6 +222,22 @@ class ORM(metaclass=ORMMeta):
         if kwargs:
             self._populate(kwargs)
 
+    def __setattr__(self, name, value):
+        """Set an attribute, recording explicit assignment to declared fields.
+
+        #165: ``save()`` reads ``_assigned_fields`` to tell a column the caller
+        actually assigned (write it — an explicit ``None`` becomes ``NULL``)
+        from one left at its default (OMIT from the INSERT so a
+        ``NOT NULL DEFAULT`` column gets its DB default rather than an explicit
+        ``NULL``). ``__init__`` seeds field defaults with ``object.__setattr__``,
+        so only genuine caller assignments are tracked here. Non-field attrs
+        (``last_error``, ``_rel_cache``, relationships, …) are never recorded.
+        """
+        assigned = self.__dict__.get("_assigned_fields")
+        if assigned is not None and name in type(self)._fields:
+            assigned.add(name)
+        object.__setattr__(self, name, value)
+
     def _populate(self, data: dict):
         """Set field values from a dict.
 
@@ -377,6 +402,11 @@ class ORM(metaclass=ORMMeta):
         pk_db_col = self.field_mapping.get(pk, self._fields[pk].column)
 
         data = {}
+        # #165: db columns to OMIT from an INSERT — those the caller never
+        # assigned AND whose value is None. Omitting them lets the DB DEFAULT
+        # apply (e.g. NOT NULL DEFAULT '') instead of emitting an explicit NULL
+        # that violates the constraint. Unused on the UPDATE path.
+        insert_omit = set()
         for name, field in self._fields.items():
             if field.auto_increment and pk_value is None:
                 continue  # Skip auto-increment on insert
@@ -393,6 +423,13 @@ class ORM(metaclass=ORMMeta):
                 # Serialize to the column's storage form: identity for most
                 # fields, JSON string for JSONField (see Field.to_db).
                 data[db_col] = field.to_db(value)
+                # #165: a None value the caller never assigned is an UNSET
+                # column — omit it from the INSERT so the DB DEFAULT applies.
+                # A resolved ORM default (non-None) is still written; a value
+                # the caller explicitly set to None is still written as NULL
+                # (its field name is in _assigned_fields).
+                if value is None and name not in self._assigned_fields:
+                    insert_omit.add(db_col)
 
         # v3.13.11 (issue #50): pick INSERT vs UPDATE on row existence
         # for non-auto-increment PKs. Auto-increment keeps the legacy
@@ -420,7 +457,19 @@ class ORM(metaclass=ORMMeta):
                 if update_data:
                     db.update(table, update_data, f"{pk_db_col} = ?", [pk_value])
             else:
-                db.insert(table, data)
+                # #165: drop unset-None columns so the DB DEFAULT applies.
+                insert_data = {c: v for c, v in data.items() if c not in insert_omit}
+                if insert_data:
+                    db.insert(table, insert_data)
+                else:
+                    # Every insertable column was left unset — let the DB
+                    # apply ALL its column defaults rather than emitting
+                    # explicit NULLs. DEFAULT VALUES is valid on SQLite /
+                    # PostgreSQL / MSSQL / Firebird; MySQL spells it () VALUES ().
+                    if db.get_database_type() == "mysql":
+                        db.execute(f"INSERT INTO {table} () VALUES ()")
+                    else:
+                        db.execute(f"INSERT INTO {table} DEFAULT VALUES")
                 # Only adopt the engine-assigned ID for auto-increment PKs.
                 # Natural-key PKs were already set by the caller; don't
                 # overwrite them with the driver's last_id (which on PG

{tina4_python-3.13.69 → tina4_python-3.13.70}/tina4_python/seeder/__init__.py

@@ -346,6 +346,72 @@ 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):
+    """Pick a FakeData generator for one column from its name + type.
+
+    The shared heuristic behind :func:`auto_field_map`, so the dev-admin
+    seeding endpoint and the MCP ``seed_table`` dev tool auto-generate
+    identical column data. Falls back to a sentence for anything unrecognised.
+    """
+    name_lower = (name or "").lower()
+    col_type = (col_type or "").upper()
+    if "email" in name_lower:
+        return fake.email
+    if "name" in name_lower and "user" in name_lower:
+        return fake.name
+    if "first" in name_lower and "name" in name_lower:
+        return fake.first_name
+    if "last" in name_lower and "name" in name_lower:
+        return fake.last_name
+    if "name" in name_lower:
+        return 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:
+        return fake.url
+    if "address" in name_lower:
+        return fake.address
+    if "date" in name_lower or "time" in name_lower or "created" in name_lower:
+        return fake.datetime_iso
+    if "desc" in name_lower or "body" in name_lower or "content" in name_lower:
+        return fake.paragraph
+    if "title" in name_lower or "subject" in name_lower:
+        return fake.sentence
+    if "active" in name_lower or "enabled" in name_lower or "done" in name_lower:
+        return fake.boolean
+    if "INT" in col_type or "SERIAL" in col_type:
+        return lambda: fake.integer(1, 10000)
+    if any(t in col_type for t in ("REAL", "FLOAT", "DOUBLE", "NUMERIC", "DECIMAL")):
+        return lambda: fake.decimal(0, 1000)
+    if "BOOL" in col_type:
+        return fake.boolean
+    return fake.sentence
+
+
+def auto_field_map(db, table: str, fake: "FakeData" = None) -> dict:
+    """Introspect ``table``'s columns and build a column->generator field_map
+    for :func:`seed_table`, skipping auto-increment / ``id`` primary keys.
+
+    This is the "seed a table I did not hand-write generators for" convenience
+    that both the dev-admin seeding endpoint and the MCP ``seed_table`` dev tool
+    need. ``seed_table`` itself stays explicit (no field_map = no rows); this
+    helper is how a caller opts into automatic generation. Returns an empty dict
+    when the table has no columns, so ``seed_table`` then seeds nothing rather
+    than crashing.
+    """
+    fake = fake or FakeData()
+    columns = db.get_columns(table) or []
+    field_map: dict[str, callable] = {}
+    for col in columns:
+        name = col.get("name", col.get("column_name", ""))
+        col_type = str(col.get("type", col.get("data_type", "")) or "").upper()
+        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)
+    return field_map
+
+
 def seed_table(db, table: str, count: int = 10,
                field_map: dict[str, callable] = None,
                overrides: dict = None, clear: bool = False,
@@ -766,4 +832,5 @@ def _generate_for_field(fake: FakeData, field_def: dict, col: str):
     return fake.word()
 
 
-__all__ = ["FakeData", "SeedSummary", "seed_table", "seed_orm", "seed_models"]
+__all__ = ["FakeData", "SeedSummary", "seed_table", "seed_orm", "seed_models",
+           "auto_field_map"]