tina4-python 3.9.2__tar.gz → 3.10.1__tar.gz

{tina4_python-3.9.2 → tina4_python-3.10.1}/PKG-INFO

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

{tina4_python-3.9.2 → tina4_python-3.10.1}/pyproject.toml

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

{tina4_python-3.9.2 → tina4_python-3.10.1}/tina4_python/CLAUDE.md

@@ -233,7 +233,7 @@ Tina4 provides a full toolkit. Before writing custom code, check if the framewor
 | GraphQL API | `GraphQL` from `tina4_python.graphql` |
 | SOAP/WSDL services | `WSDL` from `tina4_python.wsdl` |
 | Database migrations | `migrate`, `create_migration` from `tina4_python.migration` |
-| WebSockets | `WebSocketServer` from `tina4_python.websocket` |
+| WebSockets | `WebSocketServer` from `tina4_python.websocket`. Backplane via Redis pub/sub (`TINA4_WS_BACKPLANE`, `TINA4_WS_BACKPLANE_URL`) |
 | SCSS compilation | Drop `.scss` in `src/scss/` — auto-compiled |
 | Static file serving | Put files in `src/public/` — auto-served |
 | Translations / i18n | `I18n` from `tina4_python.i18n` |
@@ -336,7 +336,7 @@ tina4_python/               # Core framework package (v3.0.0)
 ├── migration/              # SQL-file migrations (migrate, create_migration, rollback)
 │   └── runner.py           # Migration runner
 ├── session/                # Pluggable sessions (Session, FileSessionHandler, DatabaseSessionHandler)
-├── websocket/              # RFC 6455 WebSocket server (WebSocketServer, WebSocketConnection)
+├── websocket/              # RFC 6455 WebSocket server (WebSocketServer, WebSocketConnection, backplane)
 ├── graphql/                # Zero-dep GraphQL engine (GraphQL, Schema)
 ├── wsdl/                   # SOAP 1.1 / WSDL server (WSDL, wsdl_operation)
 ├── crud/                   # Auto-CRUD REST endpoint generator (AutoCrud)
@@ -504,6 +504,7 @@ TINA4_SESSION_MONGO_USERNAME=             # optional
 TINA4_SESSION_MONGO_PASSWORD=             # optional
 TINA4_SESSION_MONGO_DB=tina4_sessions     # default database
 TINA4_SESSION_MONGO_COLLECTION=sessions   # default collection
+TINA4_SESSION_SAMESITE=Lax               # SameSite attribute for session cookies (default: Lax)
 ```
 
 ### Authentication & Security
@@ -836,6 +837,9 @@ result = User().select(filter="name = ?", params=["Alice"], limit=10)
 
 # Convert to dict
 user.to_dict()
+
+# NoSQL support: to_mongo() generates MongoDB query documents from the same fluent API
+result.to_mongo()
 ```
 
 ### Available field types
@@ -1532,6 +1536,7 @@ HOST_NAME=localhost:7145
 
 # Sessions
 TINA4_SESSION_HANDLER=SessionFileHandler  # SessionFileHandler, SessionRedisHandler, SessionValkeyHandler, SessionMongoHandler
+TINA4_SESSION_SAMESITE=Lax               # SameSite attribute for session cookies (default: Lax)
 
 # Swagger/OpenAPI
 SWAGGER_TITLE=Tina4 API           # API title (default: "Tina4 API")
@@ -1768,6 +1773,10 @@ async def dashboard(request, response):
 - **Messenger**: .env driven SMTP/IMAP
 - **ORM relationships**: `has_many`, `has_one`, `belongs_to` with eager loading (`include=`)
 - **Frond pre-compilation**: 2.8x template render improvement, `Frond.clear_cache()`
+- **QueryBuilder** with NoSQL/MongoDB support (`to_mongo()`)
+- **WebSocket backplane** (Redis pub/sub) for horizontal scaling
+- **SameSite=Lax** default on session cookies (`TINA4_SESSION_SAMESITE`)
+- **`tina4 init`** generates Dockerfile and .dockerignore
 - **Gallery**: 7 interactive examples with Try It deploy at `/__dev/`
 
 

