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

{admin_panel → brilliance_admin}/integrations/sqlalchemy/table/create.py

@@ -1,9 +1,9 @@
-from admin_panel import schema
-from admin_panel.auth import UserABC
-from admin_panel.exceptions import AdminAPIException, APIError
-from admin_panel.translations import LanguageManager
-from admin_panel.translations import TranslateText as _
-from admin_panel.utils import get_logger
+from brilliance_admin import schema
+from brilliance_admin.auth import UserABC
+from brilliance_admin.exceptions import AdminAPIException, APIError
+from brilliance_admin.translations import LanguageContext
+from brilliance_admin.translations import TranslateText as _
+from brilliance_admin.utils import get_logger
 
 logger = get_logger()
 
@@ -15,10 +15,10 @@ class SQLAlchemyAdminCreate:
             self,
             data: dict,
             user: UserABC,
-            language_manager: LanguageManager,
+            language_context: LanguageContext,
     ) -> schema.CreateResult:
         if not self.has_create:
-            raise AdminAPIException(APIError(message=_('method_not_allowed')), status_code=500)
+            raise AdminAPIException(APIError(message=_('errors.method_not_allowed')), status_code=500)
 
         # pylint: disable=import-outside-toplevel
         from sqlalchemy.exc import IntegrityError
@@ -37,7 +37,7 @@ class SQLAlchemyAdminCreate:
                 type(self).__name__, self.table_schema.model.__name__, e,
                 extra={'data': data},
             )
-            msg = _('connection_refused_error') % {'error': str(e)}
+            msg = _('errors.connection_refused_error') % {'error': str(e)}
             raise AdminAPIException(
                 APIError(message=msg, code='connection_refused_error'),
                 status_code=500,
@@ -62,7 +62,7 @@ class SQLAlchemyAdminCreate:
                 extra={'data': data},
             )
             raise AdminAPIException(
-                APIError(message=_('db_error_create'), code='db_error_create'), status_code=500,
+                APIError(message=_('errors.db_error_create'), code='db_error_create'), status_code=500,
             ) from e
 
         logger.info(

{admin_panel → brilliance_admin}/integrations/sqlalchemy/table/delete.py

@@ -1,6 +1,6 @@
-from admin_panel.exceptions import APIError, AdminAPIException
-from admin_panel.schema.table.admin_action import ActionData, ActionMessage, ActionResult, admin_action
-from admin_panel.translations import TranslateText as _
+from brilliance_admin.exceptions import APIError, AdminAPIException
+from brilliance_admin.schema.table.admin_action import ActionData, ActionMessage, ActionResult, admin_action
+from brilliance_admin.translations import TranslateText as _
 
 
 class SQLAlchemyDeleteAction:
@@ -14,5 +14,5 @@ class SQLAlchemyDeleteAction:
     )
     async def delete(self, action_data: ActionData):
         if not self.has_delete:
-            raise AdminAPIException(APIError(message=_('method_not_allowed')), status_code=500)
+            raise AdminAPIException(APIError(message=_('errors.method_not_allowed')), status_code=500)
         return ActionResult(message=ActionMessage(_('deleted_successfully')))

{admin_panel → brilliance_admin}/integrations/sqlalchemy/table/list.py

@@ -1,9 +1,9 @@
-from admin_panel import auth, schema
-from admin_panel.exceptions import AdminAPIException, APIError, FieldError
-from admin_panel.integrations.sqlalchemy.fields_schema import SQLAlchemyFieldsSchema
-from admin_panel.translations import LanguageManager
-from admin_panel.translations import TranslateText as _
-from admin_panel.utils import get_logger
+from brilliance_admin import auth, schema
+from brilliance_admin.exceptions import AdminAPIException, APIError, FieldError
+from brilliance_admin.integrations.sqlalchemy.fields_schema import SQLAlchemyFieldsSchema
+from brilliance_admin.translations import LanguageContext
+from brilliance_admin.translations import TranslateText as _
+from brilliance_admin.utils import get_logger
 
 logger = get_logger()
 
