fastapi-admin-kit 0.2.1__tar.gz → 0.3.1__tar.gz

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-admin-kit
-Version: 0.2.1
+Version: 0.3.1
 Summary: Drop-in admin panel for FastAPI + SQLAlchemy + SQLModel apps
 Project-URL: Homepage, https://github.com/borhanst/fastapi-admin-kit
 Project-URL: Documentation, https://borhanst.github.io/fastapi-admin-kit/
@@ -44,6 +44,8 @@ Provides-Extra: docs
 Requires-Dist: mkdocs-material>=9.5.0; extra == 'docs'
 Requires-Dist: mkdocs>=1.6.0; extra == 'docs'
 Requires-Dist: mkdocstrings[python]>=0.25.0; extra == 'docs'
+Provides-Extra: excel
+Requires-Dist: openpyxl>=3.1.0; extra == 'excel'
 Provides-Extra: full
 Requires-Dist: pyjwt>=2.13.0; extra == 'full'
 Requires-Dist: uvicorn>=0.30.0; extra == 'full'

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.1}/fastapi_admin_kit/__init__.py

@@ -5,6 +5,8 @@ from fastapi_admin_kit.admin.decorators import column
 from fastapi_admin_kit.auth.mixins import AuthModelMixin
 from fastapi_admin_kit.config import DatabaseConfig, DatabaseType
 from fastapi_admin_kit.exceptions import ConfigError
