brilliance-admin 0.43.7__py3-none-any.whl → 0.44.0__py3-none-any.whl

brilliance_admin/schema/__init__.py

@@ -1,7 +1,7 @@
 # pylint: disable=wildcard-import, unused-wildcard-import, unused-import
 # flake8: noqa: F405
 from .admin_schema import AdminSchema, AdminSchemaData
-from .category import Category
+from .category import CategoryGroup, CategoryLink
 from .graphs import *
-from .group import Group
 from .table import *
+from .table.category_table import CategoryTable

brilliance_admin/schema/admin_schema.py

@@ -7,11 +7,12 @@ from urllib.parse import urljoin
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
+from pydantic import Field
 from pydantic.dataclasses import dataclass
 
 from brilliance_admin.auth import UserABC
 from brilliance_admin.docs import build_redoc_docs, build_scalar_docs
-from brilliance_admin.schema.group import Group, GroupSchemaData
+from brilliance_admin.schema.category import BaseCategory, CategorySchemaData
 from brilliance_admin.translations import LanguageContext, LanguageManager
 from brilliance_admin.utils import DataclassBase, SupportsStr
 
@@ -23,8 +24,8 @@ DEFAULT_LANGUAGES = {
 
 @dataclass
 class AdminSchemaData(DataclassBase):
-    groups: Dict[str, GroupSchemaData]
     profile: UserABC | Any
+    categories: Dict[str, CategorySchemaData] = Field(default_factory=dict)
 
     def __post_init__(self):
         if not isinstance(self.profile, UserABC):
@@ -50,7 +51,7 @@ class AdminIndexContextData(DataclassBase):
 
 @dataclass
 class AdminSchema:
-    groups: List[Group]
+    categories: List[BaseCategory]
     auth: Any
 
     title: SupportsStr | None = 'Admin'
@@ -68,9 +69,9 @@ class AdminSchema:
     language_manager: LanguageManager | None = None
 
     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')
+        for category in self.categories:
+            if not issubclass(category.__class__, BaseCategory):
+                raise TypeError(f'Root category "{category}" is not instance of BaseCategory subclass')
 
         if not self.language_manager:
             self.language_manager = LanguageManager(DEFAULT_LANGUAGES)
@@ -81,24 +82,25 @@ class AdminSchema:
     def generate_schema(self, user: UserABC, language_slug: str | None) -> AdminSchemaData:
         language_context: LanguageContext = self.get_language_context(language_slug)
 
-        groups = {}
+        result = AdminSchemaData(profile=user)
 
-        for group in self.groups:
-            if not group.slug:
-                msg = f'Category group {type(group).__name__}.slug is empty'
+        for category in self.categories:
+            if not category.slug:
+                msg = f'Category {type(category).__name__}.slug is empty'
                 raise AttributeError(msg)
 
-            groups[group.slug] = group.generate_schema(user, language_context)
+            try:
+                result.categories[category.slug] = category.generate_schema(user, language_context).to_dict(keep_none=False)
+            except Exception as e:
+                msg = f'Root category "{category.slug}" generate_schema error: {e}'
+                raise Exception(msg) from e
 
-        return AdminSchemaData(
-            groups=groups,
-            profile=user,
-        )
+        return result
 
-    def get_group(self, group_slug: str) -> Optional[Group]:
-        for group in self.groups:
-            if group.slug == group_slug:
-                return group
+    def get_group(self, group_slug: str) -> Optional[BaseCategory]:
+        for category in self.categories:
+            if category.slug == group_slug:
+                return category
 
         return None
 

brilliance_admin/schema/category.py

@@ -4,10 +4,13 @@ from typing import Any, ClassVar, Dict, List
 from pydantic import Field
 from pydantic.dataclasses import dataclass
 from pydantic_core import core_schema
+from structlog import get_logger
 
 from brilliance_admin.auth import UserABC
 from brilliance_admin.translations import LanguageContext
-from brilliance_admin.utils import DataclassBase, SupportsStr, humanize_field_name
+from brilliance_admin.utils import DataclassBase, KwargsInitMixin, SupportsStr, humanize_field_name
+
+logger = get_logger()
 
 
 # pylint: disable=too-many-instance-attributes
@@ -106,37 +109,56 @@ class CategorySchemaData(DataclassBase):
     icon: str | None
     type: str
 
+    categories: dict = Field(default_factory=dict)
+
     table_info: TableInfoSchemaData | None = None
     graph_info: GraphInfoSchemaData | None = None
 
+    link: str | None = None
+
     def __repr__(self):
         return f'<CategorySchemaData type={self.type} "{self.title}">'
 
 
-class Category(abc.ABC):
-    slug: ClassVar[str]
-    title: ClassVar[SupportsStr | None] = None
-    description: ClassVar[SupportsStr | None] = None
+class BaseCategory(KwargsInitMixin, abc.ABC):
+    slug: str
+    title: SupportsStr | None = None
+    description: SupportsStr | None = None
 
     # https://pictogrammers.com/library/mdi/
-    icon: ClassVar[str | None] = None
+    icon: str | None = None
 
     _type_slug: ClassVar[str]
 
     def generate_schema(self, user: UserABC, language_context: LanguageContext) -> CategorySchemaData:
-        return CategorySchemaData(
+        type_slug = getattr(type(self), '_type_slug', None)
+        if not type_slug:
+            msg = f'{type(self).__name__}._type_slug must be set!'
+            raise AttributeError(msg)
+
+        result = CategorySchemaData(
             title=language_context.get_text(self.title) or humanize_field_name(self.slug),
             description=language_context.get_text(self.description),
             icon=self.icon,
-            type=self._type_slug,
+            type=type_slug,
         )
+        return result
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+
+        if cls is BaseCategory:
+            return
+
+        if not issubclass(cls, BaseCategory):
+            raise TypeError(f'{cls.__name__} must inherit from Category')
 
     @classmethod
     def __get_pydantic_core_schema__(cls, source_type: Any, handler: Any) -> core_schema.CoreSchema:
-        def validate(v: Any) -> "Category":
+        def validate(v: Any) -> "BaseCategory":
             if isinstance(v, cls):
                 return v
-            raise TypeError(f"Expected {cls.__name__} instance")
+            raise TypeError(f"Expected {cls.__name__} instance, recieved: {type(v)} {v}")
 
         return core_schema.no_info_plain_validator_function(
             validate,
@@ -146,3 +168,56 @@ class Category(abc.ABC):
                 return_schema=core_schema.str_schema(),
             ),
         )
+
+
+class CategoryLink(BaseCategory):
+    _type_slug: str = 'link'
+
+    link: str
+
+    def generate_schema(self, user: UserABC, language_context: LanguageContext) -> CategorySchemaData:
+        result = super().generate_schema(user, language_context)
+        result.link = self.link
+        return result
+
+
+class CategoryGroup(BaseCategory):
+    _type_slug: str = 'group'
+
+    subcategories: list = Field(default_factory=list)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        for category in self.subcategories:
+            if not isinstance(category, BaseCategory):
+                raise TypeError(f'Category "{category}" is not instance of BaseCategory subclass')
+
+    def generate_schema(self, user: UserABC, language_context: LanguageContext) -> CategorySchemaData:
+        result = super().generate_schema(user, language_context)
+
+        for category in self.subcategories:
+
+            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)
+
+            try:
+                result.categories[category.slug] = category.generate_schema(user, language_context)
+            except Exception as e:
+                msg = f'Category "{category.slug}" {type(category)} generate_schema error: {e}'
+                raise Exception(msg) from e
+
+        return result
+
+    def get_category(self, category_slug: str):
+        for category in self.subcategories:
+            if category.slug == category_slug:
+                return category
+
+        return None

