tina4-python 3.13.134__tar.gz → 3.13.136__tar.gz

{tina4_python-3.13.134 → tina4_python-3.13.136}/PKG-INFO

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

{tina4_python-3.13.134 → tina4_python-3.13.136}/pyproject.toml

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

{tina4_python-3.13.134 → tina4_python-3.13.136}/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.134"
+    return "3.13.136"
 
 
 __version__ = _resolve_version()

{tina4_python-3.13.134 → tina4_python-3.13.136}/tina4_python/database/connection.py

@@ -10,6 +10,7 @@ Connection pooling:
     db = Database("sqlite:///data/app.db", pool=4)  # 4 connections, round-robin
 """
 import hashlib
+import importlib
 import os
 import threading
 import time
@@ -129,43 +130,56 @@ def register_driver(scheme: str, adapter_class: type):
     _DRIVERS[scheme] = adapter_class
 
 
-# Register built-in SQLite
+# Register built-in SQLite eagerly. It is stdlib, so importing it drags in no
+# third-party package -- the zero-dependency default carries no import cost.
 from tina4_python.database.sqlite import SQLiteAdapter
 register_driver("sqlite", SQLiteAdapter)
 
-# Register ODBC (lazy — only fails if you actually use it without pyodbc)
-try:
-    from tina4_python.database.odbc import ODBCAdapter
-    register_driver("odbc", ODBCAdapter)
-except ImportError:
-    pass  # pyodbc not installed — that's fine
-
-# Register PostgreSQL (psycopg2 — optional)
-from tina4_python.database.postgres import PostgreSQLAdapter
-register_driver("postgresql", PostgreSQLAdapter)
-register_driver("postgres", PostgreSQLAdapter)
-register_driver("pgsql", PostgreSQLAdapter)  # PDO / Laravel / Doctrine scheme name (issue #58)
-
-# Register MySQL (mysql-connector-python — optional)
-from tina4_python.database.mysql import MySQLAdapter
-register_driver("mysql", MySQLAdapter)
-
-# Register MSSQL (pymssql — optional)
-from tina4_python.database.mssql import MSSQLAdapter
-register_driver("mssql", MSSQLAdapter)
-register_driver("sqlserver", MSSQLAdapter)
-
-# Register Firebird (fdb — optional)
-from tina4_python.database.firebird import FirebirdAdapter
-register_driver("firebird", FirebirdAdapter)
-
-# Register MongoDB (pymongo — optional)
-try:
-    from tina4_python.database.mongodb import MongoDBAdapter
-    register_driver("mongodb", MongoDBAdapter)
-    register_driver("pymongo", MongoDBAdapter)
-except ImportError:
-    pass
+# Every OTHER adapter is registered LAZILY: its module -- and the third-party
+# driver that module imports -- is loaded only when a URL for that scheme is
+# actually connected. Importing tina4_python.database (which happens on the first
+# Database(url), regardless of engine) therefore never drags psycopg2,
+# firebird-driver (+ protobuf + dateutil), pymssql or pymongo into an app that
+# does not use them. Connecting to Postgres loads only psycopg2; a SQLite app
+# loads no third-party driver at all. This mirrors PHP/Ruby autoload and Node's
+# optionalDependencies + dynamic import. Aliases share the same target so the
+# canonical engine and every alias resolve to one adapter class.
+_LAZY_DRIVERS: dict[str, tuple[str, str]] = {
+    "postgres": ("tina4_python.database.postgres", "PostgreSQLAdapter"),
+    "postgresql": ("tina4_python.database.postgres", "PostgreSQLAdapter"),
+    "pgsql": ("tina4_python.database.postgres", "PostgreSQLAdapter"),  # PDO / Laravel / Doctrine (issue #58)
+    "mysql": ("tina4_python.database.mysql", "MySQLAdapter"),
+    "mssql": ("tina4_python.database.mssql", "MSSQLAdapter"),
+    "sqlserver": ("tina4_python.database.mssql", "MSSQLAdapter"),
+    "firebird": ("tina4_python.database.firebird", "FirebirdAdapter"),
+    "odbc": ("tina4_python.database.odbc", "ODBCAdapter"),
+    "mongodb": ("tina4_python.database.mongodb", "MongoDBAdapter"),
+    "pymongo": ("tina4_python.database.mongodb", "MongoDBAdapter"),
+}
+
+
+def known_drivers() -> set[str]:
+    """Every URL scheme the framework can resolve: eagerly-registered (sqlite,
+    plus anything an app registered by hand via register_driver) and the
+    lazily-registered built-ins that import their driver on first use."""
+    return set(_DRIVERS) | set(_LAZY_DRIVERS)
+
+
+def _resolve_lazy_driver(scheme: str) -> None:
+    """Import a lazily-declared adapter and register it, on first use.
+
+    Raises a clear ValueError if the adapter's driver package is not installed,
+    rather than an opaque ImportError from deep in the driver.
+    """
+    module_path, class_name = _LAZY_DRIVERS[scheme]
+    try:
+        module = importlib.import_module(module_path)
+    except ImportError as exc:
+        raise ValueError(
+            f"Database driver '{scheme}' is unavailable: {exc}. "
+            f"Install the driver package and it will register automatically."
+        ) from exc
+    register_driver(scheme, getattr(module, class_name))
 
 
 class Database:
@@ -339,12 +353,16 @@ class Database:
             scheme = (urlparse(self.url).scheme or "").lower()
 
         if scheme not in _DRIVERS:
-            available = ", ".join(_DRIVERS.keys())
-            raise ValueError(
-                f"Unknown database driver '{scheme}'. "
-                f"Available: {available}. "
-                f"Install the driver package and it will register automatically."
-            )
+            if scheme in _LAZY_DRIVERS:
+                # First connection to this engine: import + register its adapter.
+                _resolve_lazy_driver(scheme)
+            else:
+                available = ", ".join(sorted(known_drivers()))
+                raise ValueError(
+                    f"Unknown database driver '{scheme}'. "
+                    f"Available: {available}. "
+                    f"Install the driver package and it will register automatically."
+                )
 
         return _DRIVERS[scheme]()
 

{tina4_python-3.13.134 → tina4_python-3.13.136}/tina4_python/dev_admin/__init__.py

@@ -1933,20 +1933,41 @@ def _route_count() -> int:
 
 
 async def _api_version_check(request, response):
-    """Proxy version check to PyPI to avoid browser CORS errors."""
+    """Proxy the version check to PyPI so the browser dodges a CORS error.
+
+    A check that did not happen says so. This used to fall back to
+    latest = current on any failure, and the toolbar renders that as a green
+    "You are up to date!" -- so a developer several releases behind, on a
+    machine with no route out, was told the opposite of the truth, and the
+    toolbar's own "Could not check for updates" branch could never fire because
+    the failure arrived as a success. latest is None when the check could not be
+    made, and error says why.
+
+    The registry URL is TINA4_VERSION_CHECK_URL when set (a mirror, or a test's
+    own server), else PyPI.
+    """
     import urllib.request
     current = __version__
-    latest = current
+    url = os.environ.get(
+        "TINA4_VERSION_CHECK_URL", "https://pypi.org/pypi/tina4-python/json"
+    )
+
+    def failed(why):
+        return response({"current": current, "latest": None, "error": why})
+
     try:
         req = urllib.request.Request(
-            "https://pypi.org/pypi/tina4-python/json",
-            headers={"User-Agent": "tina4-python/" + current},
+            url, headers={"User-Agent": "tina4-python/" + current}
         )
         with urllib.request.urlopen(req, timeout=5) as resp:
             data = json.loads(resp.read().decode())
-            latest = data.get("info", {}).get("version", current)
-    except Exception:
-        pass  # Offline or timeout — return current as latest
+    except Exception as exc:  # offline, timeout, DNS, unreadable body
+        return failed(str(exc) or exc.__class__.__name__)
+    # Reaching PyPI is not the same as learning the version: an answer we
+    # cannot read a version out of is the same lie by another route.
+    latest = (data.get("info") or {}).get("version")
+    if not latest:
+        return failed("PyPI did not report a version")
     return response({"current": current, "latest": latest})
 
 
@@ -2139,6 +2160,13 @@ def toolbar_js() -> str:
         el.className = 't4-ok';
         el.innerHTML = 'Latest: <strong class="t4-ok">v' + latest + '</strong> &mdash; You are up to date!';
     }
+    // A check that did not happen is not a clean bill of health. The server
+    // sends latest: null when it could not reach the registry, and saying so is
+    // the whole point -- "up to date" here would be a guess dressed as a fact.
+    function couldNotCheck(el, why) {
+        el.className = 't4-err';
+        el.textContent = 'Could not check for updates' + (why ? ' (' + why + ')' : '');
+    }
     function checkVersion() {
         if (modal.style.display === 'block') { modal.style.display = 'none'; return; }
         modal.style.display = 'block';
@@ -2147,6 +2175,7 @@ def toolbar_js() -> str:
         el.textContent = 'Checking for updates...';
         fetch('/__dev/api/version-check').then(function (r) { return r.json(); }).then(function (d) {
             var latest = d.latest, current = d.current;
+            if (!latest) { couldNotCheck(el, d.error); return; }
             if (latest === current) { upToDate(el, latest); return; }
             var cP = current.split('.').map(Number), lP = latest.split('.').map(Number);
             var isNewer = false, i, c, l;

{tina4_python-3.13.134 → tina4_python-3.13.136}/tina4_python/public/swagger/index.html

@@ -71,7 +71,7 @@
 
         // Build a system
         const ui = SwaggerUIBundle({
-            url: "{SWAGGER_ROUTE}/swagger.json",
+            url: "/swagger/openapi.json",
             dom_id: '#swagger-ui',
             deepLinking: true,
             presets: [