tina4-python 0.2.193__tar.gz → 0.2.194__tar.gz

{tina4_python-0.2.193 → tina4_python-0.2.194}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 0.2.193
+Version: 0.2.194
 Summary: Tina4Python - This is not another framework for Python
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 Requires-Python: <4.0,>=3.12

{tina4_python-0.2.193 → tina4_python-0.2.194}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "0.2.193"
+version = "0.2.194"
 description = "Tina4Python - This is not another framework for Python"
 authors = [
     {name = "Andre van Zuydam",email = "andrevanzuydam@gmail.com"}

{tina4_python-0.2.193 → tina4_python-0.2.194}/tina4_python/Router.py

@@ -354,6 +354,7 @@ class Router:
         tina4_python.tina4_current_request = {"url": url, "headers": headers}
 
         validated = False
+        has_form_token = False
         # we can add other methods later but right now we validate gets, posts and other risky methods
         if method in [Constant.TINA4_GET, Constant.TINA4_POST, Constant.TINA4_PUT, Constant.TINA4_PATCH,
                       Constant.TINA4_DELETE]:
@@ -377,11 +378,13 @@ class Router:
                 token = request["params"]["formToken"]
                 if tina4_python.tina4_auth.valid(token):
                     validated = True
+                    has_form_token = True
 
             if request["body"] is not None and "formToken" in request["body"]:
                 token = request["body"]["formToken"]
                 if tina4_python.tina4_auth.valid(token):
                     validated = True
+                    has_form_token = True
 
             if request["body"] is not None and "formToken" in request["body"]:
                 request["params"]["formToken"] = request["body"]["formToken"]
@@ -521,7 +524,8 @@ class Router:
                                 return Response(result.content, result.http_code, result.content_type)
 
                     if result is not None:
-                        result.headers["FreshToken"] = tina4_python.tina4_auth.get_token({"path": url})
+                        if has_form_token:
+                            result.headers["FreshToken"] = tina4_python.tina4_auth.get_token({"path": url})
                         if "cache" in route and route["cache"] is not None:
                             if not route["cache"]["cached"]:
                                 result.headers["Cache-Control"] = "max-age=1, must-revalidate"
@@ -542,7 +546,9 @@ class Router:
         if result is None and route_matched:
             output = buffer.getvalue()
             if output:
-                fresh_headers = {"FreshToken": tina4_python.tina4_auth.get_token({"path": url})}
+                fresh_headers = {}
+                if has_form_token:
+                    fresh_headers["FreshToken"] = tina4_python.tina4_auth.get_token({"path": url})
                 try:
                     return Response(json.loads(output), Constant.HTTP_OK, Constant.APPLICATION_JSON, fresh_headers)
                 except Exception:
@@ -566,10 +572,11 @@ class Router:
                                 )
 
                     twig_headers = {
-                        "FreshToken": tina4_python.tina4_auth.get_token({"path": url}),
                         "Cache-Control": "max-age=-1, public",
                         "Pragma": "no-cache"
                     }
+                    if has_form_token:
+                        twig_headers["FreshToken"] = tina4_python.tina4_auth.get_token({"path": url})
                     content = Template.render_twig_template(twig_file, {"request": tina4_python.tina4_current_request})
                     if content != "":
                         return Response(content, Constant.HTTP_OK, Constant.TEXT_HTML, twig_headers)
@@ -579,7 +586,7 @@ class Router:
                 "errors/404.twig", {"server": {"url": url}})
             return Response(content, Constant.HTTP_NOT_FOUND, Constant.TEXT_HTML)
 
-        result.headers["FreshToken"] = tina4_python.tina4_auth.get_token({"path": url})
+        # FreshToken already set on line 524 inside the route loop
         return result
 
     @staticmethod

{tina4_python-0.2.193 → tina4_python-0.2.194}/tina4_python/Session.py

