tina4-python 3.13.1__tar.gz → 3.13.3__tar.gz

{tina4_python-3.13.1 → tina4_python-3.13.3}/PKG-INFO

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

{tina4_python-3.13.1 → tina4_python-3.13.3}/pyproject.toml

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

{tina4_python-3.13.1 → tina4_python-3.13.3}/tina4_python/__init__.py

@@ -8,7 +8,7 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.13.1"
+__version__ = "3.13.3"
 
 # ── Route decorators ──
 from tina4_python.core.router import (  # noqa: E402, F401
@@ -42,6 +42,9 @@ from tina4_python.orm import (  # noqa: E402, F401
     has_many, has_one, belongs_to,  # relationship descriptors
 )
 
+# ── Env (typed env-var helpers) ──
+from tina4_python.env import Env  # noqa: E402, F401
+
 # ── Auth ──
 from tina4_python.auth import Auth  # noqa: E402, F401
 

{tina4_python-3.13.1 → tina4_python-3.13.3}/tina4_python/database/connection.py

@@ -725,8 +725,9 @@ class Database:
     def from_env(env_key: str = "TINA4_DATABASE_URL", pool: int = 0) -> "Database | None":
         """Construct a Database instance from environment variables.
 
-        Reads the connection URL from the named env var (default DATABASE_URL),
-        and DATABASE_USERNAME / DATABASE_PASSWORD for credentials.
+        Reads the connection URL from the named env var (default
+        TINA4_DATABASE_URL), and TINA4_DATABASE_USERNAME /
+        TINA4_DATABASE_PASSWORD for credentials.
 
         Args:
             env_key: Environment variable name holding the connection URL.

{tina4_python-3.13.1 → tina4_python-3.13.3}/tina4_python/debug/__init__.py

@@ -320,10 +320,57 @@ class Log:
         now = datetime.now(timezone.utc)
         return now.strftime("%Y-%m-%dT%H:%M:%S.") + f"{now.microsecond // 1000:03d}Z"
 
+    # Frame names that belong to Log itself — walk past them when looking
+    # for the real caller. Kept as a class attribute so subclasses can
+    # extend if they layer extra wrappers (and so tests can introspect).
+    _OWN_FRAMES = frozenset({
+        "_caller_name", "_format_line", "_format", "_log",
+        "debug", "info", "warning", "error", "critical",
+    })
+
+    @classmethod
+    def _caller_name(cls) -> str | None:
+        """Return the function name that called Log.{debug,info,warning,error}.
+
+        Active only when ``TINA4_LOG_FUNC=true`` — the lookup uses
+        ``inspect.currentframe()`` which is ~5% overhead per log call.
+        Walks past Log's own frames (``_OWN_FRAMES``) to land on the
+        real caller, so the count is robust whether the test calls
+        ``_format_line`` directly or goes through ``Log.info`` →
+        ``_log`` → ``_format_line``. Returns ``None`` if the stack is
+        too shallow (e.g. log called from module import) or if anything
+        goes wrong — never raises. Parity feature #41 across all four
+        Tina4 frameworks.
+        """
+        import os
+        if os.environ.get("TINA4_LOG_FUNC", "").strip().lower() not in (
+            "1", "true", "on", "yes", "y", "t"
+        ):
+            return None
+        try:
+            import inspect
+            frame = inspect.currentframe()
+            # Walk past Log's own frames. Cap the walk at 16 to defend
+            # against any pathological recursion / wrapper stack.
+            for _ in range(16):
+                if frame is None:
+                    return None
+                name = frame.f_code.co_name
+                if name not in cls._OWN_FRAMES:
+                    # Filter out anonymous / module-level callers — they're noise.
+                    if name in ("<module>", "<lambda>", "<genexpr>", "<listcomp>", "<setcomp>", "<dictcomp>"):
+                        return None
+                    return name
+                frame = frame.f_back
+            return None
+        except Exception:
+            return None
+
     @classmethod
     def _format_line(cls, level: str, message: str, **kwargs) -> str:
         timestamp = cls._timestamp()
         request_id = get_request_id()
+        caller = cls._caller_name()
 
         # JSON format wins whenever the explicit env opt-in is set,
         # regardless of production flag (so dev devs can ship JSON to
@@ -336,6 +383,8 @@ class Log:
             }
             if request_id:
                 entry["request_id"] = request_id
+            if caller:
+                entry["function"] = caller
             if kwargs:
                 entry["context"] = {k: v for k, v in kwargs.items()}
             return json.dumps(entry, default=str)
@@ -345,6 +394,8 @@ class Log:
         parts = [timestamp, f"[{level_str}]"]
         if request_id:
             parts.append(f"[{request_id}]")
+        if caller:
+            parts.append(f"[{caller}]")
         parts.append(message)
         if kwargs:
             parts.append(json.dumps(kwargs, default=str))

{tina4_python-3.13.1 → tina4_python-3.13.3}/tina4_python/dev_admin/__init__.py

@@ -1743,7 +1743,7 @@ def _tina4_robot_fallback(message: str) -> str:
     elif "orm" in msg or "model" in msg:
         return "Define ORM models in src/orm/ — one class per file. Use IntegerField, StringField, etc. Call model.save(), model.load(), model.select(). Don't forget to create a migration for the table."
     elif "database" in msg or "db" in msg:
-        return "Set DATABASE_URL in .env. Supports sqlite, postgres, mysql, firebird, mssql, mongodb. Use db.fetch(), db.insert(), db.update(), db.delete()."
+        return "Set TINA4_DATABASE_URL in .env. Supports sqlite, postgres, mysql, firebird, mssql, mongodb. Use db.fetch(), db.insert(), db.update(), db.delete()."
     elif "queue" in msg:
         return "Use Queue(topic='name') with queue.produce() to enqueue, queue.consume() to process. Supports litequeue, RabbitMQ, Kafka, MongoDB backends."
     elif "template" in msg or "twig" in msg:
@@ -1848,14 +1848,18 @@ async def _api_connections_save(request, response):
                 new_lines.append(line)
                 continue
             key = stripped.split("=", 1)[0].strip()
+            # Preserve the TINA4_ prefix when rewriting — the boot guard
+            # rejects bare DATABASE_URL / DATABASE_USERNAME / DATABASE_PASSWORD
+            # since v3.12, so stripping the prefix here would break the next
+            # restart. Bug filed as tina4-python#45.
             if key == "TINA4_DATABASE_URL":
-                new_lines.append(f"DATABASE_URL={url}")
+                new_lines.append(f"TINA4_DATABASE_URL={url}")
                 keys_found["TINA4_DATABASE_URL"] = True
             elif key == "TINA4_DATABASE_USERNAME":
-                new_lines.append(f"DATABASE_USERNAME={username}")
+                new_lines.append(f"TINA4_DATABASE_USERNAME={username}")
                 keys_found["TINA4_DATABASE_USERNAME"] = True
             elif key == "TINA4_DATABASE_PASSWORD":
-                new_lines.append(f"DATABASE_PASSWORD={password}")
+                new_lines.append(f"TINA4_DATABASE_PASSWORD={password}")
                 keys_found["TINA4_DATABASE_PASSWORD"] = True
             else:
                 new_lines.append(line)

tina4_python-3.13.3/tina4_python/env.py

@@ -0,0 +1,111 @@
+# Tina4 Env — Typed environment-variable helpers.
+# Copyright 2007 - present Tina4
+# License: MIT
+"""Typed environment-variable helpers — zero-deps.
+
+Reading env vars by hand gets old fast: every boolean flag becomes a
+``os.getenv("TINA4_DEBUG", "false").lower() in ("1", "true", "on", "yes")``
+incantation. Every numeric tuning knob needs a try/except around int().
+Env centralises that. Same API across all four Tina4 frameworks
+(``Tina4\\Env`` in PHP, ``Tina4::Env`` in Ruby, ``Env`` in Node.js).
+
+    from tina4_python import Env
+
+    debug   = Env.bool("TINA4_DEBUG", default=False)
+    workers = Env.int("WORKERS", default=4)
+    rate    = Env.float("RATE_LIMIT", default=10.0)
+    region  = Env.str("AWS_REGION", default="us-east-1")
+
+Values are accepted case-insensitively after ``strip()``. Truthy:
+``1 / true / on / yes / y / t``. Falsy: ``0 / false / off / no / n / f``.
+Any other value triggers the ``default``. Unparseable ints and floats
+log a warning via ``Log`` and fall back to ``default`` — never raise.
+"""
+from __future__ import annotations
+
+import os
+
+# Lazy import so ``import tina4_python.env`` doesn't drag the whole Log
+# chain in for callers who don't want it (CLI scaffolding, etc).
+_TRUTHY = frozenset({"1", "true", "on", "yes", "y", "t"})
+_FALSY = frozenset({"0", "false", "off", "no", "n", "f", ""})
+
+
+def _log_warning(message: str) -> None:
+    """Emit a warning via Log without creating a circular import at module load."""
+    try:
+        from tina4_python.debug import Log
+        Log.warning(message)
+    except Exception:
+        # Log not yet wired (e.g. very early bootstrap) — silently skip.
+        pass
+
+
+class Env:
+    """Typed environment-variable helpers.
+
+    All methods are classmethods so callers can write ``Env.bool(...)``
+    without instantiating anything — matching the PHP/Ruby/Node ports.
+    """
+
+    @classmethod
+    def bool(cls, name: str, default: bool = False) -> bool:
+        """Read ``name`` and coerce to bool.
+
+        Truthy values (case-insensitive after strip): ``1``, ``true``,
+        ``on``, ``yes``, ``y``, ``t``. Falsy: ``0``, ``false``, ``off``,
+        ``no``, ``n``, ``f``, empty string. Anything else returns the
+        ``default`` — never raises.
+        """
+        raw = os.environ.get(name)
+        if raw is None:
+            return default
+        token = raw.strip().lower()
+        if token in _TRUTHY:
+            return True
+        if token in _FALSY:
+            return False
+        return default
+
+    @classmethod
+    def int(cls, name: str, default: int = 0) -> int:
+        """Read ``name`` and coerce to int. Returns ``default`` on parse failure."""
+        raw = os.environ.get(name)
+        if raw is None:
+            return default
+        try:
+            return int(raw.strip())
+        except (ValueError, TypeError):
+            _log_warning(
+                f"Env.int({name!r}): could not parse {raw!r} as int — "
+                f"using default {default!r}"
+            )
+            return default
+
+    @classmethod
+    def float(cls, name: str, default: float = 0.0) -> float:
+        """Read ``name`` and coerce to float. Returns ``default`` on parse failure."""
+        raw = os.environ.get(name)
+        if raw is None:
+            return default
+        try:
+            return float(raw.strip())
+        except (ValueError, TypeError):
+            _log_warning(
+                f"Env.float({name!r}): could not parse {raw!r} as float — "
+                f"using default {default!r}"
+            )
+            return default
+
+    @classmethod
+    def str(cls, name: str, default: str = "") -> str:
+        """Read ``name`` as a string. Returns ``default`` if unset.
+
+        Whitespace is preserved — this is a pass-through for the raw env
+        value. ``Env.str("PATH")`` is exactly ``os.environ.get("PATH", "")``
+        with a more discoverable name.
+        """
+        raw = os.environ.get(name)
+        if raw is None:
+            return default
+        return raw

{tina4_python-3.13.1 → tina4_python-3.13.3}/tina4_python/orm/model.py

@@ -278,7 +278,7 @@ class ORM(metaclass=ORMMeta):
             return cls._db  # Direct Database instance
 
         if _database is None:
-            # Try auto-discovery from DATABASE_URL
+            # Try auto-discovery from TINA4_DATABASE_URL
             import os
             url = os.environ.get("TINA4_DATABASE_URL")
             if url:
@@ -289,7 +289,7 @@ class ORM(metaclass=ORMMeta):
                 orm_bind(db)
                 return db
             raise RuntimeError(
-                "No database bound. Call orm_bind(db) or set DATABASE_URL in .env"
+                "No database bound. Call orm_bind(db) or set TINA4_DATABASE_URL in .env"
             )
         return _database
 

{tina4_python-3.13.1 → tina4_python-3.13.3}/tina4_python/scss/__init__.py

@@ -249,41 +249,79 @@ def _resolve_extends(scss: str, placeholders: dict) -> str:
 
 
 def _eval_math(scss: str) -> str:
-    """Evaluate simple math in property values (e.g., 10px + 5px)."""
+    """Evaluate simple math in property values (e.g., 10px + 5px).
+
+    Mixed-unit arithmetic is left verbatim — that is exactly what CSS calc()
+    is for, and folding it silently produces invalid output (see #42). Math
+    inside calc(...) is preserved untouched on the same principle: the author
+    asked the browser to compute it.
+
+    Rules for folding:
+      * Both operands unitless                  → fold
+      * Same unit on both operands              → fold, keep unit
+      * One operand unitless for * or /         → fold, keep the other unit
+      * Anything else (mixed units on +/-, etc) → leave verbatim
+    """
+    # Step 1 — mask calc(...) ranges so the math regex cannot eat into them.
+    # CSS calc() is the contract for mixed-unit arithmetic; the browser does it.
+    placeholders: list[str] = []
+
+    def _mask(m):
+        placeholders.append(m.group(0))
+        return f"\x00CALC{len(placeholders) - 1}\x00"
+
+    masked = re.sub(r'calc\([^()]*\)', _mask, scss)
+
+    # Step 2 — run the math fold on what remains.
     def _calc(m):
         full = m.group(0)
         try:
-            # Extract numbers and operator
-            num1 = float(re.search(r'[\d.]+', m.group(1)).group())
-            num2 = float(re.search(r'[\d.]+', m.group(3)).group())
-            op = m.group(2).strip()
-            # Extract unit from first operand
-            unit_match = re.search(r'[a-z%]+', m.group(1))
-            unit = unit_match.group() if unit_match else ""
-
-            if op == "+":
-                result = num1 + num2
-            elif op == "-":
-                result = num1 - num2
-            elif op == "*":
-                result = num1 * num2
-            elif op == "/":
-                result = num1 / num2 if num2 != 0 else 0
-            else:
-                return full
-
-            # Format result
-            if result == int(result):
-                return f"{int(result)}{unit}"
-            return f"{result:.2f}{unit}"
+            num1 = float(m.group(1))
+            unit1 = m.group(2) or ""
+            op = m.group(3)
+            num2 = float(m.group(4))
+            unit2 = m.group(5) or ""
         except (ValueError, AttributeError):
             return full
 
-    return re.sub(
-        r'([\d.]+[a-z%]*)\s*([+\-*/])\s*([\d.]+[a-z%]*)',
-        _calc, scss
+        # Decide result unit; bail (leave verbatim) if units are incompatible.
+        if unit1 == unit2:
+            unit = unit1
+        elif op in ("*", "/") and not unit1:
+            unit = unit2
+        elif op in ("*", "/") and not unit2:
+            unit = unit1
+        else:
+            return full
+
+        if op == "+":
+            result = num1 + num2
+        elif op == "-":
+            result = num1 - num2
+        elif op == "*":
+            result = num1 * num2
+        elif op == "/":
+            if num2 == 0:
+                return full
+            result = num1 / num2
+        else:
+            return full
+
+        if result == int(result):
+            return f"{int(result)}{unit}"
+        return f"{result:.2f}{unit}"
+
+    folded = re.sub(
+        r'([\d.]+)([a-z%]*)\s*([+\-*/])\s*([\d.]+)([a-z%]*)',
+        _calc, masked
     )
 
+    # Step 3 — restore the calc() ranges verbatim.
+    def _unmask(m):
+        return placeholders[int(m.group(1))]
+
+    return re.sub(r'\x00CALC(\d+)\x00', _unmask, folded)
+
 
 def _resolve_color_functions(scss: str, variables: dict) -> str:
     """Resolve lighten(), darken(), rgba() functions."""