tina4-python 0.2.172__tar.gz → 0.2.173__tar.gz

{tina4_python-0.2.172 → tina4_python-0.2.173}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 0.2.172
+Version: 0.2.173
 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.172 → tina4_python-0.2.173}/pyproject.toml

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

{tina4_python-0.2.172 → tina4_python-0.2.173}/tina4_python/Auth.py

@@ -152,6 +152,9 @@ class Auth:
         """
         self.root_path = root_path
         self.secret = os.environ.get("SECRET", "{self.secret}")
+        if self.secret == "{self.secret}":
+            from tina4_python.Debug import Debug
+            Debug.warning("No SECRET env var set - using default secret. Set SECRET in your .env for production.")
         self.private_key = os.path.join(root_path, "secrets", "private.key")
         self.public_key = os.path.join(root_path, "secrets", "public.key")
         self.self_signed = os.path.join(root_path, "secrets", "domain.cert")

{tina4_python-0.2.172 → tina4_python-0.2.173}/tina4_python/Database.py

@@ -34,7 +34,7 @@ class Database:
             if _username == "":
                 _username = os.environ.get("DATABASE_USERNAME", "")
             if _password == "":
-                _password = os.environ.get("DATABASE_USERNAME", "")
+                _password = os.environ.get("DATABASE_PASSWORD", "")
 
             if _connection_string is None:
                 raise Exception("Database connection string is missing, try declaring DATABASE_PATH in the .env file.")
@@ -270,7 +270,7 @@ class Database:
         """
         if params is None:
             params = []
-        if params is list:
+        if isinstance(params, list):
             params = params.copy()
         else:
             params = list(params)
@@ -298,8 +298,8 @@ class Database:
                             cols.append(name)
 
             if cols:
-                if self.database_engine == "POSTGRES":
-                    like_op = "LIKE"
+                if self.database_engine == POSTGRES:
+                    like_op = "ILIKE"
                 else:
                     like_op = "LIKE"
 
@@ -371,7 +371,7 @@ class Database:
         finally:
             cursor.close()
 
-    def fetch_one(self, sql, params=[], skip=0):
+    def fetch_one(self, sql, params=None, skip=0):
         """
         Fetch a single record based on a SQL statement, take note that BLOB and byte record data is converted into base64 automatically
         :param str sql: A plain SQL statement or one with params in it designated by ?
@@ -379,6 +379,8 @@ class Database:
         :param int skip: Offset of records to skip
         :return: dict : A dictionary containing the single record
         """
+        if params is None:
+            params = []
         # Calling the fetch method with limit as 1 and returning the result
         record = self.fetch(sql, params=params, limit=1, skip=skip)
         if record.error is None and record.count == 1:
@@ -386,15 +388,14 @@ class Database:
             for key in record.records[0]:
                 if isinstance(record.records[0][key], Decimal):
                     data[key] = float(record.records[0][key])
-                if isinstance(record.records[0][key], (datetime.date, datetime.datetime)):
+                elif isinstance(record.records[0][key], (datetime.date, datetime.datetime)):
                     data[key] = record.records[0][key].isoformat()
-                if isinstance(record.records[0][key], bytes):
+                elif isinstance(record.records[0][key], bytes):
                     data[key] = base64.b64encode(record.records[0][key]).decode('utf-8')
+                elif isinstance(record.records[0][key], str) and self.is_json(record.records[0][key]):
+                    data[key] = json.loads(record.records[0][key])
                 else:
-                    if isinstance(record.records[0][key], str) and self.is_json(record.records[0][key]):
-                        data[key] = json.loads(record.records[0][key])
-                    else:
-                        data[key] = record.records[0][key]
+                    data[key] = record.records[0][key]
             return data
         else:
             return None
@@ -562,8 +563,8 @@ class Database:
 
             result = None
             for record in data:
