tina4-python 3.13.47__tar.gz → 3.13.48__tar.gz

{tina4_python-3.13.47 → tina4_python-3.13.48}/PKG-INFO

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

{tina4_python-3.13.47 → tina4_python-3.13.48}/pyproject.toml

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

{tina4_python-3.13.47 → tina4_python-3.13.48}/tina4_python/__init__.py

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

{tina4_python-3.13.47 → tina4_python-3.13.48}/tina4_python/i18n/__init__.py

@@ -9,10 +9,27 @@ Simple key-based translations loaded from JSON files.
     _("greeting")  # "Hello" or "Bonjour" depending on locale
 """
 import os
+import re
 import json
 from pathlib import Path
 
 
+_PLACEHOLDER = re.compile(r"\{(\w+)\}")
+
+
+def _interpolate(template: str, params: dict) -> str:
+    """Substitute {name} placeholders from params.
+
+    Partial + literal-leftover: a placeholder present in params is replaced; a
+    missing or malformed placeholder ({x.y}, {n:d}, a lone brace) is left
+    untouched. Never raises -- a bad template must not crash t().
+    """
+    return _PLACEHOLDER.sub(
+        lambda m: str(params[m.group(1)]) if m.group(1) in params else m.group(0),
+        template,
+    )
+
+
 class I18n:
     """Internationalization support with JSON translation files.
 
@@ -61,12 +78,11 @@ class I18n:
         if value is None:
             value = key
 
-        # Interpolate
+        # Interpolate {placeholder} tokens. Partial substitution: each token
+        # present in kwargs is replaced; a missing or malformed placeholder is
+        # left literal. Never raises (a bad template must not crash t()).
         if kwargs:
-            try:
-                value = value.format(**kwargs)
-            except (KeyError, IndexError):
-                pass
+            value = _interpolate(value, kwargs)
 
         return value
 
@@ -86,9 +102,10 @@ class I18n:
         if locale:
             old = self._current_locale
             self.locale = locale
-            result = self.t(key, **(params or {}))
-            self.locale = old
-            return result
+            try:
+                return self.t(key, **(params or {}))
+            finally:
+                self.locale = old
         return self.t(key, **(params or {}))
 
     def load_translations(self, locale: str) -> dict:
@@ -183,28 +200,50 @@ class I18n:
 
     @staticmethod
     def _flatten(data: dict, prefix: str = "") -> dict:
-        """Flatten nested dict with leaf-key aliasing.
+        """Flatten a nested dict to dot-paths, then add leaf-key aliases.
 
-        {"nav": {"home": "Home"}} → {"nav.home": "Home", "home": "Home"}
+        {"nav": {"home": "Home"}} -> {"nav.home": "Home", "home": "Home"}
 
-        Both the full dot-path AND the leaf key are stored, so templates
-        can use either ``t("home")`` or ``t("nav.home")``.  If two
-        sections define the same leaf key, the full dot-path always works
-        and the leaf key keeps whichever value was seen first.
+        Two passes so the alias rule is correct:
+        1. Flatten to full dot-path keys only.
+        2. Add each leaf key as a shortcut ONLY if it is not already present.
+
+        So the FIRST dot-path wins on a leaf-key collision, and an explicit
+        top-level flat key is never overwritten by a derived alias. (The old
+        single-pass recursive merge was last-wins and could clobber an
+        explicit flat key -- silent data loss.)
         """
+        flat = I18n._flatten_paths(data, prefix)
+        result = dict(flat)
+        for full_key, value in flat.items():
+            leaf = full_key.rsplit(".", 1)[-1]
+            if leaf not in result:
+                result[leaf] = value
+        return result
+
+    @staticmethod
+    def _flatten_paths(data: dict, prefix: str = "") -> dict:
+        """Flatten a nested dict to dot-path keys only (no leaf aliasing)."""
         result = {}
         for key, value in data.items():
             full_key = f"{prefix}.{key}" if prefix else key
             if isinstance(value, dict):
-                result.update(I18n._flatten(value, full_key))
+                result.update(I18n._flatten_paths(value, full_key))
             else:
-                str_value = str(value)
-                result[full_key] = str_value
-                # Also store the leaf key as a shortcut (first-wins on conflict)
-                if key not in result:
-                    result[key] = str_value
+                result[full_key] = I18n._coerce_scalar(value)
         return result
 
+    @staticmethod
+    def _coerce_scalar(value) -> str:
+        """Render a non-string locale scalar JSON-natively (true/false/null)."""
+        if value is True:
+            return "true"
+        if value is False:
+            return "false"
+        if value is None:
+            return "null"
+        return str(value)
+
     @staticmethod
     def _resolve(key: str, translations: dict) -> str | None:
         return translations.get(key)

{tina4_python-3.13.47 → tina4_python-3.13.48}/tina4_python/swagger/__init__.py

@@ -39,23 +39,11 @@ v3.13.42 — configurability for external/public APIs:
 import json
 import os
 import re
-import functools
 
 
 # ── Decorators ─────────────────────────────────────────────────
 # These attach metadata to route handlers for Swagger generation.
 
-# Every swagger attr a decorator may need to carry forward when it wraps a
-# handler that another decorator already annotated.
-_SWAGGER_ATTRS = (
-    "_swagger_description", "_swagger_detail", "_swagger_params", "_swagger_query",
-    "_swagger_summary", "_swagger_tags", "_swagger_example", "_swagger_example_content_type",
-    "_swagger_example_response", "_swagger_example_responses", "_swagger_deprecated",
-    "_swagger_model", "_swagger_model_list",
-    "_swagger_security", "_swagger_request_schema", "_swagger_response_schemas",
-)
-
-
 # ── Configuration registry ─────────────────────────────────────
 # Process-wide registries for security schemes and reusable component schemas
 # declared programmatically (Swagger.add_security_scheme / Swagger.add_schema).
@@ -65,13 +53,6 @@ _REGISTERED_SCHEMES: dict[str, dict] = {}
 _REGISTERED_SCHEMAS: dict[str, dict] = {}
 
 
-def _carry(fn, wrapper):
-    """Copy any already-set swagger attrs from fn onto wrapper (idempotent)."""
-    for attr in _SWAGGER_ATTRS:
-        if hasattr(fn, attr) and not hasattr(wrapper, attr):
-            setattr(wrapper, attr, getattr(fn, attr))
-
-
 def description(text: str = "", detail: str = "", params: dict | None = None,
                 query: dict | None = None):
     """Add a description, optional detail body, and parameter docs to a route.