+from fastapi_admin_kit.export_import import CSVExport, CSVImport, ExportBase, ImportBase
+from fastapi_admin_kit.inline import InlineModelAdmin, StackedInline, TabularInline
 from fastapi_admin_kit.nav import (
     BuiltNavGroup,
     BuiltNavItem,
@@ -22,6 +24,7 @@ from fastapi_admin_kit.types import (
     FieldsetContext,
     FieldsetSpec,
     FormContext,
+    InlineFormsetData,
     PermissionSet,
     RelationMeta,
     SeedRole,
@@ -64,6 +67,11 @@ __all__ = [
     "FieldsetContext",
     "FieldsetSpec",
     "FormContext",
+    "InlineFormsetData",
+    # Inline admin
+    "InlineModelAdmin",
+    "StackedInline",
+    "TabularInline",
     # View classes
     "BaseView",
     "ListView",
@@ -74,5 +82,10 @@ __all__ = [
     "SearchView",
     # Per-model assets
     "AdminExtra",
+    # Export/Import
+    "ExportBase",
+    "ImportBase",
+    "CSVExport",
+    "CSVImport",
 ]
-__version__ = "0.2.1"
+__version__ = "0.3.1"

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.1}/fastapi_admin_kit/admin/admin_database.py

@@ -6,6 +6,7 @@ import logging
 import re
 from typing import Any
 
+from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyDatabaseBackend
 from fastapi_admin_kit.config.database import DatabaseConfig
 
 logger = logging.getLogger(__name__)
@@ -21,7 +22,11 @@ def _validate_identifier(name: str, kind: str = "table") -> str:
 
 
 class AdminDatabase:
-    """Handles database setup, table creation, and role seeding."""
+    """Handles database setup, table creation, and role seeding.
+
+    Delegates engine creation, table creation, and auto-migration to
+    :class:`SqlAlchemyDatabaseBackend`.
+    """
 
     def __init__(
         self,
@@ -32,11 +37,12 @@ class AdminDatabase:
         self.engine = engine
         self.base = base
         self.database_config = database_config
+        self._backend = SqlAlchemyDatabaseBackend(
+            admin_database=self, database_config=database_config
+        )
 
     def _ensure_engine(self) -> Any:
-        """
-        Create the async engine from ``database_config`` if no engine is set.
-        """
+        """Create the async engine from ``database_config`` if no engine is set."""
         if self.engine is None and self.database_config is not None:
             self.engine = self.database_config.create_engine()
         return self.engine
@@ -108,9 +114,7 @@ class AdminDatabase:
                         conn.execute(sql)
 
     def _auto_migrate(self, sync_conn: Any, metadata: Any) -> None:
-        """
-        Add missing columns to existing tables (sync, called via run_sync).
-        """
+        """Add missing columns to existing tables (sync, called via run_sync)."""
         from sqlalchemy import inspect as sa_inspect
         from sqlalchemy import text
 

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.1}/fastapi_admin_kit/admin/admin_template.py

@@ -1,10 +1,13 @@
 """Admin template management and context building."""
 
+import logging
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     pass
 
+logger = logging.getLogger(__name__)
+
 
 class AdminTemplate:
     """Manages Jinja2 template environment and sidebar context."""
@@ -19,6 +22,7 @@ class AdminTemplate:
         dark_mode_default: bool = False,
         dashboard_permission: str | None = None,
         settings_permission: str | None = None,
+        sidebar_bottom_links: list[dict[str, str]] | None = None,
     ):
         self.title = title
         self.logo_url = logo_url
@@ -28,6 +32,7 @@ class AdminTemplate:
         self.dark_mode_default = dark_mode_default
         self.dashboard_permission = dashboard_permission
         self.settings_permission = settings_permission
+        self.sidebar_bottom_links: list[dict[str, str]] = sidebar_bottom_links or []
         self._nav_groups_built: list = []
 
     def _init_jinja(self, app: Any) -> None:
@@ -46,11 +51,11 @@ class AdminTemplate:
         jinja_env.env.filters["slugify"] = slugify
         app.state.admin_jinja_env = jinja_env
 
-    def sidebar_template_kwargs(self, request: Any) -> dict[str, Any]:
+    async def sidebar_template_kwargs(self, request: Any) -> dict[str, Any]:
         """Thin wrapper — returns sidebar kwargs for TemplateResponse contexts."""
-        return self.build_sidebar_context(request)
+        return await self.build_sidebar_context(request)
 
-    def build_sidebar_context(
+    async def build_sidebar_context(
         self,
         request: Any,
         user: Any = None,
@@ -84,28 +89,34 @@ class AdminTemplate:
             permissions_map = {}
 
             if user and not is_superuser:
+                user_id = snapshot.get("id") if snapshot else getattr(user, "id", None)
                 role_ids = (
                     snapshot.get("role_ids", []) if snapshot else getattr(user, "role_ids", [])
                 )
-                if role_ids:
+                if role_ids or user_id is not None:
                     try:
                         from sqlalchemy import select
-                        from sqlalchemy.orm import Session
 
-                        from fastapi_admin_kit.auth.models import Permission, admin_role_permissions
+                        from fastapi_admin_kit.auth.models import (
+                            Permission,
+                            UserPermission,
+                            admin_role_permissions,
+                        )
+                        from fastapi_admin_kit.db import get_db_session
+
+                        session = get_db_session(request)
 
-                        engine = request.app.state.admin_engine
-                        with Session(engine) as s:
-                            result = s.execute(
+                        # Load permissions from all roles, merge with OR logic
+                        if role_ids:
+                            result = await session.execute(
                                 select(Permission)
                                 .join(
                                     admin_role_permissions,
                                     Permission.id == admin_role_permissions.c.permission_id,
                                 )
-                                .filter(admin_role_permissions.c.role_id.in_(role_ids))
+                                .where(admin_role_permissions.c.role_id.in_(role_ids))
                             )
-                            rows = result.scalars().all()
-                            for perm in rows:
+                            for perm in result.scalars():
                                 if perm.table_name in permissions_map:
                                     existing = permissions_map[perm.table_name]
                                     permissions_map[perm.table_name] = PermissionSet(
@@ -121,10 +132,35 @@ class AdminTemplate:
                                         can_edit=perm.can_edit,
                                         can_delete=perm.can_delete,
                                     )
-                    except Exception as exc:
-                        import logging
 
-                        logging.getLogger(__name__).debug("Permission query failed: %s", exc)
+                        # Load direct user permission overrides, merge on top
+                        if user_id is not None:
+                            result = await session.execute(
+                                select(UserPermission, Permission)
+                                .join(Permission, UserPermission.permission_id == Permission.id)
+                                .where(UserPermission.user_id == user_id)
+                            )
+                            for up, perm in result:
+                                table = perm.table_name
+                                if table in permissions_map:
+                                    existing = permissions_map[table]
+                                    permissions_map[table] = PermissionSet(
+                                        can_view=existing.can_view or perm.can_view,
+                                        can_create=existing.can_create or perm.can_create,
+                                        can_edit=existing.can_edit or perm.can_edit,
+                                        can_delete=existing.can_delete or perm.can_delete,
+                                    )
+                                else:
+                                    permissions_map[table] = PermissionSet(
+                                        can_view=perm.can_view,
+                                        can_create=perm.can_create,
+                                        can_edit=perm.can_edit,
+                                        can_delete=perm.can_delete,
+                                    )
+                    except Exception as exc:
+                        logger.warning(
+                            "Permission query failed in sidebar fallback: %s", exc, exc_info=True
+                        )
 
         def _item_visible(item: Any) -> bool:
             return (
@@ -187,9 +223,10 @@ class AdminTemplate:
             "current_user": user_for_template,
             "dashboard_visible": dashboard_visible,
             "settings_visible": settings_visible,
+            "sidebar_bottom_links": self.sidebar_bottom_links,
         }
 
-    def apply_sidebar_context(self, request: Any, user: Any, context: dict) -> dict:
+    async def apply_sidebar_context(self, request: Any, user: Any, context: dict) -> dict:
         """Inject nav_groups + permissions_map into a template context dict."""
-        context.update(self.build_sidebar_context(request, user=user))
+        context.update(await self.build_sidebar_context(request, user=user))
         return context

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.1}/fastapi_admin_kit/admin/core.py

@@ -35,6 +35,7 @@ if TYPE_CHECKING:
     from sqlalchemy.engine import Engine
 
     from fastapi_admin_kit.auth.backend import AuthBackend
+    from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyBackend
     from fastapi_admin_kit.nav import NavGroupConfig, SidebarBuilder
     from fastapi_admin_kit.storage.base import StorageBackend
     from fastapi_admin_kit.views import ModelAdmin
@@ -124,6 +125,7 @@ class Admin:
         database: AdminDatabase | None = None,
         router: AdminRouter | None = None,
         template: AdminTemplate | None = None,
+        backend: SqlAlchemyBackend | None = None,
         # Legacy kwargs for backward compatibility
         base: type | None = None,
         title: str = "FastAPI Admin Kit",
@@ -178,6 +180,7 @@ class Admin:
         mobile_sidebar: str = "overlay",
         dashboard_permission: str | None = None,
         settings_permission: str | None = None,
+        sidebar_bottom_links: list[dict[str, str]] | None = None,
     ):
         self.registry = AdminRegistry()
         self._app: FastAPI | None = app
@@ -259,6 +262,7 @@ class Admin:
                     require_tags=require_tags,
                     dashboard_permission=dashboard_permission,
                     settings_permission=settings_permission,
+                    sidebar_bottom_links=sidebar_bottom_links,
                 ),
             )
 
