paginate-fastapi 0.1.0__tar.gz → 1.0.2__tar.gz

{paginate_fastapi-0.1.0 → paginate_fastapi-1.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: paginate-fastapi
-Version: 0.1.0
+Version: 1.0.2
 Summary: A simple and efficient pagination library for FastAPI applications
 License: MIT
 Keywords: fastapi,sqlmodel,pagination,async,filtering,sorting
@@ -67,6 +67,21 @@ pip install paginate-fastapi
 
 ## Quick Start
 
+### Usage as decorator
+```python
+from pagination.decorator import paginate
+
+@router.get("/", response_model=PageResponse[YourModel])
+@paginate(YourModel, lambda: get_db)
+async def get_items(
+    db: AsyncSession = Depends(get_db),
+    pagination: PaginationParams = Depends()
+):
+    ...
+    return { 'extra_data': 'data' }
+```
+
+### Usage as middleware
 ```python
 from fastapi import FastAPI, Depends
 from sqlmodel import SQLModel, Field

{paginate_fastapi-0.1.0 → paginate_fastapi-1.0.2}/README.md

@@ -29,6 +29,21 @@ pip install paginate-fastapi
 
 ## Quick Start
 
+### Usage as decorator
+```python
+from pagination.decorator import paginate
+
+@router.get("/", response_model=PageResponse[YourModel])
+@paginate(YourModel, lambda: get_db)
+async def get_items(
+    db: AsyncSession = Depends(get_db),
+    pagination: PaginationParams = Depends()
+):
+    ...
+    return { 'extra_data': 'data' }
+```
+
+### Usage as middleware
 ```python
 from fastapi import FastAPI, Depends
 from sqlmodel import SQLModel, Field

{paginate_fastapi-0.1.0 → paginate_fastapi-1.0.2}/pagination/__init__.py

@@ -6,9 +6,11 @@ to FastAPI applications using SQLModel.
 
 Example:
     from fastapi import FastAPI, Depends
-    from pagination import PaginationMiddleware, PaginationParams
+    from pagination import PaginationMiddleware, PaginationParams, paginate
 
     app = FastAPI()
+
+    # Using middleware
     paginator = PaginationMiddleware(get_session)
 
     @app.get("/items/")
@@ -17,8 +19,15 @@ Example:
         paginator: PaginationMiddleware = Depends(lambda: paginator),
     ):
         return await paginator.paginate(Item, pagination)