@@ -99,19 +80,12 @@ def description(text: str = "", detail: str = "", params: dict | None = None,
             fn._swagger_params = params
         if query:
             fn._swagger_query = query
-
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_description = text
-        if detail:
-            wrapper._swagger_detail = detail
-        if params:
-            wrapper._swagger_params = params
-        if query:
-            wrapper._swagger_query = query
-        _carry(fn, wrapper)
-        return wrapper
+        # No wrapper: annotate the handler in place and return the SAME object.
+        # @get is innermost and registers this exact object, so every stacked
+        # decorator must land its metadata here. A wrapper would be registered
+        # by nothing (the outer decorators never reach the router) and silently
+        # drop all metadata except the decorator adjacent to @get.
+        return fn
     return decorator
 
 
@@ -119,12 +93,7 @@ def summary(text: str):
     """Add a short summary to a route handler."""
     def decorator(fn):
         fn._swagger_summary = text
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_summary = text
-        _carry(fn, wrapper)
-        return wrapper
+        return fn
     return decorator
 
 
@@ -140,12 +109,7 @@ def tags(tag_list):
 
     def decorator(fn):
         fn._swagger_tags = tag_list
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_tags = tag_list
-        _carry(fn, wrapper)
-        return wrapper
+        return fn
     return decorator
 
 
@@ -160,13 +124,7 @@ def example(data: dict | list, content_type: str = "application/json"):
     def decorator(fn):
         fn._swagger_example = data
         fn._swagger_example_content_type = content_type
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_example = data
-        wrapper._swagger_example_content_type = content_type
-        _carry(fn, wrapper)
-        return wrapper
+        return fn
     return decorator
 
 
@@ -198,13 +156,7 @@ def example_response(status_or_data, data=None):
         responses[status_code] = body
         fn._swagger_example_responses = responses
         fn._swagger_example_response = body
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_example_responses = responses
-        wrapper._swagger_example_response = body
-        _carry(fn, wrapper)
-        return wrapper
+        return fn
     return decorator
 
 
@@ -212,12 +164,7 @@ def deprecated():
     """Mark a route as deprecated."""
     def decorator(fn):
         fn._swagger_deprecated = True
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_deprecated = True
-        _carry(fn, wrapper)
-        return wrapper
+        return fn
     return decorator
 
 
@@ -257,12 +204,7 @@ def security(scheme_or_reqs="bearerAuth", scopes=None):
     reqs = _normalize_security(scheme_or_reqs, scopes)
     def decorator(fn):
         fn._swagger_security = reqs
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_security = reqs
-        _carry(fn, wrapper)
-        return wrapper
+        return fn
     return decorator
 
 
@@ -274,12 +216,7 @@ def request_schema(name: str, content_type: str = "application/json"):
     """
     def decorator(fn):
         fn._swagger_request_schema = (name, content_type)
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_request_schema = (name, content_type)
-        _carry(fn, wrapper)
-        return wrapper
+        return fn
     return decorator
 
 
@@ -294,12 +231,7 @@ def response_schema(name: str, status: int = 200, is_list: bool = False):
         existing = dict(getattr(fn, "_swagger_response_schemas", {}) or {})
         existing[int(status)] = (name, bool(is_list))
         fn._swagger_response_schemas = existing
-        @functools.wraps(fn)
-        def wrapper(*args, **kwargs):
-            return fn(*args, **kwargs)
-        wrapper._swagger_response_schemas = existing
-        _carry(fn, wrapper)
-        return wrapper
+        return fn
     return decorator