@@ -281,6 +285,7 @@ class Admin:
                 dark_mode_default=config.ui.dark_mode_default,
                 dashboard_permission=config.nav.dashboard_permission,
                 settings_permission=config.nav.settings_permission,
+                sidebar_bottom_links=config.nav.sidebar_bottom_links,
             )
 
         self.config = config
@@ -288,6 +293,16 @@ class Admin:
         self.router = router
         self.template = template
 
+        # Backend: defaults to composed SqlAlchemyBackend
+        if backend is None:
+            from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyBackend
+
+            backend = SqlAlchemyBackend.from_admin_database(database)
+        self.backend = backend
+
+        # Inject backend's introspection adapter into the registry's ModelInspector
+        self.registry.inspector._adapter = self.backend.introspection
+
         # RBAC
         self.seed_roles = seed_roles if seed_roles is not None else DEFAULT_SEED_ROLES
         self.seed_roles_overwrite = seed_roles_overwrite
@@ -535,8 +550,6 @@ class Admin:
                 registered.admin.skip_auto_routes = True
 
         # 8.3 Attach audit event listeners (after registry is populated)
-        from fastapi_admin_kit.audit.listener import attach_audit_listener
-
         engine = self.database.engine
         if engine is not None:
             from sqlalchemy.ext.asyncio import AsyncEngine
@@ -545,7 +558,12 @@ class Admin:
                 from fastapi_admin_kit.db import create_session_factory
 
                 session_factory = create_session_factory(engine)
-                attach_audit_listener(session_factory, self.registry)
+                from fastapi_admin_kit.backends.sqlalchemy import (
+                    SqlAlchemyAuditBackend,
+                )
+
+                audit_backend = SqlAlchemyAuditBackend()
+                audit_backend.attach_listeners(session_factory, self.registry)
 
         # 9. Validate require_tags
         if self.config.nav.require_tags:
@@ -703,6 +721,7 @@ class Admin:
             admin_instance=self,
             secret_key=self.router.secret_key,
             session_samesite=self.config.auth.session_samesite,