@@ -87,7 +87,7 @@ class SQLAlchemyAdminListMixin:
         self,
         list_data: schema.ListData,
         user: auth.UserABC,
-        language_manager: LanguageManager,
+        language_context: LanguageContext,
     ) -> schema.TableListResult:
         # pylint: disable=import-outside-toplevel
         from sqlalchemy import exc, func, select
@@ -109,7 +109,7 @@ class SQLAlchemyAdminListMixin:
                     'list_data': list_data,
                 }
             )
-            msg = _('filter_error') % {'error': e.message}
+            msg = _('errors.filter_error') % {'error': e.message}
             raise AdminAPIException(APIError(message=msg, code='filters_exception'), status_code=500) from e
 
         except Exception as e:
@@ -120,7 +120,7 @@ class SQLAlchemyAdminListMixin:
                     'list_data': list_data,
                 }
             )
-            raise AdminAPIException(APIError(message=_('filters_exception'), code='filters_exception'), status_code=500) from e
+            raise AdminAPIException(APIError(message=_('errors.filters_exception'), code='filters_exception'), status_code=500) from e
 
         data = []
 
@@ -143,7 +143,7 @@ class SQLAlchemyAdminListMixin:
                     'list_data': list_data,
                 }
             )
-            msg = _('connection_refused_error') % {'error': str(e)}
+            msg = _('errors.connection_refused_error') % {'error': str(e)}
             raise AdminAPIException(
                 APIError(message=msg, code='connection_refused_error'),
                 status_code=500,
@@ -172,7 +172,7 @@ class SQLAlchemyAdminListMixin:
                 }
             )
             raise AdminAPIException(
-                APIError(message=_('db_error_list'), code='db_error_list'), status_code=500,
+                APIError(message=_('errors.db_error_list'), code='db_error_list'), status_code=500,
             ) from e
 
         return schema.TableListResult(data=data, total_count=int(total_count or 0))

{admin_panel → brilliance_admin}/integrations/sqlalchemy/table/retrieve.py

@@ -1,10 +1,11 @@
 from typing import Any
 
-from admin_panel import auth, schema
-from admin_panel.exceptions import AdminAPIException, APIError
-from admin_panel.translations import LanguageManager
-from admin_panel.translations import TranslateText as _
-from admin_panel.utils import get_logger
+from brilliance_admin import auth, schema
+from brilliance_admin.exceptions import AdminAPIException, APIError, FieldError
+from brilliance_admin.integrations.sqlalchemy.fields_schema import SQLAlchemyFieldsSchema
+from brilliance_admin.translations import LanguageContext
+from brilliance_admin.translations import TranslateText as _
+from brilliance_admin.utils import get_logger
 
 logger = get_logger()
 
@@ -12,14 +13,16 @@ logger = get_logger()
 class SQLAlchemyAdminRetrieveMixin:
     has_retrieve: bool = True
 
+    table_schema: SQLAlchemyFieldsSchema
+
     async def retrieve(
             self,
             pk: Any,
             user: auth.UserABC,
-            language_manager: LanguageManager,
+            language_context: LanguageContext,
     ) -> schema.RetrieveResult:
         if not self.has_delete:
-            raise AdminAPIException(APIError(message=_('method_not_allowed')), status_code=500)
+            raise AdminAPIException(APIError(message=_('errors.method_not_allowed')), status_code=500)
 
         # pylint: disable=import-outside-toplevel
         from sqlalchemy import inspect
@@ -38,16 +41,25 @@ class SQLAlchemyAdminRetrieveMixin:
                     extra={"record": record, "user": user},
                 )
 
