tina4-python 3.10.48__tar.gz → 3.10.50__tar.gz

{tina4_python-3.10.48 → tina4_python-3.10.50}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.10.48
+Version: 3.10.50
 Summary: Tina4 for Python — 54 built-in features, zero dependencies
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT

{tina4_python-3.10.48 → tina4_python-3.10.50}/tina4_python/__init__.py

@@ -8,7 +8,14 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.10.48"
+__version__ = "3.10.50"
+
+# ── Route decorators ──
+from tina4_python.core.router import (  # noqa: E402, F401
+    get, post, put, patch, delete, any_method,
+    noauth, secured, cached, middleware, template,
+    Router,
+)
 
 # ── HTTP Constants ──
 from tina4_python.core.constants import (  # noqa: E402, F401
@@ -22,6 +29,9 @@ from tina4_python.core.constants import (  # noqa: E402, F401
     APPLICATION_OCTET, TEXT_HTML, TEXT_PLAIN, TEXT_CSV, TEXT_XML,
 )
 
+# ── Database ──
+from tina4_python.database import Database  # noqa: E402, F401
+
 # ── ORM ──
 from tina4_python.orm import (  # noqa: E402, F401
     ORM, orm_bind, Field,
@@ -31,6 +41,15 @@ from tina4_python.orm import (  # noqa: E402, F401
     has_many, has_one, belongs_to,  # relationship descriptors
 )
 
+# ── Auth ──
+from tina4_python.auth import Auth  # noqa: E402, F401
+
+# ── Queue ──
+from tina4_python.queue import Queue  # noqa: E402, F401
+
+# ── Template engine ──
+from tina4_python.frond import Frond  # noqa: E402, F401
+
 # ── Response Cache ──
 from tina4_python.cache import (  # noqa: E402, F401
     ResponseCache, cache_stats, clear_cache,
@@ -38,3 +57,6 @@ from tina4_python.cache import (  # noqa: E402, F401
 
 # ── DI Container ──
 from tina4_python.container import Container  # noqa: E402, F401
+
+# ── Server ──
+from tina4_python.core.server import run  # noqa: E402, F401

{tina4_python-3.10.48 → tina4_python-3.10.50}/tina4_python/cli/__init__.py

@@ -202,6 +202,24 @@ def _init(args):
     for folder in folders:
         (target / folder).mkdir(parents=True, exist_ok=True)
 
+    # Copy framework public assets into the project so they're visible
+    framework_public = Path(__file__).parent.parent / "public"
+    project_public = target / "src" / "public"
+    assets_to_copy = [
+        "css/tina4.css",
+        "css/tina4.min.css",
+        "js/tina4.min.js",
+        "js/frond.min.js",
+        "images/tina4-logo-icon.webp",
+    ]
+    for asset in assets_to_copy:
+        src = framework_public / asset
+        dst = project_public / asset
+        dst.parent.mkdir(parents=True, exist_ok=True)
+        if src.exists() and not dst.exists():
+            import shutil
+            shutil.copy2(src, dst)
+
     # Copy frontend README
     frontend_readme = target / "frontend" / "README.md"
     if not frontend_readme.exists():

{tina4_python-3.10.48 → tina4_python-3.10.50}/tina4_python/core/request.py

@@ -80,6 +80,21 @@ class Request:
         # Parse body
         req.body = _parse_body(body, req.content_type)
 
+        # Separate files from body for multipart uploads
+        if isinstance(req.body, dict) and "multipart/form-data" in req.content_type:
+            files = {}
+            fields = {}
+            for key, value in req.body.items():
+                if isinstance(value, dict) and "filename" in value:
+                    # Base64-encode file content for safe transport
+                    import base64
+                    value["content"] = base64.b64encode(value["content"]).decode()
+                    files[key] = value
+                else:
+                    fields[key] = value
+            req.files = files
+            req.body = fields
+
         return req
 
     def merge_route_params(self):

{tina4_python-3.10.48 → tina4_python-3.10.50}/tina4_python/core/router.py

@@ -262,7 +262,7 @@ def _compile_pattern(path: str) -> tuple[re.Pattern, list[str]]:
     for i, segment in enumerate(segments):
         if segment == "*":
             # Wildcard: matches the rest of the path (greedy)
-            param_names.append("wildcard")
+            param_names.append("*")
             regex_parts.append("(.+)")
             break  # Nothing can follow a wildcard
         elif segment.startswith("{") and segment.endswith("}"):

{tina4_python-3.10.48 → tina4_python-3.10.50}/tina4_python/core/server.py

@@ -640,6 +640,10 @@ def _init_session(request: Request) -> None:
         sess = Session()
         sess.start(sid_match)
         request.session = sess
+        # Probabilistic garbage collection (1% of requests)
+        import random
+        if random.randint(1, 100) == 1:
+            sess.gc()
     except Exception:
         pass  # Session module not available — session stays None
 

{tina4_python-3.10.48 → tina4_python-3.10.50}/tina4_python/database/adapter.py

@@ -33,8 +33,10 @@ class DatabaseResult:
 
     def to_paginate(self, page: int = 1, per_page: int = 20) -> dict:
         total_pages = max(1, -(-self.count // per_page))  # ceil division
+        start = (page - 1) * per_page
+        end = start + per_page
         return {
-            "data": self.records,
+            "data": self.records[start:end],
             "total": self.count,
             "page": page,
             "per_page": per_page,
@@ -210,21 +212,31 @@ class DatabaseResult:
         return columns
 
     def _fallback_column_info(self) -> list[dict]:
-        """Derive basic column info from record keys when no adapter is available."""
+        """Derive basic column info from record keys and values when no adapter is available."""
         if not self.records:
             return []
-        keys = list(self.records[0].keys()) if isinstance(self.records[0], dict) else []
-        return [
-            {
+        row = self.records[0] if isinstance(self.records[0], dict) else {}
+        result = []
+        for k, v in row.items():
+            if isinstance(v, int):
+                col_type = "INTEGER"
+            elif isinstance(v, float):
+                col_type = "REAL"
+            elif isinstance(v, bool):
+                col_type = "BOOLEAN"
+            elif v is None:
+                col_type = "TEXT"
+            else:
+                col_type = "TEXT"
+            result.append({
                 "name": k,
-                "type": "UNKNOWN",
+                "type": col_type,
                 "size": None,
                 "decimals": None,
                 "nullable": True,
-                "primary_key": False,
-            }
-            for k in keys
-        ]
+                "primary_key": k.lower() == "id",
+            })
+        return result
 
 
 class DatabaseAdapter:
@@ -285,7 +297,7 @@ class DatabaseAdapter:
         )
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 20, offset: int = 0) -> DatabaseResult:
+              limit: int = 100, offset: int = 0) -> DatabaseResult:
         """Execute a read query and return multiple rows."""
         raise NotImplementedError
 

{tina4_python-3.10.48 → tina4_python-3.10.50}/tina4_python/database/connection.py

@@ -283,7 +283,7 @@ class Database:
         return adapter.execute_many(sql, params_list)
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 20, offset: int = 0) -> DatabaseResult:
+              limit: int = 100, offset: int = 0) -> DatabaseResult:
         """Fetch rows with pagination."""
         if self._cache_enabled:
             key = self._cache_key(sql + f":L{limit}:S{offset}", params)

{tina4_python-3.10.48 → tina4_python-3.10.50}/tina4_python/database/firebird.py

@@ -138,7 +138,7 @@ class FirebirdAdapter(DatabaseAdapter):
         )
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 20, offset: int = 0) -> DatabaseResult:
+              limit: int = 100, offset: int = 0) -> DatabaseResult:
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor()
 

