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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tina4-python
-Version: 3.5.0
+Version: 3.6.0
 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.6.0}/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.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "tina4-python"
-version = "3.5.0"
+version = "3.6.0"
 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.6.0}/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.6.0}/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.6.0}/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.6.0}/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.6.0}/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.6.0}/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.6.0}/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.6.0}/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.6.0}/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.6.0}/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.6.0}/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.6.0}/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.6.0}/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.6.0}/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.6.0}/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.6.0}/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)

{tina4_python-3.5.0 → tina4_python-3.6.0}/tina4_python/orm/fields.py

@@ -232,7 +232,7 @@ class HasManyDescriptor(RelationshipDescriptor):
         table = related_cls._get_table()
         db = obj._get_db()
         sql = f"SELECT * FROM {table} WHERE {fk} = ?"
-        result = db.fetch(sql, [pk_value], limit=1000, skip=0)
+        result = db.fetch(sql, [pk_value], limit=1000, offset=0)
         return [related_cls(row) for row in result.records]
 
 

{tina4_python-3.5.0 → tina4_python-3.6.0}/tina4_python/orm/model.py

@@ -297,7 +297,7 @@ class ORM(metaclass=ORMMeta):
         return result
 
     @classmethod
-    def all(cls, limit: int = 100, skip: int = 0, include: list[str] = None):
+    def all(cls, limit: int = 100, offset: int = 0, include: list[str] = None):
         """Fetch all records (respects soft delete).
 
         Args:
@@ -310,14 +310,14 @@ class ORM(metaclass=ORMMeta):
         if cls.soft_delete:
             sql += " WHERE deleted_at IS NULL"
 
-        result = db.fetch(sql, limit=limit, skip=skip)
+        result = db.fetch(sql, limit=limit, offset=offset)
         instances = [cls(row) for row in result.records]
         if include:
             cls._eager_load(instances, include)
         return instances, result.count
 
     @classmethod
-    def select(cls, sql: str, params: list = None, limit: int = 20, skip: int = 0,
+    def select(cls, sql: str, params: list = None, limit: int = 20, offset: int = 0,
                include: list[str] = None):
         """SQL-first query — you write the SQL, ORM maps results.
 
@@ -325,14 +325,14 @@ class ORM(metaclass=ORMMeta):
             include: List of relationship names to eager-load.
         """
         db = cls._get_db()
-        result = db.fetch(sql, params, limit=limit, skip=skip)
+        result = db.fetch(sql, params, limit=limit, offset=offset)
         instances = [cls(row) for row in result.records]
         if include:
             cls._eager_load(instances, include)
         return instances, result.count
 
     @classmethod
-    def where(cls, filter_sql: str, params: list = None, limit: int = 20, skip: int = 0,
+    def where(cls, filter_sql: str, params: list = None, limit: int = 20, offset: int = 0,
               include: list[str] = None):
         """Query with WHERE clause shorthand.
 
@@ -346,19 +346,19 @@ class ORM(metaclass=ORMMeta):
         if cls.soft_delete:
             sql = f"SELECT * FROM {table} WHERE ({filter_sql}) AND deleted_at IS NULL"
 
-        result = db.fetch(sql, params, limit=limit, skip=skip)
+        result = db.fetch(sql, params, limit=limit, offset=offset)
         instances = [cls(row) for row in result.records]
         if include:
             cls._eager_load(instances, include)
         return instances, result.count
 
     @classmethod
-    def with_trashed(cls, filter_sql: str = "1=1", params: list = None, limit: int = 20, skip: int = 0):
+    def with_trashed(cls, filter_sql: str = "1=1", params: list = None, limit: int = 20, offset: int = 0):
         """Query including soft-deleted records."""
         db = cls._get_db()
         table = cls._get_table()
         sql = f"SELECT * FROM {table} WHERE {filter_sql}"
-        result = db.fetch(sql, params, limit=limit, skip=skip)
+        result = db.fetch(sql, params, limit=limit, offset=offset)
         return [cls(row) for row in result.records], result.count
 
     @classmethod
@@ -473,18 +473,18 @@ class ORM(metaclass=ORMMeta):
 
     @classmethod
     def cached(cls, sql: str, params: list = None, ttl: int = 60,
-               limit: int = 20, skip: int = 0):
+               limit: int = 20, offset: int = 0):
         """SQL query with result caching.
 
         Usage:
             users, count = User.cached("SELECT * FROM users WHERE active = ?", [1], ttl=120)
         """
-        cache_key = f"{cls.__name__}:{Cache.query_key(sql, params)}:{limit}:{skip}"
+        cache_key = f"{cls.__name__}:{Cache.query_key(sql, params)}:{limit}:{offset}"
         cached = _query_cache.get(cache_key)
         if cached is not None:
             return cached
 
-        result = cls.select(sql, params, limit=limit, skip=skip)
+        result = cls.select(sql, params, limit=limit, offset=offset)
         _query_cache.set(cache_key, result, ttl=ttl, tags=[cls.__name__])
         return result
 
@@ -506,7 +506,7 @@ class ORM(metaclass=ORMMeta):
         row = self._get_db().fetch_one(sql, [pk_value])
         return related_class(row) if row else None
 
-    def has_many(self, related_class, foreign_key: str = None, limit: int = 100, skip: int = 0):
+    def has_many(self, related_class, foreign_key: str = None, limit: int = 100, offset: int = 0):
         """Load multiple related records (imperative style)."""
         pk = self._get_pk()
         pk_value = getattr(self, pk)
@@ -514,7 +514,7 @@ class ORM(metaclass=ORMMeta):
         table = related_class._get_table()
 
         sql = f"SELECT * FROM {table} WHERE {fk} = ?"
-        result = self._get_db().fetch(sql, [pk_value], limit=limit, skip=skip)
+        result = self._get_db().fetch(sql, [pk_value], limit=limit, offset=offset)
         return [related_class(row) for row in result.records]
 
     def belongs_to(self, related_class, foreign_key: str = None):
@@ -570,7 +570,7 @@ class ORM(metaclass=ORMMeta):
                 table = related_cls._get_table()
                 placeholders = ",".join("?" for _ in pk_values)
                 sql = f"SELECT * FROM {table} WHERE {fk} IN ({placeholders})"
-                result = db.fetch(sql, pk_values, limit=len(pk_values) * 1000, skip=0)
+                result = db.fetch(sql, pk_values, limit=len(pk_values) * 1000, offset=0)
                 related_records = [related_cls(row) for row in result.records]
 
                 # Eager load nested relationships on related records
@@ -607,7 +607,7 @@ class ORM(metaclass=ORMMeta):
                 placeholders = ",".join("?" for _ in fk_values)
                 pk_col = related_cls.field_mapping.get(related_pk, related_cls._fields[related_pk].column)
                 sql = f"SELECT * FROM {table} WHERE {pk_col} IN ({placeholders})"
-                result = db.fetch(sql, fk_values, limit=len(fk_values) * 10, skip=0)
+                result = db.fetch(sql, fk_values, limit=len(fk_values) * 10, offset=0)
                 related_records = [related_cls(row) for row in result.records]
 
                 if nested:
@@ -627,8 +627,8 @@ class ORM(metaclass=ORMMeta):
             User.scope("active", "active = ?", [1])
             users, count = User.active()
         """
-        def scope_method(limit: int = 20, skip: int = 0):
-            return cls.where(filter_sql, params, limit=limit, skip=skip)
+        def scope_method(limit: int = 20, offset: int = 0):
+            return cls.where(filter_sql, params, limit=limit, offset=offset)
 
         setattr(cls, name, staticmethod(scope_method))