+        except FieldError as e:
+            logger.exception(
+                'SQLAlchemy %s retrieve %s #%s field error: %s',
+                type(self).__name__, self.model.__name__, pk, e,
+            )
+            msg = _('errors.serialize_field_error') % {'error': e.message}
+            raise AdminAPIException(APIError(message=msg, code='filters_exception'), status_code=500) from e
+
         except Exception as e:
             logger.exception(
-                'SQLAlchemy %s retrieve db error: %s', type(self).__name__, e,
+                'SQLAlchemy %s retrieve %s #%s db error: %s',
+                type(self).__name__, self.model.__name__, pk, e,
             )
             raise AdminAPIException(
-                APIError(message=_('db_error_retrieve'), code='db_error_retrieve'), status_code=500,
+                APIError(message=_('errors.db_error_retrieve'), code='db_error_retrieve'), status_code=500,
             ) from e
 
         if record is None:
-            msg = _('record_not_found') % {'pk_name': self.pk_name, 'pk': pk}
+            msg = _('errors.record_not_found') % {'pk_name': self.pk_name, 'pk': pk}
             raise AdminAPIException(
                 APIError(message=msg, code='record_not_found'),
                 status_code=400,

{admin_panel → brilliance_admin}/integrations/sqlalchemy/table/update.py

@@ -1,10 +1,10 @@
 from typing import Any
 
-from admin_panel import auth, schema
-from admin_panel.exceptions import AdminAPIException, APIError
-from admin_panel.translations import LanguageManager
-from admin_panel.translations import TranslateText as _
-from admin_panel.utils import get_logger
+from brilliance_admin import auth, schema
+from brilliance_admin.exceptions import AdminAPIException, APIError
+from brilliance_admin.translations import LanguageContext
+from brilliance_admin.translations import TranslateText as _
+from brilliance_admin.utils import get_logger
 
 logger = get_logger()
 
@@ -18,10 +18,10 @@ class SQLAlchemyAdminUpdate:
             pk: Any,
             data: dict,
             user: auth.UserABC,
-            language_manager: LanguageManager,
+            language_context: LanguageContext,
     ) -> schema.UpdateResult:
         if not self.has_update:
-            raise AdminAPIException(APIError(message=_('method_not_allowed')), status_code=500)
+            raise AdminAPIException(APIError(message=_('errors.method_not_allowed')), status_code=500)
 
         # pylint: disable=import-outside-toplevel
         from sqlalchemy import inspect
@@ -29,7 +29,7 @@ class SQLAlchemyAdminUpdate:
 
         if pk is None:
             raise AdminAPIException(
-                APIError(message=_('pk_not_found') % {'pk_name': self.pk_name}, code='pk_not_found'),
+                APIError(message=_('errors.pk_not_found') % {'pk_name': self.pk_name}, code='pk_not_found'),
                 status_code=400,
             )
 
@@ -42,7 +42,7 @@ class SQLAlchemyAdminUpdate:
             async with self.db_async_session() as session:
                 record = (await session.execute(stmt)).scalars().first()
                 if record is None:
-                    msg = _('record_not_found') % {'pk_name': self.pk_name, 'pk': pk}
+                    msg = _('errors.record_not_found') % {'pk_name': self.pk_name, 'pk': pk}
                     raise AdminAPIException(
                         APIError(message=msg, code='record_not_found'),
                         status_code=400,
@@ -59,7 +59,7 @@ class SQLAlchemyAdminUpdate:
                 type(self).__name__, self.table_schema.model.__name__, pk, e,
                 extra={'data': data},
             )
-            msg = _('connection_refused_error') % {'error': str(e)}
+            msg = _('errors.connection_refused_error') % {'error': str(e)}
             raise AdminAPIException(
                 APIError(message=msg, code='connection_refused_error'),
                 status_code=400,
@@ -84,7 +84,7 @@ class SQLAlchemyAdminUpdate:
                 extra={'data': data}
             )
             raise AdminAPIException(
-                APIError(message=_('db_error_update'), code='db_error_update'), status_code=500,
+                APIError(message=_('errors.db_error_update'), code='db_error_update'), status_code=500,
             ) from e
 
         logger.info(

brilliance_admin/locales/en.yml

@@ -0,0 +1,25 @@
+delete: 'Delete'
+delete_confirmation_text: "Are you sure you want to delete those records?\nThis action cannot be undone."
+deleted_successfully: 'The entries were successfully deleted.'
+
+errors:
+  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}'
+
+search_help: 'Available search fields: %(fields)s'
+sqlalchemy_search_help: |
+  <b>Available search fields:</b>
+  %(fields)s
+
+  <b>Available operators:</b>
+  <b>""</b> - quotes for exact match
+  <b>%%</b> - any sequence of characters
+  <b>_</b> - any single character

