fastapi-lite-admin 0.1.0__tar.gz

fastapi_lite_admin-0.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: fastapi-lite-admin
+Version: 0.1.0
+Summary: A lightweight, pluggable admin panel for FastAPI
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: fastapi>=0.100.0
+Requires-Dist: sqlalchemy>=2.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: jinja2>=3.1.0
+Requires-Dist: python-multipart>=0.0.6
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: httpx; extra == "dev"
+Requires-Dist: uvicorn; extra == "dev"
+
+# FastAPI Lite Admin
+
+A premium, lightweight, pluggable admin panel for FastAPI and SQLAlchemy.
+
+## Features
+
+- **Zero-config CRUD**: Automatically generate admin interfaces for your models.
+- **ORM Agnostic**: Initial support for SQLAlchemy, designed to support others.
+- **API First**: All admin actions are available via a REST API.
+- **Lightweight UI**: Simple Jinja2 templates for the dashboard and forms.
+
+## Quick Start
+
+(Documentation coming soon)
+
+## Development
+
+```bash
+# Install dependencies
+pip install -e ".[dev]"
+
+# Run example
+python -m example.main
+```

fastapi_lite_admin-0.1.0/README.md

@@ -0,0 +1,24 @@
+# FastAPI Lite Admin
+
+A premium, lightweight, pluggable admin panel for FastAPI and SQLAlchemy.
+
+## Features
+
+- **Zero-config CRUD**: Automatically generate admin interfaces for your models.
+- **ORM Agnostic**: Initial support for SQLAlchemy, designed to support others.
+- **API First**: All admin actions are available via a REST API.
+- **Lightweight UI**: Simple Jinja2 templates for the dashboard and forms.
+
+## Quick Start
+
+(Documentation coming soon)
+
+## Development
+
+```bash
+# Install dependencies
+pip install -e ".[dev]"
+
+# Run example
+python -m example.main
+```

fastapi_lite_admin-0.1.0/fastapi_admin_lite/__init__.py

@@ -0,0 +1,3 @@
+from .main import Admin
+
+__all__ = ["Admin"]

fastapi_lite_admin-0.1.0/fastapi_admin_lite/core/config.py

@@ -0,0 +1,14 @@
+from typing import List, Optional
+from pydantic import BaseModel, Field
+
+class ModelConfig(BaseModel):
+    name: str
+    display_name: Optional[str] = None
+    fields: List[str] = Field(default_factory=list)
+    readonly_fields: List[str] = Field(default_factory=list)
+    searchable_fields: List[str] = Field(default_factory=list)
+    hidden_fields: List[str] = Field(default_factory=list)
+
+    @property
+    def label(self) -> str:
+        return self.display_name or self.name.capitalize()

fastapi_lite_admin-0.1.0/fastapi_admin_lite/core/crud.py

@@ -0,0 +1,115 @@
+from typing import Any, List, Optional, Type
+from sqlalchemy.orm import Session
+from sqlalchemy import Boolean, Integer, Float
+
+class CRUDEngine:
+    def __init__(self, model: Type[Any]):
+        self.model = model
+
+    def _prepare_data(self, data: dict) -> dict:
+        """
+        Cast string values from form data to correct types based on SQLAlchemy model.
+        """
+        prepared = {}
+        columns = self.model.__table__.columns
+        
+        for key, value in data.items():
+            if key not in columns:
+                continue
+            
+            col = columns[key]
+            
+            if isinstance(col.type, Boolean):
+                if isinstance(value, str):
+                    prepared[key] = value.lower() in ('true', '1', 'yes', 'on')
+                else:
+                    prepared[key] = bool(value)
+            elif isinstance(col.type, Integer):
+                try:
+                    prepared[key] = int(value)
+                except (ValueError, TypeError):
+                    prepared[key] = value
+            elif isinstance(col.type, Float):
+                try:
+                    prepared[key] = float(value)
+                except (ValueError, TypeError):
+                    prepared[key] = value
+            else:
+                prepared[key] = value
+        
+        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()
+
+    def list(
+        self, 
+        db: Session, 
+        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)
+        
+        # Apply Search
+        if search:
+            # TODO: Implement generic search logic
+            pass
+            
+        # Apply Sorting
+        if order_by and hasattr(self.model, order_by):
+            column = getattr(self.model, order_by)
+            if order_dir.lower() == "desc":
+                query = query.order_by(column.desc())
+            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
+
+    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()
+
+    def create(self, db: Session, data: dict) -> Any:
+        prepared_data = self._prepare_data(data)
+        obj = self.model(**prepared_data)
+        db.add(obj)
+        db.commit()
+        db.refresh(obj)
+        return obj
+
+    def update(self, db: Session, id: Any, data: dict) -> Optional[Any]:
+        obj = 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)
+        return obj
+
+    def delete(self, db: Session, id: Any) -> bool:
+        obj = self.get(db, id)
+        if not obj:
+            return False
+        db.delete(obj)
+        db.commit()
+        return True

