tina4-python 3.10.54__tar.gz → 3.10.55__tar.gz

{tina4_python-3.10.54 → tina4_python-3.10.55}/PKG-INFO

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

{tina4_python-3.10.54 → tina4_python-3.10.55}/tina4_python/__init__.py

@@ -8,13 +8,13 @@ Tina4 Python v3.0 — Zero-dependency, lightweight web framework.
 
 One import, everything works.
 """
-__version__ = "3.10.54"
+__version__ = "3.10.55"
 
 # ── Route decorators ──
 from tina4_python.core.router import (  # noqa: E402, F401
     get, post, put, patch, delete, any_method,
     noauth, secured, cached, middleware, template,
-    Router,
+    Router, RouteGroup,
 )
 
 # ── HTTP Constants ──

{tina4_python-3.10.54 → tina4_python-3.10.55}/tina4_python/core/router.py

@@ -57,6 +57,51 @@ class RouteRef:
         return self
 
 
+class RouteGroup:
+    """A group of routes sharing a common prefix and middleware.
+
+    Passed to the callback in Router.group(). Supports nesting.
+
+    Usage::
+
+        Router.group("/api", lambda group: [
+            group.get("/users", list_handler),
+            group.post("/users", create_handler),
+            group.group("/admin", lambda admin: [
+                admin.get("/stats", stats_handler),
+            ], middleware=[admin_check]),
+        ], middleware=[auth_check])
+    """
+
+    def __init__(self, router_cls, prefix: str, middleware: list = None):
+        self._router = router_cls
+        self._prefix = prefix
+        self._middleware = middleware or []
+
+    def get(self, path: str, handler, **options) -> RouteRef:
+        return self._router.add("GET", self._prefix + path, handler, middleware=self._middleware, **options)
+
+    def post(self, path: str, handler, **options) -> RouteRef:
+        return self._router.add("POST", self._prefix + path, handler, middleware=self._middleware, **options)
+
+    def put(self, path: str, handler, **options) -> RouteRef:
+        return self._router.add("PUT", self._prefix + path, handler, middleware=self._middleware, **options)
+
+    def patch(self, path: str, handler, **options) -> RouteRef:
+        return self._router.add("PATCH", self._prefix + path, handler, middleware=self._middleware, **options)
+
+    def delete(self, path: str, handler, **options) -> RouteRef:
+        return self._router.add("DELETE", self._prefix + path, handler, middleware=self._middleware, **options)
+
+    def any(self, path: str, handler, **options) -> RouteRef:
+        return self._router.add("ANY", self._prefix + path, handler, middleware=self._middleware, **options)
+
+    def group(self, prefix: str, callback, middleware=None):
+        merged = list(self._middleware) + (middleware or [])
+        nested = RouteGroup(self._router, self._prefix + prefix.rstrip("/"), merged)
+        callback(nested)
+
+
 class Router:
     """Route registry and matcher."""
 
@@ -68,14 +113,17 @@ class Router:
     def group(cls, prefix: str, callback, middleware=None):
         """Register routes with a shared prefix and optional middleware.
 
-        Saves/restores static prefix and middleware state around the
-        callback so that nested groups concatenate correctly.
+        The callback receives a RouteGroup object with get/post/put/patch/
+        delete/any/group methods for registering routes under the prefix.
 
         Usage::
 
