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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.5.0
+Version: 3.7.1
 Summary: Tina4 Python v3 — Zero-dependency, lightweight web framework
 Author-email: Andre van Zuydam <andrevanzuydam@gmail.com>
 License: MIT
@@ -412,7 +412,7 @@ db = Database("firebird://SYSDBA:masterkey@localhost:3050//path/to/db")
 db = Database("mongodb://localhost:27017/mydb")
 db = Database("odbc://DSN=mydsn")
 
-result = db.fetch("SELECT * FROM users WHERE age > ?", [18], limit=20, skip=0)
+result = db.fetch("SELECT * FROM users WHERE age > ?", [18], limit=20, offset=0)
 row = db.fetch_one("SELECT * FROM users WHERE id = ?", [1])
 db.insert("users", {"name": "Alice", "email": "alice@test.com"})
 db.commit()
@@ -440,8 +440,8 @@ async def protected(request, response):
 from tina4_python.auth import Auth
 
 auth = Auth(secret="your-secret")
-token = auth.create_token({"user_id": 42})
-payload = auth.validate_token(token)
+token = auth.get_token({"user_id": 42})
+payload = auth.valid_token(token)
 ```
 
 POST/PUT/PATCH/DELETE routes require `Authorization: Bearer <token>` by default. Use `@noauth()` to make public, `@secured()` to protect GET routes.
@@ -699,7 +699,7 @@ SECRET=your-jwt-secret
 DATABASE_URL=sqlite:///data/app.db
 TINA4_DEBUG=true                     # Enable dev toolbar, error overlay
 TINA4_LOG_LEVEL=ALL                  # ALL, DEBUG, INFO, WARNING, ERROR
-TINA4_LANGUAGE=en                    # en, fr, af, zh, ja, es
+TINA4_LOCALE=en                      # en, fr, af, zh, ja, es
 TINA4_SESSION_HANDLER=SessionFileHandler
 SWAGGER_TITLE=My API
 ```

{tina4_python-3.5.0 → tina4_python-3.7.1}/README.md

@@ -380,7 +380,7 @@ db = Database("firebird://SYSDBA:masterkey@localhost:3050//path/to/db")
 db = Database("mongodb://localhost:27017/mydb")
 db = Database("odbc://DSN=mydsn")
 
-result = db.fetch("SELECT * FROM users WHERE age > ?", [18], limit=20, skip=0)
+result = db.fetch("SELECT * FROM users WHERE age > ?", [18], limit=20, offset=0)
 row = db.fetch_one("SELECT * FROM users WHERE id = ?", [1])
 db.insert("users", {"name": "Alice", "email": "alice@test.com"})
 db.commit()
@@ -408,8 +408,8 @@ async def protected(request, response):
 from tina4_python.auth import Auth
 
 auth = Auth(secret="your-secret")
-token = auth.create_token({"user_id": 42})
-payload = auth.validate_token(token)
+token = auth.get_token({"user_id": 42})
+payload = auth.valid_token(token)
 ```
 
 POST/PUT/PATCH/DELETE routes require `Authorization: Bearer <token>` by default. Use `@noauth()` to make public, `@secured()` to protect GET routes.
@@ -667,7 +667,7 @@ SECRET=your-jwt-secret
 DATABASE_URL=sqlite:///data/app.db
 TINA4_DEBUG=true                     # Enable dev toolbar, error overlay
 TINA4_LOG_LEVEL=ALL                  # ALL, DEBUG, INFO, WARNING, ERROR
-TINA4_LANGUAGE=en                    # en, fr, af, zh, ja, es
+TINA4_LOCALE=en                      # en, fr, af, zh, ja, es
 TINA4_SESSION_HANDLER=SessionFileHandler
 SWAGGER_TITLE=My API
 ```

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

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.5.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.5.0 → tina4_python-3.7.1}/tina4_python/CLAUDE.md

@@ -221,7 +221,7 @@ Tina4 provides a full toolkit. Before writing custom code, check if the framewor
 |------|--------------------------------|
 | Background jobs / async work | `Queue` from `tina4_python.queue` (use `queue.push()`, `queue.consume()`) |
 | HTTP calls to external APIs | `Api` from `tina4_python.api` |