brilliance_admin/locales/ru.yml

@@ -0,0 +1,26 @@
+delete: 'Удалить'
+delete_confirmation_text: "Вы уверены, что хотите удалить данные записи?\nДанное действие нельзя отменить."
+deleted_successfully: 'Записи успешно удалены.'
+
+errors:
+  pk_not_found: 'Поле "%(pk_name)s" не найдено среди переданных данных.'
+  record_not_found: 'Запись по ключу %(pk_name)s=%(pk)s не найдена.'
+  db_error_create: 'Ошибка создания записи в базе данных.'
+  db_error_update: 'Ошибка обновления записи в базе данных.'
+  db_error_retrieve: 'Ошибка получения записи из базы данных.'
+  db_error_list: 'Ошибка получения данных таблицы из базы данных.'
+  connection_refused_error: 'Ошибка подключения к базе данных: %(error)s'
+  filters_exception: 'Произошла неизвестная техническая ошибка при фильтрации данных.'
+  method_not_allowed: 'Ошибка, данный метод недоступен.'
+  filter_error: 'Проишла ошибка при фильтрации: %(error)s'
+  serialize_field_error: 'Ошибка чтения данных: %(error)s'
+
+search_help: 'Доступные поля для поиска: %(fields)s'
+sqlalchemy_search_help: |
+  <b>Доступные поля для поиска:</b>
+  %(fields)s
+
+  <b>Доступные операторы:</b>
+  <b>""</b> - кавычки для точного совпадения
+  <b>%%</b> - любая последовательность символов
+  <b>_</b> - один любой символ

{admin_panel → brilliance_admin}/schema/admin_schema.py

@@ -1,7 +1,7 @@
 import importlib.metadata
 import json
 from importlib import resources
-from typing import Any, Dict, List, Optional, Type
+from typing import Any, Dict, List, Optional
 from urllib.parse import urljoin
 
 from fastapi import FastAPI, Request
@@ -9,11 +9,16 @@ 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
+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.translations import LanguageContext, LanguageManager
+from brilliance_admin.utils import DataclassBase, SupportsStr
+
+DEFAULT_LANGUAGES = {
+    'ru': 'Russian',
+    'en': 'English',
+}
 
 
 @dataclass
@@ -29,9 +34,9 @@ class AdminSchemaData(DataclassBase):
 # pylint: disable=too-many-instance-attributes
 @dataclass
 class AdminSettingsData(DataclassBase):
-    title: str | TranslateText
-    description: str | TranslateText | None
-    login_greetings_message: str | TranslateText | None
+    title: SupportsStr
+    description: SupportsStr | None
+    login_greetings_message: SupportsStr | None
     navbar_density: str
     languages: Dict[str, str] | None
 
@@ -39,7 +44,7 @@ class AdminSettingsData(DataclassBase):
 @dataclass
 class AdminIndexContextData(DataclassBase):
     title: str
-    favicon_image: str
+    favicon_image: str | None
     settings_json: str
 
 
@@ -48,30 +53,33 @@ class AdminSchema:
     groups: List[Group]
     auth: Any
 
-    title: str | TranslateText | None = 'Admin'
-    description: str | TranslateText | None = None
-    login_greetings_message: str | TranslateText | None = None
+    title: SupportsStr | None = 'Admin'
+    description: SupportsStr | None = None
+    login_greetings_message: SupportsStr | None = None
 
     logo_image: str | None = None
-    favicon_image: str = '/admin/static/favicon.jpg'
+    favicon_image: str | None = None
 
     navbar_density: str = 'default'
 
     backend_prefix = None
     static_prefix = None
 
-    language_manager_class: Type[LanguageManager] = LanguageManager
+    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')
 