-            Router.group("/api", lambda: [
-                Router.get("/users", handler),
-                Router.post("/users", handler),
+            Router.group("/api", lambda group: [
+                group.get("/users", list_handler),
+                group.post("/users", create_handler),
+                group.group("/admin", lambda admin: [
+                    admin.get("/stats", stats_handler),
+                ], middleware=[admin_check]),
             ], middleware=[auth_check])
         """
         prev_prefix = cls._group_prefix
@@ -85,7 +133,8 @@ class Router:
         cls._group_middleware = prev_middleware + (middleware or [])
 
         try:
-            callback()
+            group = RouteGroup(cls, cls._group_prefix, list(cls._group_middleware))
+            callback(group)
         finally:
             cls._group_prefix = prev_prefix
             cls._group_middleware = prev_middleware

{tina4_python-3.10.54 → tina4_python-3.10.55}/tina4_python/crud/__init__.py

@@ -15,7 +15,7 @@ Discovers ORM models and registers CRUD routes automatically.
 
 Generated endpoints per model:
 
-    GET    /api/{table_name}       — list with pagination (limit, skip)
+    GET    /api/{table_name}       — list with pagination (limit, offset; also accepts page, per_page)
     GET    /api/{table_name}/{id}  — get single record by primary key
     POST   /api/{table_name}       — create new record
     PUT    /api/{table_name}/{id}  — update record by primary key
@@ -94,18 +94,37 @@ class AutoCrud:
         # ── GET /api/{table} — list with pagination ──────────────
         async def list_handler(request, response, _cls=model_class):
             try:
-                limit = int(request.params.get("limit", 10))
-                skip = int(request.params.get("skip", 0))
+                # Primary names: limit / offset
+                # Compat names: per_page / page (PHP/Ruby/Node style)
+                limit = int(request.params.get("limit", request.params.get("per_page", 10)))
+                offset = int(request.params.get("offset", 0))
+                # page/per_page compat: if page is provided, derive offset from it
+                if "page" in request.params and "offset" not in request.params:
+                    page = int(request.params.get("page", 1))
+                    per_page = int(request.params.get("per_page", limit))
+                    offset = (page - 1) * per_page
+                    limit = per_page
+                else:
+                    page = (offset // limit) + 1 if limit else 1
             except (ValueError, TypeError):
                 limit = 10
-                skip = 0
+                offset = 0
+                page = 1
 
-            records, total = _cls.all(limit=limit, skip=skip)
+            records, total = _cls.all(limit=limit, skip=offset)
+            total_pages = max(1, -(-total // limit)) if limit else 1
+            data = [r.to_dict() for r in records]
             return response({
-                "data": [r.to_dict() for r in records],
-                "total": total,
+                "records": data,       # standard name
+                "data": data,          # backwards compat
+                "count": total,        # standard name
+                "total": total,        # backwards compat
                 "limit": limit,
-                "skip": skip,
+                "offset": offset,
+                "page": page,
+                "per_page": limit,     # backwards compat
+                "totalPages": total_pages,   # camelCase standard
+                "total_pages": total_pages,  # backwards compat
             })
 
         list_handler.__name__ = f"autocrud_list_{table}"

{tina4_python-3.10.54 → tina4_python-3.10.55}/tina4_python/database/adapter.py

@@ -33,16 +33,19 @@ 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
+        offset = (page - 1) * per_page
+        data = self.records[offset:offset + per_page]
         return {
-            "data": self.records[start:end],
-            "total": self.count,
+            "records": data,        # standard name
+            "data": data,           # backwards compat (PHP/Ruby/Node)
+            "count": self.count,    # standard name
+            "total": self.count,    # backwards compat
+            "limit": per_page,      # standard name
+            "offset": offset,       # standard name
             "page": page,
-            "per_page": per_page,
-            "total_pages": total_pages,
-            "has_next": page < total_pages,
-            "has_prev": page > 1,
+            "per_page": per_page,   # backwards compat
+            "totalPages": total_pages,   # camelCase standard
+            "total_pages": total_pages,  # backwards compat
         }
 
     def column_info(self) -> list[dict]:

{tina4_python-3.10.54 → tina4_python-3.10.55}/tina4_python/database/connection.py

@@ -123,6 +123,14 @@ register_driver("sqlserver", MSSQLAdapter)
 from tina4_python.database.firebird import FirebirdAdapter
 register_driver("firebird", FirebirdAdapter)
 
+# Register MongoDB (pymongo — optional)
+try:
+    from tina4_python.database.mongodb import MongoDBAdapter
+    register_driver("mongodb", MongoDBAdapter)
+    register_driver("pymongo", MongoDBAdapter)
+except ImportError:
+    pass
+
 
 class Database:
     """Database connection manager.