-| JWT tokens & auth | `Auth` from `tina4_python.auth` (create_token, validate_token, get_payload) |
+| JWT tokens & auth | `Auth` from `tina4_python.auth` (get_token, valid_token, get_payload) |
 | Password hashing | `Auth.hash_password()` / `Auth.check_password()` from `tina4_python.auth` |
 | Session management | `Session` from `tina4_python.session` |
 | Database queries & CRUD | `Database` from `tina4_python.database` |
@@ -480,7 +480,7 @@ Response.add_header("X-Custom", "value")
 
 ## Sessions
 
-TINA4_TOKEN_LIMIT is used to set the session time, recommend 15-30 minutes
+TINA4_TOKEN_EXPIRES_IN is used to set the session time, recommend 15-60 minutes
 
 ### Session Backends
 
@@ -775,7 +775,7 @@ row = db.fetch_one("SELECT * FROM users WHERE id = ?", [1])
 # Result methods
 result.to_json()       # JSON string
 result.to_array()      # List of dicts
-result.to_paginate()   # Dict with records, count, limit, skip
+result.to_paginate()   # Dict with records, count, limit, offset
 result.to_csv()        # CSV string
 
 # Transactions
@@ -1185,7 +1185,7 @@ Tina4 v3 supports translations via JSON files in `src/locales/`.
 
 Set the language in `.env`:
 ```bash
-TINA4_LANGUAGE=en           # Default locale
+TINA4_LOCALE=en             # Default locale
 TINA4_LOCALE_DIR=src/locales  # Directory for translation files
 ```
 
@@ -1516,8 +1516,7 @@ Key `.env` settings:
 # Authentication
 SECRET=your-jwt-secret            # JWT signing (default uses insecure placeholder)
 API_KEY=your-api-key              # Static bearer token for API auth
-TINA4_TOKEN_LIMIT=2               # Token lifetime in minutes (default: 2)
-TINA4_TOKEN_EXPIRES_IN=2          # Alternative token expiry setting
+TINA4_TOKEN_EXPIRES_IN=60         # Token lifetime in minutes (default: 60)
 
 # Database
 DATABASE_URL=sqlite:///app.db     # Connection URL (driver://host:port/database)
@@ -1527,7 +1526,7 @@ DATABASE_PASSWORD=                 # DB password
 # Framework
 TINA4_DEBUG=true                  # Enable dev mode (toolbar, live reload, error overlay)
 TINA4_LOG_LEVEL=ALL               # Log verbosity: ALL, DEBUG, INFO, WARNING, ERROR
-TINA4_LANGUAGE=en                 # Language for framework messages (en, fr, af, zh, ja, es)
+TINA4_LOCALE=en                   # Language for framework messages (en, fr, af, zh, ja, es)
 TINA4_DEFAULT_WEBSERVER=FALSE     # Set to TRUE to use Tina4's built-in webserver instead of ASGI
 HOST_NAME=localhost:7145
 

{tina4_python-3.5.0 → tina4_python-3.7.1}/tina4_python/__init__.py

@@ -8,7 +8,7 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.5.0"
+__version__ = "3.6.0"
 
 # ── HTTP Constants ──
 from tina4_python.core.constants import (  # noqa: E402, F401

{tina4_python-3.5.0 → tina4_python-3.7.1}/tina4_python/auth/__init__.py

@@ -10,8 +10,8 @@ No PyJWT, no cryptography package.
     payload = auth.valid_token(token)
 
     # Legacy aliases also work:
-    token = auth.create_token({"user_id": 1, "role": "admin"})
-    payload = auth.validate_token(token)
+    token = auth.get_token({"user_id": 1, "role": "admin"})
+    payload = auth.valid_token(token)
 
     hashed = Auth.hash_password("secret123")
     Auth.check_password(hashed, "secret123")  # True
@@ -29,27 +29,38 @@ class Auth:
     """JWT authentication and password hashing — zero dependencies."""
 
     def __init__(self, secret: str = None, algorithm: str = "HS256",
-                 token_expiry: int = None):
+                 expires_in: int = None):
+        """
+        Args:
+            secret:     Signing secret (falls back to SECRET env var).
+            algorithm:  JWT algorithm (default HS256).
+            expires_in: Token lifetime in seconds (default 3600).
+        """
         self.secret = secret or os.environ.get("SECRET", "tina4-default-secret")
         self.algorithm = algorithm
