tina4-python 3.13.10__tar.gz → 3.13.11__tar.gz

{tina4_python-3.13.10 → tina4_python-3.13.11}/PKG-INFO

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

{tina4_python-3.13.10 → tina4_python-3.13.11}/pyproject.toml

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

{tina4_python-3.13.10 → tina4_python-3.13.11}/tina4_python/__init__.py

@@ -8,7 +8,7 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.13.10"
+__version__ = "3.13.11"
 
 # ── Route decorators ──
 from tina4_python.core.router import (  # noqa: E402, F401

{tina4_python-3.13.10 → tina4_python-3.13.11}/tina4_python/database/connection.py

@@ -421,7 +421,14 @@ class Database:
 
     def fetch(self, sql: str, params: list = None,
               limit: int = 100, offset: int = 0) -> DatabaseResult:
-        """Fetch rows with pagination."""
+        """Fetch rows with pagination.
+
+        v3.13.11 (issue #49 Gap 3): mirror :meth:`execute` and capture
+        ``last_error`` here too — pre-v3.13.11 a failed ``fetch`` left
+        ``db.get_error()`` returning ``None`` even though the adapter
+        had stored the failure on its own ``last_error``. Callers had
+        no way to read the cause via the public API.
+        """
         if self._cache_enabled:
             key = self._cache_key(sql + f":L{limit}:S{offset}", params)
             cached = self._cache_get(key)
@@ -430,13 +437,24 @@ class Database:
                     self._cache_hits += 1
                 return cached
             adapter = self._get_adapter()
-            result = adapter.fetch(sql, params, limit, offset)
+            try:
+                result = adapter.fetch(sql, params, limit, offset)
+                self.last_error = None
+            except Exception:
+                self.last_error = getattr(adapter, "last_error", None) or self.last_error
+                raise
             self._cache_set(key, result)
             with self._cache_lock:
                 self._cache_misses += 1
             return result
         adapter = self._get_adapter()
-        return adapter.fetch(sql, params, limit, offset)
+        try:
+            result = adapter.fetch(sql, params, limit, offset)
+            self.last_error = None
+            return result
+        except Exception:
+            self.last_error = getattr(adapter, "last_error", None) or self.last_error
+            raise
 
     def fetch_all(self, sql: str, params: list = None,
                   limit: int = 100, offset: int = 0) -> list[dict]:

{tina4_python-3.13.10 → tina4_python-3.13.11}/tina4_python/database/postgres.py

@@ -137,7 +137,16 @@ class PostgreSQLAdapter(DatabaseAdapter):
             raise
 
     def _on_query_error(self, exc: Exception, sql: str, params=None):
-        """Handle a failed query: log, store, auto-rollback if implicit."""
+        """Handle a failed query: log, store, auto-rollback if implicit.
+
+        v3.13.11 (issue #49 Gap 1): inside an explicit transaction the
+        auto-rollback step defers to the user — they may be running a
+        SAVEPOINT/retry pattern. The visibility half stays: the original
+        cause is still logged via ``Log.error``, and an additional
+        ``Log.warning`` makes the context explicit so a tail-the-log
+        operator can spot the upstream cause that's about to be buried
+        by a downstream ``InFailedSqlTransaction`` cascade.
+        """
         # Lazy import — avoid circular import at module load and let the
         # framework boot without Log if something exotic is happening.
         try:
@@ -148,6 +157,15 @@ class PostgreSQLAdapter(DatabaseAdapter):
                 sql=preview,
                 params=params,
             )
+            # v3.13.11: extra in-txn marker so the original cause is
+            # easy to spot above the cascade line.
+            if self._in_transaction:
+                Log.warning(
+                    "Above failure occurred inside an explicit transaction — "
+                    "auto-rollback skipped (caller owns the transaction). "
+                    "Subsequent queries on this connection will cascade with "
+                    "'current transaction is aborted' until rollback() is called."
+                )
         except Exception:
             pass
 
@@ -166,6 +184,29 @@ class PostgreSQLAdapter(DatabaseAdapter):
                 # Don't mask the original error if rollback itself fails.
                 pass
 