@@ -30,7 +30,7 @@ Typical usage inside a route handler::
 """
 
 __all__ = [
-    "Session", "SessionHandler", "SessionFileHandler",
+    "Session", "LazySession", "SessionHandler", "SessionFileHandler",
     "SessionRedisHandler", "SessionValkeyHandler",
     "SessionMongoHandler",
 ]
@@ -685,3 +685,91 @@ class Session:
         for key, value in self.session_values.items():
             if key != "expires":
                 yield key, value
+
+
+class LazySession:
+    """Proxy that defers expensive Session creation until first use.
+
+    Creating and starting a ``Session`` requires RSA key signing (~1ms
+    per call) which dominates request latency for API routes that never
+    touch the session.  ``LazySession`` wraps the session creation
+    parameters and only instantiates the real ``Session`` when a method
+    like ``set()``, ``get()``, or ``load()`` is called.
+
+    The ``activated`` property lets the response builder know whether
+    to emit a ``Set-Cookie`` header.
+    """
+
+    def __init__(self, name, path, handler, cookies):
+        self._name = name
+        self._path = path
+        self._handler = handler
+        self._cookies = cookies
+        self._real = None
+
+    @property
+    def activated(self):
+        """True if the real Session has been created."""
+        return self._real is not None
+
+    def _activate(self):
+        """Create and start/load the real Session on first access."""
+        if self._real is None:
+            self._real = Session(self._name, self._path, self._handler)
+            if self._name in self._cookies:
+                self._real.load(self._cookies[self._name])
+            else:
+                self._cookies[self._name] = self._real.start()
+        return self._real
+
+    # --- Forwarded Session API ---
+
+    @property
+    def session_name(self):
+        return self._name
+
+    @property
+    def session_values(self):
+        if self._real is None:
+            return {}
+        return self._real.session_values
+
+    @property
+    def session_hash(self):
+        if self._real is None:
+            return ""
+        return self._real.session_hash
+
+    @session_hash.setter
+    def session_hash(self, value):
+        self._activate().session_hash = value
+
+    def start(self, session_hash=None):
+        return self._activate().start(session_hash)
+
+    def load(self, session_hash):
+        return self._activate().load(session_hash)
+
+    def set(self, key, value):
+        return self._activate().set(key, value)
+
+    def get(self, key):
+        return self._activate().get(key)
+
+    def unset(self, key):
+        return self._activate().unset(key)
+
+    def close(self):
+        if self._real is not None:
+            return self._real.close()
+        return True
+
+    def save(self):
+        if self._real is not None:
+            return self._real.save()
+        return True
+
+    def __iter__(self):
+        if self._real is not None:
+            return iter(self._real)
+        return iter([])

{tina4_python-0.2.193 → tina4_python-0.2.194}/tina4_python/Webserver.py

@@ -434,9 +434,10 @@ class Webserver:
             self.send_header("Content-Type", response.content_type or "text/html", headers)
             await self.send_basic_headers(headers)
 
-            # Preserve session cookie
+            # Preserve session cookie (only if session was used)
             session_name = os.getenv("TINA4_SESSION", "PY_SESS")
-            if session_name in self.cookies:
+            session_activated = not hasattr(self.session, 'activated') or self.session.activated
+            if session_activated and session_name in self.cookies:
                 self.send_header("Set-Cookie", f"{session_name}={self.cookies[session_name]}", headers)
 
         # Custom headers from route
@@ -585,14 +586,11 @@ class Webserver:
                         name, val = part.strip().split("=", 1)
                         self.cookies[name] = val
 
+            from tina4_python.Session import LazySession
             session_name = os.getenv("TINA4_SESSION", "PY_SESS")
             session_folder = os.getenv("TINA4_SESSION_FOLDER", os.path.join(tina4_python.root_path, "sessions"))
-            self.session = Session(session_name, session_folder)
-
-            if session_name in self.cookies:
-                self.session.load(self.cookies[session_name])
-            else:
-                self.cookies[session_name] = self.session.start()
+            session_handler = os.getenv("TINA4_SESSION_HANDLER", "SessionFileHandler")
+            self.session = LazySession(session_name, session_folder, session_handler, self.cookies)
 
             # ------------------------------------------------------------------
             # Route or WebSocket

{tina4_python-0.2.193 → tina4_python-0.2.194}/tina4_python/__init__.py

@@ -21,8 +21,6 @@ Just `pip install tina4-python` and run your project – everything just works.
 """
 import asyncio
 import os
-if os.getenv("TINA4_DEBUG_LEVEL", "") == "":
-    os.environ["TINA4_DEBUG_LEVEL"] = "DEBUG"
 
 import shutil
 import importlib
@@ -46,7 +44,7 @@ from tina4_python.Auth import Auth
 from tina4_python.Debug import Debug
 from tina4_python.Debug import setup_logging
 from tina4_python.ShellColors import ShellColors
-from tina4_python.Session import Session
+from tina4_python.Session import Session, LazySession
 from tina4_python.HtmlElement import add_html_helpers
 from tina4_python import ShellColors
 from tina4_python.Constant import TINA4_LOG_INFO, TINA4_LOG_ALL, TINA4_LOG_DEBUG
@@ -428,15 +426,13 @@ async def app(scope, receive, send):
 
             webserver.cookies = cookie_list
 
-            webserver.session = Session(os.getenv("TINA4_SESSION", "PY_SESS"),
-                                        os.getenv("TINA4_SESSION_FOLDER", root_path + os.sep + "sessions"),
-                                        os.getenv("TINA4_SESSION_HANDLER", "SessionFileHandler")
-                                        )
-
-            if os.getenv("TINA4_SESSION", "PY_SESS") in webserver.cookies:
-                webserver.session.load(webserver.cookies[os.getenv("TINA4_SESSION", "PY_SESS")])
-            else:
-                webserver.cookies[os.getenv("TINA4_SESSION", "PY_SESS")] = webserver.session.start()
+            session_name = os.getenv("TINA4_SESSION", "PY_SESS")
+            webserver.session = LazySession(
+                session_name,
+                os.getenv("TINA4_SESSION_FOLDER", root_path + os.sep + "sessions"),
+                os.getenv("TINA4_SESSION_HANDLER", "SessionFileHandler"),
+                webserver.cookies,
+            )
 
             tina4_response, tina4_headers = await webserver.get_response(webserver.method, scope=scope, reader=receive, writer=send,  asgi_response=True)