-        self.token_expiry = token_expiry or int(
-            os.environ.get("TINA4_TOKEN_LIMIT", "30")
+        self.expires_in = expires_in or int(
+            os.environ.get("TINA4_TOKEN_EXPIRES_IN", "60")
         )
 
     # ── JWT ────────────────────────────────────────────────────────
 
-    def get_token(self, payload: dict, expiry_minutes: int = None) -> str:
+    def get_token(self, payload: dict, expires_in: int = None) -> str:
         """Create a signed JWT token.
 
+        Args:
+            expires_in: Lifetime in minutes (default: self.expires_in).
+
         Returns: header.payload.signature
         """
-        exp = expiry_minutes if expiry_minutes is not None else self.token_expiry
+        exp_minutes = expires_in if expires_in is not None else self.expires_in
+        exp_seconds = exp_minutes * 60
+
         header = {"alg": self.algorithm, "typ": "JWT"}
 
         claims = dict(payload)
         claims["iat"] = int(time.time())
-        if exp > 0:
-            claims["exp"] = claims["iat"] + (exp * 60)
+        if exp_seconds > 0:
+            claims["exp"] = claims["iat"] + exp_seconds
 
         h = _b64url_encode(json.dumps(header).encode())
         p = _b64url_encode(json.dumps(claims, default=str).encode())
@@ -88,14 +99,18 @@ class Auth:
         except Exception:
             return None
 
-    def refresh_token(self, token: str, expiry_minutes: int = None) -> str | None:
-        """Validate and issue a fresh token with the same claims."""
+    def refresh_token(self, token: str, expires_in: int = None) -> str | None:
+        """Validate and issue a fresh token with the same claims.
+
+        Args:
+            expires_in: Lifetime in minutes (default: self.expires_in).
+        """
         payload = self.valid_token(token)
         if payload is None:
             return None
         payload.pop("iat", None)
         payload.pop("exp", None)
-        return self.get_token(payload, expiry_minutes)
+        return self.get_token(payload, expires_in=expires_in)
 
     def _sign(self, message: str) -> str:
         sig = hmac.new(
@@ -105,8 +120,37 @@ class Auth:
 
     # ── Legacy aliases ─────────────────────────────────────────────
 
-    create_token = get_token
-    validate_token = valid_token
+    # get_token and valid_token are the primary names
+
+    # ── Class-level convenience methods (read SECRET from env) ────
+
+    @classmethod
+    def get_token_static(cls, payload: dict, expires_in: int = 60) -> str:
+        """Create a JWT without instantiating Auth — reads SECRET from env."""
+        secret = os.environ.get("SECRET", "tina4-default-secret")
+        auth = cls(secret=secret, expires_in=expires_in)
+        return auth.get_token(payload)
+
+    @classmethod
+    def valid_token_static(cls, token: str) -> dict | None:
+        """Validate a JWT without instantiating Auth — reads SECRET from env."""
+        secret = os.environ.get("SECRET", "tina4-default-secret")
+        auth = cls(secret=secret)
+        return auth.valid_token(token)
+
+    @classmethod
+    def get_payload_static(cls, token: str) -> dict | None:
+        """Decode payload (no validation) without instantiating Auth."""
+        secret = os.environ.get("SECRET", "tina4-default-secret")
+        auth = cls(secret=secret)
+        return auth.get_payload(token)
+
+    @classmethod
+    def refresh_token_static(cls, token: str, expires_in: int = 60) -> str | None:
+        """Refresh a JWT without instantiating Auth — reads SECRET from env."""
+        secret = os.environ.get("SECRET", "tina4-default-secret")
+        auth = cls(secret=secret, expires_in=expires_in)
+        return auth.refresh_token(token)
 
     # ── Password Hashing ──────────────────────────────────────────
 
@@ -189,4 +233,26 @@ def _b64url_decode(s: str) -> bytes:
     return base64.urlsafe_b64decode(s)
 
 
-__all__ = ["Auth"]
+# ── Module-level convenience functions (use static methods) ────
+
+def get_token(payload: dict, expires_in: int = 60) -> str:
+    """Create a JWT — reads SECRET from env. Shortcut for Auth.get_token_static()."""
+    return Auth.get_token_static(payload, expires_in=expires_in)
+
+
+def valid_token(token: str) -> dict | None:
+    """Validate a JWT — reads SECRET from env. Shortcut for Auth.valid_token_static()."""
+    return Auth.valid_token_static(token)
+
+
+def get_payload(token: str) -> dict | None:
+    """Decode JWT payload (no validation). Shortcut for Auth.get_payload_static()."""
+    return Auth.get_payload_static(token)
+
+
+def refresh_token(token: str, expires_in: int = 60) -> str | None:
+    """Refresh a JWT — reads SECRET from env. Shortcut for Auth.refresh_token_static()."""
+    return Auth.refresh_token_static(token, expires_in=expires_in)
+
+
+__all__ = ["Auth", "get_token", "valid_token", "get_payload", "refresh_token"]

{tina4_python-3.5.0 → tina4_python-3.7.1}/tina4_python/core/request.py

@@ -75,6 +75,7 @@ class Request:
         return self.params.get(key, self._route_params.get(key, default))
 
 
+
 def _extract_ip(scope: dict, headers: dict) -> str:
     """Extract client IP, respecting X-Forwarded-For."""
     forwarded = headers.get("x-forwarded-for", "")

{tina4_python-3.5.0 → tina4_python-3.7.1}/tina4_python/core/response.py

@@ -191,6 +191,10 @@ class Response:
 
         return self.html(f"<pre>Template not found: {template}</pre>", 404)
 
+    def template(self, template: str, data: dict = None) -> "Response":
+        """Alias for render() — parity with PHP/Node.js naming."""
+        return self.render(template, data)
+
     def build_headers(self, accept_encoding: str = "") -> list[tuple[bytes, bytes]]:
         """Build final ASGI headers with compression and ETag."""
         # Compress if applicable

{tina4_python-3.5.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.5.0 → tina4_python-3.7.1}/tina4_python/database/adapter.py

@@ -285,7 +285,7 @@ class DatabaseAdapter:
         )
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 20, skip: int = 0) -> DatabaseResult:
+              limit: int = 20, offset: int = 0) -> DatabaseResult:
         """Execute a read query and return multiple rows."""
         raise NotImplementedError
 