fastapi_lite_admin-0.1.0/fastapi_admin_lite/core/registry.py

@@ -0,0 +1,39 @@
+from typing import Any, Dict, Type, Callable, Optional
+from dataclasses import dataclass, field
+
+@dataclass
+class ModelRegistration:
+    model: Type[Any]
+    get_db: Callable
+    config: Dict[str, Any] = field(default_factory=dict)
+    name: str = ""
+
+class Registry:
+    def __init__(self):
+        self._models: Dict[str, ModelRegistration] = {}
+
+    def register(
+        self,
+        model: Type[Any],
+        get_db: Callable,
+        config: Optional[Dict[str, Any]] = None
+    ):
+        config = config or {}
+        name = config.get("name") or model.__name__.lower()
+        
+        if name in self._models:
+            raise ValueError(f"Model with name '{name}' already registered.")
+            
+        registration = ModelRegistration(
+            model=model,
+            get_db=get_db,
+            config=config,
+            name=name
+        )
+        self._models[name] = registration
+
+    def get_models(self) -> Dict[str, ModelRegistration]:
+        return self._models
+
+    def get_model(self, name: str) -> Optional[ModelRegistration]:
+        return self._models.get(name)

fastapi_lite_admin-0.1.0/fastapi_admin_lite/core/schema.py

@@ -0,0 +1,27 @@
+from typing import Any, Dict, List
+from .registry import Registry
+from ..integrations.sqlalchemy import introspect_sqlalchemy_model
+
+def generate_admin_schema(registry: Registry) -> Dict[str, Any]:
+    """
+    Generate a JSON schema of all registered models for the UI.
+    """
+    models_info = []
+    for name, reg in registry.get_models().items():
+        introspection = introspect_sqlalchemy_model(reg.model)
+        
+        clean_config = reg.config.copy()
+        if "attention_filter" in clean_config:
+            del clean_config["attention_filter"]
+
+        models_info.append({
+            "name": name,
+            "display_name": reg.config.get("display_name") or name.capitalize(),
+            "fields": introspection["fields"],
+            "list_display": reg.config.get("list_display"),
+            "config": clean_config
+        })
+    
+    return {
+        "models": models_info
+    }

fastapi_lite_admin-0.1.0/fastapi_admin_lite/dependencies/db.py

@@ -0,0 +1,7 @@
+# Common database dependencies
+from typing import Generator
+from sqlalchemy.orm import Session
+
+# This can be used as a default if none is provided, but usually the user provides their own get_db
+def get_db_placeholder() -> Generator[Session, None, None]:
+    yield None

fastapi_lite_admin-0.1.0/fastapi_admin_lite/integrations/sqlalchemy.py

@@ -0,0 +1,22 @@
+from typing import Any, Dict, List, Type
+from sqlalchemy import inspect
+from sqlalchemy.orm import DeclarativeMeta
+
+def introspect_sqlalchemy_model(model: Type[Any]) -> Dict[str, Any]:
+    """
+    Introspect a SQLAlchemy model to extract field information.
+    """
+    mapper = inspect(model)
+    fields = []
+    for column in mapper.columns:
+        fields.append({
+            "name": column.key,
+            "type": str(column.type),
+            "primary_key": column.primary_key,
+            "nullable": column.nullable,
+            "default": str(column.default) if column.default else None,
+            "required": not column.nullable and column.default is None and not column.primary_key
+        })
+    return {
+        "fields": fields
+    }

fastapi_lite_admin-0.1.0/fastapi_admin_lite/main.py