{tina4_python-3.10.48 → tina4_python-3.10.50}/tina4_python/database/mssql.py

@@ -102,7 +102,7 @@ class MSSQLAdapter(DatabaseAdapter):
         )
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 20, offset: int = 0) -> DatabaseResult:
+              limit: int = 100, offset: int = 0) -> DatabaseResult:
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor(as_dict=True)
 

{tina4_python-3.10.48 → tina4_python-3.10.50}/tina4_python/database/mysql.py

@@ -91,7 +91,7 @@ class MySQLAdapter(DatabaseAdapter):
         )
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 20, offset: int = 0) -> DatabaseResult:
+              limit: int = 100, offset: int = 0) -> DatabaseResult:
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor(dictionary=True)
 

{tina4_python-3.10.48 → tina4_python-3.10.50}/tina4_python/database/odbc.py

@@ -74,7 +74,7 @@ class ODBCAdapter(DatabaseAdapter):
         )
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 20, offset: int = 0) -> DatabaseResult:
+              limit: int = 100, offset: int = 0) -> DatabaseResult:
         # Count total
         count_sql = f"SELECT COUNT(*) FROM ({sql}) AS _t"
         cursor = self._conn.cursor()

{tina4_python-3.10.48 → tina4_python-3.10.50}/tina4_python/database/postgres.py

