brilliance-admin 0.42.0__py3-none-any.whl

admin_panel/schema/admin_schema.py

@@ -0,0 +1,191 @@
+import importlib.metadata
+import json
+from importlib import resources
+from typing import Any, Dict, List, Optional, Type
+from urllib.parse import urljoin
+
+from fastapi import FastAPI, Request
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.staticfiles import StaticFiles
+from pydantic.dataclasses import dataclass
+
+from admin_panel.auth import UserABC
+from admin_panel.docs import build_redoc_docs, build_scalar_docs
+from admin_panel.schema.group import Group, GroupSchemaData
+from admin_panel.translations import LanguageManager, TranslateText
+from admin_panel.utils import DataclassBase
+
+
+@dataclass
+class AdminSchemaData(DataclassBase):
+    groups: Dict[str, GroupSchemaData]
+    profile: UserABC | Any
+
+    def __post_init__(self):
+        if not isinstance(self.profile, UserABC):
+            self.profile = UserABC(username=self.profile.username)
+
+
+# pylint: disable=too-many-instance-attributes
+@dataclass
+class AdminSettingsData(DataclassBase):
+    title: str | TranslateText
+    description: str | TranslateText | None
+    login_greetings_message: str | TranslateText | None
+    navbar_density: str
+    languages: Dict[str, str] | None
+
+
+@dataclass
+class AdminIndexContextData(DataclassBase):
+    title: str
+    favicon_image: str
+    settings_json: str
+
+
+@dataclass
+class AdminSchema:
+    groups: List[Group]
+    auth: Any
+
+    title: str | TranslateText | None = 'Admin'
+    description: str | TranslateText | None = None
+    login_greetings_message: str | TranslateText | None = None
+
+    logo_image: str | None = None
+    favicon_image: str = '/admin/static/favicon.jpg'
+
+    navbar_density: str = 'default'
+
+    backend_prefix = None
+    static_prefix = None
+
+    language_manager_class: Type[LanguageManager] = LanguageManager
+
+    def __post_init__(self):
+        for group in self.groups:
+            if not issubclass(group.__class__, Group):
+                raise TypeError(f'Group "{group}" is not instance of Group subclass')
+
+    def get_language_manager(self, language_slug: str | None) -> LanguageManager:
+        return self.language_manager_class(language_slug)
+
+    def generate_schema(self, user: UserABC, language_slug: str | None) -> AdminSchemaData:
+        language_manager: LanguageManager = self.get_language_manager(language_slug)
+
+        groups = {}
+
+        for group in self.groups:
+            if not group.slug:
+                msg = f'Category group {type(group).__name__}.slug is empty'
+                raise AttributeError(msg)
+
+            groups[group.slug] = group.generate_schema(user, language_manager)
+
+        return AdminSchemaData(
+            groups=groups,
+            profile=user,
+        )
+
+    def get_group(self, group_slug: str) -> Optional[Group]:
+        for group in self.groups:
+            if group.slug == group_slug:
+                return group
+
+        return None
+
+    async def get_settings(self, request: Request) -> AdminSettingsData:
+        language_slug = request.headers.get('Accept-Language')
+        language_manager: LanguageManager = self.get_language_manager(language_slug)
+
+        languages = None
+        if language_manager.languages:
+            languages = {}
+            for k, v in language_manager.languages.items():
+                languages[k] = language_manager.get_text(v)
+
+        return AdminSettingsData(
+            title=self.title,
+            description=self.description,
+            login_greetings_message=self.login_greetings_message,
+            navbar_density=self.navbar_density,
+            languages=languages,
+        )
+
+    # pylint: disable=too-many-arguments
+    # pylint: disable=too-many-positional-arguments
+    def generate_app(
+            self,
+            debug=False,
+            allow_cors=True,
+
+            include_scalar=False,
+            include_docs=False,
+            include_redoc=False,
+    ) -> FastAPI:
+        # pylint: disable=unused-variable
+        language_manager = self.get_language_manager(language_slug=None)
+
+        app = FastAPI(
+            title=language_manager.get_text(self.title),
+            description=language_manager.get_text(self.description),
+            debug=debug,
+            docs_url='/docs' if include_docs else None,
+            redoc_url=None,
+        )
+
+        if allow_cors:
+            app.add_middleware(
+                CORSMiddleware,
+                allow_origins=["*"],
+                allow_credentials=True,
+                allow_methods=["*"],
+                allow_headers=["*"]
+            )
+
+        static_dir = resources.files("admin_panel").joinpath("static")
+        app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
+
+        app.state.schema = self
+
+        if include_scalar:
+            app.include_router(build_scalar_docs(app))
+
+        if include_redoc:
+            app.include_router(build_redoc_docs(app, redoc_url='/redoc'))
+
+        # pylint: disable=import-outside-toplevel
+        from admin_panel.api.routers import admin_panel_router
+        app.include_router(admin_panel_router)
+
+        return app
+
+    async def get_index_context_data(self, request: Request) -> dict:
+        language_manager = self.get_language_manager(language_slug=None)
+        context = {'language_manager': language_manager}
+
+        backend_prefix = self.backend_prefix
+        if not backend_prefix:
+            backend_prefix = urljoin(str(request.base_url), '/admin/')
+
+        static_prefix = self.static_prefix
+        if not static_prefix:
+            static_prefix = urljoin(str(request.base_url), '/admin/static/')
+
+        logo_image = self.logo_image
+        if logo_image and logo_image.startswith('/'):
+            logo_image = urljoin(str(request.base_url), logo_image)
+
+        settings_json = {
+            'backend_prefix': backend_prefix,
+            'static_prefix': static_prefix,
+            'version': importlib.metadata.version('brilliance-admin'),
+            'api_timeout_ms': 1000 * 5,
+            'logo_image': logo_image,
+        }
+        data = AdminIndexContextData(
+            title=str(self.title),
+            favicon_image=self.favicon_image,
+            settings_json=json.dumps(settings_json),
+        )
+        return data.model_dump(mode='json', context=context)

