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

brilliance_admin/api/views/table.py

@@ -8,7 +8,8 @@ from brilliance_admin.exceptions import AdminAPIException, APIError
 from brilliance_admin.schema import AdminSchema
 from brilliance_admin.schema.table.admin_action import ActionData, ActionResult
 from brilliance_admin.schema.table.category_table import CategoryTable
-from brilliance_admin.schema.table.table_models import CreateResult, ListData, RetrieveResult, TableListResult, UpdateResult
+from brilliance_admin.schema.table.table_models import (
+    CreateResult, ListData, RetrieveResult, TableListResult, UpdateResult)
 from brilliance_admin.translations import LanguageContext
 from brilliance_admin.utils import get_logger
 

brilliance_admin/locales/en.yml

@@ -3,16 +3,18 @@ delete_confirmation_text: "Are you sure you want to delete those records?\nThis
 deleted_successfully: 'The entries were successfully deleted.'
 
 errors:
+  pk_not_found: 'The "%(pk_name)s" field was not found in the submitted data.'
+  record_not_found: 'No record found for %(pk_name)s=%(pk)s.'
   db_error_create: 'Error creating a record in the database.'
   db_error_update: 'Error updating the record in the database.'
   db_error_retrieve: 'Error retrieving the record from the database.'
   db_error_list: 'Failed to retrieve table data from the database.'
-  pk_not_found: 'The "%(pk_name)s" field was not found in the submitted data.'
-  record_not_found: 'No record found for %(pk_name)s=%(pk)s.'
   connection_refused_error: 'Database connection error: %(error)s'
   filters_exception: 'An unknown technical error occurred while filtering data.'
   method_not_allowed: 'Error, method not allowed. This action is not permitted.'
   filter_error: 'An error occurred during filtering: {error}'
+  serialize_field_error: 'Serialize error: %(error)s'
+  bad_type_error: 'Invalid data type: %(type)s but %(expected)s expected'
 
 search_help: 'Available search fields: %(fields)s'
 sqlalchemy_search_help: |

brilliance_admin/locales/ru.yml

@@ -14,6 +14,7 @@ errors:
   method_not_allowed: 'Ошибка, данный метод недоступен.'
   filter_error: 'Проишла ошибка при фильтрации: %(error)s'
   serialize_field_error: 'Ошибка чтения данных: %(error)s'
+  bad_type_error: 'Некорректный тип данных: %(type)s; ожидается %(expected)s'
 
 search_help: 'Доступные поля для поиска: %(fields)s'
 sqlalchemy_search_help: |

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
 

brilliance_admin/schema/table/fields/base.py

@@ -8,6 +8,7 @@ from pydantic.dataclasses import dataclass
 from brilliance_admin.exceptions import FieldError
 from brilliance_admin.schema.category import FieldSchemaData
 from brilliance_admin.translations import LanguageContext
+from brilliance_admin.translations import TranslateText as _
 from brilliance_admin.utils import DeserializeAction, SupportsStr, humanize_field_name
 
 
@@ -80,7 +81,7 @@ class IntegerField(TableField):
     async def deserialize(self, value, action: DeserializeAction, extra: dict, *args, **kwargs) -> Any:
         value = await super().deserialize(value, action, extra, *args, **kwargs)
         if value and not isinstance(value, int):
-            raise FieldError(f'bad int type: {type(value)}')
+            raise FieldError(_('errors.bad_type_error') % {'type': type(value), 'expected': 'init'})
 
         return value
 
@@ -116,7 +117,7 @@ class StringField(TableField):
     async def deserialize(self, value, action: DeserializeAction, extra: dict, *args, **kwargs) -> Any:
         value = await super().deserialize(value, action, extra, *args, **kwargs)
         if value and not isinstance(value, str):
-            raise FieldError(f'bad string type: {type(value)}')
+            raise FieldError(_('errors.bad_type_error') % {'type': type(value), 'expected': 'string'})
 
         return value
 
@@ -151,7 +152,7 @@ class DateTimeField(TableField):
             return
 
         if value and not isinstance(value, (str, dict)):
-            raise FieldError(f'bad datetime type: {type(value)}')
+            raise FieldError(_('errors.bad_type_error') % {'type': type(value), 'expected': 'datetime'})
 
         if isinstance(value, str):
             return datetime.datetime.strptime(value, self.format)
@@ -166,13 +167,24 @@ class DateTimeField(TableField):
                 'to': datetime.datetime.strptime(value.get('to'), self.format),
             }
 
-        raise NotImplementedError(f'Value "{value}" is not supporetd for datetime')
+        raise FieldError(_('errors.bad_type_error') % {'type': type(value), 'expected': 'datetime'})
 
 
 @dataclass
 class JSONField(TableField):
     _type = 'json'
 
+    async def deserialize(self, value, action: DeserializeAction, extra: dict, *args, **kwargs) -> Any:
+        value = await super().deserialize(value, action, extra, *args, **kwargs)
+
+        if value is None:
+            return
+
+        if not isinstance(value, (dict, list)):
+            raise FieldError(_('errors.bad_type_error') % {'type': type(value), 'expected': 'JSON'})
+
+        return value
+
 
 @dataclass
 class ArrayField(TableField):
@@ -190,8 +202,11 @@ class ArrayField(TableField):
     async def deserialize(self, value, action: DeserializeAction, extra: dict, *args, **kwargs) -> Any:
         value = await super().deserialize(value, action, extra, *args, **kwargs)
 
-        if value and not isinstance(value, list):
-            raise FieldError(f'bad array type: {type(value)}')
+        if value is None:
+            return
+
+        if not isinstance(value, list):
+            raise FieldError(_('errors.bad_type_error') % {'type': type(value), 'expected': 'Array'})
 
         return value