{tina4_python-3.5.0 → tina4_python-3.7.1}/tina4_python/database/connection.py

@@ -182,20 +182,21 @@ class Database:
         return self._adapter.execute_many(sql, params_list)
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 20, skip: int = 0) -> DatabaseResult:
+              limit: int = 20, offset: int = 0) -> DatabaseResult:
+        """Fetch rows with pagination."""
         if self._cache_enabled:
-            key = self._cache_key(sql + f":L{limit}:S{skip}", params)
+            key = self._cache_key(sql + f":L{limit}:S{offset}", params)
             cached = self._cache_get(key)
             if cached is not None:
                 with self._cache_lock:
                     self._cache_hits += 1
                 return cached
-            result = self._adapter.fetch(sql, params, limit, skip)
+            result = self._adapter.fetch(sql, params, limit, offset)
             self._cache_set(key, result)
             with self._cache_lock:
                 self._cache_misses += 1
             return result
-        return self._adapter.fetch(sql, params, limit, skip)
+        return self._adapter.fetch(sql, params, limit, offset)
 
     def fetch_one(self, sql: str, params: list = None) -> dict | None:
         if self._cache_enabled:

{tina4_python-3.5.0 → tina4_python-3.7.1}/tina4_python/database/firebird.py

@@ -114,7 +114,7 @@ class FirebirdAdapter(DatabaseAdapter):
         )
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 20, skip: int = 0) -> DatabaseResult:
+              limit: int = 20, offset: int = 0) -> DatabaseResult:
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor()
 
