tina4-python 3.11.10__tar.gz → 3.11.12__tar.gz

{tina4_python-3.11.10 → tina4_python-3.11.12}/PKG-INFO

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

{tina4_python-3.11.10 → tina4_python-3.11.12}/tina4_python/__init__.py

@@ -8,7 +8,7 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.11.10"
+__version__ = "3.11.12"
 
 # ── Route decorators ──
 from tina4_python.core.router import (  # noqa: E402, F401

{tina4_python-3.11.10 → tina4_python-3.11.12}/tina4_python/core/server.py

@@ -73,12 +73,20 @@ def _auto_discover(root_dir: str = "src"):
 
 
 def _ensure_folders():
-    """Create project folders if missing (auto-repair)."""
+    """Create project folders if missing (auto-repair).
+
+    Note: ``migrations/`` lives at the project root (matches the CLI's
+    ``migrations`` default and the documented project structure), never
+    under ``src/``. Don't add ``src/migrations`` here — it creates an
+    empty directory that the migration runner ignores and confuses users.
+    """
     folders = [
-        "src/routes", "src/orm", "src/migrations", "src/seeds",
+        "src/routes", "src/orm", "src/seeds",
         "src/templates", "src/templates/errors",
         "src/public", "src/public/js", "src/public/css", "src/public/icons",
-        "src/locales", "data", "data/.broken", "logs", "secrets", "tests",
+        "src/locales",
+        "migrations",
+        "data", "data/.broken", "logs", "secrets", "tests",
     ]
     for folder in folders:
         Path(folder).mkdir(parents=True, exist_ok=True)

{tina4_python-3.11.10 → tina4_python-3.11.12}/tina4_python/database/connection.py

@@ -195,27 +195,67 @@ class Database:
         return _DRIVERS[scheme]()
 
     def _connection_path(self) -> str:
-        """Extract connection-specific path/params from the URL."""
+        """Extract connection-specific path/params from the URL.
+
+        SQLite URL convention (matches PHP and the Python CLAUDE.md docs):
+
+            sqlite::memory:                → in-memory database
+            sqlite:///:memory:             → in-memory database (URL form)
+            sqlite:///app.db               → ./app.db  (relative to cwd)
+            sqlite:///data/app.db          → ./data/app.db  (relative)
+            sqlite:///./data/app.db        → ./data/app.db  (relative, explicit)
+            sqlite:////absolute/path.db    → /absolute/path.db  (absolute)
+            sqlite:///C:/Users/app.db      → C:/Users/app.db  (Windows absolute)
+
+        Directories are auto-created ONLY when the resolved path is
+        inside the current working directory (the project root). We
+        never try to ``os.makedirs`` at root (``/data``, ``C:\\data``)
+        — that's both hostile on read-only filesystems and not what
+        any project actually wants.
+        """
         parsed = urlparse(self.url)
 
-        if parsed.scheme.startswith("sqlite"):
-            # urlparse("sqlite:///path").path = "/path"
-            # Strip the leading / only when it precedes a Windows drive
-            # letter (e.g. /C:/Users/app.db → C:/Users/app.db). On Linux
-            # the leading / is the root directory and must be kept.
-            path = parsed.path
-            if len(path) >= 3 and path[0] == "/" and path[1].isalpha() and path[2] == ":":
-                path = path[1:]  # Windows: /C:/... → C:/...
+        if not parsed.scheme.startswith("sqlite"):
+            # For other drivers, return the full URL (adapter parses it)
+            return self.url
+
+        # In-memory forms — passthrough
+        raw_path = parsed.path
+        if raw_path in (":memory:", "/:memory:"):
+            return ":memory:"
 
-            # Ensure directory exists
+        # Strip exactly one leading "/" — the URL "/"-delimiter between the
+        # empty netloc and the start of the path.
+        if raw_path.startswith("/"):
+            stripped = raw_path[1:]
+        else:
+            stripped = raw_path
+
+        # Windows absolute path (drive-letter form): C:/... or C:\...
+        is_windows_abs = (
+            len(stripped) >= 3
+            and stripped[0].isalpha()
+            and stripped[1] == ":"
+            and stripped[2] in ("/", "\\")
+        )
+        # Unix absolute path: urlparse("sqlite:////abs/app.db").path == "//abs/app.db"
+        # After one strip it's still "/abs/app.db" → still starts with "/".
+        is_unix_abs = stripped.startswith("/")
+
+        if is_windows_abs or is_unix_abs:
+            path = stripped
+            # Don't auto-create directories outside cwd. If the user gave
+            # an absolute path, they're responsible for it existing.
+        else:
+            # Relative — resolve under the project root (cwd).
+            cwd = os.getcwd()
+            path = os.path.join(cwd, stripped)
+            # Only auto-create subdirectories *inside* cwd.
             directory = os.path.dirname(path)
-            if directory:
+            if directory and os.path.commonpath([os.path.abspath(directory), cwd]) == cwd:
                 os.makedirs(directory, exist_ok=True)
 
-            return path
-
-        # For other drivers, return the full URL (adapter parses it)
-        return self.url
+        return path
 
     # ── Query Cache ──────────────────────────────────────────────
 

{tina4_python-3.11.10 → tina4_python-3.11.12}/tina4_python/orm/fields.py

@@ -58,10 +58,41 @@ class Field:
                 raise ValueError(f"Field '{self.name}' is required")
             return self.default
 
-        # Type coercion
+        # Type coercion.
+        #
+        # `validate()` runs on BOTH the write path (user input from routes/forms)
+        # and the read path (rows coming back from the database driver). Drivers
+        # return values in different shapes per engine:
+        #
+        #   engine        datetime column     bool column    numeric column
+        #   --------      ----------------    -----------    --------------
+        #   SQLite        str                 int (0/1)      float / int
+        #   PostgreSQL    datetime            bool           Decimal
+        #   MySQL         datetime            int (0/1)      Decimal
+        #   MSSQL         datetime            bool           Decimal
+        #   Firebird      datetime            int (0/1)      Decimal
+        #
+        # So the rule is: if the driver already handed us the right type,
+        # accept it as-is. Otherwise coerce. This avoids the classic crash
+        # `datetime(datetime_instance)` that hit every PostgreSQL ORM read.
+        #
+        # Care is needed around `bool` being a subclass of `int` in Python —
+        # we handle those two paths explicitly before the generic fast path.
         try:
-            if self.field_type == bool and isinstance(value, int):
+            # BooleanField receiving an int (e.g. SQLite 0/1) → cast to bool
+            if self.field_type is bool and isinstance(value, int) and not isinstance(value, bool):
                 value = bool(value)
+            # IntegerField receiving a bool → cast to int (preserve legacy behaviour
+            # where True/False round-trip as 1/0 in numeric columns)
+            elif self.field_type is int and isinstance(value, bool):
+                value = int(value)
+            # DateTimeField receiving an ISO-8601 string (SQLite default) → parse
+            elif self.field_type is datetime and isinstance(value, str):
+                value = datetime.fromisoformat(value)
+            # Fast path: driver already handed us the correct type. Don't re-coerce —
+            # `datetime(datetime_instance)` etc. raises TypeError otherwise.
+            elif isinstance(value, self.field_type):
+                pass
             else:
                 value = self.field_type(value)
         except (TypeError, ValueError) as e: