brilliance-admin 0.40.0__py3-none-any.whl → 0.41.2__py3-none-any.whl

{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,11 +34,10 @@ 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
-    logo_image: str | None
     languages: Dict[str, str] | None
 
 
@@ -49,27 +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 | None = None
+
     navbar_density: str = 'default'
 
-    favicon_image: str = '/admin/static/favicon.ico'
     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 = {}
 
@@ -78,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,
@@ -94,20 +104,19 @@ 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,
             description=self.description,
             login_greetings_message=self.login_greetings_message,
             navbar_density=self.navbar_density,
-            logo_image=None,
             languages=languages,
         )
 
@@ -123,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,
@@ -142,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
@@ -154,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:
@@ -171,11 +180,16 @@ class AdminSchema:
         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('admin-panel'),
+            'version': importlib.metadata.version('brilliance-admin'),
             'api_timeout_ms': 1000 * 5,
+            'logo_image': logo_image,
         }
         data = AdminIndexContextData(
             title=str(self.title),

{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
 
 
 # pylint: disable=too-many-instance-attributes
@@ -116,18 +116,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 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
 
 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 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,

{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

@@ -4,24 +4,24 @@ from typing import Any, ClassVar, List, Tuple
 
 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,
@@ -59,8 +59,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)
+    def generate_schema(self, user, field_slug, language_context: LanguageContext) -> FieldSchemaData:
+        schema = super().generate_schema(user, field_slug, language_context)
 
         schema.choices = self.choices
 
@@ -97,8 +97,8 @@ class StringField(TableField):
 
     choices: List[Tuple[str, str]] | 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
@@ -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
@@ -234,8 +234,8 @@ class ChoiceField(TableField):
     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 generate_schema(self, user, field_slug, language_context: LanguageContext) -> FieldSchemaData:
+        schema = super().generate_schema(user, field_slug, language_context)
 
         schema.choices = self.choices
 

{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,13 +143,13 @@ 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,
         )
 
         for field_slug, field in self.get_fields().items():
-            field_schema: FieldSchemaData = field.generate_schema(user, field_slug, language_manager)
+            field_schema: FieldSchemaData = field.generate_schema(user, field_slug, language_context)
             fields_schema.fields[field_slug] = field_schema.to_dict(keep_none=False)
 
         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