brilliance_admin/schema/graphs/category_graphs.py

@@ -2,8 +2,7 @@ from typing import Any, Dict, List
 
 from pydantic import BaseModel, Field
 
-from brilliance_admin.schema import Category
-from brilliance_admin.schema.category import GraphInfoSchemaData
+from brilliance_admin.schema.category import BaseCategory, GraphInfoSchemaData
 from brilliance_admin.schema.table.fields_schema import FieldsSchema
 from brilliance_admin.translations import LanguageContext
 from brilliance_admin.utils import SupportsStr
@@ -26,7 +25,7 @@ class GraphsDataResult(BaseModel):
     charts: List[ChartData]
 
 
-class CategoryGraphs(Category):
+class CategoryGraphs(BaseCategory):
     _type_slug: str = 'graphs'
 
     search_enabled: bool = False

brilliance_admin/schema/table/category_table.py

@@ -8,7 +8,7 @@ from pydantic import Field
 
 from brilliance_admin.auth import UserABC
 from brilliance_admin.exceptions import AdminAPIException, APIError
-from brilliance_admin.schema import Category
+from brilliance_admin.schema.category import BaseCategory
 from brilliance_admin.schema.category import TableInfoSchemaData
 from brilliance_admin.schema.table.admin_action import ActionData, ActionResult
 from brilliance_admin.schema.table.fields_schema import FieldsSchema
@@ -17,7 +17,7 @@ from brilliance_admin.translations import LanguageContext
 from brilliance_admin.utils import DeserializeAction, SupportsStr
 
 
-class CategoryTable(Category):
+class CategoryTable(BaseCategory):
     _type_slug: str = 'table'
 
     search_enabled: bool = False
@@ -32,6 +32,8 @@ class CategoryTable(Category):
     pk_name: str | None = None
 
     def __init__(self, *args, table_schema=None, table_filters=None, **kwargs):
+        super().__init__(*args, **kwargs)
+
         if table_schema:
             self.table_schema = table_schema