+    def _log_silent_probe_failure(self, exc: Exception, sql: str, params=None):
+        """v3.13.11 (issue #49 Gap 1): log a probe-query failure as a
+        warning WITHOUT touching ``last_error`` or rolling back.
+
+        Used by the COUNT probe in :meth:`fetch` which is best-effort —
+        it's allowed to fail without surfacing to the caller — but inside
+        an explicit transaction the connection is now poisoned, the
+        paginated query that follows will cascade, and the real cause
+        used to be lost entirely. This logs it so an operator scrolling
+        back through the log can spot the upstream cause.
+        """
+        try:
+            from tina4_python.debug import Log
+            preview = sql.strip().splitlines()[0][:200] if sql else "<no sql>"
+            Log.warning(
+                f"PostgreSQL probe query failed (original cause, before "
+                f"any cascade): {exc.__class__.__name__}: {exc}",
+                sql=preview,
+                params=params,
+            )
+        except Exception:
+            pass
+
     def connect(self, connection_string: str, username: str = "", password: str = "", **kwargs):
         """Connect to PostgreSQL.
 
@@ -280,8 +321,15 @@ class PostgreSQLAdapter(DatabaseAdapter):
         try:
             self._safe_execute(cursor, count_sql, params)
             total = cursor.fetchone()["cnt"]
-        except Exception:
+        except Exception as e:
             total = 0
+            # v3.13.11 (issue #49 Gap 1): log the probe failure as a
+            # warning so the original cause appears in the log even
+            # though the probe itself swallows. Without this line, a
+            # failure inside an explicit transaction is invisible —
+            # the cascade message from the paginated query below is
+            # all the operator sees.
+            self._log_silent_probe_failure(e, count_sql, params)
             # If the probe failed because the connection arrived (or
             # became) aborted, roll back so the real pagination query
             # below sees a clean txn. Without this we'd cascade.

{tina4_python-3.13.10 → tina4_python-3.13.11}/tina4_python/orm/fields.py

@@ -51,12 +51,36 @@ class Field:
         self.choices = choices
         self.validator = validator  # Custom callable(value) → raises ValueError
 
+    # ── v3.13.11 (issue #50): callable-default resolution ──────────────
+    #
+    # Pre-v3.13.11 a callable default (e.g. ``DateTimeField(default=lambda:
+    # datetime.now())``) reached the driver verbatim and blew up with
+    # ``can't adapt type 'function'``. Now we evaluate the callable at the
+    # point of use, so every instance gets a freshly computed value (per-row
+    # timestamps actually differ). Types are excluded — ``default=int`` is
+    # almost never intended to mean "call int()".
+    def _resolve_default(self):
+        d = self.default
+        if callable(d) and not isinstance(d, type):
+            return d()
+        return d
+
     def validate(self, value):
         """Validate and coerce value to the field type."""
         if value is None:
             if self.required and self.default is None:
                 raise ValueError(f"Field '{self.name}' is required")
-            return self.default
+            return self._resolve_default()
+
+        # v3.13.11 (issue #50): if the user stored a callable as the field
+        # value (e.g. ``default=lambda: datetime.now()`` reached us without
+        # being resolved on instance init), evaluate it now so the driver
+        # gets a real value, not the function object. Types are excluded —
+        # ``default=int`` is almost never intended to mean "call int()".
+        if callable(value) and not isinstance(value, type):
+            value = value()
+            if value is None:
+                return None
 
         # Type coercion.
         #

{tina4_python-3.13.10 → tina4_python-3.13.11}/tina4_python/orm/model.py

@@ -177,9 +177,14 @@ class ORM(metaclass=ORMMeta):
         # Initialize relationship cache
         self._rel_cache = {}
 
-        # Set defaults from field definitions
+        # Set defaults from field definitions.
+        # v3.13.11 (issue #50): callable defaults are evaluated *per
+        # instance* so per-row timestamps (e.g. ``default=lambda:
+        # datetime.now()``) actually differ. Pre-v3.13.11 the function
+        # 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.default)
+            setattr(self, name, field._resolve_default())
 
         # Accept JSON string or dict
         if isinstance(data, str):
@@ -304,10 +309,22 @@ class ORM(metaclass=ORMMeta):
     # ── CRUD ────────────────────────────────────────────────────
 
     def save(self) -> Self | bool:
-        """Insert or update. Returns self on success, False on failure."""
+        """Insert or update. Returns self on success, False on failure.
+
+        v3.13.11 (issue #50): for non-auto-increment primary keys (e.g.
+        user-supplied string IDs like ``"GC-100"``), the decision between
+        INSERT and UPDATE is made on whether the row *exists*, not on
+        whether the PK is set. Pre-v3.13.11 a natural-key save() always
+        chose UPDATE — matched zero rows — and silently returned success
+        without inserting anything.
+
+        Auto-increment behaviour is unchanged: ``pk_value is None`` means
+        "new row, let the engine assign an ID" and we still INSERT.
+        """
         db = self._get_db()
         pk = self._get_pk()
         pk_value = getattr(self, pk, None)
+        pk_field = self._fields[pk]
         table = self._get_table()
         pk_db_col = self.field_mapping.get(pk, self._fields[pk].column)
 
@@ -316,22 +333,52 @@ class ORM(metaclass=ORMMeta):
             if field.auto_increment and pk_value is None:
                 continue  # Skip auto-increment on insert
             value = getattr(self, name)
+            # v3.13.11 (issue #50): resolve callable values at write time
+            # too, in case the user set ``self.created_at = lambda: ...``
+            # directly. Defensive — Field.validate() already handles this
+            # for the normal __init__ + _populate paths.
+            if callable(value) and not isinstance(value, type):
+                value = value()
             if value is not None or not field.auto_increment:
                 # Use field_mapping for the column name, fall back to field.column
                 db_col = self.field_mapping.get(name, field.column)
                 data[db_col] = value
 
+        # v3.13.11 (issue #50): pick INSERT vs UPDATE on row existence
+        # for non-auto-increment PKs. Auto-increment keeps the legacy
+        # behaviour (PK is None → INSERT, PK is set → UPDATE).
+        is_update = False
+        if pk_value is not None:
+            if pk_field.auto_increment:
+                is_update = True
+            else:
+                # Natural-key model — check if the row already exists.
+                # type(self).exists() handles soft-delete + scope filters
+                # the same way the rest of the ORM does.
+                try:
+                    is_update = type(self).exists(pk_value)
+                except Exception:
+                    # If we can't tell (e.g. table doesn't exist yet),
+                    # fall back to INSERT — the user will see the real
+                    # error from the driver instead of a silent no-op.
+                    is_update = False
+
         db.start_transaction()
         try:
-            if pk_value is not None:
+            if is_update:
                 update_data = {k: v for k, v in data.items() if k != pk_db_col}
                 if update_data:
                     db.update(table, update_data, f"{pk_db_col} = ?", [pk_value])
             else:
                 db.insert(table, data)
-                last_id = db.get_last_id()
-                if last_id and pk in self._fields:
-                    setattr(self, pk, last_id)
+                # 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
+                # may be a sequence value that doesn't apply here).
+                if pk_field.auto_increment:
+                    last_id = db.get_last_id()
+                    if last_id and pk in self._fields:
+                        setattr(self, pk, last_id)
             db.commit()
         except Exception:
             db.rollback()
@@ -673,10 +720,21 @@ class ORM(metaclass=ORMMeta):
             StringField  → VARCHAR(255)
             TextField    → TEXT
             NumericField/FloatField → REAL
-            BooleanField → INTEGER
+            BooleanField → engine-aware (see below)
             DateTimeField → DATETIME
             BlobField    → BLOB
 
+        v3.13.11 BooleanField mapping (engine-aware):
+            SQLite    → INTEGER    (no native bool — historic convention)
+            PostgreSQL → BOOLEAN   (native type; psycopg2 binds Python
+                                    ``bool`` as BOOLEAN, so INTEGER columns
+                                    caused ``operator does not exist:
+                                    boolean = integer``)
+            MySQL     → BOOLEAN    (synonym for TINYINT(1))
+            MSSQL     → BIT        (the SQL Server bool type)
+            Firebird  → INTEGER    (driver round-trip is uneven; integer
+                                    is the safer choice on Firebird)
+
         Auto-increment primary keys use engine-appropriate syntax.
         Returns True on success.
         """