{tina4_python-3.9.2 → tina4_python-3.10.1}/tina4_python/core/response.py

@@ -22,6 +22,54 @@ import mimetypes
 from pathlib import Path
 
 
+# ---------------------------------------------------------------------------
+# Global Frond template engine registry
+# ---------------------------------------------------------------------------
+_global_frond = None
+_framework_frond = None
+
+
+def get_frond():
+    """Return the global Frond engine, creating a default if needed."""
+    global _global_frond
+    if _global_frond is None:
+        from tina4_python.frond.engine import Frond
+        _global_frond = Frond("src/templates")
+    return _global_frond
+
+
+def get_framework_frond():
+    """Return the singleton Frond engine for built-in framework templates."""
+    global _framework_frond
+    framework_dir = Path(__file__).resolve().parent.parent / "templates"
+    if _framework_frond is None and framework_dir.is_dir():
+        from tina4_python.frond.engine import Frond
+        _framework_frond = Frond(str(framework_dir))
+    # Sync custom filters/globals from the user engine
+    if _framework_frond is not None:
+        user_engine = get_frond()
+        _framework_frond._filters.update(user_engine._filters)
+        _framework_frond._globals.update(user_engine._globals)
+    return _framework_frond
+
+
+def set_frond(engine):
+    """Register a pre-configured Frond engine for response.render().
+
+    Call this at startup after registering custom filters and globals:
+
+        from tina4_python.frond import Frond
+        from tina4_python.core.response import set_frond
+
+        engine = Frond("src/templates")
+        engine.add_filter("money", my_money_filter)
+        engine.add_global("APP_VERSION", "1.0")
+        set_frond(engine)
+    """
+    global _global_frond
+    _global_frond = engine
+
+
 class Response:
     """HTTP response builder with compression and ETag support."""
 
@@ -175,27 +223,33 @@ class Response:
         return self
 
     def render(self, template: str, data: dict = None) -> "Response":
-        """Render a Frond/Twig template with data."""
-        from tina4_python.frond.engine import Frond
-        from pathlib import Path
-
-        # Search for templates in user dir first, then framework dir
-        template_dirs = []
-        user_dir = Path("src/templates")
-        if user_dir.is_dir():
-            template_dirs.append(str(user_dir))
-        framework_dir = Path(__file__).resolve().parent.parent / "templates"
-        if framework_dir.is_dir():
-            template_dirs.append(str(framework_dir))
-
-        for tdir in template_dirs:
-            if (Path(tdir) / template).exists():
-                try:
-                    frond = Frond(tdir)
-                    html = frond.render(template, data or {})
-                    return self.html(html)
-                except Exception as e:
-                    return self.html(f"<pre>Template error: {e}</pre>", 500)
+        """Render a Frond/Twig template with data.
+
+        Uses the global Frond engine (registered via set_frond()) so that
+        custom filters and globals are available in all templates.
+        Falls back to framework templates if not found in user dir.
+        """
+        engine = get_frond()
+
+        # Try user templates first (the global engine's directory)
+        try:
+            html = engine.render(template, data or {})
+            return self.html(html)
+        except FileNotFoundError:
+            pass
+        except Exception as e:
+            return self.html(f"<pre>Template error: {e}</pre>", 500)
+
+        # Fallback: framework templates (singleton, filters/globals synced)
+        fw_engine = get_framework_frond()
+        if fw_engine is not None:
+            try:
+                html = fw_engine.render(template, data or {})
+                return self.html(html)
+            except FileNotFoundError:
+                pass
+            except Exception as e:
+                return self.html(f"<pre>Template error: {e}</pre>", 500)
 
         return self.html(f"<pre>Template not found: {template}</pre>", 404)
 

{tina4_python-3.9.2 → tina4_python-3.10.1}/tina4_python/core/router.py

@@ -180,10 +180,12 @@ class Router:
         if cls._group_prefix:
             path = cls._group_prefix + path
 
