fastapi-lite-admin 0.1.0__py3-none-any.whl

fastapi_admin_lite/__init__.py

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

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_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_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_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_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_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_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_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

fastapi_admin_lite/ui/templates/dashboard.html

@@ -0,0 +1,236 @@
+{% extends "layout.html" %}
+
+{% set active_nav = 'dashboard' %}
+
+{% block extra_css %}
+    .stats-grid {
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(240px, 1fr));
+        gap: 24px;
+        margin-bottom: 32px;
+    }
+
+    .stat-card {
+        padding: 24px;
+        position: relative;
+    }
+
+    .stat-card .icon {
+        position: absolute;
+        right: 24px;
+        top: 24px;
+        font-size: 1.5rem;
+        color: var(--primary);
+        opacity: 0.8;
+    }
+
+    .stat-card .label {
+        font-size: 0.8rem;
+        font-weight: 700;
+        text-transform: uppercase;
+        color: var(--text-muted);
+        letter-spacing: 0.05em;
+        margin-bottom: 8px;
+    }
+
+    .stat-card .value {
+        font-size: 2rem;
+        font-weight: 700;
+        margin-bottom: 8px;
+    }
+
+    .stat-card .trend {
+        font-size: 0.85rem;
+        font-weight: 500;
+    }
+
+    .trend.up { color: var(--success); }
+    .trend.down { color: var(--error); }
+    .trend.neutral { color: var(--text-muted); }
+
+    /* Recent Logs Table */
+    .section-header {
+        display: flex;
+        justify-content: space-between;
+        align-items: center;
+        margin-bottom: 16px;
+    }
+
+    .section-title {
+        font-size: 1.25rem;
+        font-weight: 700;
+    }
+
+    .view-all {
+        font-size: 0.85rem;
+        color: var(--primary);
+        text-decoration: none;
+        font-weight: 600;
+    }
+
+    .data-table {
+        width: 100%;
+        border-collapse: collapse;
+    }
+
+    .data-table th {
+        text-align: left;
+        padding: 12px 16px;
+        font-size: 0.75rem;
+        font-weight: 700;
+        text-transform: uppercase;
+        color: var(--text-muted);
+        border-bottom: 1px solid var(--border);
+    }
+
+    .data-table td {
+        padding: 16px;
+        font-size: 0.9rem;
+        border-bottom: 1px solid var(--border);
+    }
+
+    .badge {
+        padding: 4px 8px;
+        border-radius: 4px;
+        font-size: 0.7rem;
+        font-weight: 700;
+        text-transform: uppercase;
+    }
+
+    .badge-info { background-color: #e0f2fe; color: #0369a1; }
+    .badge-warn { background-color: #fef3c7; color: #b45309; }
+    .badge-error { background-color: #fee2e2; color: #b91c1c; }
+    .badge-success { background-color: #dcfce7; color: #15803d; }
+
+    .status-text {
+        font-weight: 600;
+        font-family: monospace;
+    }
+
+    .status-200 { color: var(--success); }
+    .status-422 { color: var(--error); }
+    .status-latency { color: var(--warning); }
+
+    /* Quick Actions */
+    .quick-actions {
+        margin-top: 32px;
+        display: grid;
+        grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
+        gap: 24px;
+    }
+
+    .action-card {
+        display: flex;
+        gap: 20px;
+        padding: 24px;
+        cursor: pointer;
+        transition: transform 0.2s;
+    }
+
+    .action-card:hover {
+        transform: translateY(-2px);
+    }
+
+    .action-icon {
+        width: 48px;
+        height: 48px;
+        background-color: #f1f5f9;
+        border-radius: 12px;
+        display: flex;
+        align-items: center;
+        justify-content: center;
+        color: var(--text-muted);
+        font-size: 1.25rem;
+    }
+
+    .action-title {
+        font-weight: 700;
+        margin-bottom: 4px;
+    }
+
+    .action-desc {
+        font-size: 0.85rem;
+        color: var(--text-muted);
+    }
+{% endblock %}
+
+{% block content %}
+<div class="page-header">
+    <h1 class="page-title">System Overview</h1>
+    <p class="page-subtitle">Real-time status of your FastAPI environment</p>
+</div>
+
+<div class="stats-grid">
+    {% for stat in stats %}
+    <div class="card stat-card" onclick="location.href='/admin/{{ stat.model_name }}'" style="cursor: pointer;">
+        <div class="label">{{ stat.name }}</div>
+        <div class="value">{{ stat.count }}</div>
+        <div class="trend {% if stat.has_date_field %}up{% else %}neutral{% endif %}">
+            <i class="fas {% if stat.has_date_field %}fa-clock{% else %}fa-exclamation-triangle{% endif %}"></i> 
+            {% if stat.has_date_field %}
+                {{ stat.recent_count }} new in last 24h
+            {% else %}
+                Set date_field for 24h stats
+            {% endif %}
+        </div>
+        <div class="icon"><i class="fas fa-layer-group"></i></div>
+    </div>
+    {% endfor %}
+    
+    {% if not stats %}
+    <div class="card stat-card">
+        <div class="label">System</div>
+        <div class="value">0</div>
+        <div class="trend">No models registered</div>
+        <div class="icon"><i class="fas fa-info-circle"></i></div>
+    </div>
+    {% endif %}
+</div>
+
+<div class="section-header">
+    <h2 class="section-title">{{ logs_config.title }}</h2>
+    {% if logs %}
+    <a href="#" class="view-all">View All Logs</a>
+    {% endif %}
+</div>
+
+<div class="card" style="padding: 0; overflow: hidden;">
+    <table class="data-table">
+        <thead>
+            <tr>
+                {% for col in logs_config.columns %}
+                <th>{{ col|capitalize }}</th>
+                {% endfor %}
+            </tr>
+        </thead>
+        <tbody>
+            {% for log in logs %}
+            <tr>
+                {% for col in logs_config.columns %}
+                <td>
+                    {% if col == 'level' %}
+                        {% set level = log[col]|upper %}
+                        <span class="badge {% if level == 'INFO' %}badge-info{% elif level == 'ERROR' %}badge-error{% elif level == 'WARN' %}badge-warn{% else %}badge-success{% endif %}">
+                            {{ level }}
+                        </span>
+                    {% else %}
+                        {{ log[col] }}
+                    {% endif %}
+                </td>
+                {% endfor %}
+            </tr>
+            {% endfor %}
+            
+            {% if not logs %}
+            <tr>
+                <td colspan="100%" style="text-align: center; padding: 48px; color: var(--text-muted);">
+                    <i class="fas fa-clipboard-list" style="font-size: 2rem; margin-bottom: 12px; display: block; opacity: 0.5;"></i>
+                    No recent logs to display
+                </td>
+            </tr>
+            {% endif %}
+        </tbody>
+    </table>
+</div>
+
+{% endblock %}