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

brilliance_admin/integrations/sqlalchemy/__init__.py

@@ -1,5 +1,6 @@
 # pylint: disable=wildcard-import, unused-wildcard-import, unused-import
 # flake8: noqa: F405
+from .fields import SQLAlchemyRelatedField
 from .auth import SQLAlchemyJWTAdminAuthentication
 from .autocomplete import SQLAlchemyAdminAutocompleteMixin
 from .fields_schema import SQLAlchemyFieldsSchema

brilliance_admin/integrations/sqlalchemy/auth.py

@@ -54,7 +54,7 @@ class SQLAlchemyJWTAdminAuthentication(AdminAuthentication):
             logger.exception(
                 'SQLAlchemy %s login db error: %s', type(self).__name__, e,
             )
-            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,
@@ -127,7 +127,7 @@ class SQLAlchemyJWTAdminAuthentication(AdminAuthentication):
             logger.exception(
                 'SQLAlchemy %s authenticate db error: %s', type(self).__name__, e,
             )
-            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,

brilliance_admin/integrations/sqlalchemy/autocomplete.py

@@ -32,7 +32,11 @@ class SQLAlchemyAdminAutocompleteMixin:
         if not field:
             raise Exception(f'Field "{data.field_slug}" is not found')
 
-        async with self.db_async_session() as session:
-            results = await field.autocomplete(self.model, data, user, extra={'db_session': session})
+        results = await field.autocomplete(
+            self.model,
+            data,
+            user,
+            extra={'db_async_session': self.db_async_session},
+        )
 
         return AutocompleteResult(results=results)

brilliance_admin/integrations/sqlalchemy/fields.py

@@ -43,7 +43,7 @@ class SQLAlchemyRelatedField(TableField):
     # - для доступа к связи через ORM
     #   getattr(record, rel_name)
     # - для записи и чтения связанных объектов
-    rel_name: str | None = None
+    rel_name: str | None
 
     # Класс связанной SQLAlchemy-модели.
     # Откуда берётся:
@@ -101,11 +101,11 @@ class SQLAlchemyRelatedField(TableField):
         from sqlalchemy import select
         from sqlalchemy.sql import expression
 
-        if extra is None or extra.get('db_session') is None:
-            msg = f'SQLAlchemyRelatedField.autocomplete {type(self).__name__} requires extra["db_session"] (AsyncSession)'
+        if extra is None or extra.get('db_async_session') is None:
+            msg = f'SQLAlchemyRelatedField.autocomplete {type(self).__name__} requires extra["db_async_session"] (AsyncSession)'
             raise AttributeError(msg)
 
-        session = extra['db_session']
+        db_async_session = extra['db_async_session']
 
         results = []
 
@@ -125,7 +125,9 @@ class SQLAlchemyRelatedField(TableField):
         if existed_choices and hasattr(target_model, 'id'):
             stmt = stmt.where(getattr(target_model, 'id').in_(existed_choices) | expression.true())
 
-        records = (await session.execute(stmt)).scalars().all()
+        async with db_async_session() as session:
+            records = (await session.execute(stmt)).scalars().all()
+
         for record in records:
             results.append(Record(key=getattr(record, 'id'), title=str(record)))
 