@@ -684,6 +742,21 @@ class ORM(metaclass=ORMMeta):
 
         db = cls._get_db()
         table = cls._get_table()
+        engine = (db.get_database_type() or "").lower()
+
+        # v3.13.11: BooleanField now uses each engine's native type
+        # where it's reliable. SQLite and Firebird stay on INTEGER —
+        # SQLite has no native bool, and Firebird's driver round-trip
+        # for native BOOLEAN is uneven across versions.
+        if engine == "postgres":
+            bool_sql = "BOOLEAN"
+        elif engine == "mysql":
+            bool_sql = "BOOLEAN"  # MySQL alias for TINYINT(1)
+        elif engine == "mssql":
+            bool_sql = "BIT"
+        else:
+            # sqlite, firebird, odbc, anything else
+            bool_sql = "INTEGER"
 
         # Don't recreate if table already exists
         if db.table_exists(table):
@@ -706,7 +779,7 @@ class ORM(metaclass=ORMMeta):
             elif kind in ("NumericField", "FloatField"):
                 sql_type = "REAL"
             elif kind == "BooleanField":
-                sql_type = "INTEGER"
+                sql_type = bool_sql
             elif kind == "DateTimeField":
                 sql_type = "DATETIME"
             elif kind == "BlobField":
@@ -719,7 +792,7 @@ class ORM(metaclass=ORMMeta):
                 elif ft == float:
                     sql_type = "REAL"
                 elif ft == bool:
-                    sql_type = "INTEGER"
+                    sql_type = bool_sql
                 elif ft == bytes:
                     sql_type = "BLOB"