-    def get_language_manager(self, language_slug: str | None) -> LanguageManager:
-        return self.language_manager_class(language_slug)
+        if not self.language_manager:
+            self.language_manager = LanguageManager(DEFAULT_LANGUAGES)
+
+    def get_language_context(self, language_slug: str | None) -> LanguageContext:
+        return LanguageContext(language_slug, language_manager=self.language_manager)
 
     def generate_schema(self, user: UserABC, language_slug: str | None) -> AdminSchemaData:
-        language_manager: LanguageManager = self.get_language_manager(language_slug)
+        language_context: LanguageContext = self.get_language_context(language_slug)
 
         groups = {}
 
@@ -80,7 +88,7 @@ class AdminSchema:
                 msg = f'Category group {type(group).__name__}.slug is empty'
                 raise AttributeError(msg)
 
-            groups[group.slug] = group.generate_schema(user, language_manager)
+            groups[group.slug] = group.generate_schema(user, language_context)
 
         return AdminSchemaData(
             groups=groups,
@@ -96,13 +104,13 @@ class AdminSchema:
 
     async def get_settings(self, request: Request) -> AdminSettingsData:
         language_slug = request.headers.get('Accept-Language')
-        language_manager: LanguageManager = self.get_language_manager(language_slug)
+        language_context: LanguageContext = self.get_language_context(language_slug)
 
         languages = None
-        if language_manager.languages:
+        if self.language_manager.languages:
             languages = {}
-            for k, v in language_manager.languages.items():
-                languages[k] = language_manager.get_text(v)
+            for k, v in self.language_manager.languages.items():
+                languages[k] = v
 
         return AdminSettingsData(
             title=self.title,
@@ -124,11 +132,11 @@ class AdminSchema:
             include_redoc=False,
     ) -> FastAPI:
         # pylint: disable=unused-variable
-        language_manager = self.get_language_manager(language_slug=None)
+        language_context = self.get_language_context(language_slug=None)
 
         app = FastAPI(
-            title=language_manager.get_text(self.title),
-            description=language_manager.get_text(self.description),
+            title=language_context.get_text(self.title),
+            description=language_context.get_text(self.description),
             debug=debug,
             docs_url='/docs' if include_docs else None,
             redoc_url=None,
@@ -143,7 +151,7 @@ class AdminSchema:
                 allow_headers=["*"]
             )
 
-        static_dir = resources.files("admin_panel").joinpath("static")
+        static_dir = resources.files("brilliance_admin").joinpath("static")
         app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
 
         app.state.schema = self
@@ -155,14 +163,14 @@ class AdminSchema:
             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)
+        from brilliance_admin.api.routers import brilliance_admin_router
+        app.include_router(brilliance_admin_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}
+        language_context = self.get_language_context(language_slug=None)
+        context = {'language_context': language_context}
 
         backend_prefix = self.backend_prefix
         if not backend_prefix:

{admin_panel → brilliance_admin}/schema/category.py

@@ -5,9 +5,9 @@ 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
+from brilliance_admin.auth import UserABC
+from brilliance_admin.translations import LanguageContext
+from brilliance_admin.utils import DataclassBase, SupportsStr, humanize_field_name
 
 
 # pylint: disable=too-many-instance-attributes
@@ -30,7 +30,6 @@ class FieldSchemaData(DataclassBase):
 
     choices: List[dict] | None = None
 
-    tag_colors: dict | None = None
     variant: str | None = None
     size: str | None = None
 
@@ -116,18 +115,18 @@ class CategorySchemaData(DataclassBase):
 
 class Category(abc.ABC):
     slug: ClassVar[str]
