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

{admin_panel → brilliance_admin}/schema/table/category_table.py

@@ -6,22 +6,22 @@ from typing import Awaitable, List
 from fastapi import HTTPException, Request
 from pydantic import Field
 
-from admin_panel.auth import UserABC
-from admin_panel.exceptions import AdminAPIException, APIError
-from admin_panel.schema import Category
-from admin_panel.schema.category import TableInfoSchemaData
-from admin_panel.schema.table.admin_action import ActionData, ActionResult
-from admin_panel.schema.table.fields_schema import FieldsSchema
-from admin_panel.schema.table.table_models import AutocompleteData, AutocompleteResult, ListData, TableListResult
-from admin_panel.translations import LanguageManager, TranslateText
-from admin_panel.utils import DeserializeAction
+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 TableInfoSchemaData
+from brilliance_admin.schema.table.admin_action import ActionData, ActionResult
+from brilliance_admin.schema.table.fields_schema import FieldsSchema
+from brilliance_admin.schema.table.table_models import AutocompleteData, AutocompleteResult, ListData, TableListResult
+from brilliance_admin.translations import LanguageContext
+from brilliance_admin.utils import DeserializeAction, SupportsStr
 
 
 class CategoryTable(Category):
     _type_slug: str = 'table'
 
     search_enabled: bool = False
-    search_help: str | TranslateText | None = None
+    search_help: SupportsStr | None = None
 
     table_schema: FieldsSchema = None
     table_filters: FieldsSchema | None = None
@@ -60,20 +60,20 @@ class CategoryTable(Category):
         fn = getattr(self, 'update', None)
         return asyncio.iscoroutinefunction(fn)
 
-    def generate_schema(self, user, language_manager: LanguageManager) -> dict:
-        schema = super().generate_schema(user, language_manager)
+    def generate_schema(self, user, language_context: LanguageContext) -> dict:
+        schema = super().generate_schema(user, language_context)
 
         table_schema = getattr(self, 'table_schema', None)
         if not table_schema or not issubclass(table_schema.__class__, FieldsSchema):
             raise AttributeError(f'Admin category {self.__class__} must have table_schema instance of FieldsSchema')
 
         table = TableInfoSchemaData(
-            table_schema=self.table_schema.generate_schema(user, language_manager),
+            table_schema=self.table_schema.generate_schema(user, language_context),
             ordering_fields=self.ordering_fields,
             default_ordering=self.default_ordering,
 
             search_enabled=self.search_enabled,
-            search_help=language_manager.get_text(self.search_help),
+            search_help=language_context.get_text(self.search_help),
 
             pk_name=self.pk_name,
             can_retrieve=self.has_retrieve,
@@ -83,7 +83,7 @@ class CategoryTable(Category):
         )
 
         if self.table_filters:
-            table.table_filters = self.table_filters.generate_schema(user, language_manager)
+            table.table_filters = self.table_filters.generate_schema(user, language_context)
 
         actions = {}
         for attribute_name in dir(self):
@@ -94,14 +94,14 @@ class CategoryTable(Category):
             if asyncio.iscoroutinefunction(attribute) and getattr(attribute, '__action__', False):
                 action = copy.copy(attribute.action_info)
 
-                action['title'] = language_manager.get_text(action.get('title'))
-                action['description'] = language_manager.get_text(action.get('description'))
-                action['confirmation_text'] = language_manager.get_text(action.get('confirmation_text'))
+                action['title'] = language_context.get_text(action.get('title'))
+                action['description'] = language_context.get_text(action.get('description'))
+                action['confirmation_text'] = language_context.get_text(action.get('confirmation_text'))
 
                 form_schema = action['form_schema']
                 if form_schema:
                     try:
-                        action['form_schema'] = form_schema.generate_schema(user, language_manager)
+                        action['form_schema'] = form_schema.generate_schema(user, language_context)
                     except Exception as e:
                         msg = f'Action {attribute} form schema {form_schema} error: {e}'
                         raise Exception(msg) from e
@@ -126,7 +126,7 @@ class CategoryTable(Category):
             request: Request,
             action: str,
             action_data: ActionData,
-            language_manager: LanguageManager,
+            language_context: LanguageContext,
             user: UserABC,
     ) -> ActionResult:
         action_fn = self._get_action_fn(action)
@@ -162,7 +162,7 @@ class CategoryTable(Category):
 
     # pylint: disable=too-many-arguments
     @abc.abstractmethod
-    async def get_list(self, list_data: ListData, user: UserABC, language_manager: LanguageManager) -> TableListResult:
+    async def get_list(self, list_data: ListData, user: UserABC, language_context: LanguageContext) -> TableListResult:
         raise NotImplementedError()
 
 #     async def retrieve(self, pk: Any, user: UserABC) -> RetrieveResult:

{admin_panel → brilliance_admin}/schema/table/fields/base.py