+            backend=self.backend,
         )
 
         # Store typed state as single attribute
@@ -721,6 +740,16 @@ class Admin:
         app.state.admin_jinja_env = state.jinja_env
         # Unified signing-key source for sessions, CSRF, and JWT (see AdminState).
         app.state.admin_secret_key = state.secret_key
+        # Multi-ORM backend: store composed backend and derive individual adapters
+        from fastapi_admin_kit.backends.sqlalchemy import (
+            SqlAlchemySessionAdapter,
+        )
+
+        app.state.admin_backend = self.backend
+        app.state.admin_session_backend_class = SqlAlchemySessionAdapter
+        app.state.admin_query_adapter = self.backend.query
+        app.state.admin_introspection_adapter = self.backend.introspection
+        app.state.admin_audit_backend = self.backend.audit
 
         # Wire the password hasher to the User model
         from fastapi_admin_kit.auth.models import User
@@ -826,6 +855,7 @@ class Admin:
             "bars-": "menu",
             "bars-3": "menu",
             "arrow-down-tray": "download",
+            "arrow-up-tray": "upload",
             "arrow-path": "refresh",
             "paper-airplane": "send",
             "exclamation-triangle": "warning",
@@ -1018,21 +1048,21 @@ class Admin:
             admin_path=self.router.admin_path,
         )
 
-    def build_sidebar_context(
+    async def build_sidebar_context(
         self,
         request: Any,
         user: Any = None,
         permissions_map: dict | None = None,
     ) -> dict:
         """Build per-request sidebar context (RBAC filter + permissions map)."""
-        return self.template.build_sidebar_context(
+        return await self.template.build_sidebar_context(
             request, user=user, permissions_map=permissions_map
         )
 
-    def sidebar_template_kwargs(self, request: Any) -> dict[str, Any]:
+    async def sidebar_template_kwargs(self, request: Any) -> dict[str, Any]:
         """Thin wrapper — returns sidebar kwargs for TemplateResponse contexts."""
-        return self.template.sidebar_template_kwargs(request)
+        return await self.template.sidebar_template_kwargs(request)
 
-    def apply_sidebar_context(self, request: Any, user: Any, context: dict) -> dict:
+    async def apply_sidebar_context(self, request: Any, user: Any, context: dict) -> dict:
         """Inject nav_groups + permissions_map into a template context dict."""
-        return self.template.apply_sidebar_context(request, user, context)
+        return await self.template.apply_sidebar_context(request, user, context)

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.1}/fastapi_admin_kit/admin/state.py

@@ -12,6 +12,7 @@ if TYPE_CHECKING:
     from fastapi_admin_kit.admin.core import Admin
     from fastapi_admin_kit.auth.backend import AuthBackend
     from fastapi_admin_kit.auth.session import SignedCookieSessionBackend
+    from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyBackend
     from fastapi_admin_kit.registry import AdminRegistry
     from fastapi_admin_kit.storage.base import StorageBackend
 
@@ -36,6 +37,8 @@ class AdminState:
     # Unified signing-key source — used by signed-cookie sessions, CSRF, and JWT.
     secret_key: str = ""
     session_samesite: str = "strict"
+    # Multi-ORM backend — composes introspection, query, audit, database adapters.
+    backend: SqlAlchemyBackend | None = None
 
     @classmethod
     def from_request(cls, request: Any) -> AdminState:
@@ -73,4 +76,5 @@ class AdminState:
             jinja_env=getattr(app_state, "admin_jinja_env", None),
             admin_instance=getattr(app_state, "admin", None),
             secret_key=getattr(app_state, "admin_secret_key", ""),
+            backend=getattr(app_state, "admin_backend", None),
         )

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.1}/fastapi_admin_kit/audit/context.py

@@ -3,7 +3,10 @@
 from __future__ import annotations
 
 from contextvars import ContextVar
-from typing import Any
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from fastapi_admin_kit.audit.events import AuditEvent
 
 # Context variable to store audit context (user, IP, user_agent, etc.)
 _current_audit_context: ContextVar[dict] = ContextVar("_current_audit_context", default={})
@@ -60,3 +63,32 @@ class AuditContext:
     def clear_context(self) -> None:
         """Clear the audit context."""
         clear_audit_context()