-        # Merge group middleware with route-level middleware
-        if cls._group_middleware:
-            route_mw = options.get("middleware", [])
-            options["middleware"] = list(cls._group_middleware) + list(route_mw)
+        # Merge group middleware with route-level middleware and handler-level middleware
+        handler_mw = getattr(handler, "_middleware", [])
+        route_mw = options.get("middleware", [])
+        combined_mw = list(cls._group_middleware) + list(handler_mw) + list(route_mw)
+        if combined_mw:
+            options["middleware"] = combined_mw
 
         pattern, param_names = _compile_pattern(path)
 
@@ -251,8 +253,14 @@ def _compile_pattern(path: str) -> tuple[re.Pattern, list[str]]:
     param_names = []
     regex_parts = []
 
-    for segment in path.strip("/").split("/"):
-        if segment.startswith("{") and segment.endswith("}"):
+    segments = path.strip("/").split("/")
+    for i, segment in enumerate(segments):
+        if segment == "*":
+            # Wildcard: matches the rest of the path (greedy)
+            param_names.append("wildcard")
+            regex_parts.append("(.+)")
+            break  # Nothing can follow a wildcard
+        elif segment.startswith("{") and segment.endswith("}"):
             inner = segment[1:-1]
             if ":" in inner:
                 name, type_hint = inner.split(":", 1)
@@ -277,51 +285,53 @@ def _compile_pattern(path: str) -> tuple[re.Pattern, list[str]]:
 
 # Decorator functions — the public API
 
+def _register_route(method: str, path: str, fn, **options):
+    """Common registration logic that preserves handler attributes on the returned ref."""
+    ref = Router.add(method, path, fn, **options)
+    # Propagate handler attributes to the wrapper so stacked decorators still work
+    fn._route_ref = ref
+    return fn
+
+
 def get(path: str, **options):
     """Register a GET route."""
     def decorator(fn):
-        Router.add("GET", path, fn, **options)
-        return fn
+        return _register_route("GET", path, fn, **options)
     return decorator
 
 
 def post(path: str, **options):
     """Register a POST route."""
     def decorator(fn):
-        Router.add("POST", path, fn, **options)
-        return fn
+        return _register_route("POST", path, fn, **options)
     return decorator
 
 
 def put(path: str, **options):
     """Register a PUT route."""
     def decorator(fn):
-        Router.add("PUT", path, fn, **options)
-        return fn
+        return _register_route("PUT", path, fn, **options)
     return decorator
 
 
 def patch(path: str, **options):
     """Register a PATCH route."""
     def decorator(fn):
-        Router.add("PATCH", path, fn, **options)
-        return fn
+        return _register_route("PATCH", path, fn, **options)
     return decorator
 
 
 def delete(path: str, **options):
     """Register a DELETE route."""
     def decorator(fn):
-        Router.add("DELETE", path, fn, **options)
-        return fn
+        return _register_route("DELETE", path, fn, **options)
     return decorator
 
 
 def any_method(path: str, **options):
     """Register a route for any HTTP method."""
     def decorator(fn):
-        Router.add("ANY", path, fn, **options)
-        return fn
+        return _register_route("ANY", path, fn, **options)
     return decorator
 
 # Alias — @any() is the standard name across all Tina4 frameworks
@@ -352,6 +362,10 @@ def noauth():
     """Make a write route (POST/PUT/PATCH/DELETE) public — no auth required."""
     def decorator(fn):
         fn._noauth = True
+        # If route was already registered (decorator applied after @get/@post),
+        # update the route dict directly.
+        if hasattr(fn, "_route_ref"):
+            fn._route_ref._route["auth_required"] = False
         return fn
     return decorator
 
@@ -360,6 +374,10 @@ def secured():
     """Require auth on a GET route (which is public by default)."""
     def decorator(fn):
         fn._secured = True
+        # If route was already registered (decorator applied after @get/@post),
+        # update the route dict directly.
+        if hasattr(fn, "_route_ref"):
+            fn._route_ref._route["auth_required"] = True
         return fn
     return decorator
 
@@ -370,6 +388,11 @@ def middleware(*middleware_classes):
     """Attach middleware classes to a route handler."""
     def decorator(fn):
         fn._middleware = list(middleware_classes)