-    title: ClassVar[str | TranslateText | None] = None
-    description: ClassVar[str | TranslateText | None] = None
+    title: ClassVar[SupportsStr | None] = None
+    description: ClassVar[SupportsStr | 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:
+    def generate_schema(self, user: UserABC, language_context: LanguageContext) -> CategorySchemaData:
         return CategorySchemaData(
-            title=language_manager.get_text(self.title) or self.slug,
-            description=language_manager.get_text(self.description),
+            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,
         )

{admin_panel → brilliance_admin}/schema/graphs/category_graphs.py

@@ -2,10 +2,11 @@ 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
+from brilliance_admin.schema import Category
+from brilliance_admin.schema.category import GraphInfoSchemaData
+from brilliance_admin.schema.table.fields_schema import FieldsSchema
+from brilliance_admin.translations import LanguageContext
+from brilliance_admin.utils import SupportsStr
 
 
 class GraphData(BaseModel):
@@ -29,19 +30,19 @@ class CategoryGraphs(Category):
     _type_slug: str = 'graphs'
 
     search_enabled: bool = False
-    search_help: str | TranslateText | None = None
+    search_help: SupportsStr | None = None
 
     table_filters: FieldsSchema | None = None
 
-    def generate_schema(self, user, language_manager: LanguageManager) -> GraphInfoSchemaData:
-        schema = super().generate_schema(user, language_manager)
+    def generate_schema(self, user, language_context: LanguageContext) -> GraphInfoSchemaData:
+        schema = super().generate_schema(user, language_context)
         graph = GraphInfoSchemaData(
             search_enabled=self.search_enabled,
-            search_help=language_manager.get_text(self.search_help),
+            search_help=language_context.get_text(self.search_help),
         )
 
         if self.table_filters:
-            graph.table_filters = self.table_filters.generate_schema(user, language_manager)
+            graph.table_filters = self.table_filters.generate_schema(user, language_context)
 
         schema.graph_info = graph
         return schema

{admin_panel → brilliance_admin}/schema/group.py

@@ -3,10 +3,10 @@ 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
+from brilliance_admin.auth import UserABC
+from brilliance_admin.schema.category import Category, CategorySchemaData
+from brilliance_admin.translations import LanguageContext
+from brilliance_admin.utils import DataclassBase, SupportsStr, get_logger, humanize_field_name
 
 logger = get_logger()
 
@@ -23,8 +23,8 @@ class GroupSchemaData(DataclassBase):
 class Group(abc.ABC):
     categories: List[Category]
     slug: str
-    title: str | TranslateText | None = None
-    description: str | TranslateText | None = None
+    title: SupportsStr | None = None
+    description: SupportsStr | None = None
 
     # https://pictogrammers.com/library/mdi/
     icon: str | None = None
@@ -34,10 +34,10 @@ class Group(abc.ABC):
             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:
+    def generate_schema(self, user: UserABC, language_context: LanguageContext) -> GroupSchemaData:
         result = GroupSchemaData(
-            title=language_manager.get_text(self.title) or self.slug,
-            description=language_manager.get_text(self.description),
+            title=language_context.get_text(self.title) or humanize_field_name(self.slug),
+            description=language_context.get_text(self.description),
             icon=self.icon,
             categories={},
         )
@@ -55,7 +55,7 @@ class Group(abc.ABC):
                 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)
+            result.categories[category.slug] = category.generate_schema(user, language_context)
 
         return result
 

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

@@ -4,8 +4,9 @@ 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
+from brilliance_admin.schema.table.fields_schema import FieldsSchema
+from brilliance_admin.translations import DataclassBase
+from brilliance_admin.utils import SupportsStr
 
 
 class ActionData(BaseModel):
@@ -20,7 +21,7 @@ class ActionData(BaseModel):
 
 @dataclass
 class ActionMessage(DataclassBase):
-    text: str | TranslateText
+    text: SupportsStr
     type: str = 'success'
     position: str = 'top-center'
 
@@ -28,16 +29,16 @@ class ActionMessage(DataclassBase):
 @dataclass
 class ActionResult(DataclassBase):
     message: ActionMessage | None = None
-    persistent_message: str | TranslateText | None = None
+    persistent_message: SupportsStr | 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,
+    title: SupportsStr,
+    description: Optional[SupportsStr] = None,
+    confirmation_text: Optional[SupportsStr] = None,
 
     # https://vuetifyjs.com/en/styles/colors/#material-colors
     base_color: Optional[str] = None,