@@ -1,27 +1,28 @@
 import abc
 import datetime
-from typing import Any, ClassVar, List, Tuple
+from enum import Enum
+from typing import Any, ClassVar
 
 from pydantic.dataclasses import dataclass
 
-from admin_panel.exceptions import FieldError
-from admin_panel.schema.category import FieldSchemaData
-from admin_panel.translations import LanguageManager, TranslateText
-from admin_panel.utils import DeserializeAction, humanize_field_name
+from brilliance_admin.exceptions import FieldError
+from brilliance_admin.schema.category import FieldSchemaData
+from brilliance_admin.translations import LanguageContext
+from brilliance_admin.utils import DeserializeAction, SupportsStr, humanize_field_name
 
 
 @dataclass
 class TableField(abc.ABC, FieldSchemaData):
     _type: ClassVar[str]
 
-    label: str | TranslateText | None = None
-    help_text: str | TranslateText | None = None
+    label: SupportsStr | None = None
+    help_text: SupportsStr | None = None
 
-    def generate_schema(self, user, field_slug, language_manager: LanguageManager) -> FieldSchemaData:
+    def generate_schema(self, user, field_slug, language_context: LanguageContext) -> FieldSchemaData:
         schema = FieldSchemaData(
             type=self._type,
-            label=language_manager.get_text(self.label) or humanize_field_name(field_slug),
-            help_text=language_manager.get_text(self.help_text),
+            label=language_context.get_text(self.label) or humanize_field_name(field_slug),
+            help_text=language_context.get_text(self.help_text),
             header=self.header,
             read_only=self.read_only,
             default=self.default,
@@ -52,6 +53,8 @@ class TableField(abc.ABC, FieldSchemaData):
 class IntegerField(TableField):
     _type = 'integer'
 
+    choices: Any | None = None
+
     max_value: int | None = None
     min_value: int | None = None
 
@@ -59,10 +62,8 @@ class IntegerField(TableField):
     precision: int | None = None
     scale: int | None = None
 
-    def generate_schema(self, user, field_slug, language_manager: LanguageManager) -> FieldSchemaData:
-        schema = super().generate_schema(user, field_slug, language_manager)
-
-        schema.choices = self.choices
+    def generate_schema(self, user, field_slug, language_context: LanguageContext) -> FieldSchemaData:
+        schema = super().generate_schema(user, field_slug, language_context)
 
         if self.max_value is not None:
             schema.max_value = self.max_value
@@ -95,13 +96,12 @@ class StringField(TableField):
     min_length: int | None = None
     max_length: int | None = None
 
-    choices: List[Tuple[str, str]] | None = None
+    choices: Any | None = None
 
-    def generate_schema(self, user, field_slug, language_manager: LanguageManager) -> FieldSchemaData:
-        schema = super().generate_schema(user, field_slug, language_manager)
+    def generate_schema(self, user, field_slug, language_context: LanguageContext) -> FieldSchemaData:
+        schema = super().generate_schema(user, field_slug, language_context)
 
         schema.multilined = self.multilined
-        schema.choices = self.choices
         schema.ckeditor = self.ckeditor
         schema.tinymce = self.tinymce
 
@@ -135,8 +135,8 @@ class DateTimeField(TableField):
     include_date: bool | None = True
     include_time: bool | None = True
 
-    def generate_schema(self, user, field_slug, language_manager: LanguageManager) -> FieldSchemaData:
-        schema = super().generate_schema(user, field_slug, language_manager)
+    def generate_schema(self, user, field_slug, language_context: LanguageContext) -> FieldSchemaData:
+        schema = super().generate_schema(user, field_slug, language_context)
 
         schema.range = self.range
         schema.include_date = self.include_date
@@ -180,8 +180,8 @@ class ArrayField(TableField):
 
     array_type: str | None
 
-    def generate_schema(self, user, field_slug, language_manager: LanguageManager) -> FieldSchemaData:
-        schema = super().generate_schema(user, field_slug, language_manager)
+    def generate_schema(self, user, field_slug, language_context: LanguageContext) -> FieldSchemaData:
+        schema = super().generate_schema(user, field_slug, language_context)
 
         schema.array_type = self.array_type
 
@@ -208,8 +208,8 @@ class ImageField(TableField):
     preview_max_height: int = 100
     preview_max_width: int = 100
 
-    def generate_schema(self, user, field_slug, language_manager: LanguageManager) -> FieldSchemaData:
-        schema = super().generate_schema(user, field_slug, language_manager)
+    def generate_schema(self, user, field_slug, language_context: LanguageContext) -> FieldSchemaData:
+        schema = super().generate_schema(user, field_slug, language_context)
 
         if self.preview_max_height is not None:
             schema.preview_max_height = self.preview_max_height
@@ -227,23 +227,52 @@ class ImageField(TableField):
 class ChoiceField(TableField):
     _type = 'choice'
 
+    # Tag color available:
     # https://vuetifyjs.com/en/styles/colors/#classes
-    tag_colors: dict | None = None
+    choices: Any | None = None
 
     # https://vuetifyjs.com/en/components/chips/#color-and-variants
     variant: str = 'elevated'
     size: str = 'default'
 
-    def generate_schema(self, user, field_slug, language_manager: LanguageManager) -> FieldSchemaData:
-        schema = super().generate_schema(user, field_slug, language_manager)
+    def __post_init__(self):
+        self.choices = self.generate_choices()
+
+    def generate_choices(self):
+        if not self.choices:
+            return None
+
+        if issubclass(self.choices, Enum):
+            return [
+                {'value': c.value, 'title': c.label, 'tag_color': getattr(c, 'tag_color', None)}
+                for c in self.choices
+            ]
+
+        msg = f'Field choices is not suppored: {self.choices}'
+        raise NotImplementedError(msg)
+
+    def find_choice(self, value):
+        if not self.choices:
+            return None
+
+        return next((c for c in self.choices if c.get('value') == value), None)
+
+    def generate_schema(self, user, field_slug, language_context: LanguageContext) -> FieldSchemaData:
+        schema = super().generate_schema(user, field_slug, language_context)
 
         schema.choices = self.choices
 
-        schema.tag_colors = self.tag_colors
         schema.size = self.size
         schema.variant = self.variant
 
         return schema
 
     async def serialize(self, value, extra: dict, *args, **kwargs) -> Any:
-        return {'value': value, 'title': value.capitalize() if value else value}
+        if not value:
+            return
+
+        choice = self.find_choice(value)
+        return {
+            'value': value,
+            'title': choice.get('title') or value if choice else value.capitalize(),
+        }

{admin_panel → brilliance_admin}/schema/table/fields/function_field.py

@@ -4,9 +4,9 @@ from typing import Any
 
 from pydantic.dataclasses import dataclass
 
-from admin_panel.exceptions import AdminAPIException, APIError
-from admin_panel.schema.table.fields.base import TableField
-from admin_panel.utils import get_logger
+from brilliance_admin.exceptions import AdminAPIException, APIError
+from brilliance_admin.schema.table.fields.base import TableField
+from brilliance_admin.utils import get_logger
 
 logger = get_logger()
 

{admin_panel → brilliance_admin}/schema/table/fields_schema.py

@@ -3,13 +3,13 @@ from typing import Any, ClassVar, Dict, List
 
 from pydantic_core import core_schema
 
-from admin_panel.auth import UserABC
-from admin_panel.exceptions import AdminAPIException, APIError, FieldError
-from admin_panel.schema.category import FieldSchemaData, FieldsSchemaData
-from admin_panel.schema.table.fields.base import TableField
-from admin_panel.schema.table.fields.function_field import FunctionField
-from admin_panel.translations import LanguageManager
-from admin_panel.utils import DeserializeAction
+from brilliance_admin.auth import UserABC
+from brilliance_admin.exceptions import AdminAPIException, APIError, FieldError
+from brilliance_admin.schema.category import FieldSchemaData, FieldsSchemaData
+from brilliance_admin.schema.table.fields.base import TableField
+from brilliance_admin.schema.table.fields.function_field import FunctionField
+from brilliance_admin.translations import LanguageContext
+from brilliance_admin.utils import DeserializeAction
 
 NOT_FUND_EXCEPTION = '''Field slug "{field_slug}" not found inside generated fields inside {class_name}
 Available options: {available_fields}
@@ -143,14 +143,15 @@ class FieldsSchema:
     def get_fields(self) -> Dict[str, TableField]:
         return self._generated_fields
 
-    def generate_schema(self, user: UserABC, language_manager: LanguageManager) -> FieldsSchemaData:
+    def generate_schema(self, user: UserABC, language_context: LanguageContext) -> FieldsSchemaData:
         fields_schema = FieldsSchemaData(
             list_display=self.list_display,
         )
 
+        context = {'language_context': language_context}
         for field_slug, field in self.get_fields().items():
-            field_schema: FieldSchemaData = field.generate_schema(user, field_slug, language_manager)
-            fields_schema.fields[field_slug] = field_schema.to_dict(keep_none=False)
+            field_schema: FieldSchemaData = field.generate_schema(user, field_slug, language_context)
+            fields_schema.fields[field_slug] = field_schema.to_dict(keep_none=False, context=context)
 
         return fields_schema
 

{admin_panel → brilliance_admin}/schema/table/table_models.py

@@ -3,7 +3,7 @@ from typing import Any, Dict, List
 from pydantic import BaseModel, Field
 from pydantic.dataclasses import dataclass
 
-from admin_panel.utils import DataclassBase
+from brilliance_admin.utils import DataclassBase
 
 
 @dataclass