+        # If route was already registered (decorator applied after @get/@post),
+        # update the route dict directly.
+        if hasattr(fn, "_route_ref"):
+            existing = fn._route_ref._route.get("middleware", [])
+            fn._route_ref._route["middleware"] = list(middleware_classes) + existing
         return fn
     return decorator
 

{tina4_python-3.9.2 → tina4_python-3.10.1}/tina4_python/core/server.py

@@ -105,7 +105,7 @@ def _render_error_page(status_code: int, path: str, request_id: str, error_messa
 
     Returns rendered HTML string, or None if no template found.
     """
-    from tina4_python.frond.engine import Frond
+    from tina4_python.core.response import get_frond, get_framework_frond
 
     template_name = f"errors/{status_code}.twig"
     data = {
@@ -115,21 +115,17 @@ def _render_error_page(status_code: int, path: str, request_id: str, error_messa
         "status_code": status_code,
     }
 
-    # 1. Try user override
-    user_dir = Path("src/templates")
-    if (user_dir / template_name).exists():
-        try:
-            engine = Frond(str(user_dir))
-            return engine.render(template_name, data)
-        except Exception:
-            pass
+    # 1. Try user override (singleton engine with custom filters/globals)
+    try:
+        return get_frond().render(template_name, data)
+    except (FileNotFoundError, Exception):
+        pass
 
-    # 2. Try framework default
-    framework_dir = Path(__file__).resolve().parent.parent / "templates"
-    if (framework_dir / template_name).exists():
+    # 2. Try framework default (singleton, filters/globals synced)
+    fw_engine = get_framework_frond()
+    if fw_engine is not None:
         try:
-            engine = Frond(str(framework_dir))
-            return engine.render(template_name, data)
+            return fw_engine.render(template_name, data)
         except Exception:
             pass
 
@@ -848,9 +844,8 @@ async def app(scope: dict, receive, send):
             # Try serving a template file (e.g. /hello -> src/templates/hello.twig or hello.html)
             tpl_file = _resolve_template(request.path)
             if tpl_file:
-                from tina4_python.frond import Frond
-                frond = Frond()
-                html = frond.render(tpl_file, {})
+                from tina4_python.core.response import get_frond
+                html = get_frond().render(tpl_file, {})
                 response.html(html)
             elif request.path == "/":
                 response.html(_render_landing_page())

{tina4_python-3.9.2 → tina4_python-3.10.1}/tina4_python/messenger/__init__.py

@@ -203,9 +203,8 @@ class Messenger:
             **kwargs: Passed to send() (cc, bcc, attachments, etc.)
         """
         try:
-            from tina4_python.frond import Frond
-            engine = Frond()
-            body = engine.render_string(template, data or {})
+            from tina4_python.core.response import get_frond
+            body = get_frond().render_string(template, data or {})
         except ImportError:
             body = template
 

{tina4_python-3.9.2 → tina4_python-3.10.1}/tina4_python/orm/model.py

@@ -43,6 +43,22 @@ def orm_bind(db, name: str = None):
         _databases[name] = db
 
 
+def snake_to_camel(name: str) -> str:
+    """Convert snake_case to camelCase: 'first_name' -> 'firstName'."""
+    parts = name.split("_")
+    return parts[0] + "".join(p.capitalize() for p in parts[1:])
+
+
+def camel_to_snake(name: str) -> str:
+    """Convert camelCase to snake_case: 'firstName' -> 'first_name'."""
+    result = []
+    for c in name:
+        if c.isupper() and result:
+            result.append("_")
+        result.append(c.lower())
+    return "".join(result)
+
+
 class ORMMeta(type):
     """Metaclass that collects Field definitions and relationship descriptors."""
 
@@ -79,6 +95,7 @@ class ORM(metaclass=ORMMeta):
     table_name: str = ""
     soft_delete: bool = False  # Set True to enable soft delete
     field_mapping: dict[str, str] = {}  # {"python_attribute": "db_column"}
+    auto_map: bool = False  # No-op in Python (snake_case matches DB); exists for cross-language parity
     _db: str | object | None = None  # Per-model database override
     _fields: dict[str, Field] = {}