+
+
+async def log_audit_event(request: Any, event: AuditEvent) -> None:
+    """Persist an AuditEvent directly to the database.
+
+    Used for EXPORT/IMPORT events that don't go through the SQLAlchemy
+    before_flush listener.
+    """
+    from fastapi_admin_kit.audit.models import AuditLog
+    from fastapi_admin_kit.db import get_db_session
+
+    session = get_db_session(request)
+    ctx = get_audit_context()
+
+    entry = AuditLog(
+        action=event.event_type,
+        model_name=event.model_name,
+        table_name=event.table_name,
+        object_id=event.object_id,
+        object_repr=event.object_repr,
+        changes=event.changes,
+        full_snapshot=event.full_snapshot,
+        user_id=event.user_id or ctx.get("user_id"),
+        user_email=event.user_email or ctx.get("user_email"),
+        ip_address=event.ip_address or ctx.get("ip_address"),
+        user_agent=event.user_agent or ctx.get("user_agent"),
+    )
+    session.add(entry)
+    await session.flush()

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.1}/fastapi_admin_kit/audit/diff.py

@@ -1,4 +1,8 @@
-"""Audit diff utilities — snapshot and diff computation for SQLAlchemy models."""
+"""Audit diff utilities — snapshot and diff computation for SQLAlchemy models.
+
+``serialize_value()`` is ORM-agnostic and stays here.
+``snapshot()`` and ``compute_diff()`` delegate to the active AuditBackend.
+"""
 
 from __future__ import annotations
 
@@ -8,8 +12,6 @@ import enum
 from typing import Any
 from uuid import UUID
 
-from sqlalchemy.inspection import inspect as sqlalchemy_inspect
-
 
 def serialize_value(val: Any) -> Any:
     """Convert a value to a JSON-serializable form.
@@ -33,12 +35,9 @@ def serialize_value(val: Any) -> Any:
     if isinstance(val, UUID):
         return str(val)
     if isinstance(val, bytes):
-        # For simplicity, we'll return the hex representation.
-        # Alternatively, we could use base64, but hex is simpler.
         return val.hex()
     if isinstance(val, enum.Enum):
         return val.value
-    # For other types, we assume they are JSON serializable (or let JSON encoder handle it)
     return val
 
 
@@ -46,18 +45,12 @@ def snapshot(obj: Any) -> dict[str, Any]:
     """Snapshot all mapped columns of a SQLAlchemy model instance.
 
     Returns a dict mapping column name to serialized value.
+    Delegates to the active AuditBackend.
     """
-    if not hasattr(obj, "__table__"):
-        raise ValueError("Object is not a SQLAlchemy model instance")
+    from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyAuditBackend
 
-    mapper = sqlalchemy_inspect(obj.__class__)
-    data = {}
-    for column in mapper.columns:
-        # Skip foreign key columns that are represented by relationships?
-        # We'll include all columns for simplicity.
-        value = getattr(obj, column.key)
-        data[column.key] = serialize_value(value)
-    return data
+    backend = SqlAlchemyAuditBackend()
+    return backend.snapshot(obj)
 
 
 def compute_diff(before: dict[str, Any], after: dict[str, Any]) -> dict[str, Any]:
@@ -66,12 +59,9 @@ def compute_diff(before: dict[str, Any], after: dict[str, Any]) -> dict[str, Any
     Returns a dict of changed fields, each containing:
         {"old": <value>, "new": <value>}
     Only fields that have changed are included.
+    Delegates to the active AuditBackend.
     """
-    diff = {}
-    all_keys = set(before.keys()) | set(after.keys())
-    for key in all_keys:
-        old_val = before.get(key)
-        new_val = after.get(key)
-        if old_val != new_val:
-            diff[key] = {"old": old_val, "new": new_val}
-    return diff
+    from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyAuditBackend
+
+    backend = SqlAlchemyAuditBackend()
+    return backend.compute_diff(before, after)

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.1}/fastapi_admin_kit/audit/events.py

@@ -9,13 +9,13 @@ from typing import Any
 
 @dataclass
 class AuditEvent:
-    """Represents a single audit event (CREATE, UPDATE, or DELETE).
+    """Represents a single audit event (CREATE, UPDATE, DELETE, EXPORT, or IMPORT).
 
     This is a pure data structure with no side effects, making it
     easy to test and serialize.
     """
 
-    event_type: str  # "CREATE" | "UPDATE" | "DELETE"
+    event_type: str  # "CREATE" | "UPDATE" | "DELETE" | "EXPORT" | "IMPORT"
     model_name: str
     table_name: str
     object_id: str

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.1}/fastapi_admin_kit/audit/listener.py

@@ -55,31 +55,29 @@ def _snapshot_from_committed(obj: Any) -> dict[str, Any]:
 
 
 def _snapshot_current(obj: Any) -> dict[str, Any]:
-    """Snapshot all mapped columns of a SQLAlchemy model instance."""
-    if not hasattr(obj, "__table__"):
-        return {}
-    from sqlalchemy.inspection import inspect as sa_inspect
+    """Snapshot all mapped columns of a SQLAlchemy model instance.
 
-    mapper = sa_inspect(obj.__class__)
-    data: dict[str, Any] = {}
-    for column in mapper.columns:
-        data[column.key] = serialize_value(getattr(obj, column.key))
-    return data
+    Delegates to the SqlAlchemyAuditBackend. Returns {} for non-model objects.
+    """
+    from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyAuditBackend
+
+    backend = SqlAlchemyAuditBackend()
+    try:
+        return backend.snapshot(obj)
+    except ValueError:
+        return {}
 
 
 def _compute_diff(before: dict[str, Any], after: dict[str, Any]) -> dict[str, Any]:
     """Compute changed fields between two snapshots.
 
     Returns ``{"field": {"old": ..., "new": ...}}`` for each difference.
+    Delegates to the SqlAlchemyAuditBackend.
     """
-    diff: dict[str, Any] = {}
-    all_keys = set(before.keys()) | set(after.keys())
-    for key in all_keys:
-        old_val = before.get(key)
-        new_val = after.get(key)
-        if old_val != new_val:
-            diff[key] = {"old": old_val, "new": new_val}
-    return diff
+    from fastapi_admin_kit.backends.sqlalchemy import SqlAlchemyAuditBackend
+
+    backend = SqlAlchemyAuditBackend()
+    return backend.compute_diff(before, after)
 
 
 def _build_audit_row(

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.1}/fastapi_admin_kit/audit/logger.py

@@ -26,3 +26,11 @@ class AuditLogger(ABC):
     @abstractmethod
     def log_delete(self, event: AuditEvent) -> None:
         """Persist a DELETE audit event."""
+
+    @abstractmethod
+    def log_export(self, event: AuditEvent) -> None:
+        """Persist an EXPORT audit event."""
+
+    @abstractmethod
+    def log_import(self, event: AuditEvent) -> None:
+        """Persist an IMPORT audit event."""

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.1}/fastapi_admin_kit/audit/sqlalchemy_logger.py

@@ -32,6 +32,12 @@ class SqlAlchemyAuditLogger(AuditLogger):
     def log_delete(self, event: AuditEvent) -> None:
         self._buffer(event)
 
+    def log_export(self, event: AuditEvent) -> None:
+        self._buffer(event)
+
+    def log_import(self, event: AuditEvent) -> None:
+        self._buffer(event)
+
     def _buffer(self, event: AuditEvent) -> None:
         entry = AuditLog(
             user_id=event.user_id,

{fastapi_admin_kit-0.2.1 → fastapi_admin_kit-0.3.1}/fastapi_admin_kit/auth/__init__.py

@@ -17,14 +17,28 @@ from fastapi_admin_kit.auth.models import (
     User,
     UserPermission,
 )
+from fastapi_admin_kit.auth.password import (
+    PasswordManager,
+    password_manager,
+    validate_password_strength,
+)
+from fastapi_admin_kit.auth.protocol import (
+    AdminPermissionProtocol,
+    AdminRoleProtocol,
+    AdminUserProtocol,
+)
 from fastapi_admin_kit.auth.session import (
     SessionBackend,
     SignedCookieSessionBackend,
 )
 
 __all__ = [
+    "AdminPermissionProtocol",
+    "AdminRoleProtocol",
+    "AdminUserProtocol",
     "AuthModelMixin",
     "BcryptHasher",
+    "PasswordManager",
     "Permission",
     "PasswordHasher",
     "Role",
@@ -36,6 +50,8 @@ __all__ = [
     "SignedCookieSessionBackend",
     "auth_redirect_handler",
     "forbidden_handler",
+    "password_manager",
     "require_csrf_token",
     "set_csrf_cookie",
+    "validate_password_strength",
 ]