admin_panel/schema/category.py

@@ -0,0 +1,149 @@
+import abc
+from typing import Any, ClassVar, Dict, List
+
+from pydantic import Field
+from pydantic.dataclasses import dataclass
+from pydantic_core import core_schema
+
+from admin_panel.auth import UserABC
+from admin_panel.translations import LanguageManager, TranslateText
+from admin_panel.utils import DataclassBase
+
+
+# pylint: disable=too-many-instance-attributes
+@dataclass
+class FieldSchemaData(DataclassBase):
+    type: str = None
+
+    label: str | None = None
+    help_text: str | None = None
+
+    # Table header parameters
+    header: dict = Field(default_factory=dict)
+
+    read_only: bool = False
+    default: Any | None = None
+    required: bool = False
+
+    max_length: int | None = None
+    min_length: int | None = None
+
+    choices: List[dict] | None = None
+
+    tag_colors: dict | None = None
+    variant: str | None = None
+    size: str | None = None
+
+    preview_max_height: int | None = None
+    preview_max_width: int | None = None
+
+    # StringField
+    multilined: bool | None = None
+    ckeditor: bool | None = None
+    tinymce: bool | None = None
+
+    # ArrayField
+    array_type: str | None = None
+
+    # SQLAlchemyRelatedField
+    many: bool | None = None
+    rel_name: str | None = None
+    dual_list: bool | None = None
+
+    # IntegerField
+    inputmode: str | None = None
+    precision: int | None = None
+    scale: int | None = None
+
+    # DateTimeField
+    range: bool | None = None
+    include_date: bool | None = None
+    include_time: bool | None = None
+
+
+@dataclass
+class FieldsSchemaData(DataclassBase):
+    fields: Dict[str, dict] = Field(default_factory=dict)
+    list_display: List[str] = Field(default_factory=list)
+
+
+# pylint: disable=too-many-instance-attributes
+@dataclass
+class TableInfoSchemaData(DataclassBase):
+    table_schema: FieldsSchemaData
+
+    search_enabled: bool = Field(default=False)
+    search_help: str | None = Field(default=None)
+
+    pk_name: str | None = Field(default=None)
+    can_retrieve: bool = Field(default=False)
+
+    can_create: bool = Field(default=False)
+    can_update: bool = Field(default=False)
+
+    table_filters: FieldsSchemaData | None = Field(default=None)
+
+    ordering_fields: List[str] = Field(default_factory=list)
+    default_ordering: str | None = None
+
+    actions: Dict[str, dict] | None = Field(default_factory=dict)
+
+    def __repr__(self):
+        return f'<TableInfoSchemaData id={id(self)}>'
+
+
+@dataclass
+class GraphInfoSchemaData(DataclassBase):
+    search_enabled: bool
+    search_help: str | None
+
+    table_filters: FieldsSchemaData | None = None
+
+
+@dataclass
+class CategorySchemaData(DataclassBase):
+    title: str | None
+    description: str | None
+    icon: str | None
+    type: str
+
+    table_info: TableInfoSchemaData | None = None
+    graph_info: GraphInfoSchemaData | None = None
+
+    def __repr__(self):
+        return f'<CategorySchemaData type={self.type} "{self.title}">'
+
+
+class Category(abc.ABC):
+    slug: ClassVar[str]
+    title: ClassVar[str | TranslateText | None] = None
+    description: ClassVar[str | TranslateText | None] = None
+
+    # https://pictogrammers.com/library/mdi/
+    icon: ClassVar[str | None] = None
+
+    _type_slug: ClassVar[str]
+
+    def generate_schema(self, user: UserABC, language_manager: LanguageManager) -> CategorySchemaData:
+        return CategorySchemaData(
+            title=language_manager.get_text(self.title) or self.slug,
+            description=language_manager.get_text(self.description),
+            icon=self.icon,
+            type=self._type_slug,
+        )
+
+    @classmethod
+    def __get_pydantic_core_schema__(cls, source_type: Any, handler: Any) -> core_schema.CoreSchema:
+        def validate(v: Any) -> "Category":
+            if isinstance(v, cls):
+                return v
+            raise TypeError(f"Expected {cls.__name__} instance")
+
+        return core_schema.no_info_plain_validator_function(
+            validate,
+            serialization=core_schema.plain_serializer_function_ser_schema(
+                lambda v: repr(v),
+                info_arg=False,
+                return_schema=core_schema.str_schema(),
+            ),
+        )