+
+    # Using decorator
+    @app.get("/users/")
+    @paginate(User, get_session)
+    async def get_users():
+        return {"extra": "Additional data can be included"}
 """
 
+from .decorator import paginate
 from .middleware import PaginationMiddleware
 from .models import FilterOperator, PageResponse, PaginationParams, SortOrder
 
@@ -28,4 +37,5 @@ __all__ = [
     "PaginationMiddleware",
     "PaginationParams",
     "SortOrder",
+    "paginate",
 ]

paginate_fastapi-1.0.2/pagination/decorator.py

@@ -0,0 +1,117 @@
+"""
+Pagination utilities.
+"""
+
+from collections.abc import Callable
+
+from fastapi import Depends
+from sqlalchemy import func
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlmodel import SQLModel, select
+
+from pagination.models import PageResponse, PaginationParams
+
+
+def paginate(model: type[SQLModel], db_dependency: Callable):
+    """
+    Decorator for FastAPI endpoints to add pagination support.
+
+    Usage:
+    @router.get("/", response_model=PageResponse[YourModel])
+    @paginate(YourModel, lambda: get_db)
+    async def get_items(
+        db: AsyncSession = Depends(get_db),
+        pagination: PaginationParams = Depends()
+    ):
+        pass  # The decorator handles everything
+    """
+
+    def decorator(function: Callable) -> Callable:
+        def _apply_filter(query, field, operator: str, value):
+            """Apply filter operation to query."""
+            filter_ops = {
+                "eq": lambda: field == value,
+                "neq": lambda: field != value,
+                "gt": lambda: field > value,
+                "lt": lambda: field < value,
+                "gte": lambda: field >= value,
+                "lte": lambda: field <= value,
+                "in": lambda: field.in_(value),
+                "not_in": lambda: field.not_in(value),
+                "contains": lambda: field.contains(value),
+            }
+            if op_func := filter_ops.get(operator):
+                return query.where(op_func())
+            return query
+
+        async def wrapper(
+            db: AsyncSession = Depends(db_dependency),  # noqa: B008
+            pagination: PaginationParams = Depends(),  # noqa: B008
+        ) -> PageResponse:
+            # Build the base query
+            query = select(model)
+
+            # Apply filtering if specified
+            if all(
+                [
+                    pagination.filter_field,
+                    pagination.filter_operator,
+                    pagination.filter_value,
+                ]
+            ):
+                if field := getattr(model, pagination.filter_field, None):
+                    query = _apply_filter(
+                        query, field, pagination.filter_operator, pagination.filter_value
+                    )
+
+            # Apply sorting if specified
+            if pagination.sort_by:
+                field = getattr(model, pagination.sort_by, None)
+                if field is not None:
+                    query = query.order_by(
+                        field.desc() if pagination.sort_order == "desc" else field
+                    )
+
+            # Execute count query
+            count_query = select(func.count()).select_from(query.subquery())
+            total = await db.scalar(count_query) or 0
+
+            # Calculate pages
+            pages = (total + pagination.page_size - 1) // pagination.page_size
+
+            # Apply pagination
+            offset = (pagination.page - 1) * pagination.page_size
+            query = query.offset(offset).limit(pagination.page_size)
+
+            # Execute main query
+            result = await db.execute(query)
+            items = result.scalars().all()
+
+            # Calculate pagination flags
+            has_next = pagination.page < pages
+            has_previous = pagination.page > 1
+
+            # Create base pagination response
+            pagination_response = {
+                "items": items,
+                "total": total,
+                "page": pagination.page,
+                "pages": pages,
+                "page_size": pagination.page_size,
+                "has_next": has_next,
+                "has_previous": has_previous,
+            }
+
+            # Execute the original function to get any custom data
+            custom_data = await function(db=db, pagination=pagination)
+            print(custom_data)
+            if isinstance(custom_data, dict):
+                # Merge custom data with pagination data
+                pagination_response.update(custom_data)
+            print(pagination_response)
+
+            return pagination_response
+
+        return wrapper
+
+    return decorator

{paginate_fastapi-0.1.0 → paginate_fastapi-1.0.2}/pagination/middleware.py

@@ -102,8 +102,6 @@ class PaginationMiddleware:
             FilterOperator.LT: lambda f, v: f < v,
             FilterOperator.GTE: lambda f, v: f >= v,
             FilterOperator.LTE: lambda f, v: f <= v,
-            FilterOperator.LIKE: lambda f, v: f.like(f"%{v}%"),
-            FilterOperator.ILIKE: lambda f, v: f.ilike(f"%{v}%"),
             FilterOperator.IN: lambda f, v: f.in_(v),
             FilterOperator.NOT_IN: lambda f, v: ~f.in_(v),
         }

{paginate_fastapi-0.1.0 → paginate_fastapi-1.0.2}/pagination/models.py

@@ -39,8 +39,6 @@ class FilterOperator(str, Enum):
         LT: Less than (<)
         GTE: Greater than or equal (>=)
         LTE: Less than or equal (<=)
-        LIKE: SQL LIKE pattern matching
-        ILIKE: Case-insensitive LIKE pattern matching
         IN: Value in list
         NOT_IN: Value not in list
     """
@@ -51,8 +49,6 @@ class FilterOperator(str, Enum):
     LT = "lt"  # less than
     GTE = "gte"  # greater than or equal
     LTE = "lte"  # less than or equal
-    LIKE = "like"  # LIKE operator
-    ILIKE = "ilike"  # ILIKE operator
     IN = "in"  # IN operator
     NOT_IN = "not_in"  # NOT IN operator
 
@@ -74,13 +70,13 @@ class PaginationParams(BaseModel):
         filter_value: Value to filter by
     """
 
-    page: int = Field(default=1, gt=0)
-    page_size: int = Field(default=10, gt=0)
-    sort_by: str | None = None
-    sort_order: SortOrder = SortOrder.ASC
-    filter_field: str | None = None
-    filter_operator: FilterOperator | None = None
-    filter_value: Any | None = None
+    page: int = Field(default=1, gt=0, description="Page number")
+    page_size: int = Field(default=10, gt=0, le=100, description="Items per page")
+    sort_by: str | None = Field(default=None, description="Field to sort by")
+    sort_order: SortOrder = Field(default=SortOrder.ASC, description="Sort direction (asc/desc)")
+    filter_field: str | None = Field(default=None, description="Field to filter on")
+    filter_operator: FilterOperator | None = Field(default=None, description="Filter operator")
+    filter_value: Any | None = Field(default=None, description="Filter value")
 
     model_config = ConfigDict(from_attributes=True)
 

{paginate_fastapi-0.1.0 → paginate_fastapi-1.0.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "paginate-fastapi"
-version = "0.1.0"
+version = "1.0.2"
 description = "A simple and efficient pagination library for FastAPI applications"
 authors = [
     {name = "Ritvik Dayal", email = "ritvikr1605@gmail.com"}