@@ -0,0 +1,103 @@
+from typing import Any, Dict, List, Optional, Type, Callable
+from fastapi import FastAPI, APIRouter, Depends
+from .core.registry import Registry
+from .routers.admin import create_admin_router
+from .ui.views import create_ui_router
+
+class Admin:
+    def __init__(
+        self,
+        title: str = "FastAPI Admin Lite",
+        base_url: str = "/admin",
+        enable_ui: bool = True,
+        dependencies: Optional[List[Any]] = None,
+        auth_dependency: Optional[Callable] = None,
+        permission_checker: Optional[Callable] = None,
+        dashboard_template: Optional[str] = None,
+        dashboard_models: Optional[List[str]] = None,
+        get_logs: Optional[Callable] = None,
+        logs_config: Optional[Dict[str, Any]] = None
+    ):
+        self.title = title
+        self.base_url = base_url
+        self.enable_ui = enable_ui
+        self.dependencies = dependencies or []
+        self.registry = Registry()
+        self.dashboard_template = dashboard_template
+        self.dashboard_models = dashboard_models
+        self.get_logs = get_logs
+        self.logs_config = logs_config or {
+            "columns": ["level", "timestamp", "message"],
+            "title": "System Activity"
+        }
+        
+        # Auth & Permissions
+        self.auth_dependency = auth_dependency
+        self.permission_checker = permission_checker or self.default_permission
+
+        # Print warnings if not configured
+        if not auth_dependency:
+            print("\033[93m[WARNING] FastAPI Admin Lite: No auth_dependency provided. Admin panel is publicly accessible!\033[0m")
+        if not permission_checker:
+            print("\033[93m[WARNING] FastAPI Admin Lite: No permission_checker provided. Using default (allow all).\033[0m")
+
+    async def default_permission(self, user: Any = None) -> bool:
+        """Default permission checker that allows everything."""
+        return True
+
+    def register(
+        self,
+        model: Type[Any],
+        get_db: Callable,
+        list_display: Optional[List[str]] = None,
+        date_field: Optional[str] = None,
+        attention_filter: Optional[Any] = None,
+        readonly_fields: Optional[List[str]] = None,
+        config: Optional[Dict[str, Any]] = None
+    ):
+        """
+        Register a model with the admin panel.
+        """
+        config = config or {}
+        if list_display:
+            # Only include fields that exist in the model
+            valid_columns = {c.key for c in model.__table__.columns}
+            sanitized_display = [f for f in list_display if f in valid_columns]
+            config["list_display"] = sanitized_display
+            
+        if date_field:
+            config["date_field"] = date_field
+            
+        if attention_filter is not None:
+            config["attention_filter"] = attention_filter
+            
+        if readonly_fields:
+            config["readonly_fields"] = readonly_fields
+            
+        self.registry.register(model, get_db, config)
+
+    def mount(self, app: FastAPI):
+        """
+        Mount the admin router to the FastAPI application.
+        """
+        # Collect all dependencies
+        all_deps = list(self.dependencies)
+        if self.auth_dependency:
+            all_deps.append(Depends(self.auth_dependency))
+
+        router = create_admin_router(self)
+        app.include_router(
+            router, 
+            prefix=self.base_url + "/api", 
+            tags=["Admin"],
+            dependencies=all_deps
+        )
+
+        if self.enable_ui:
+            ui_router = create_ui_router(self)
+            app.include_router(
+                ui_router, 
+                prefix=self.base_url, 
+                include_in_schema=False,
+                dependencies=all_deps
+            )

fastapi_lite_admin-0.1.0/fastapi_admin_lite/routers/admin.py

@@ -0,0 +1,75 @@
+from typing import Any, Dict, List
+from fastapi import APIRouter, Depends, HTTPException, Query
+from sqlalchemy.orm import Session
+from ..core.schema import generate_admin_schema
+from ..core.crud import CRUDEngine
+
+def create_admin_router(admin: Any) -> APIRouter:
+    router = APIRouter()
+
+    @router.get("/schema")
+    async def get_schema():
+        return generate_admin_schema(admin.registry)
+
+    @router.get("/models")
+    async def list_models():
+        return list(admin.registry.get_models().keys())
+
+    # Dynamically generate routes for each registered model
+    for name, registration in admin.registry.get_models().items():
+        crud = CRUDEngine(registration.model)
+        get_db_dep = registration.get_db
+        
+        def create_routes(model_name: str, crud_engine: CRUDEngine, db_dep: Any, reg: Any):
+            @router.get(f"/{model_name}", name=f"admin_list_{model_name}")
+            async def list_records(
+                skip: int = 0, 
+                limit: int = 100, 
+                search: str = None, 
+                order_by: str = None,
+                order_dir: str = "asc",
+                db: Session = Depends(db_dep)
+            ):
+                records = 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)
+                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)
+                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)):
+                readonly = reg.config.get("readonly_fields", [])
+                for field in readonly:
+                    if field in data:
+                        del data[field]
+                return 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)):
+                readonly = reg.config.get("readonly_fields", [])
+                for field in readonly:
+                    if field in data:
+                        del data[field]
+                record = 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)
+                if not success:
+                    raise HTTPException(status_code=404, detail="Record not found")
+                return {"success": True}
+
+        create_routes(name, crud, get_db_dep, registration)
+        
+    return router