admin_panel/schema/graphs/__init__.py

@@ -0,0 +1 @@
+from .category_graphs import CategoryGraphs

admin_panel/schema/graphs/category_graphs.py

@@ -0,0 +1,50 @@
+from typing import Any, Dict, List
+
+from pydantic import BaseModel, Field
+
+from admin_panel.schema import Category
+from admin_panel.schema.category import GraphInfoSchemaData
+from admin_panel.schema.table.fields_schema import FieldsSchema
+from admin_panel.translations import LanguageManager, TranslateText
+
+
+class GraphData(BaseModel):
+    search: str | None = None
+    filters: Dict[str, Any] = Field(default_factory=dict)
+
+
+class ChartData(BaseModel):
+    data: dict
+    options: dict
+    width: int | None = None
+    height: int = 50
+    type: str = 'line'
+
+
+class GraphsDataResult(BaseModel):
+    charts: List[ChartData]
+
+
+class CategoryGraphs(Category):
+    _type_slug: str = 'graphs'
+
+    search_enabled: bool = False
+    search_help: str | TranslateText | None = None
+
+    table_filters: FieldsSchema | None = None
+
+    def generate_schema(self, user, language_manager: LanguageManager) -> GraphInfoSchemaData:
+        schema = super().generate_schema(user, language_manager)
+        graph = GraphInfoSchemaData(
+            search_enabled=self.search_enabled,
+            search_help=language_manager.get_text(self.search_help),
+        )
+
+        if self.table_filters:
+            graph.table_filters = self.table_filters.generate_schema(user, language_manager)
+
+        schema.graph_info = graph
+        return schema
+
+    async def get_data(self, data: GraphData, user) -> GraphsDataResult:
+        raise NotImplementedError('get_data is not implemented')

admin_panel/schema/group.py

