tina4-python 0.2.205__tar.gz → 0.2.206__tar.gz

{tina4_python-0.2.205 → tina4_python-0.2.206}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 0.2.205
+Version: 0.2.206
 Summary: Tina4Python - This is not another framework for Python
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 Requires-Python: <4.0,>=3.12
 Requires-Dist: bcrypt<5.0.0,>=4.2.1
 Requires-Dist: hypercorn>=0.18.0
+Requires-Dist: jinja2<4.0.0,>=3.1.5
 Requires-Dist: libsass<0.24.0,>=0.23.0
 Requires-Dist: litequeue<0.10,>=0.9
 Requires-Dist: pyjwt<3.0.0,>=2.10.1

{tina4_python-0.2.205 → tina4_python-0.2.206}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "0.2.205"
+version = "0.2.206"
 description = "Tina4Python - This is not another framework for Python"
 authors = [
     {name = "Andre van Zuydam",email = "andrevanzuydam@gmail.com"}
@@ -8,6 +8,7 @@ authors = [
 readme = "README.md"
 requires-python = ">=3.12,<4.0"
 dependencies = [
+    "jinja2>=3.1.5,<4.0.0",
     "libsass (>=0.23.0,<0.24.0)",
     "python-dotenv (>=1.0.1,<2.0.0)",
     "pyjwt>=2.10.1,<3.0.0",

{tina4_python-0.2.205 → tina4_python-0.2.206}/tina4_python/Response.py

@@ -104,12 +104,11 @@ class Response:
 
         # Merge any headers added via add_header() before this Response was created
         pending = _pending_headers.get()
+        merged_headers = {}
+        if pending:
+            merged_headers.update(pending)
         if headers_in is not None:
-            merged_headers = dict(headers_in)
-        elif pending:
-            merged_headers = dict(pending)
-        else:
-            merged_headers = {}
+            merged_headers.update(headers_in)
 
         self.headers = merged_headers
         self.content = content_in if content_in is not None else ""

{tina4_python-0.2.205 → tina4_python-0.2.206}/tina4_python/Router.py

@@ -501,10 +501,23 @@ class Router:
             with open(cached_static, 'rb') as file:
                 return Response(file.read(), Constant.HTTP_OK, mime_type)
 
-        # Always use full scan for route matching — simple, correct, and fast
-        # enough for typical route counts. The pre-compiled segments and cached
-        # signatures provide the main per-request speedup.
-        route_iter = list(tina4_python.tina4_routes.values())
+        # Build candidate route list using prefix index (O(1) lookup vs O(n) scan)
+        url_segments = Router._normalize_request_url(url)
+        first_seg = url_segments[0] if url_segments else ""
+
+        # Collect indexed candidates
+        candidates = set()
+        if first_seg in Router._route_index:
+            candidates.update(Router._route_index[first_seg])
+        candidates.update(Router._wildcard_routes)
+        if not url_segments and "" in Router._route_index:
+            candidates.update(Router._route_index[""])
+
+        # If index is empty (e.g. tests reset tina4_routes directly), fall back to full scan
+        if not Router._route_index and not Router._wildcard_routes:
+            route_iter = tina4_python.tina4_routes.values()
+        else:
+            route_iter = (tina4_python.tina4_routes[cb] for cb in candidates if cb in tina4_python.tina4_routes)
 
         buffer = io.StringIO()
         for route in route_iter:

{tina4_python-0.2.205 → tina4_python-0.2.206}/tina4_python/Template.py

@@ -4,14 +4,13 @@
 # License: MIT https://opensource.org/licenses/MIT
 #
 # flake8: noqa: E501
-"""Twig template engine for Tina4.
+"""Jinja2-based template engine for Tina4.
 
-The ``Template`` class wraps Tina4's built-in TwigEngine to provide
-Twig/PHP-compatible HTML rendering with automatic template discovery
-from ``src/templates/``.
+The ``Template`` class wraps Jinja2 to provide Twig-compatible HTML
+rendering with automatic template discovery from ``src/templates/``.
 
 Features:
-    - Automatic template path setup scanning ``src/templates/``
+    - Automatic ``FileSystemLoader`` setup scanning ``src/templates/``
     - Built-in filters: ``json_decode``, ``base64_encode``, ``date``,
       ``slugify``, and more
     - Built-in globals: ``url``, ``root``, ``session``, ``uniqid``, ``localize``
@@ -37,9 +36,9 @@ import base64
 import tina4_python
 from tina4_python import Constant
 from tina4_python.Debug import Debug
-from tina4_python.TwigEngine import TwigEngine, TemplateNotFound
 from pathlib import Path
 from datetime import datetime, date
+from jinja2 import Environment, FileSystemLoader, Undefined, TemplateNotFound
 from tina4_python.Session import Session
 from random import random as RANDOM
 from typing import Dict, Any
@@ -55,34 +54,36 @@ class Template:
 
     @staticmethod
     def add_filter(name, func):
-        """Register a custom template filter."""
+        """Register a custom Jinja2 filter."""
         Template._custom_filters[name] = func
         if Template.twig is not None:
-            Template.twig.add_filter(name, func)
+            Template.twig.filters[name] = func
 
     @staticmethod
     def add_global(name, value):
-        """Register a custom template global (function or value)."""
+        """Register a custom Jinja2 global (function or value)."""
         Template._custom_globals[name] = value
         if Template.twig is not None:
-            Template.twig.add_global(name, value)
+            Template.twig.globals[name] = value
 
     @staticmethod
     def add_test(name, func):
-        """Register a custom template test for use with {% if x is testname %}."""
+        """Register a custom Jinja2 test for use with {% if x is testname %}."""
         Template._custom_tests[name] = func
         if Template.twig is not None:
-            Template.twig.add_test(name, func)
+            Template.twig.tests[name] = func
 
     @staticmethod
     def add_extension(extension):
-        """Register a template extension (kept for API compatibility)."""
+        """Register a Jinja2 extension class."""
         if extension not in Template._custom_extensions:
             Template._custom_extensions.append(extension)
+        if Template.twig is not None:
+            Template.twig.add_extension(extension)
 
     @staticmethod
     def get_environment():
-        """Return the underlying TwigEngine instance, initializing if needed."""
+        """Return the underlying Jinja2 Environment instance, initializing if needed."""
         if Template.twig is None:
             Template.init_twig(tina4_python.root_path + os.sep + "src" + os.sep + "templates")
         return Template.twig
@@ -104,55 +105,52 @@ class Template:
             return Template.twig
         Debug.debug("Initializing Twig on " + path)
         twig_path = Path(path)
-        # Search project templates first, then framework built-in templates as fallback
-        fw_templates = Path(tina4_python.library_path) / "templates"
-        search_paths = [str(twig_path)]
-        if fw_templates.is_dir() and str(fw_templates) != str(twig_path):
-            search_paths.append(str(fw_templates))
-        Template.twig = TwigEngine(search_paths)
-
+        Template.twig = Environment(loader=FileSystemLoader(Path(twig_path)))
+        Template.twig.add_extension('jinja2.ext.debug')
+        Template.twig.add_extension('jinja2.ext.do')
         # i18n translation function — available as _() global and | translate filter
         from tina4_python.Localization import localize
         _translate = localize()
-        Template.twig.add_global('_', _translate)
-        Template.twig.add_filter('translate', _translate)
-        Template.twig.add_global('RANDOM', RANDOM)
-        Template.twig.add_global('range', range)
-        Template.twig.add_global('json', json)
-        Template.twig.add_global('base64encode', Template.base64encode)
-        Template.twig.add_filter('base64encode', Template.base64encode)
-        Template.twig.add_filter('detect_image', Template.detect_image)
-        Template.twig.add_filter('json_encode', json.dumps)
-        Template.twig.add_global('json_encode', json.dumps)
-        Template.twig.add_filter('json_decode', Template.json_decode)
-        Template.twig.add_global('json_decode', Template.json_decode)
-        Template.twig.add_filter('nice_label', Template.get_nice_label)
-        Template.twig.add_global('datetime_format', Template.datetime_format)
-        Template.twig.add_filter('datetime_format', Template.datetime_format)
-        Template.twig.add_global('formToken', Template.get_form_token)
-        Template.twig.add_filter('formToken', Template.get_form_token_input)
-        Template.twig.add_global('form_token', Template.get_form_token)
-        Template.twig.add_filter('form_token', Template.get_form_token_input)
+        Template.twig.globals['_'] = _translate
+        Template.twig.filters['translate'] = _translate
+        Template.twig.globals['RANDOM'] = RANDOM
+        Template.twig.globals['json'] = json
+        Template.twig.globals['base64encode'] = Template.base64encode
+        Template.twig.filters['base64encode'] = Template.base64encode
+        Template.twig.filters['detect_image'] = Template.detect_image
+        Template.twig.filters['json_encode'] = json.dumps
+        Template.twig.globals['json_encode'] = json.dumps
+        Template.twig.filters['json_decode'] = Template.json_decode
+        Template.twig.globals['json_decode'] = Template.json_decode
+        Template.twig.filters['nice_label'] = Template.get_nice_label
+        Template.twig.globals['datetime_format'] = Template.datetime_format
+        Template.twig.filters['datetime_format'] = Template.datetime_format
+        Template.twig.globals['formToken'] = Template.get_form_token
+        Template.twig.filters['formToken'] = Template.get_form_token_input
+        Template.twig.globals['form_token'] = Template.get_form_token
+        Template.twig.filters['form_token'] = Template.get_form_token_input
         debug_level = os.getenv("TINA4_DEBUG_LEVEL", "")
         if Constant.TINA4_LOG_DEBUG in debug_level or Constant.TINA4_LOG_ALL in debug_level:
-            Template.twig.add_global('dump', Template.dump)
+            Template.twig.globals['dump'] = Template.dump
         else:
-            Template.twig.add_global('dump', Template.production_dump)
+            Template.twig.globals['dump'] = Template.production_dump
 
-        # Apply any custom filters, globals, tests registered before init
+        # Apply any custom filters, globals, tests, and extensions registered before init
         for name, func in Template._custom_filters.items():
-            Template.twig.add_filter(name, func)
+            Template.twig.filters[name] = func
         for name, value in Template._custom_globals.items():
-            Template.twig.add_global(name, value)
+            Template.twig.globals[name] = value
         for name, func in Template._custom_tests.items():
-            Template.twig.add_test(name, func)
+            Template.twig.tests[name] = func
+        for ext in Template._custom_extensions:
+            Template.twig.add_extension(ext)
 
         Debug.debug("Twig Initialized on " + path)
         return Template.twig
 
     @staticmethod
     def datetime_format(value, format="%H:%M %d-%m-%y"):
-        if isinstance(value, str) and value.strip().upper() == "NOW":
+        if value.strip().upper() == "NOW":
             value = datetime.now()
         try:
             return value.strftime(format)
@@ -171,14 +169,14 @@ class Template:
 
     @staticmethod
     def dump(param):
-        param = html.unescape(str(param)) if param is not None else None
-        if param is not None:
+        param = html.unescape(param)
+        if param is not None and not isinstance(param, Undefined):
             def json_serialize(obj):
                 if isinstance(obj, (date, datetime)):
                     return obj.isoformat()
                 if isinstance(obj, Session):
                     return obj.session_values
-                raise TypeError("Type %s not serializable" % type(obj))
+                raise TypeError("Type %s not serializable to Jinja2 template" % type(obj))
 
             return "<pre>" + json.dumps(param, indent=True, default=json_serialize) + "</pre>"
         else:
@@ -186,7 +184,7 @@ class Template:
 
     @staticmethod
     def base64encode(param):
-        value = base64.b64encode(param.encode('utf-8')).decode('utf-8')
+        value =  base64.b64encode(param.encode('utf-8')).decode('utf-8')
         return value
 
     @staticmethod
@@ -204,9 +202,9 @@ class Template:
     def convert_special_types(obj):
         """
         Recursively convert non-JSON-serializable objects:
-          - datetime/date -> ISO 8601 string
-          - bytes -> base64 string
-          - dict/list/tuple/set -> recursively processed
+          • datetime/date → ISO 8601 string
+          • bytes base64 string
+          • dict/list/tuple/set → recursively processed
         Safe for deeply nested data (arrays of arrays, dicts in lists, etc.)
         """
         if isinstance(obj, (date, datetime)):
@@ -228,7 +226,7 @@ class Template:
             ]
 
         else:
-            # Primitives: str, int, float, bool, None -> pass through
+            # Primitives: str, int, float, bool, None → pass through
             return obj
 
     @staticmethod
@@ -243,8 +241,9 @@ class Template:
         twig = Template.init_twig(tina4_python.root_path + os.sep + "src" + os.sep + "templates")
         try:
             try:
-                template = twig.get_template(template_or_file_name)
-                content = template.render(data)
+                if twig.get_template(template_or_file_name):
+                    template = twig.get_template(template_or_file_name)
+                    content = template.render(data)
             except TemplateNotFound:
                 template = twig.from_string(template_or_file_name)
                 content = template.render(data)
@@ -261,12 +260,13 @@ class Template:
 
     @staticmethod
     def get_nice_label(field_name: str) -> str:
-        # snake_case / camelCase / PascalCase -> words
+        # snake_case / camelCase / PascalCase → words
         s = re.sub(r'[_.-]+', ' ', field_name)
         s = re.sub(r'(?<=[a-z])(?=[A-Z])', ' ', s)
         # Capitalize words & strip id
         words = s.split()
-        return " ".join(word.capitalize() for word in words)
+        return " ".join(word.capitalize() for word in words )
+
 
     @staticmethod
     def detect_image(value: Any) -> Dict[str, str]:
@@ -280,12 +280,12 @@ class Template:
                 content = data.get('content', '')
 
                 if not content:
-                    return {"content": value, "content_type": ""}
+                    return  {"content": value, "content_type": ""}
 
                 content_type = data.get('content_type', '')
                 if content_type.startswith('image/'):
                     mime_type = content_type.split('/')[1]
-                    return {"content": content, "content_type": mime_type}
+                    return  {"content": content, "content_type": mime_type}
 
                 # Fallback to magic bytes if no content_type
                 if content[:4] == '/9j/':
@@ -297,7 +297,7 @@ class Template:
                 elif content[:5] == 'UklGR':
                     mime_type = 'webp'
                 else:
-                    return {"content": content, "content_type": ""}
+                    return  {"content": content, "content_type": ""}
 
                 return {"content": content, "content_type": mime_type}
             except json.JSONDecodeError as e:
@@ -328,14 +328,14 @@ def template(twig_file: str):
         async def wrapper(*args, **kwargs):
             result = await func(*args, **kwargs)
 
-            # If the route returns a dict -> render the template
+            # If the route returns a dict → render the template
             if isinstance(result, dict):
-                rendered = Template.render(twig_file, result)
+                html = Template.render(twig_file, result)
                 from tina4_python.Response import Response
-                return Response(rendered, Constant.HTTP_OK, Constant.TEXT_HTML)
+                return Response(html, Constant.HTTP_OK, Constant.TEXT_HTML)
 
             # Anything else (redirects, JSON, etc.) is passed through unchanged
             return result
 
         return wrapper
-    return decorator
+    return decorator

{tina4_python-0.2.205 → tina4_python-0.2.206}/tina4_python/__init__.py

@@ -223,9 +223,9 @@ if not os.path.exists(root_path + os.sep + "src" + os.sep + "public"):
     shutil.copytree(source_dir, destination_dir)
 
 # Declare built-ins so we don't always have to import stuff.
-# NOTE: Names that shadow submodule names (Database, ORM, Api, etc.) MUST be
-# imported eagerly — Python's import system resolves submodules before __getattr__.
-# Only names that don't shadow submodules can use lazy __getattr__.
+# Light imports (no heavy deps) are loaded eagerly.
+# Heavy imports (jwt, jinja2, database drivers) are deferred until first use
+# via module __getattr__ and registered as builtins on first access.
 import builtins
 from .Router import get, post, put, patch, delete, middleware, cached, noauth, secured, wsdl
 from .Testing import tests, assert_equal, assert_raises
@@ -233,34 +233,57 @@ from .Debug import Debug
 from .FieldTypes import IntegerField, StringField, JSONBField, TextField, BlobField, NumericField, DateTimeField
 from .Constant import TEXT_HTML, TEXT_PLAIN, TEXT_CSS, TINA4_POST, TINA4_DELETE, TINA4_ANY, TINA4_PUT, TINA4_PATCH, TINA4_OPTIONS, TINA4_LOG_ALL, TINA4_LOG_WARNING, TINA4_LOG_ERROR, TINA4_LOG_DEBUG, TINA4_GET, TINA4_LOG_INFO, HTTP_OK, HTTP_SERVER_ERROR, HTTP_FORBIDDEN, HTTP_NO_CONTENT, HTTP_PARTIAL_CONTENT, HTTP_CREATED, HTTP_UNAUTHORIZED, HTTP_ACCEPTED, HTTP_REDIRECT, HTTP_REDIRECT_MOVED, HTTP_REDIRECT_OTHER, HTTP_BAD_REQUEST, HTTP_NOT_FOUND, LOOKUP_HTTP_CODE, APPLICATION_JSON, APPLICATION_XML
 
-# These shadow submodule names so they must be imported eagerly
-from .Database import Database
-from .ORM import ORM, orm
-from .Api import Api
-from .Template import template
-from .Swagger import Swagger, description, secure, summary, example, example_response, tags, params, describe
-from .GraphQL import GraphQL, GraphQLSchema, GraphQLType
-from .Seeder import FakeData, Seeder, seed_orm, seed_table, seed
-
-# Register all as builtins
-for _obj in (get, post, put, patch, delete, middleware, cached, noauth, secured, wsdl,
-             tests, assert_equal, assert_raises,
-             IntegerField, StringField, JSONBField, TextField, BlobField, NumericField, DateTimeField,
-             description, secure, summary, example, example_response, tags, params, describe, template):
-    if _obj.__name__ not in builtins.__dict__:
-        builtins.__dict__[_obj.__name__] = _obj
+# Register light builtins immediately
+for deco in (get, post, put, patch, delete, middleware, cached, noauth, secured, wsdl, tests, assert_equal, assert_raises,
+             IntegerField, StringField, JSONBField, TextField, BlobField, NumericField, DateTimeField):
+    if deco.__name__ not in builtins.__dict__:
+        builtins.__dict__[deco.__name__] = deco
 
 builtins.Debug = Debug
-builtins.Database = Database
-builtins.ORM = ORM
-builtins.orm = orm
-builtins.Api = Api
-builtins.GraphQL = GraphQL
-builtins.GraphQLSchema = GraphQLSchema
-builtins.FakeData = FakeData
-builtins.Seeder = Seeder
-builtins.seed_orm = seed_orm
-builtins.seed_table = seed_table
+
+# Lazy module attributes — resolved on `from tina4_python import X` or `tina4_python.X`
+# Maps attribute name → (submodule_path, attribute_name)
+_LAZY_ATTRS = {
+    "Database": (".Database", "Database"),
+    "ORM": (".ORM", "ORM"),
+    "orm": (".ORM", "orm"),
+    "Api": (".Api", "Api"),
+    "template": (".Template", "template"),
+    "description": (".Swagger", "description"),
+    "secure": (".Swagger", "secure"),
+    "summary": (".Swagger", "summary"),
+    "example": (".Swagger", "example"),
+    "example_response": (".Swagger", "example_response"),
+    "tags": (".Swagger", "tags"),
+    "params": (".Swagger", "params"),
+    "describe": (".Swagger", "describe"),
+    "GraphQL": (".GraphQL", "GraphQL"),
+    "GraphQLSchema": (".GraphQL", "GraphQLSchema"),
+    "GraphQLType": (".GraphQL", "GraphQLType"),
+    "FakeData": (".Seeder", "FakeData"),
+    "Seeder": (".Seeder", "Seeder"),
+    "seed_orm": (".Seeder", "seed_orm"),
+    "seed_table": (".Seeder", "seed_table"),
+    "seed": (".Seeder", "seed"),
+}
+
+def __getattr__(name):
+    """Module-level __getattr__ for lazy imports.
+
+    Called when ``from tina4_python import X`` or ``tina4_python.X`` is used
+    and X isn't already in the module namespace.  Loads the real attribute
+    from the submodule and caches it in both the module dict and builtins.
+    """
+    if name in _LAZY_ATTRS:
+        submod, attr = _LAZY_ATTRS[name]
+        mod = importlib.import_module(submod, package="tina4_python")
+        obj = getattr(mod, attr)
+        # Cache in module dict so __getattr__ isn't called again
+        globals()[name] = obj
+        # Also register as builtin for zero-import convenience
+        builtins.__dict__[name] = obj
+        return obj
+    raise AttributeError(f"module 'tina4_python' has no attribute {name!r}")
 
 
 # src/ is loaded lazily inside run_web_server() via _autoload_routes()
@@ -351,10 +374,8 @@ async def get_swagger_json(request, response):
 @get(os.getenv("SWAGGER_ROUTE", "/swagger"))
 async def get_swagger(request, response):
     """Serve interactive Swagger UI page."""
-    swagger_path = root_path + os.sep + "src" + os.sep + "public" + os.sep + "swagger" + os.sep + "index.html"
-    if not os.path.isfile(swagger_path):
-        swagger_path = library_path + os.sep + "public" + os.sep + "swagger" + os.sep + "index.html"
-    html = file_get_contents(swagger_path)
+    html = file_get_contents(
+        root_path + os.sep + "src" + os.sep + "public" + os.sep + "swagger" + os.sep + "index.html")
 
     html = html.replace("{SWAGGER_ROUTE}", os.getenv("SWAGGER_ROUTE", "/swagger"))
     return response(html)
@@ -579,7 +600,7 @@ def run_web_server(hostname="localhost", port=7145, debug: bool = False):
     # ------------------------------------------------------------------
     # Show a clickable URL in the banner (0.0.0.0 isn't useful for devs)
     display_host = "localhost" if hostname in ("0.0.0.0", "::") else hostname
-    Debug.info(f"Server started http://{display_host}:{port} ({len(tina4_routes)} routes)")
+    Debug.info(f"Server started http://{display_host}:{port}")
     webserver(hostname, port, debug=debug)  # Pass debug flag down