tina4-python 3.6.0__tar.gz → 3.7.1__tar.gz

{tina4_python-3.6.0 → tina4_python-3.7.1}/PKG-INFO

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

{tina4_python-3.6.0 → tina4_python-3.7.1}/pyproject.toml

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

{tina4_python-3.6.0 → tina4_python-3.7.1}/tina4_python/core/server.py

@@ -136,13 +136,45 @@ def _render_error_page(status_code: int, path: str, request_id: str, error_messa
     return None
 
 
-def _has_index_template() -> bool:
-    """Check if the user has an index template in src/templates/."""
+_template_cache: dict[str, str] | None = None
+
+
+def _resolve_template(path: str) -> str | None:
+    """Resolve a URL path to a template file in src/templates/.
+    Dev mode: checks filesystem every time for live changes.
+    Production: uses a cached lookup built once at startup.
+    """
+    clean_path = path.strip("/") or "index"
+    is_dev = os.environ.get("TINA4_DEBUG", "false").lower() in ("true", "1", "yes")
+
+    if is_dev:
+        template_dir = Path("src/templates")
+        for ext in (".twig", ".html"):
+            candidate = clean_path + ext
+            if (template_dir / candidate).is_file():
+                return candidate
+        return None
+
+    global _template_cache
+    if _template_cache is None:
+        _build_template_cache()
+    return _template_cache.get(clean_path)
+
+
+def _build_template_cache() -> None:
+    """Scan src/templates/ once and build url_path -> template_file lookup."""
+    global _template_cache
+    _template_cache = {}
     template_dir = Path("src/templates")
-    for name in ("index.html", "index.twig", "index.php", "index.erb"):
-        if (template_dir / name).is_file():
-            return True
-    return False
+    if not template_dir.is_dir():
+        return
+    for f in template_dir.rglob("*"):
+        if not f.is_file() or f.suffix not in (".twig", ".html"):
+            continue
+        rel = str(f.relative_to(template_dir)).replace("\\", "/")
+        url_path = rel.rsplit(".", 1)[0]
+        if url_path not in _template_cache:
+            _template_cache[url_path] = rel
 
 
 def _is_gallery_deployed(name: str) -> bool:
@@ -779,19 +811,26 @@ async def app(scope: dict, receive, send):
         static = _try_static(request.path)
         if static:
             response = static
-        elif request.path == "/" and not _has_index_template():
-            # No "/" route registered and no index template — show default landing page
-            response.html(_render_landing_page())
         else:
-            html = _render_error_page(404, request.path, request_id)
-            if html:
-                response.status(404).html(html)
+            # 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, {})
+                response.html(html)
+            elif request.path == "/":
+                response.html(_render_landing_page())
             else:
-                response.status(404).json({
-                    "error": "Not Found",
-                    "path": request.path,
-                    "status": 404,
-                })
+                html = _render_error_page(404, request.path, request_id)
+                if html:
+                    response.status(404).html(html)
+                else:
+                    response.status(404).json({
+                        "error": "Not Found",
+                        "path": request.path,
+                        "status": 404,
+                    })
 
     # Apply CORS headers to all responses
     _cors.apply(request, response)

{tina4_python-3.6.0 → tina4_python-3.7.1}/tina4_python/migration/runner.py

@@ -8,11 +8,14 @@ Both naming patterns are supported. New migrations use timestamp format by defau
 Each file is executed once. State tracked in tina4_migration table.
 Rollback uses matching .down.sql files.
 """
+import logging
 import os
 import re
 from pathlib import Path
 from datetime import datetime, timezone
 
+logger = logging.getLogger(__name__)
+
 
 def _ensure_tracking_table(db):
     """Create the migration tracking table if it doesn't exist."""
@@ -94,6 +97,64 @@ def _split_statements(sql: str, delimiter: str = ";") -> list[str]:
     return statements
 
 
+def _is_firebird(db) -> bool:
+    """Check if the database connection is Firebird."""
+    try:
+        return db.get_database_type() == "firebird"
+    except (AttributeError, Exception):
+        return False
+
+
+# Regex to match ALTER TABLE <table> ADD <column> ...
+# Captures the table name and column name from the SQL statement.
+_ALTER_ADD_RE = re.compile(
+    r"^\s*ALTER\s+TABLE\s+"
+    r"(?:\"([^\"]+)\"|(\S+))"       # table name (quoted or unquoted)
+    r"\s+ADD\s+"
+    r"(?:\"([^\"]+)\"|(\S+))",       # column name (quoted or unquoted)
+    re.IGNORECASE,
+)
+
+
+def _firebird_column_exists(db, table: str, column: str) -> bool:
+    """Check if a column already exists in a Firebird table via RDB$RELATION_FIELDS.
+
+    Firebird does not support IF NOT EXISTS for ALTER TABLE ADD, so we query
+    the system catalogue directly. Column and table names are compared in
+    upper-case because Firebird stores unquoted identifiers that way.
+    """
+    row = db.fetch_one(
+        "SELECT 1 FROM RDB$RELATION_FIELDS "
+        "WHERE RDB$RELATION_NAME = ? AND TRIM(RDB$FIELD_NAME) = ?",
+        [table.upper(), column.upper()],
+    )
+    return row is not None
+
+
+def _should_skip_for_firebird(db, stmt: str) -> str | None:
+    """If stmt is an ALTER TABLE ... ADD on Firebird and the column already exists, return a skip reason.
+
+    Returns None if the statement should be executed normally.
+    This makes ALTER TABLE ADD idempotent on Firebird, which lacks IF NOT EXISTS
+    for column additions. Only genuine duplicates are skipped — other errors
+    (bad syntax, wrong data type, etc.) will still raise normally on execute().
+    """
+    if not _is_firebird(db):
+        return None
+
+    m = _ALTER_ADD_RE.match(stmt)
+    if not m:
+        return None
+
+    table = m.group(1) or m.group(2)
+    column = m.group(3) or m.group(4)
+
+    if _firebird_column_exists(db, table, column):
+        return f"Column {column} already exists in {table}, skipping"
+
+    return None
+
+
 def migrate(db, migration_folder: str = "migrations", delimiter: str = ";") -> list[str]:
     """Run all pending migrations.
 
@@ -127,6 +188,13 @@ def migrate(db, migration_folder: str = "migrations", delimiter: str = ";") -> l
         try:
             db.start_transaction()
             for stmt in statements:
+                # Firebird lacks IF NOT EXISTS for ALTER TABLE ADD.
+                # Pre-check the system catalogue so duplicate columns are
+                # silently skipped instead of raising an error.
+                skip_reason = _should_skip_for_firebird(db, stmt)
+                if skip_reason:
+                    logger.info(f"Migration {sql_file.name}: {skip_reason}")
+                    continue
                 db.execute(stmt)
 
             # Record as passed

{tina4_python-3.6.0 → tina4_python-3.7.1}/tina4_python/queue/__init__.py

@@ -483,7 +483,7 @@ class Queue:
 
         if job_id is not None:
             # Consume a specific job by ID
-            job = self._pop_by_id(topic, job_id)
+            job = self.pop_by_id(topic, job_id)
             if job is not None:
                 yield job
             return
@@ -495,7 +495,7 @@ class Queue:
                 break
             yield job
 
-    def _pop_by_id(self, topic: str, job_id: str) -> Job | None:
+    def pop_by_id(self, topic: str, job_id: str) -> Job | None:
         """Pop a specific job by ID from the queue."""
         if hasattr(self._backend, '_db'):
             # SQLite backend — query by ID