fastapi-lite-admin 0.1.0__tar.gz → 0.1.1__tar.gz

fastapi_lite_admin-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Rishav Sharma
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

{fastapi_lite_admin-0.1.0 → fastapi_lite_admin-0.1.1}/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: fastapi-lite-admin
-Version: 0.1.0
+Version: 0.1.1
 Summary: A lightweight, pluggable admin panel for FastAPI
 License: MIT
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: fastapi>=0.100.0
 Requires-Dist: sqlalchemy>=2.0.0
 Requires-Dist: pydantic>=2.0.0
@@ -14,6 +15,7 @@ Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: httpx; extra == "dev"
 Requires-Dist: uvicorn; extra == "dev"
+Dynamic: license-file
 
 # FastAPI Lite Admin
 
@@ -39,3 +41,4 @@ pip install -e ".[dev]"
 # Run example
 python -m example.main
 ```
+pypi-AgEIcHlwaS5vcmcCJGFkOTJiMmI0LTZhYjEtNGFhMi04MWNiLWY2ZjYwZTQwODMyYwACKlszLCJmMzAxYzgyMC0wMjIxLTQ1YTEtOTJhYi03N2MyMTAzNjg3NWYiXQAABiC_AwPMy7ot3kaVFMV3sTtEyKa_TJeZLX2tuOY9uwCBRg

{fastapi_lite_admin-0.1.0 → fastapi_lite_admin-0.1.1}/README.md

@@ -21,4 +21,5 @@ pip install -e ".[dev]"
 
 # Run example
 python -m example.main
-```
+```
+pypi-AgEIcHlwaS5vcmcCJGFkOTJiMmI0LTZhYjEtNGFhMi04MWNiLWY2ZjYwZTQwODMyYwACKlszLCJmMzAxYzgyMC0wMjIxLTQ1YTEtOTJhYi03N2MyMTAzNjg3NWYiXQAABiC_AwPMy7ot3kaVFMV3sTtEyKa_TJeZLX2tuOY9uwCBRg

{fastapi_lite_admin-0.1.0 → fastapi_lite_admin-0.1.1}/fastapi_admin_lite/core/crud.py

@@ -1,6 +1,7 @@
 from typing import Any, List, Optional, Type
-from sqlalchemy.orm import Session
-from sqlalchemy import Boolean, Integer, Float
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy import select, func, Boolean, Integer, Float
+
 
 class CRUDEngine:
     def __init__(self, model: Type[Any]):
@@ -39,26 +40,33 @@ class CRUDEngine:
         
         return prepared
 
-    def count(self, db: Session, search: Optional[str] = None) -> int:
-        query = db.query(self.model)
-        # TODO: Implement search filtering in count
-        return query.count()
+    async def count(self, db: AsyncSession, search: Optional[str] = None) -> int:
+        query = select(func.count()).select_from(self.model)
+        if search:
+            for column in self.model.__table__.columns:
+                if hasattr(column.type, "python_type") and column.type.python_type == str:
+                    query = query.filter(column.contains(search))
+                    break
+        result = await db.execute(query)
+        return result.scalar()
 
-    def list(
+    async def list(
         self, 
-        db: Session, 
+        db: AsyncSession, 
         skip: int = 0, 
         limit: int = 100, 
         search: Optional[str] = None,
         order_by: Optional[str] = None,
         order_dir: str = "asc"
     ) -> List[Any]:
-        query = db.query(self.model)
+        query = select(self.model).offset(skip).limit(limit)
         
         # Apply Search
         if search:
-            # TODO: Implement generic search logic
-            pass
+            for column in self.model.__table__.columns:
+                if hasattr(column.type, "python_type") and column.type.python_type == str:
+                    query = query.filter(column.contains(search))
+                    break
             
         # Apply Sorting
         if order_by and hasattr(self.model, order_by):
@@ -68,48 +76,36 @@ class CRUDEngine:
             else:
                 query = query.order_by(column.asc())
         
-        return query.offset(skip).limit(limit).all()
-
-    def _cast_id(self, id: Any) -> Any:
-        """
-        Cast ID to the correct type based on the model's primary key.
-        """
-        col = self.model.__table__.primary_key.columns[0]
-        if isinstance(col.type, Integer):
-            try:
-                return int(id)
-            except (ValueError, TypeError):
-                return id
-        return id
+        result = await db.execute(query)
+        return result.scalars().all()
 
-    def get(self, db: Session, id: Any) -> Optional[Any]:
-        casted_id = self._cast_id(id)
-        return db.query(self.model).filter(self.model.id == casted_id).first()
+    async def get(self, db: AsyncSession, id: Any) -> Optional[Any]:
+        return await db.get(self.model, id)
 
-    def create(self, db: Session, data: dict) -> Any:
+    async def create(self, db: AsyncSession, data: dict) -> Any:
         prepared_data = self._prepare_data(data)
         obj = self.model(**prepared_data)
         db.add(obj)
-        db.commit()
-        db.refresh(obj)
+        await db.commit()
+        await db.refresh(obj)
         return obj
 
-    def update(self, db: Session, id: Any, data: dict) -> Optional[Any]:
-        obj = self.get(db, id)
+    async def update(self, db: AsyncSession, id: Any, data: dict) -> Optional[Any]:
+        obj = await self.get(db, id)
         if not obj:
             return None
         
         prepared_data = self._prepare_data(data)
         for key, value in prepared_data.items():
             setattr(obj, key, value)
-        db.commit()
-        db.refresh(obj)
+        await db.commit()
+        await db.refresh(obj)
         return obj
 
-    def delete(self, db: Session, id: Any) -> bool:
-        obj = self.get(db, id)
+    async def delete(self, db: AsyncSession, id: Any) -> bool:
+        obj = await self.get(db, id)
         if not obj:
             return False
-        db.delete(obj)
-        db.commit()
+        await db.delete(obj)
+        await db.commit()
         return True

{fastapi_lite_admin-0.1.0 → fastapi_lite_admin-0.1.1}/fastapi_admin_lite/routers/admin.py

@@ -1,6 +1,6 @@
 from typing import Any, Dict, List
 from fastapi import APIRouter, Depends, HTTPException, Query
-from sqlalchemy.orm import Session
+from sqlalchemy.ext.asyncio import AsyncSession
 from ..core.schema import generate_admin_schema
 from ..core.crud import CRUDEngine
 
@@ -28,44 +28,46 @@ def create_admin_router(admin: Any) -> APIRouter:
                 search: str = None, 
                 order_by: str = None,
                 order_dir: str = "asc",
-                db: Session = Depends(db_dep)
+                db: AsyncSession = Depends(db_dep)
             ):
-                records = crud_engine.list(
+                records = await crud_engine.list(
                     db, skip=skip, limit=limit, search=search, 
                     order_by=order_by, order_dir=order_dir
                 )
-                total = crud_engine.count(db, search=search)
+                total = await crud_engine.count(db, search=search)
                 return {"data": records, "total": total}
 
             @router.get(f"/{model_name}/{{id}}", name=f"admin_get_{model_name}")
-            async def get_record(id: Any, db: Session = Depends(db_dep)):
-                record = crud_engine.get(db, id)
+            async def get_record(id: Any, db: AsyncSession = Depends(db_dep)):
+                record = await crud_engine.get(db, id)
                 if not record:
                     raise HTTPException(status_code=404, detail="Record not found")
                 return record
 
             @router.post(f"/{model_name}", name=f"admin_create_{model_name}")
-            async def create_record(data: Dict[str, Any], db: Session = Depends(db_dep)):
+            async def create_record(data: Dict[str, Any], db: AsyncSession = Depends(db_dep)):
+                # Remove readonly fields from incoming data
                 readonly = reg.config.get("readonly_fields", [])
                 for field in readonly:
                     if field in data:
                         del data[field]
-                return crud_engine.create(db, data)
+                return await crud_engine.create(db, data)
 
             @router.put(f"/{model_name}/{{id}}", name=f"admin_update_{model_name}")
-            async def update_record(id: Any, data: Dict[str, Any], db: Session = Depends(db_dep)):
+            async def update_record(id: Any, data: Dict[str, Any], db: AsyncSession = Depends(db_dep)):
+                # Remove readonly fields from incoming data
                 readonly = reg.config.get("readonly_fields", [])
                 for field in readonly:
                     if field in data:
                         del data[field]
-                record = crud_engine.update(db, id, data)
+                record = await crud_engine.update(db, id, data)
                 if not record:
                     raise HTTPException(status_code=404, detail="Record not found")
                 return record
 
             @router.delete(f"/{model_name}/{{id}}", name=f"admin_delete_{model_name}")
-            async def delete_record(id: Any, db: Session = Depends(db_dep)):
-                success = crud_engine.delete(db, id)
+            async def delete_record(id: Any, db: AsyncSession = Depends(db_dep)):
+                success = await crud_engine.delete(db, id)
                 if not success:
                     raise HTTPException(status_code=404, detail="Record not found")
                 return {"success": True}

{fastapi_lite_admin-0.1.0 → fastapi_lite_admin-0.1.1}/fastapi_admin_lite/ui/views.py

@@ -14,31 +14,38 @@ def create_ui_router(admin: Any) -> APIRouter:
     @router.get("/", response_class=HTMLResponse)
     async def dashboard(request: Request):
         from datetime import datetime, timedelta
+        from sqlalchemy import select, func
         models = admin.registry.get_models()
-        model_names = list(models.keys())
         
         # Collect real counts for each model
         stats = []
         for name, reg in models.items():
-            # Skip if user has specified a subset of models for the dashboard
             if admin.dashboard_models and name not in admin.dashboard_models:
                 continue
                 
             db_gen = reg.get_db()
-            db = next(db_gen)
+            # Handle both async and sync generators for maximum compatibility
+            if hasattr(db_gen, "__anext__"):
+                db = await db_gen.__anext__()
+            else:
+                db = next(db_gen)
+
             try:
                 # 1. Get Total Count
-                total_count = db.query(reg.model).count()
+                total_query = select(func.count()).select_from(reg.model)
+                total_result = await db.execute(total_query)
+                total_count = total_result.scalar()
                 
-                # 2. Get 24h Count if date_field is set
+                # 2. Get 24h Count
                 recent_count = None
                 date_field = reg.config.get("date_field")
-                
                 if date_field and hasattr(reg.model, date_field):
                     yesterday = datetime.now() - timedelta(hours=24)
-                    recent_count = db.query(reg.model).filter(
+                    recent_query = select(func.count()).select_from(reg.model).filter(
                         getattr(reg.model, date_field) >= yesterday
-                    ).count()
+                    )
+                    recent_result = await db.execute(recent_query)
+                    recent_count = recent_result.scalar()
 
                 stats.append({
                     "name": reg.config.get("display_name") or name.capitalize(),
@@ -48,68 +55,68 @@ def create_ui_router(admin: Any) -> APIRouter:
                     "has_date_field": bool(date_field)
                 })
             finally:
-                # Handle generators properly
-                try:
-                    next(db_gen)
-                except StopIteration:
-                    pass
-                    
-        # Fetch Logs
-        logs = []
+                if hasattr(db_gen, "aclose"):
+                    await db_gen.aclose()
+                elif hasattr(db_gen, "close"):
+                    db_gen.close()
+
+        # Handle logs
+        recent_logs = []
         if admin.get_logs:
             try:
-                logs = admin.get_logs()
+                if asyncio.iscoroutinefunction(admin.get_logs):
+                    recent_logs = await admin.get_logs()
+                else:
+                    recent_logs = admin.get_logs()
             except Exception as e:
                 print(f"Error fetching logs: {e}")
 
         return templates.TemplateResponse(
             request=request, 
-            name=admin.dashboard_template or "dashboard.html", 
-            context={
-                "models": model_names, 
-                "stats": stats,
-                "admin_title": admin.title,
-                "logs": logs,
-                "logs_config": admin.logs_config
-            }
+            name="dashboard.html", 
+            context={"stats": stats, "recent_logs": recent_logs, "models": list(models.keys())}
         )
 
     @router.get("/{model_name}", response_class=HTMLResponse)
     async def model_list(request: Request, model_name: str):
         from datetime import datetime, timedelta
+        from sqlalchemy import select, func
         reg = admin.registry.get_model(model_name)
         if not reg:
             raise HTTPException(status_code=404, detail="Model not found")
             
         models = list(admin.registry.get_models().keys())
         
-        # Calculate 24h stats for this specific model
+        # Calculate stats for this specific model
         recent_count = None
+        attention_count = None
         date_field = reg.config.get("date_field")
+        attn_filter = reg.config.get("attention_filter")
         
-        if date_field and hasattr(reg.model, date_field):
-            db_gen = reg.get_db()
+        db_gen = reg.get_db()
+        if hasattr(db_gen, "__anext__"):
+            db = await db_gen.__anext__()
+        else:
             db = next(db_gen)
-            try:
+
+        try:
+            if date_field and hasattr(reg.model, date_field):
                 yesterday = datetime.now() - timedelta(hours=24)
-                recent_count = db.query(reg.model).filter(
+                recent_query = select(func.count()).select_from(reg.model).filter(
                     getattr(reg.model, date_field) >= yesterday
-                ).count()
-            finally:
-                try: next(db_gen)
-                except StopIteration: pass
-        
-        # Calculate Attention count
-        attention_count = None
-        attn_filter = reg.config.get("attention_filter")
-        if attn_filter is not None:
-            db_gen = reg.get_db()
-            db = next(db_gen)
-            try:
-                attention_count = db.query(reg.model).filter(attn_filter).count()
-            finally:
-                try: next(db_gen)
-                except StopIteration: pass
+                )
+                recent_result = await db.execute(recent_query)
+                recent_count = recent_result.scalar()
+            
+            if attn_filter is not None:
+                attn_query = select(func.count()).select_from(reg.model).filter(attn_filter)
+                attn_result = await db.execute(attn_query)
+                attention_count = attn_result.scalar()
+        finally:
+            if hasattr(db_gen, "aclose"):
+                await db_gen.aclose()
+            elif hasattr(db_gen, "close"):
+                db_gen.close()
 
         return templates.TemplateResponse(
             request=request, 

{fastapi_lite_admin-0.1.0 → fastapi_lite_admin-0.1.1}/fastapi_lite_admin.egg-info/PKG-INFO

@@ -1,10 +1,11 @@
 Metadata-Version: 2.4
 Name: fastapi-lite-admin
-Version: 0.1.0
+Version: 0.1.1
 Summary: A lightweight, pluggable admin panel for FastAPI
 License: MIT
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
+License-File: LICENSE
 Requires-Dist: fastapi>=0.100.0
 Requires-Dist: sqlalchemy>=2.0.0
 Requires-Dist: pydantic>=2.0.0
@@ -14,6 +15,7 @@ Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: httpx; extra == "dev"
 Requires-Dist: uvicorn; extra == "dev"
+Dynamic: license-file
 
 # FastAPI Lite Admin
 
@@ -39,3 +41,4 @@ pip install -e ".[dev]"
 # Run example
 python -m example.main
 ```
+pypi-AgEIcHlwaS5vcmcCJGFkOTJiMmI0LTZhYjEtNGFhMi04MWNiLWY2ZjYwZTQwODMyYwACKlszLCJmMzAxYzgyMC0wMjIxLTQ1YTEtOTJhYi03N2MyMTAzNjg3NWYiXQAABiC_AwPMy7ot3kaVFMV3sTtEyKa_TJeZLX2tuOY9uwCBRg

{fastapi_lite_admin-0.1.0 → fastapi_lite_admin-0.1.1}/fastapi_lite_admin.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+LICENSE
 README.md
 pyproject.toml
 fastapi_admin_lite/__init__.py

{fastapi_lite_admin-0.1.0 → fastapi_lite_admin-0.1.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fastapi-lite-admin"
-version = "0.1.0"
+version = "0.1.1"
 description = "A lightweight, pluggable admin panel for FastAPI"
 readme = "README.md"
 requires-python = ">=3.9"