@@ -127,8 +127,8 @@ class FirebirdAdapter(DatabaseAdapter):
             total = 0
 
         # Apply Firebird pagination — ROWS start TO end
-        start = skip + 1
-        end = skip + limit
+        start = offset + 1
+        end = offset + limit
         paginated_sql = f"{sql} ROWS {start} TO {end}"
         cursor.execute(paginated_sql, params or [])
 

{tina4_python-3.5.0 → tina4_python-3.7.1}/tina4_python/database/mssql.py

@@ -102,7 +102,7 @@ class MSSQLAdapter(DatabaseAdapter):
         )
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 20, skip: int = 0) -> DatabaseResult:
+              limit: int = 20, offset: int = 0) -> DatabaseResult:
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor(as_dict=True)
 
@@ -121,7 +121,7 @@ class MSSQLAdapter(DatabaseAdapter):
         else:
             paginated_sql = f"{sql} OFFSET %s ROWS FETCH NEXT %s ROWS ONLY"
 
-        paginated_params = tuple(params or []) + (skip, limit)
+        paginated_params = tuple(params or []) + (offset, limit)
         cursor.execute(paginated_sql, paginated_params)
         rows = [dict(row) for row in cursor.fetchall()]
 

{tina4_python-3.5.0 → tina4_python-3.7.1}/tina4_python/database/mysql.py

@@ -91,7 +91,7 @@ class MySQLAdapter(DatabaseAdapter):
         )
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 20, skip: int = 0) -> DatabaseResult:
+              limit: int = 20, offset: int = 0) -> DatabaseResult:
         sql = self._translate_sql(sql)
         cursor = self._conn.cursor(dictionary=True)
 
@@ -105,7 +105,7 @@ class MySQLAdapter(DatabaseAdapter):
 
         # Apply pagination
         paginated_sql = f"{sql} LIMIT %s OFFSET %s"
-        paginated_params = (params or []) + [limit, skip]
+        paginated_params = (params or []) + [limit, offset]
         cursor.execute(paginated_sql, paginated_params)
         rows = [dict(row) for row in cursor.fetchall()]
 

{tina4_python-3.5.0 → tina4_python-3.7.1}/tina4_python/database/odbc.py

@@ -74,7 +74,7 @@ class ODBCAdapter(DatabaseAdapter):
         )
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 20, skip: int = 0) -> DatabaseResult:
+              limit: int = 20, offset: int = 0) -> DatabaseResult:
         # Count total
         count_sql = f"SELECT COUNT(*) FROM ({sql}) AS _t"
         cursor = self._conn.cursor()
@@ -86,14 +86,14 @@ class ODBCAdapter(DatabaseAdapter):
 
         # Apply pagination — use OFFSET/FETCH for ODBC (SQL Server style)
         paginated_sql = f"{sql} OFFSET ? ROWS FETCH NEXT ? ROWS ONLY"
-        paginated_params = (params or []) + [skip, limit]
+        paginated_params = (params or []) + [offset, limit]
 
         try:
             cursor.execute(paginated_sql, paginated_params)
         except Exception:
             # Fallback: try LIMIT/OFFSET for non-SQL Server ODBC sources
             paginated_sql = f"{sql} LIMIT ? OFFSET ?"
-            paginated_params = (params or []) + [limit, skip]
+            paginated_params = (params or []) + [limit, offset]
             cursor.execute(paginated_sql, paginated_params)
 
         columns = [desc[0] for desc in cursor.description] if cursor.description else []

{tina4_python-3.5.0 → tina4_python-3.7.1}/tina4_python/database/postgres.py

@@ -100,7 +100,7 @@ class PostgreSQLAdapter(DatabaseAdapter):
         )
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 20, skip: int = 0) -> DatabaseResult:
+              limit: int = 20, offset: int = 0) -> DatabaseResult:
         import psycopg2.extras
 
         sql = self._translate_sql(sql)
@@ -117,7 +117,7 @@ class PostgreSQLAdapter(DatabaseAdapter):
 
         # Apply pagination
         paginated_sql = f"{sql} LIMIT %s OFFSET %s"