@@ -100,7 +100,7 @@ class PostgreSQLAdapter(DatabaseAdapter):
         )
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 20, offset: int = 0) -> DatabaseResult:
+              limit: int = 100, offset: int = 0) -> DatabaseResult:
         import psycopg2.extras
 
         sql = self._translate_sql(sql)

{tina4_python-3.10.48 → tina4_python-3.10.50}/tina4_python/database/sqlite.py

@@ -93,7 +93,7 @@ class SQLiteAdapter(DatabaseAdapter):
         )
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 20, offset: int = 0) -> DatabaseResult:
+              limit: int = 100, offset: int = 0) -> DatabaseResult:
         # Count total rows (without LIMIT/OFFSET)
         count_sql = f"SELECT COUNT(*) as cnt FROM ({sql})"
         try:

{tina4_python-3.10.48 → tina4_python-3.10.50}/tina4_python/frond/engine.py

@@ -118,6 +118,7 @@ _SET_RE = re.compile(r"set\s+(\w+)\s*=\s*(.+)")
 _INCLUDE_RE = re.compile(r'include\s+["\'](.+?)["\'](?:\s+with\s+(.+))?')
 _MACRO_RE = re.compile(r"macro\s+(\w+)\s*\(([^)]*)\)")
 _FROM_IMPORT_RE = re.compile(r'from\s+["\'](.+?)["\']\s+import\s+(.+)')
+_IMPORT_AS_RE = re.compile(r'import\s+["\'](.+?)["\']\s+as\s+(\w+)')
 _CACHE_RE = re.compile(r'cache\s+["\'](.+?)["\']\s*(\d+)?')
 _AUTOESCAPE_RE = re.compile(r"autoescape\s+(false|true)")
 _SPACELESS_RE = re.compile(r">\s+<")
@@ -1328,6 +1329,10 @@ class Frond:
                     self._handle_from_import(content, context)
                     i += 1
 
+                elif tag == "import":
+                    self._handle_import_as(content, context)
+                    i += 1
+
                 elif tag == "cache":
                     result, skip = self._handle_cache(tokens, i, context)
                     output.append(result)
@@ -1803,6 +1808,70 @@ class Frond:
                         continue
             i += 1
 
+    def _handle_import_as(self, content: str, context: dict):
+        """Handle {% import "file" as alias %}.
+
+        Loads ALL macros from the file and registers them as an object
+        with methods, so {{ alias.macro_name(args) }} works.
+        """
+        m = _IMPORT_AS_RE.match(content)
+        if not m:
+            return
+
+        filename = m.group(1)
+        alias = m.group(2)
+
+        # Load and tokenize the macro file
+        source = self._load(filename)
+        tokens = _tokenize(source)
+
+        # Collect all macro definitions
+        macros = {}
+        i = 0
+        while i < len(tokens):
+            ttype, raw = tokens[i]
+            if ttype == BLOCK:
+                tag_content, _, _ = _strip_tag(raw)
+                tag = tag_content.split()[0] if tag_content.split() else ""
+                if tag == "macro":
+                    macro_m = _MACRO_RE.match(tag_content)
+                    if macro_m:
+                        macro_name = macro_m.group(1)
+                        parsed_params = self._parse_macro_params(macro_m.group(2))
+
+                        body_tokens = []
+                        i += 1
+                        while i < len(tokens):
+                            if tokens[i][0] == BLOCK and "endmacro" in tokens[i][1]:
+                                i += 1
+                                break
+                            body_tokens.append(tokens[i])
+                            i += 1
+
+                        engine = self
+                        captured_body = list(body_tokens)
+                        captured_params = list(parsed_params)
+                        captured_context = dict(context)
+
+                        def make_fn(_params, _body, _ctx):
+                            def fn(*args):
+                                macro_ctx = dict(_ctx)
+                                for pi, (pname, pdefault) in enumerate(_params):
+                                    if pi < len(args):
+                                        macro_ctx[pname] = args[pi]
+                                    else:
+                                        macro_ctx[pname] = pdefault
+                                return SafeString(engine._render_tokens(list(_body), macro_ctx))
+                            return fn
+
+                        macros[macro_name] = make_fn(captured_params, captured_body, captured_context)
+                        continue
+            i += 1
+
+        # Create a namespace object so alias.macro_name() works
+        namespace = type("MacroNamespace", (), macros)()
+        context[alias] = namespace
+
     def _handle_cache(self, tokens: list, start: int, context: dict) -> tuple[str, int]:
         """Handle {% cache "key" ttl %}...{% endcache %}.