@@ -139,20 +141,22 @@ class SQLAlchemyRelatedField(TableField):
         - value всегда scalar (None или int)
         - ORM-объект доступен через extra["record"]
         """
+        if not value:
+            return
+
         record = extra.get('record')
         if record is None:
             raise FieldError(f'Missing record in serialize context in value: {value}')
 
+        related = getattr(record, self.rel_name, None)
+
         if self.many:
-            related = getattr(record, self.rel_name, None)
             if related is None:
-                raise FieldError(f'Related field "{self.rel_name}" is missing on record {record} (many=True)')
-
+                raise FieldError(f'Many Related field "{self.rel_name}" is missing on record "{record}"')
             return [{'key': get_pk(obj), 'title': str(obj)} for obj in related]
 
-        related = getattr(record, self.rel_name, None)
         if related is None:
-            raise FieldError(f'Related field "{self.rel_name}" is missing on record (many=False)')
+            return None
 
         return {'key': get_pk(related), 'title': str(related)}
 

brilliance_admin/integrations/sqlalchemy/fields_schema.py

@@ -54,9 +54,6 @@ class SQLAlchemyFieldsSchema(schema.FieldsSchema):
                 and not col.primary_key
             )
 
-            if "choices" in info:
-                field_data["choices"] = [(c[0], c[1]) for c in info["choices"]]
-
             col_type = col.type
             try:
                 py_t = col_type.python_type
@@ -64,12 +61,16 @@ class SQLAlchemyFieldsSchema(schema.FieldsSchema):
                 py_t = None
 
             impl = getattr(attr, 'impl', None)
-            is_mutable = isinstance(impl, Mutable)
+            is_impl_mutable = isinstance(impl, Mutable)
 
             # Foreign key column
             if col.foreign_keys:
                 continue
 
+            elif "choices" in info:
+                field_data["choices"] = info['choices']
+                field_class = schema.ChoiceField
+
             elif isinstance(col_type, (sqltypes.BigInteger, sqltypes.Integer)) or py_t is int:
                 field_class = schema.IntegerField
 
@@ -97,7 +98,7 @@ class SQLAlchemyFieldsSchema(schema.FieldsSchema):
             elif isinstance(col_type, ARRAY):
                 field_class = schema.ArrayField
                 field_data["array_type"] = type(col_type.item_type).__name__.lower()
-                field_data["read_only"] = not is_mutable
+                field_data["read_only"] = is_impl_mutable or isinstance(col_type, Mutable)
 
             elif isinstance(col_type, sqltypes.NullType):
                 continue
@@ -126,6 +127,12 @@ class SQLAlchemyFieldsSchema(schema.FieldsSchema):
 
         # relationship-поля
         for rel in mapper.relationships:
+            # relationship, у которых есть локальные FK-колонки, не добавляем в схему,
+            # так как связь редактируется через scalar-поле (FK),
+            # а relationship используется только для ORM-навигации
+            if any(col.foreign_keys for col in rel.local_columns):
+                continue
+
             field_slug = rel.key
 
             field_data = {}
@@ -233,15 +240,17 @@ class SQLAlchemyFieldsSchema(schema.FieldsSchema):
         return stmt
 
     async def serialize(self, record, extra: dict, *args, **kwargs) -> dict:
-        # pylint: disable=import-outside-toplevel
-        from sqlalchemy import inspect
 
         # Convert model values to dict
-        record_data = {
-            attr.key: getattr(record, attr.key, None)
-            for attr in inspect(record).mapper.column_attrs
-            if self.get_field(attr.key)
-        }
+        record_data = {}
+
+        for slug, field in self.get_fields().items():
+            # pylint: disable=protected-access
+            if field._type == 'related':
+                record_data[slug] = record
+            else:
+                record_data[slug] = getattr(record, slug, None)
+
         return await super().serialize(record_data, extra, *args, **kwargs)
 
     def validate_incoming_data(self, data):

brilliance_admin/integrations/sqlalchemy/table/base.py

@@ -123,11 +123,11 @@ class SQLAlchemyAdminBase(SQLAlchemyAdminAutocompleteMixin, CategoryTable):
             # pylint: disable=protected-access
             if field._type == "related":
 
-                # pylint: disable=import-outside-toplevel
-                from sqlalchemy import inspect
-
-                model_attrs = [attr.key for attr in inspect(self.model).mapper.attrs]
                 if not hasattr(self.model, field.rel_name):
+                    # pylint: disable=import-outside-toplevel
+                    from sqlalchemy import inspect
+                    model_attrs = [attr.key for attr in inspect(self.model).mapper.attrs]
+
                     msg = EXCEPTION_REL_NAME.format(
                         slug=slug,
                         model_name=self.model.__name__,

brilliance_admin/integrations/sqlalchemy/table/create.py

@@ -18,7 +18,7 @@ class SQLAlchemyAdminCreate:
             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(

brilliance_admin/integrations/sqlalchemy/table/delete.py

@@ -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')))

brilliance_admin/integrations/sqlalchemy/table/list.py

@@ -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))

brilliance_admin/integrations/sqlalchemy/table/retrieve.py

@@ -1,7 +1,8 @@
 from typing import Any
 
 from brilliance_admin import auth, schema
-from brilliance_admin.exceptions import AdminAPIException, APIError
+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
@@ -12,6 +13,8 @@ logger = get_logger()
 class SQLAlchemyAdminRetrieveMixin:
     has_retrieve: bool = True
 
+    table_schema: SQLAlchemyFieldsSchema
+
     async def retrieve(
             self,
             pk: Any,
@@ -19,7 +22,7 @@ class SQLAlchemyAdminRetrieveMixin:
             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,

brilliance_admin/integrations/sqlalchemy/table/update.py

@@ -21,7 +21,7 @@ class SQLAlchemyAdminUpdate:
             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

@@ -1,13 +1,19 @@
 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.'
-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.'
-connection_refused_error: 'Database connection error: %(error)s'
+
+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>
@@ -17,6 +23,3 @@ sqlalchemy_search_help: |
   <b>""</b> - quotes for exact match
   <b>%%</b> - any sequence of characters
   <b>_</b> - any single character
-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}'

brilliance_admin/locales/ru.yml

@@ -1,13 +1,20 @@
 delete: 'Удалить'
 delete_confirmation_text: "Вы уверены, что хотите удалить данные записи?\nДанное действие нельзя отменить."
 deleted_successfully: 'Записи успешно удалены.'
-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'
+
+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>
@@ -17,6 +24,3 @@ sqlalchemy_search_help: |
   <b>""</b> - кавычки для точного совпадения
   <b>%%</b> - любая последовательность символов
   <b>_</b> - один любой символ
-filters_exception: 'Произошла неизвестная техническая ошибка при фильтрации данных.'
-method_not_allowed: 'Ошибка, данный метод недоступен.'
-filter_error: 'Проишла ошибка при фильтрации: {error}'

brilliance_admin/schema/category.py

@@ -7,7 +7,7 @@ from pydantic_core import core_schema
 
 from brilliance_admin.auth import UserABC
 from brilliance_admin.translations import LanguageContext
-from brilliance_admin.utils import DataclassBase, SupportsStr
+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
 
@@ -126,7 +125,7 @@ class Category(abc.ABC):
 
     def generate_schema(self, user: UserABC, language_context: LanguageContext) -> CategorySchemaData:
         return CategorySchemaData(
-            title=language_context.get_text(self.title) or self.slug,
+            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,

brilliance_admin/schema/group.py

@@ -6,7 +6,7 @@ from pydantic.dataclasses import dataclass
 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
+from brilliance_admin.utils import DataclassBase, SupportsStr, get_logger, humanize_field_name
 
 logger = get_logger()
 
@@ -36,7 +36,7 @@ class Group(abc.ABC):
 
     def generate_schema(self, user: UserABC, language_context: LanguageContext) -> GroupSchemaData:
         result = GroupSchemaData(
-            title=language_context.get_text(self.title) or self.slug,
+            title=language_context.get_text(self.title) or humanize_field_name(self.slug),
             description=language_context.get_text(self.description),
             icon=self.icon,
             categories={},

brilliance_admin/schema/table/fields/base.py

@@ -1,6 +1,7 @@
 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
 
@@ -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
 
@@ -62,8 +65,6 @@ class IntegerField(TableField):
     def generate_schema(self, user, field_slug, language_context: LanguageContext) -> FieldSchemaData:
         schema = super().generate_schema(user, field_slug, language_context)
 
-        schema.choices = self.choices
-
         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_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
 
@@ -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 __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(),
+        }

brilliance_admin/schema/table/fields_schema.py

@@ -148,9 +148,10 @@ class FieldsSchema:
             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_context)
-            fields_schema.fields[field_slug] = field_schema.to_dict(keep_none=False)
+            fields_schema.fields[field_slug] = field_schema.to_dict(keep_none=False, context=context)
 
         return fields_schema