-        paginated_params = (params or []) + [limit, skip]
+        paginated_params = (params or []) + [limit, offset]
         cursor.execute(paginated_sql, paginated_params)
         rows = [dict(row) for row in cursor.fetchall()]
 

{tina4_python-3.5.0 → tina4_python-3.7.1}/tina4_python/database/sqlite.py

@@ -93,7 +93,7 @@ class SQLiteAdapter(DatabaseAdapter):
         )
 
     def fetch(self, sql: str, params: list = None,
-              limit: int = 20, skip: int = 0) -> DatabaseResult:
+              limit: int = 20, offset: int = 0) -> DatabaseResult:
         # Count total rows (without LIMIT/OFFSET)
         count_sql = f"SELECT COUNT(*) as cnt FROM ({sql})"
         try:
@@ -103,7 +103,7 @@ class SQLiteAdapter(DatabaseAdapter):
 
         # Apply pagination
         paginated_sql = f"{sql} LIMIT ? OFFSET ?"
-        paginated_params = (params or []) + [limit, skip]
+        paginated_params = (params or []) + [limit, offset]
         cursor = self._conn.execute(paginated_sql, paginated_params)
         rows = [dict(row) for row in cursor.fetchall()]
 

{tina4_python-3.5.0 → tina4_python-3.7.1}/tina4_python/frond/engine.py

@@ -599,9 +599,9 @@ def _form_token(descriptor: str = "") -> str:
             payload["context"] = descriptor
 
     secret = os.environ.get("SECRET", "tina4-default-secret")
-    ttl = int(os.environ.get("TINA4_TOKEN_LIMIT", "30"))
-    auth = _FrondAuth(secret=secret, token_expiry=ttl)
-    token = auth.create_token(payload)
+    ttl = int(os.environ.get("TINA4_TOKEN_EXPIRES_IN", "60"))
+    auth = _FrondAuth(secret=secret, expires_in=ttl)
+    token = auth.get_token(payload)
     return SafeString(f'<input type="hidden" name="formToken" value="{token}">')
 
 

{tina4_python-3.5.0 → tina4_python-3.7.1}/tina4_python/gallery/auth/src/routes/api/gallery_auth.py

@@ -49,9 +49,9 @@ async def gallery_auth_page(request, response):
         <div class="card-body">
             <h6 style="color:#e2e8f0;">How it works</h6>
             <pre style="background:#0f172a;color:#4ade80;padding:1rem;border-radius:0.5rem;font-size:0.8rem;"><code>auth = Auth()
-token = auth.create_token({"username": "admin"})
+token = auth.get_token({"username": "admin"})
 payload = auth.get_payload(token)
-is_valid = auth.validate_token(token)</code></pre>
+is_valid = auth.valid_token(token)</code></pre>
         </div>
     </div>
 </div>
@@ -107,7 +107,7 @@ async def gallery_login(request, response):
     password = body.get("password", "")
     if username and password:
         auth = Auth()
-        token = auth.create_token({"username": username, "role": "user"})
+        token = auth.get_token({"username": username, "role": "user"})
         return response({"token": token, "message": f"Welcome {username}!"})
     return response({"error": "Username and password required"}, 401)
 
@@ -117,5 +117,5 @@ async def gallery_login(request, response):
 async def gallery_verify(request, response):
     token = request.params.get("token", "")
     auth = Auth()
-    is_valid = auth.validate_token(token)
+    is_valid = auth.valid_token(token)
     return response({"valid": is_valid})

{tina4_python-3.5.0 → tina4_python-3.7.1}/tina4_python/i18n/__init__.py

@@ -24,7 +24,9 @@ class I18n:
         self._locale_dir = Path(
             locale_dir or os.environ.get("TINA4_LOCALE_DIR", "src/locales")
         )
-        self._default_locale = default_locale or os.environ.get("TINA4_LANGUAGE", "en")
+        self._default_locale = default_locale or os.environ.get(
+            "TINA4_LOCALE", "en"
+        )
         self._current_locale = self._default_locale
         self._translations: dict[str, dict] = {}
         self._load_locale(self._default_locale)