-                columns = ", ".join(data[0].keys())
-                placeholders = ", ".join(['?'] * len(data[0]))
+                columns = ", ".join(record.keys())
+                placeholders = ", ".join(['?'] * len(record))
 
                 # Determine if we need to auto-generate the primary key
                 need_auto_id = (
@@ -687,11 +688,7 @@ class Database:
 
                     params = set_values + [pk_value]
 
-                    if self.database_engine == MSSQL:
-                        self.execute(f"SET IDENTITY_UPDATE {table_name} ON")
                     result = self.execute(sql, params)
-                    if self.database_engine == MSSQL:
-                        self.execute(f"SET IDENTITY_UPDATE {table_name} OFF")
                     if result.error is not None:
                         break
 

{tina4_python-0.2.172 → tina4_python-0.2.173}/tina4_python/ORM.py

@@ -4,6 +4,7 @@
 # License: MIT https://opensource.org/licenses/MIT
 #
 # flake8: noqa: E501
+import ast
 import base64
 from datetime import date
 import json
@@ -17,6 +18,7 @@ def find_all_sub_classes(a_class):
 
 
 def orm(dba):
+    import importlib
     from tina4_python import root_path
     Debug("Initializing ORM")
     orm_path = root_path + os.sep + "src" + os.sep + "orm"
@@ -32,7 +34,9 @@ def orm(dba):
             # import and set the database object
             try:
                 Debug('from src.orm.' + mod_name + ' import ' + mod_name)
-                exec('from src.orm.' + mod_name + ' import ' + mod_name + "\n" + mod_name + ".__dba__ = dba")
+                module = importlib.import_module('src.orm.' + mod_name)
+                orm_class = getattr(module, mod_name)
+                orm_class.__dba__ = dba
             except Exception as e:
                 Debug("Failed to import " + mod_name, str(e))
     classes = find_all_sub_classes(ORM)
@@ -263,7 +267,7 @@ class ORM:
         if order_by: sql += "\norder by " + ", ".join(order_by)
         return sql
 
-    def fetch_one(self, column_names="*", filter="", params=[], join="", group_by="", having="", order_by=""):
+    def fetch_one(self, column_names="*", filter="", params=None, join="", group_by="", having="", order_by=""):
         """
         Fetch one record from the database
         :param column_names:
@@ -275,10 +279,12 @@ class ORM:
         :param order_by:
         :return:
         """
+        if params is None:
+            params = []
         sql = self.__build_sql(column_names, join, filter, group_by, having, order_by)
         return self.__dba__.fetch_one(sql, params=params)
 
-    def fetch(self, column_names="*", filter="", params=[], join="", group_by="", having="", order_by="", limit=10,
+    def fetch(self, column_names="*", filter="", params=None, join="", group_by="", having="", order_by="", limit=10,
               skip=0):
         """
         Fetch multiple records from the database
@@ -293,20 +299,24 @@ class ORM:
         :param skip:
         :return:
         """
+        if params is None:
+            params = []
         sql = self.__build_sql(column_names, join, filter, group_by, having, order_by)
         return self.__dba__.fetch(sql, params=params, limit=limit, skip=skip)
 
-    def select(self, column_names="*", filter="", params=[], join="", group_by="", having="", order_by="", limit=10,
+    def select(self, column_names="*", filter="", params=None, join="", group_by="", having="", order_by="", limit=10,
                skip=0):
         return self.fetch(column_names, filter, params, join, group_by, having, order_by, limit, skip)
 
-    def load(self, query="", params=[]):
+    def load(self, query="", params=None):
         """
         Loads a single record into the object based on the primary key or query if query is set
         :param query:
         :param params:
         :return:
         """
+        if params is None:
+            params = []
         if not self.__table_exists:
             Debug("ORM: Load Error - Table", self.__table_name__, "does not exist", TINA4_LOG_ERROR)
             return False
@@ -315,11 +325,13 @@ class ORM:
             sql = f"select * from {self.__table_name__} where "
             primary_keys = self.__get_primary_keys()
             values = self.to_dict()
+            params = []
             counter = 0
             for key in primary_keys:
                 if counter > 0:
                     sql += " and "
-                sql += key + " = '" + str(values[key]) + "'"
+                sql += key + " = ?"
+                params.append(values[key])
                 counter += 1
         else:
             sql = f"select * from {self.__table_name__} where {query}"
@@ -396,7 +408,9 @@ class ORM:
 
         return result
 
-    def delete(self, query="", params=[]):
+    def delete(self, query="", params=None):
+        if params is None:
+            params = []
         if not self.__table_exists:
             Debug("ORM: Load Error - Table", self.__table_name__, "does not exist", TINA4_LOG_ERROR)
             return False
@@ -404,11 +418,13 @@ class ORM:
             sql = f"delete from {self.__table_name__} where "
             primary_keys = self.__get_primary_keys()
             values = self.to_dict()
+            params = []
             counter = 0
             for key in primary_keys:
                 if counter > 0:
                     sql += " and "
-                sql += key + " = '" + str(values[key]) + "'"
+                sql += key + " = ?"
+                params.append(values[key])
                 counter += 1
         else:
             sql = f"delete from {self.__table_name__} where {query}"

tina4_python-0.2.173/tina4_python/Request.py

@@ -0,0 +1,27 @@
+#
+# Tina4 - This is not a 4ramework.
+# Copy-right 2007 - current Tina4
+# License: MIT https://opensource.org/licenses/MIT
+#
+# flake8: noqa: E501
+
+
+class Request:
+    """Per-request object holding all request data. Instantiated fresh for each incoming request."""
+
+    def __init__(self):
+        self.request = None
+        self.body = None
+        self.params = {}
+        self.headers = {}
+        self.cookies = {}
+        self.url = None
+        self.session = None
+        self.files = {}
+        self.raw_request = None
+        self.raw_data = None
+        self.raw_content = None
+        self.asgi_scope = None
+        self.asgi_reader = None
+        self.asgi_writer = None
+        self.asgi_response = None

{tina4_python-0.2.172 → tina4_python-0.2.173}/tina4_python/Response.py

@@ -7,6 +7,7 @@
 import os
 import json
 import inspect
+import contextvars
 from datetime import datetime, date
 from types import ModuleType
 from tina4_python import Constant
@@ -14,10 +15,9 @@ from tina4_python import DatabaseResult
 from tina4_python.ORM import ORM
 from tina4_python.Template import Template
 
-headers = {}
-content = ""
-http_code = Constant.HTTP_OK
-content_type = Constant.TEXT_HTML
+# Per-coroutine header accumulation for add_header() calls before Response creation
+_pending_headers = contextvars.ContextVar('_pending_headers', default=None)
+
 
 class Response:
 
@@ -32,12 +32,14 @@ class Response:
         else:
             return obj
 
+    @staticmethod
+    def reset_context():
+        """Reset per-request response state. Called by Router before each request."""
+        _pending_headers.set({})
+
     def __init__(self, content_in=None, http_code_in=None, content_type_in=None,
                  headers_in=None):
-        global headers
-        global content
-        global http_code
-        global content_type
+        content_type = content_type_in if content_type_in is not None else Constant.TEXT_HTML
 
         if http_code_in is None:
             http_code_in = Constant.HTTP_OK
@@ -72,17 +74,19 @@ class Response:
             content_in = json.dumps({"error": "Cannot decode object of type " + str(type(content_in))})
             content_type = Constant.APPLICATION_JSON
 
-        if content is not None and isinstance(content_in, str) and http_code_in == Constant.HTTP_OK:
-            content_in = content + content_in
+        # Merge any headers added via add_header() before this Response was created
+        pending = _pending_headers.get()
+        if headers_in is not None:
+            merged_headers = dict(headers_in)
+        elif pending:
+            merged_headers = dict(pending)
+        else:
+            merged_headers = {}
 
-        self.headers = headers_in if headers_in is not None else headers
-        self.content = content_in if content_in is not None else content
-        self.http_code = http_code_in if http_code_in is not None else http_code
-        self.content_type = content_type_in if content_type_in is not None else content_type
-        headers = self.headers
-        http_code = self.http_code
-        content_type = self.content_type
-        content = self.content
+        self.headers = merged_headers
+        self.content = content_in if content_in is not None else ""
+        self.http_code = http_code_in
+        self.content_type = content_type
 
     @staticmethod
     def redirect(redirect_url, http_code_in=Constant.HTTP_REDIRECT):
@@ -92,25 +96,12 @@ class Response:
         :param redirect_url:
         :return:
         """
-        global headers
-        global content
-        global http_code
-        global content_type
-        headers = {}
-        http_code = http_code_in
-        headers["Location"] = redirect_url
-        content = "Redirecting..."
-        content_type = Constant.TEXT_HTML
-        return Response("Redirecting...", http_code, content_type, headers)
-
+        headers = {"Location": redirect_url}
+        return Response("Redirecting...", http_code_in, Constant.TEXT_HTML, headers)
 
     @staticmethod
     def render(template_name, data=None):
-        global content, content_type, http_code
-        http_code = Constant.HTTP_OK
-        content_type = Constant.TEXT_HTML
-
-        return Response(Template.render(template_name, data=data), http_code, content_type)
+        return Response(Template.render(template_name, data=data), Constant.HTTP_OK, Constant.TEXT_HTML)
 
     @staticmethod
     def file(file_path: str, root_path: str = "src/public"):
@@ -124,24 +115,16 @@ class Response:
         Returns:
             Response: A properly configured Response object with file content and correct MIME type
         """
-        global content, content_type, http_code
-
         # Resolve full path and prevent directory traversal
         full_path = os.path.abspath(os.path.join(root_path, file_path.lstrip("/")))
 
         # Security: ensure the requested file is inside the root_path
         if not full_path.startswith(os.path.abspath(root_path)):
-            http_code = Constant.HTTP_FORBIDDEN
-            content_type = Constant.TEXT_PLAIN
-            content = "403 - Forbidden"
-            return Response(content, http_code, content_type)
+            return Response("403 - Forbidden", Constant.HTTP_FORBIDDEN, Constant.TEXT_PLAIN)
 
         # Check if file exists
         if not os.path.isfile(full_path):
-            http_code = Constant.HTTP_NOT_FOUND
-            content_type = Constant.TEXT_PLAIN
-            content = "404 - File Not Found"
-            return Response(content, http_code, content_type)
+            return Response("404 - File Not Found", Constant.HTTP_NOT_FOUND, Constant.TEXT_PLAIN)
 
         # Determine MIME type
         extension = os.path.splitext(file_path)[1].lower()
@@ -173,24 +156,23 @@ class Response:
                 with open(full_path, "rb") as f:
                     content = f.read()
         except Exception as e:
-            http_code = Constant.HTTP_BAD_REQUEST
-            content_type = Constant.TEXT_PLAIN
-            content = f"Error reading file: {str(e)}"
-            return Response(content, http_code, content_type)
+            return Response(f"Error reading file: {str(e)}", Constant.HTTP_BAD_REQUEST, Constant.TEXT_PLAIN)
 
-        http_code = Constant.HTTP_OK
-        return Response(content, http_code, content_type)
+        return Response(content, Constant.HTTP_OK, content_type)
 
     @staticmethod
     def add_header(key, value):
         """
-        Adds a header for the response
+        Adds a header for the response (concurrency-safe via contextvars)
         :param key:
         :param value:
         :return:
         """
-        global headers
-        headers[key] = value
+        h = _pending_headers.get()
+        if h is None:
+            h = {}
+            _pending_headers.set(h)
+        h[key] = value
 
     @staticmethod
     def wsdl(wsdl_instance):

{tina4_python-0.2.172 → tina4_python-0.2.173}/tina4_python/Router.py

@@ -38,7 +38,14 @@ class Router:
 
     @staticmethod
     def clean_url(url):
-        """Normalize URL: strip query, domain, collapse slashes, trim whitespace"""
+        """Collapse double slashes in a URL path."""
+        if not url:
+            return "/"
+        return re.sub(r'/+', '/', url)
+
+    @staticmethod
+    def _normalize_url(url):
+        """Full URL normalization: strip query, domain, collapse slashes, add trailing slash."""
         if not url:
             return "/"
         url = url.split('?')[0]
@@ -54,7 +61,7 @@ class Router:
     def get_variables(url, route_path):
         """Legacy helper - extracts variables with type conversion"""
         variables = {}
-        url_path = Router.clean_url(url).rstrip('/')
+        url_path = Router._normalize_url(url).rstrip('/')
         url_segments = [s for s in url_path.strip('/').split('/') if s]
         route_segments = [s for s in route_path.strip('/').split('/') if s]
 
@@ -188,18 +195,17 @@ class Router:
     # Renders the URL and returns the content
     @staticmethod
     async def get_result(url, method, request, headers, session):
-        from tina4_python import Request
-        from tina4_python import Response
+        from tina4_python.Request import Request
+        from tina4_python.Response import Response
+
+        # Reset per-request response context (clears pending headers from add_header)
+        Response.reset_context()
 
-        Response.headers = {}
-        Response.content = ""
-        Response.http_code = Constant.HTTP_NOT_FOUND
-        Response.content_type = Constant.TEXT_HTML
-        result = Response
+        result = None
+        route_matched = False
 
         Debug.debug("Root Path " + tina4_python.root_path + " " + url, method)
-        tina4_python.tina4_current_request["url"] = url
-        tina4_python.tina4_current_request["headers"] = headers
+        tina4_python.tina4_current_request = {"url": url, "headers": headers}
 
         validated = False
         # we can add other methods later but right now we validate gets, posts and other risky methods
@@ -245,9 +251,8 @@ class Router:
         if os.path.isfile(static_file):
             mime_type = mimetypes.guess_type(url)[0]
             with open(static_file, 'rb') as file:
-                return Response.Response(file.read(), Constant.HTTP_OK, mime_type)
+                return Response(file.read(), Constant.HTTP_OK, mime_type)
 
-        old_stdout = None
         buffer = io.StringIO()
         for route in tina4_python.tina4_routes.values():
             if "methods" not in route or method not in route["methods"]:
@@ -255,33 +260,37 @@ class Router:
 
             Debug.debug(method, "Matching route ", route['routes'], " to ", url)
             if Router.match(url, route['routes']):
+                route_matched = True
+                # Snapshot variables immediately to prevent race between concurrent requests
+                matched_vars = dict(Router.variables)
 
-                if "noauth" not in route or "noauth" in route and not route["noauth"] and not validated:
+                if not route.get("noauth", False):
                     if not validated and Router.requires_auth(route, method, validated):
-                        return Response.Response("Forbidden - Access denied", Constant.HTTP_FORBIDDEN,
+                        return Response("Forbidden - Access denied", Constant.HTTP_FORBIDDEN,
                                                  Constant.TEXT_HTML)
 
                 router_response = route["callback"]
 
-                # Add the inline variables & construct a Request variable
-                request["params"].update(Router.variables)
-
-                Request.request = request  # Add the request object
-                Request.headers = headers  # Add the headers
-                Request.params = request["params"]
-                Request.body = request["body"] if "body" in request else None
-                Request.files = request["files"] if "files" in request else None
-                Request.session = session
-                Request.raw_data = request["raw_data"] if "raw_data" in request else None
-                Request.raw_request = request["raw_request"] if "raw_request" in request else None
-                Request.raw_content = request["raw_content"] if "raw_content" in request else None
-                Request.url = url
-                Request.asgi_scope = request["asgi_scope"] if "asgi_scope" in request else None
-                Request.asgi_reader = request["asgi_reader"] if "asgi_reader" in request else None
-                Request.asgi_writer = request["asgi_writer"] if "asgi_writer" in request else None
-                Request.asgi_response = request["asgi_response"] if "asgi_response" in request else None
-
-                tina4_python.tina4_current_request = Request
+                # Add the inline variables & construct a per-request Request object
+                request["params"].update(matched_vars)
+
+                req = Request()
+                req.request = request
+                req.headers = headers
+                req.params = request["params"]
+                req.body = request.get("body")
+                req.files = request.get("files")
+                req.session = session
+                req.raw_data = request.get("raw_data")
+                req.raw_request = request.get("raw_request")
+                req.raw_content = request.get("raw_content")
+                req.url = url
+                req.asgi_scope = request.get("asgi_scope")
+                req.asgi_reader = request.get("asgi_reader")
+                req.asgi_writer = request.get("asgi_writer")
+                req.asgi_response = request.get("asgi_response")
+
+                tina4_python.tina4_current_request = req
 
                 old_stdout = sys.stdout  # Memorize the default stdout stream
                 sys.stdout = buffer = io.StringIO()
@@ -289,112 +298,112 @@ class Router:
                              Constant.HTTP_FORBIDDEN, Constant.HTTP_BAD_REQUEST, Constant.HTTP_UNAUTHORIZED,
                              Constant.HTTP_SERVER_ERROR)
 
-                if "middleware" in route:
-                    middleware_runner = MiddleWare(route["middleware"]["class"])
-
-                    if "methods" in route["middleware"] and route["middleware"]["methods"] is not None and len(
-                            route["middleware"]["methods"]) > 0:
-                        for method in route["middleware"]["methods"]:
-                            Request, result = middleware_runner.call_direct_method(Request, result, method)
-                            if result.http_code in error_set:
-                                return Response.Response(result.content, result.http_code, result.content_type)
-                    else:
-                        Request, result = await middleware_runner.call_before_methods(Request, result)
-                        if result.http_code in error_set:
-                            return Response.Response(result.content, result.http_code, result.content_type)
-                        Request, result = await middleware_runner.call_any_methods(Request, result)
-                        if result.http_code in error_set:
-                            return Response.Response(result.content, result.http_code, result.content_type)
-
                 try:
-                    sig = inspect.signature(router_response)
-                    kwargs = {}
-
-                    for param_name, param in sig.parameters.items():
-                        if param_name in Router.variables:
-                            value = Router.variables[param_name]
-                            if param.annotation != inspect.Parameter.empty and callable(param.annotation):
-                                try:
-                                    value = param.annotation(value)
-                                except ValueError:
-                                    raise ValueError(
-                                        f"Invalid type for path param '{param_name}': expected {param.annotation.__name__}, got '{Router.variables[param_name]}'")
-                            kwargs[param_name] = value
-                        elif param_name == 'request':
-                            kwargs[param_name] = Request
-                        elif param_name == 'response':
-                            kwargs[param_name] = Response.Response
-                        elif param.default == inspect.Parameter.empty:
-                            raise TypeError(f"Missing required parameter: {param_name}")
-
-                    result = await router_response(**kwargs)
-                except Exception as e:
-                    error_msg = tina4_python.global_exception_handler(e)
-                    tina4_python.container_broken(error_msg)
-                    if Constant.TINA4_LOG_DEBUG in os.getenv(
-                            "TINA4_DEBUG_LEVEL") or Constant.TINA4_LOG_ALL in os.getenv("TINA4_DEBUG_LEVEL"):
-                        html = Template.render_twig_template("errors/500.twig",
-                                                             {"server": {"url": url}, "error_message": error_msg})
-                        return Response.Response(html, Constant.HTTP_SERVER_ERROR, Constant.TEXT_HTML)
-                    else:
-                        return Response.Response(error_msg, Constant.HTTP_SERVER_ERROR, Constant.TEXT_HTML)
-
-                # we have found a result ... make sure we reflect this if the user didn't actually put the correct http response code in
-                if result is not None:
-                    if result.http_code == Constant.HTTP_NOT_FOUND:
-                        result.http_code = Constant.HTTP_OK
-
-                if "middleware" in route:
-                    middleware_runner = MiddleWare(route["middleware"]["class"])
+                    if "middleware" in route:
+                        middleware_runner = MiddleWare(route["middleware"]["class"])
+                        # Pre-route middleware needs a response to pass; create a default
+                        mw_response = Response("", Constant.HTTP_OK, Constant.TEXT_HTML)
+
+                        if "methods" in route["middleware"] and route["middleware"]["methods"] is not None and len(
+                                route["middleware"]["methods"]) > 0:
+                            for mw_method in route["middleware"]["methods"]:
+                                req, mw_response = middleware_runner.call_direct_method(req, mw_response, mw_method)
+                                if mw_response.http_code in error_set:
+                                    return Response(mw_response.content, mw_response.http_code, mw_response.content_type)
+                        else:
+                            req, mw_response = await middleware_runner.call_before_methods(req, mw_response)
+                            if mw_response.http_code in error_set:
+                                return Response(mw_response.content, mw_response.http_code, mw_response.content_type)
+                            req, mw_response = await middleware_runner.call_any_methods(req, mw_response)
+                            if mw_response.http_code in error_set:
+                                return Response(mw_response.content, mw_response.http_code, mw_response.content_type)
+
+                    try:
+                        sig = inspect.signature(router_response)
+                        kwargs = {}
+
+                        for param_name, param in sig.parameters.items():
+                            if param_name in matched_vars:
+                                value = matched_vars[param_name]
+                                if param.annotation != inspect.Parameter.empty and callable(param.annotation):
+                                    try:
+                                        value = param.annotation(value)
+                                    except ValueError:
+                                        raise ValueError(
+                                            f"Invalid type for path param '{param_name}': expected {param.annotation.__name__}, got '{matched_vars[param_name]}'")
+                                kwargs[param_name] = value
+                            elif param_name == 'request':
+                                kwargs[param_name] = req
+                            elif param_name == 'response':
+                                kwargs[param_name] = Response
+                            elif param.default == inspect.Parameter.empty:
+                                raise TypeError(f"Missing required parameter: {param_name}")
+
+                        result = await router_response(**kwargs)
+                    except Exception as e:
+                        error_msg = tina4_python.global_exception_handler(e)
+                        tina4_python.container_broken(error_msg)
+                        if Constant.TINA4_LOG_DEBUG in os.getenv(
+                                "TINA4_DEBUG_LEVEL") or Constant.TINA4_LOG_ALL in os.getenv("TINA4_DEBUG_LEVEL"):
+                            html = Template.render_twig_template("errors/500.twig",
+                                                                 {"server": {"url": url}, "error_message": error_msg})
+                            return Response(html, Constant.HTTP_SERVER_ERROR, Constant.TEXT_HTML)
+                        else:
+                            return Response(error_msg, Constant.HTTP_SERVER_ERROR, Constant.TEXT_HTML)
+
+                    # we have found a result ... make sure we reflect this if the user didn't actually put the correct http response code in
+                    if result is not None:
+                        if result.http_code == Constant.HTTP_NOT_FOUND:
+                            result.http_code = Constant.HTTP_OK
+
+                    if result is not None and "middleware" in route:
+                        middleware_runner = MiddleWare(route["middleware"]["class"])
+
+                        if "methods" in route["middleware"] and route["middleware"]["methods"] is not None and len(
+                                route["middleware"]["methods"]) > 0:
+                            for mw_method in route["middleware"]["methods"]:
+                                req, result = middleware_runner.call_direct_method(req, result, mw_method)
+                                if result.http_code in error_set:
+                                    return Response(result.content, result.http_code, result.content_type)
+                        else:
+                            req, result = await middleware_runner.call_any_methods(req, result)
+                            if result.http_code in error_set:
+                                return Response(result.content, result.http_code, result.content_type)
 
-                    if "methods" in route["middleware"] and route["middleware"]["methods"] is not None and len(
-                            route["middleware"]["methods"]) > 0:
-                        for method in route["middleware"]["methods"]:
-                            Request, result = middleware_runner.call_direct_method(Request, result, method)
+                            req, result = await middleware_runner.call_after_methods(req, result)
                             if result.http_code in error_set:
-                                return Response.Response(result.content, result.http_code, result.content_type)
-                    else:
-                        Request, result = await middleware_runner.call_any_methods(Request, result)
-                        if result.http_code in error_set:
-                            return Response.Response(result.content, result.http_code, result.content_type)
-
-                        Request, result = await middleware_runner.call_after_methods(Request, result)
-                        if result.http_code in error_set:
-                            return Response.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 "cache" in route and route["cache"] is not None:
-                        if not route["cache"]["cached"]:
-                            result.headers["Cache-Control"] = "max-age=1, must-revalidate"
-                            result.headers["Pragma"] = "no-cache"
+                                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 "cache" in route and route["cache"] is not None:
+                            if not route["cache"]["cached"]:
+                                result.headers["Cache-Control"] = "max-age=1, must-revalidate"
+                                result.headers["Pragma"] = "no-cache"
+                            else:
+                                result.headers["Cache-Control"] = "max-age=" + str(
+                                    route["cache"]["max_age"]) + ", must-revalidate"
+                                result.headers["Pragma"] = "cache"
                         else:
-                            result.headers["Cache-Control"] = "max-age=" + str(
-                                route["cache"]["max_age"]) + ", must-revalidate"
+                            result.headers["Cache-Control"] = "max-age=-1, must-revalidate"
                             result.headers["Pragma"] = "cache"
-                    else:
-                        result.headers["Cache-Control"] = "max-age=-1, must-revalidate"
-                        result.headers["Pragma"] = "cache"
+                finally:
+                    sys.stdout = old_stdout
 
                 break
 
-        if result is None and old_stdout is not None:
-            result = Response
-
-            result.headers["FreshToken"] = tina4_python.tina4_auth.get_token({"path": url})
-            sys.stdout = old_stdout
-            if buffer.getvalue() != "":
+        # Callback returned None but captured stdout output
+        if result is None and route_matched:
+            output = buffer.getvalue()
+            if output:
+                fresh_headers = {"FreshToken": tina4_python.tina4_auth.get_token({"path": url})}
                 try:
-                    return Response.Response(json.loads(buffer.getvalue()), Constant.HTTP_OK, Constant.APPLICATION_JSON,
-                                             result.headers)
+                    return Response(json.loads(output), Constant.HTTP_OK, Constant.APPLICATION_JSON, fresh_headers)
                 except Exception:
-                    return Response.Response(buffer.getvalue(), Constant.HTTP_OK, Constant.TEXT_HTML, result.headers)
-            else:
-                result = Response
-                result.http_code = Constant.HTTP_NOT_FOUND
+                    return Response(output, Constant.HTTP_OK, Constant.TEXT_HTML, fresh_headers)
 
-        # If no route is matched, serve 404
-        if result.http_code == Constant.HTTP_NOT_FOUND:
+        # If no route matched or result is still None, try twig templates then 404
+        if result is None:
             # Serve twigs if the files exist
             twig_files = []
             if url == "/":
@@ -410,17 +419,19 @@ class Router:
                                 tina4_python.root_path + os.sep + "src" + os.sep + "templates" + os.sep + twig_file,
                                 )
 
-                    result.headers["FreshToken"] = tina4_python.tina4_auth.get_token({"path": url})
-                    result.headers["Cache-Control"] = "max-age=-1, public"
-                    result.headers["Pragma"] = "no-cache"
+                    twig_headers = {
+                        "FreshToken": tina4_python.tina4_auth.get_token({"path": url}),
+                        "Cache-Control": "max-age=-1, public",
+                        "Pragma": "no-cache"
+                    }
                     content = Template.render_twig_template(twig_file, {"request": tina4_python.tina4_current_request})
                     if content != "":
-                        return Response.Response(content, Constant.HTTP_OK, Constant.TEXT_HTML, result.headers)
+                        return Response(content, Constant.HTTP_OK, Constant.TEXT_HTML, twig_headers)
 
-        if result.http_code == Constant.HTTP_NOT_FOUND:
+        if result is None:
             content = Template.render_twig_template(
                 "errors/404.twig", {"server": {"url": url}})
-            return Response.Response(content, Constant.HTTP_NOT_FOUND, Constant.TEXT_HTML)
+            return Response(content, Constant.HTTP_NOT_FOUND, Constant.TEXT_HTML)
 
         result.headers["FreshToken"] = tina4_python.tina4_auth.get_token({"path": url})
         return result
@@ -431,11 +442,6 @@ class Router:
         Debug.debug(method, "Resolving URL: " + url)
         return await Router.get_result(url, method, request, headers, session)
 
-    # cleans the url of double slashes
-    @staticmethod
-    def clean_url(url):
-        return url.replace('//', '/')
-
     # adds a route to the router
     @staticmethod
     def add(method, route, callback):

{tina4_python-0.2.172 → tina4_python-0.2.173}/tina4_python/Session.py

@@ -271,8 +271,12 @@ class Session:
         self.session_path = _default_path
         self.session_values = {}
         self.session_hash = ""
-        self.default_handler = _default_handler
-        exec("self.default_handler = "+_default_handler)
+        _handlers = {
+            "SessionFileHandler": SessionFileHandler,
+            "SessionRedisHandler": SessionRedisHandler,
+            "SessionValkeyHandler": SessionValkeyHandler,
+        }
+        self.default_handler = _handlers.get(_default_handler, SessionFileHandler)
 
     def start(self, _hash=None):
         # create a file for the session?

{tina4_python-0.2.172 → tina4_python-0.2.173}/tina4_python/__init__.py

@@ -243,7 +243,11 @@ builtins.orm = orm
 # Auto-import everything from src folders
 if os.path.exists(root_path + os.sep + "src"):
     try:
-        exec("from src import *")
+        import importlib
+        src_module = importlib.import_module("src")
+        for attr in dir(src_module):
+            if not attr.startswith("_"):
+                globals()[attr] = getattr(src_module, attr)
         Debug.info("Initializing src folder")
     except ImportError as e:
         Debug.error("Cannot import src folder", str(e))
@@ -594,7 +598,7 @@ def _has_control_methods():
     if "tina4-python" in file_path:
         return True
 
-    if "tina4" in file_path or "uvicorn" in file_path in file_path or "hypercorn" in file_path:
+    if "tina4" in file_path or "uvicorn" in file_path or "hypercorn" in file_path:
         return True
 
     if not file_path or not file_path.endswith('.py'):

{tina4_python-0.2.172 → tina4_python-0.2.173}/tina4_python/cli.py

@@ -56,13 +56,20 @@ def create_project(project_name: str) -> None:
         print(f"Creating project in {project_path}")
 
     app_content = '''\
+import os
+import tina4_python
+from tina4_python import Debug
 from tina4_python import run_web_server
 from tina4_python.Router import get
 
+
 @get("/health-check")
-async def index(request, response):
+async def get_healthcheck(request, response):
+    if os.path.isfile(tina4_python.root_path + "/broken"):
+        Debug.error("broken", tina4_python.root_path + "/broken")
+        return response("Broken", 503)
+    return response("OK")
 
-    return response(f"OK")
 
 if __name__ == "__main__":
     run_web_server("0.0.0.0", 7145)

tina4_python-0.2.172/tina4_python/Request.py

@@ -1,21 +0,0 @@
-#
-# Tina4 - This is not a 4ramework.
-# Copy-right 2007 - current Tina4
-# License: MIT https://opensource.org/licenses/MIT
-#
-# flake8: noqa: E501
-request = None
-body = None
-params = {}
-headers = {}
-cookies = {}
-url = None
-session = None
-files = {}
-raw_request = None
-raw_data = None
-raw_content = None
-asgi_scope = None
-asgi_reader = None
-asgi_writer = None
-asgi_response = None