@@ -0,0 +1,67 @@
+import abc
+from typing import Dict, List
+
+from pydantic.dataclasses import dataclass
+
+from admin_panel.auth import UserABC
+from admin_panel.schema.category import Category, CategorySchemaData
+from admin_panel.translations import LanguageManager, TranslateText
+from admin_panel.utils import DataclassBase, get_logger
+
+logger = get_logger()
+
+
+@dataclass
+class GroupSchemaData(DataclassBase):
+    title: str | None
+    description: str | None
+    icon: str | None
+    categories: Dict[str, CategorySchemaData]
+
+
+@dataclass
+class Group(abc.ABC):
+    categories: List[Category]
+    slug: str
+    title: str | TranslateText | None = None
+    description: str | TranslateText | None = None
+
+    # https://pictogrammers.com/library/mdi/
+    icon: str | None = None
+
+    def __post_init__(self):
+        for category in self.categories:
+            if not issubclass(category.__class__, Category):
+                raise TypeError(f'Category "{category}" is not instance of Category subclass')
+
+    def generate_schema(self, user: UserABC, language_manager: LanguageManager) -> GroupSchemaData:
+        result = GroupSchemaData(
+            title=language_manager.get_text(self.title) or self.slug,
+            description=language_manager.get_text(self.description),
+            icon=self.icon,
+            categories={},
+        )
+        if not self.categories:
+            logger.warning('Group "%s" %s.categories is empty!', self.slug, type(self).__name__)
+
+        for category in self.categories:
+
+            if not category.slug:
+                msg = f'Category {type(category).__name__}.slug is empty'
+                raise AttributeError(msg)
+
+            if category.slug in result.categories:
+                exists = result.categories[category.slug]
+                msg = f'Category {type(category).__name__}.slug "{self.slug}" already registered by "{exists.title}"'
+                raise KeyError(msg)
+
+            result.categories[category.slug] = category.generate_schema(user, language_manager)
+
+        return result
+
+    def get_category(self, category_slug: str) -> Category | None:
+        for category in self.categories:
+            if category.slug == category_slug:
+                return category
+
+        return None

admin_panel/schema/table/__init__.py

@@ -0,0 +1,8 @@
+# pylint: disable=wildcard-import, unused-wildcard-import, unused-import
+# flake8: noqa: F405
+from .admin_action import admin_action
+from .category_table import CategoryTable
+from .fields import *
+from .fields_schema import FieldsSchema
+from .table_models import (
+    AutocompleteData, AutocompleteResult, CreateResult, ListData, RetrieveResult, TableListResult, UpdateResult)

admin_panel/schema/table/admin_action.py

@@ -0,0 +1,76 @@
+import functools
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, Field, validate_call
+from pydantic.dataclasses import dataclass
+
+from admin_panel.schema.table.fields_schema import FieldsSchema
+from admin_panel.translations import DataclassBase, TranslateText
+
+
+class ActionData(BaseModel):
+    pks: List[Any] = Field(default_factory=list)
+    form_data: dict = Field(default_factory=dict)
+
+    search: str | None = None
+    filters: Dict[str, Any] = Field(default_factory=dict)
+
+    send_to_all: bool = False
+
+
+@dataclass
+class ActionMessage(DataclassBase):
+    text: str | TranslateText
+    type: str = 'success'
+    position: str = 'top-center'
+
+
+@dataclass
+class ActionResult(DataclassBase):
+    message: ActionMessage | None = None
+    persistent_message: str | TranslateText | None = None
+
+
+# pylint: disable=too-many-arguments
+# pylint: disable=too-many-positional-arguments
+@validate_call
+def admin_action(
+    title: str | TranslateText,
+    description: Optional[str | TranslateText] = None,
+    confirmation_text: Optional[str | TranslateText] = None,
+
+    # https://vuetifyjs.com/en/styles/colors/#material-colors
+    base_color: Optional[str] = None,
+
+    # https://pictogrammers.com/library/mdi/
+    icon: Optional[str] = None,
+
+    # elevated, flat, tonal, outlined, text, and plain.
+    variant: Optional[str] = None,
+
+    allow_empty_selection: bool = False,
+    form_schema: Optional[FieldsSchema] = None,
+):
+    def wrapper(func):
+        func.__action__ = True
+
+        func.action_info = {
+            'title': title,
+            'description': description,
+            'confirmation_text': confirmation_text,
+
+            'icon': icon,
+            'base_color': base_color,
+            'variant': variant,
+
+            'allow_empty_selection': allow_empty_selection,
+            'form_schema': form_schema,
+        }
+
+        @functools.wraps(func)
+        async def wrapped(*args):
+            return await func(*args)
+
+        return wrapped
+
+    return wrapper