tina4-python 3.13.102__tar.gz → 3.13.104__tar.gz

{tina4_python-3.13.102 → tina4_python-3.13.104}/PKG-INFO

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

{tina4_python-3.13.102 → tina4_python-3.13.104}/pyproject.toml

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

{tina4_python-3.13.102 → tina4_python-3.13.104}/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.101"
+    return "3.13.104"
 
 
 __version__ = _resolve_version()
@@ -108,6 +108,9 @@ _LAZY: dict[str, tuple[str, str]] = {
     "NumericField": ("tina4_python.orm", "NumericField"),
     "DecimalField": ("tina4_python.orm", "DecimalField"),
     "JSONField": ("tina4_python.orm", "JSONField"),
+    "PointField": ("tina4_python.orm", "PointField"),
+    "Point": ("tina4_python.orm", "Point"),
+    "feature_collection": ("tina4_python.orm", "feature_collection"),
     "ForeignKeyField": ("tina4_python.orm", "ForeignKeyField"),
     "IntField": ("tina4_python.orm", "IntField"),
     "StrField": ("tina4_python.orm", "StrField"),
@@ -141,6 +144,10 @@ _LAZY: dict[str, tuple[str, str]] = {
     "AiHTTPError": ("tina4_python.ai", "AiHTTPError"),
     "AiTimeoutError": ("tina4_python.ai", "AiTimeoutError"),
     "AiParseError": ("tina4_python.ai", "AiParseError"),
+    # Provider-neutral OpenID Connect SSO (ADR-0056)
+    "Sso": ("tina4_python.sso", "Sso"),
+    "SSO": ("tina4_python.sso", "SSO"),
+    "SsoError": ("tina4_python.sso", "SsoError"),
     # SOAP / WSDL
     "WSDL": ("tina4_python.wsdl", "WSDL"),
     "wsdl_operation": ("tina4_python.wsdl", "wsdl_operation"),

{tina4_python-3.13.102 → tina4_python-3.13.104}/tina4_python/core/server.py

@@ -1691,8 +1691,16 @@ def _check_auth(request: Request, response: Response, route: dict) -> bool:
     if not _auth_ok:
         _session = getattr(request, "session", None)
         if _session:
+            # A provider-verified OIDC identity is handed into the SAME auth
+            # gate as JWT. Provider credentials stay in the reserved Session
+            # value and never enter request.user.
+            _sso = _session.get("_tina4_sso")
+            _sso_identity = _sso.get("identity") if isinstance(_sso, dict) else None
+            if isinstance(_sso_identity, dict) and _sso_identity.get("issuer") and _sso_identity.get("subject"):
+                _auth_ok = True
+                request.user = _sso_identity
             _session_token = _session.get("token") if _session else ""
-            if _session_token:
+            if not _auth_ok and _session_token:
                 try:
                     from tina4_python.auth import Auth
                     _payload = Auth.valid_token_static(_session_token)
@@ -3669,6 +3677,10 @@ def run(host: str | None = None, port: int | None = None, no_browser: bool = Fal
 
     # Auto-discover routes
     _auto_discover("src")
+    # Configuration-first OIDC: canonical routes appear only when configured,
+    # after app discovery so collisions fail loudly rather than overwrite.
+    from tina4_python.sso import Sso as _Sso
+    _Sso.mount_configured()
     route_count = len(Router.get_routes())
     Log.info(f"Discovered {route_count} routes")
 

{tina4_python-3.13.102 → tina4_python-3.13.104}/tina4_python/database/__init__.py

@@ -11,7 +11,11 @@ SQL-first database layer. One interface, many drivers.
     row = db.fetch_one("SELECT * FROM users WHERE id = ?", [42])
     db.execute("INSERT INTO users (name) VALUES (?)", ["Alice"])
 """
-from tina4_python.database.adapter import DatabaseAdapter, DatabaseResult, SQLTranslator
+from tina4_python.database.adapter import DatabaseAdapter, DatabaseResult
+from tina4_python.database.sql_translator import SQLTranslator, SpatialNotSupportedError
 from tina4_python.database.connection import Database
 
-__all__ = ["Database", "DatabaseAdapter", "DatabaseResult", "SQLTranslator"]
+__all__ = [
+    "Database", "DatabaseAdapter", "DatabaseResult", "SQLTranslator",
+    "SpatialNotSupportedError",
+]

{tina4_python-3.13.102 → tina4_python-3.13.104}/tina4_python/database/adapter.py

@@ -1131,9 +1131,10 @@ class SqlCrudMixin:
 # ── SQL Translation Rules ──────────────────────────────────────
 # Reusable translation functions for common cross-engine quirks.
 
-
 # SQLTranslator moved to sql_translator.py (feature 3: the adapter module is the
 # adapter contract and nothing else). Re-exported here because the sqlite,
 # firebird, mssql and odbc adapters import it from this module, and a file move
 # is not the place to churn their imports.
-from tina4_python.database.sql_translator import SQLTranslator  # noqa: E402,F401
+from tina4_python.database.sql_translator import (  # noqa: E402,F401
+    SQLTranslator, SpatialNotSupportedError,
+)

{tina4_python-3.13.102 → tina4_python-3.13.104}/tina4_python/database/sql_translator.py

@@ -16,6 +16,10 @@ by engine; moving it here would flatten that override.
 import re
 
 
+class SpatialNotSupportedError(NotImplementedError):
+    """The selected database engine cannot honor the GIS contract."""
+
+
 class SQLTranslator:
     """Cross-engine SQL translator.
 
@@ -23,6 +27,124 @@ class SQLTranslator:
     and stateless — just string transforms.
     """
 
+    SPATIAL_ENGINES = ("postgres", "postgresql")
+    _IDENTIFIER = re.compile(r"^[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*$")
+
+    @classmethod
+    def supports_spatial(cls, engine: str) -> bool:
+        """Return whether Tina4 has a spatial provider for ``engine``."""
+        name = (engine or "").lower()
+        name = cls.ENGINE_ALIASES.get(name, name)
+        return name in cls.SPATIAL_ENGINES
+
+    @classmethod
+    def require_spatial(cls, engine: str, feature: str) -> str:
+        """Return the normalized spatial engine or fail with an actionable error."""
+        name = (engine or "unknown").lower()
+        name = cls.ENGINE_ALIASES.get(name, name)
+        if cls.supports_spatial(name):
+            return name
+        raise SpatialNotSupportedError(
+            f"{feature} is not supported on the '{name}' database engine. "
+            "Tina4 GIS support is PostGIS-first: use PostgreSQL with the "
+            "PostGIS extension (CREATE EXTENSION postgis). Tina4 will not "
+            "replace a spatial query with an approximate latitude/longitude query. "
+            "If the application needs storage only and no GIS behavior, declare "
+            "separate longitude and latitude FloatField columns instead."
+        )
+
+    @classmethod
+    def identifier(cls, name: str, what: str = "column") -> str:
+        """Validate an identifier before placing it in spatial SQL."""
+        if not isinstance(name, str) or not cls._IDENTIFIER.fullmatch(name):
+            raise ValueError(
+                f"Spatial {what} name {name!r} is not a valid SQL identifier"
+            )
+        return name
+
+    @staticmethod
+    def _srid(srid) -> int:
+        """Coerce the interpolated SRID to an integer."""
+        if isinstance(srid, bool):
+            raise ValueError(f"Spatial SRID must be an integer, got {srid!r}")
+        try:
+            value = int(srid)
+        except (TypeError, ValueError) as error:
+            raise ValueError(f"Spatial SRID must be an integer, got {srid!r}") from error
+        if value <= 0:
+            raise ValueError(f"Spatial SRID must be positive, got {value}")
+        return value
+
+    @classmethod
+    def point_column_type(cls, engine: str, srid: int = 4326) -> str:
+        """Return PostGIS geography Point DDL."""
+        cls.require_spatial(engine, "PointField")
+        return f"geography(Point,{cls._srid(srid)})"
+
+    @classmethod
+    def spatial_index(cls, engine: str, table: str, column: str) -> str:
+        """Return idempotent PostGIS GiST-index DDL."""
+        cls.require_spatial(engine, "spatial index creation")
+        table = cls.identifier(table, "table")
+        column = cls.identifier(column)
+        index = f"{table.replace('.', '_')}_{column}_gist"
+        return f"CREATE INDEX IF NOT EXISTS {index} ON {table} USING GIST ({column})"
+
+    @classmethod
+    def point_literal(cls, engine: str, srid: int = 4326) -> str:
+        """Return a bound PostGIS point expression in longitude/latitude order."""
+        cls.require_spatial(engine, "spatial predicates")
+        return f"ST_SetSRID(ST_MakePoint(?, ?), {cls._srid(srid)})::geography"
+
+    @classmethod
+    def within_distance(cls, engine: str, column: str, srid: int = 4326) -> str:
+        """Return a bound radius predicate whose distance uses metres."""
+        cls.require_spatial(engine, "within_distance()")
+        column = cls.identifier(column)
+        return f"ST_DWithin({column}, {cls.point_literal(engine, srid)}, ?)"
+
+    @classmethod
+    def distance(cls, engine: str, column: str, srid: int = 4326) -> str:
+        """Return a bound spheroid-distance expression in metres."""
+        cls.require_spatial(engine, "order_by_distance()")
+        column = cls.identifier(column)
+        return f"ST_Distance({column}, {cls.point_literal(engine, srid)})"
+
+    @classmethod
+    def distance_as(cls, engine: str, column: str, alias: str, srid: int = 4326) -> str:
+        """Return an aliased bound distance expression for a SELECT list."""
+        alias = cls.identifier(alias, "result alias")
+        return f"{cls.distance(engine, column, srid)} AS {alias}"
+
+    @classmethod
+    def geometry_literal(cls, engine: str, form: str = "ewkt", srid: int = 4326) -> str:
+        """Return a one-parameter PostGIS geometry expression."""
+        cls.require_spatial(engine, "spatial predicates")
+        if form == "ewkt":
+            return "ST_GeogFromText(?)"
+        if form == "geojson":
+            return f"ST_SetSRID(ST_GeomFromGeoJSON(?), {cls._srid(srid)})::geography"
+        raise ValueError(
+            f"Spatial geometry form {form!r} is not supported; use 'ewkt' or 'geojson'"
+        )
+
+    @classmethod
+    def intersects(cls, engine: str, column: str, form: str = "ewkt",
+                   srid: int = 4326) -> str:
+        """Return a bound PostGIS intersection predicate."""
+        column = cls.identifier(column)
+        return f"ST_Intersects({column}, {cls.geometry_literal(engine, form, srid)})"
+
+    @classmethod
+    def bbox(cls, engine: str, column: str, srid: int = 4326) -> str:
+        """Return a bound PostGIS bounding-box predicate."""
+        cls.require_spatial(engine, "bbox()")
+        column = cls.identifier(column)
+        return (
+            f"ST_Intersects({column}, "
+            f"ST_MakeEnvelope(?, ?, ?, ?, {cls._srid(srid)})::geography)"
+        )
+
     @staticmethod
     def limit_to_rows(sql: str) -> str:
         """Convert LIMIT/OFFSET to Firebird ROWS...TO syntax.

{tina4_python-3.13.102 → tina4_python-3.13.104}/tina4_python/dev_admin/metrics.py

@@ -12,7 +12,7 @@ class MetricsEngineError(RuntimeError):
 
 _TIMEOUT_SECONDS = 60
 _SUMMARY_KEYS = ("files_analyzed", "total_functions", "avg_complexity", "avg_maintainability")
-_FILE_KEYS = ("path", "loc", "avg_complexity", "maintainability", "has_tests")
+_FILE_KEYS = ("path", "loc", "avg_complexity", "maintainability", "has_referencing_test")
 _FUNCTION_KEYS = ("name", "file", "line", "complexity", "loc")
 _INSTALL_HINT = "update the native tina4 CLI: https://tina4.com/cli"
 _last_scan_root = ""