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

{admin_panel → brilliance_admin}/__init__.py

@@ -1,4 +1,4 @@
 # pylint: disable=wildcard-import, unused-wildcard-import, unused-import
 # flake8: noqa: F405
-from admin_panel.integrations import sqlalchemy
-from admin_panel import schema
+from brilliance_admin.integrations import sqlalchemy
+from brilliance_admin import schema

brilliance_admin/api/routers.py

@@ -0,0 +1,18 @@
+from fastapi import APIRouter
+
+from .views.schema import router as schema_router
+from .views.table import router as schema_table
+from .views.auth import router as schema_auth
+from .views.autocomplete import router as schema_autocomplete
+from .views.graphs import router as schema_graphs
+from .views.settings import router as schema_settings
+from .views.index import router as schema_index
+
+brilliance_admin_router = APIRouter()
+brilliance_admin_router.include_router(schema_router)
+brilliance_admin_router.include_router(schema_table)
+brilliance_admin_router.include_router(schema_auth)
+brilliance_admin_router.include_router(schema_autocomplete)
+brilliance_admin_router.include_router(schema_graphs)
+brilliance_admin_router.include_router(schema_settings)
+brilliance_admin_router.include_router(schema_index)

{admin_panel → brilliance_admin}/api/utils.py

@@ -1,6 +1,6 @@
 from fastapi import HTTPException
 
-from admin_panel.auth import AdminAuthentication
+from brilliance_admin.auth import AdminAuthentication
 
 
 async def get_user(request):

{admin_panel → brilliance_admin}/api/views/auth.py

@@ -1,10 +1,10 @@
 from fastapi import APIRouter, Request
 from fastapi.responses import JSONResponse
 
-from admin_panel.auth import AdminAuthentication, AuthData, AuthResult
-from admin_panel.exceptions import AdminAPIException, APIError
-from admin_panel.schema.admin_schema import AdminSchema
-from admin_panel.translations import LanguageManager
+from brilliance_admin.auth import AdminAuthentication, AuthData, AuthResult
+from brilliance_admin.exceptions import AdminAPIException, APIError
+from brilliance_admin.schema.admin_schema import AdminSchema
+from brilliance_admin.translations import LanguageContext
 
 router = APIRouter(prefix="/auth", tags=["Auth"])
 
@@ -17,8 +17,8 @@ async def login(request: Request, auth_data: AuthData) -> AuthResult:
     schema: AdminSchema = request.app.state.schema
 
     language_slug = request.headers.get('Accept-Language')
-    language_manager: LanguageManager = schema.get_language_manager(language_slug)
-    context = {'language_manager': language_manager}
+    language_context: LanguageContext = schema.get_language_context(language_slug)
+    context = {'language_context': language_context}
 
     auth: AdminAuthentication = schema.auth
     try:

{admin_panel → brilliance_admin}/api/views/autocomplete.py

@@ -1,12 +1,12 @@
 from fastapi import APIRouter, Request
 from fastapi.responses import JSONResponse
 
-from admin_panel.api.utils import get_category
-from admin_panel.exceptions import AdminAPIException
-from admin_panel.schema.admin_schema import AdminSchema
-from admin_panel.schema.table.table_models import AutocompleteData, AutocompleteResult
-from admin_panel.translations import LanguageManager
-from admin_panel.utils import get_logger
+from brilliance_admin.api.utils import get_category
+from brilliance_admin.exceptions import AdminAPIException
+from brilliance_admin.schema.admin_schema import AdminSchema
+from brilliance_admin.schema.table.table_models import AutocompleteData, AutocompleteResult
+from brilliance_admin.translations import LanguageContext
+from brilliance_admin.utils import get_logger
 
 router = APIRouter(prefix="/autocomplete", tags=["Autocomplete"])
 
@@ -19,11 +19,11 @@ async def autocomplete(request: Request, group: str, category: str, data: Autoco
     schema_category, user = await get_category(request, group, category)
 
     language_slug = request.headers.get('Accept-Language')
-    language_manager: LanguageManager = schema.get_language_manager(language_slug)
-    context = {'language_manager': language_manager}
+    language_context: LanguageContext = schema.get_language_context(language_slug)
+    context = {'language_context': language_context}
 
     try:
-        result: AutocompleteResult = await schema_category.autocomplete(data, user, language_manager)
+        result: AutocompleteResult = await schema_category.autocomplete(data, user, language_context)
     except AdminAPIException as e:
         return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
     except Exception as e:

{admin_panel → brilliance_admin}/api/views/graphs.py

@@ -1,12 +1,12 @@
 from fastapi import APIRouter, Request
 from fastapi.responses import JSONResponse
 
-from admin_panel.api.utils import get_category
-from admin_panel.exceptions import AdminAPIException
-from admin_panel.schema.admin_schema import AdminSchema
-from admin_panel.schema.graphs.category_graphs import CategoryGraphs, GraphData, GraphsDataResult
-from admin_panel.translations import LanguageManager
-from admin_panel.utils import get_logger
+from brilliance_admin.api.utils import get_category
+from brilliance_admin.exceptions import AdminAPIException
+from brilliance_admin.schema.admin_schema import AdminSchema
+from brilliance_admin.schema.graphs.category_graphs import CategoryGraphs, GraphData, GraphsDataResult
+from brilliance_admin.translations import LanguageContext
+from brilliance_admin.utils import get_logger
 
 router = APIRouter(prefix="/graph", tags=["Category - Graph"])
 
@@ -21,8 +21,8 @@ async def graph_data(request: Request, group: str, category: str, data: GraphDat
     result: GraphsDataResult = await schema_category.get_data(data, user)
 
     language_slug = request.headers.get('Accept-Language')
-    language_manager: LanguageManager = schema.get_language_manager(language_slug)
-    context = {'language_manager': language_manager}
+    language_context: LanguageContext = schema.get_language_context(language_slug)
+    context = {'language_context': language_context}
 
     try:
         return JSONResponse(result.model_dump(mode='json', context=context))

{admin_panel → brilliance_admin}/api/views/index.py

@@ -1,15 +1,17 @@
+from pathlib import PurePosixPath
+
 from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import HTMLResponse
 from fastapi.templating import Jinja2Templates
 from jinja2 import Environment, PackageLoader, select_autoescape
 
-from admin_panel.schema import AdminSchema
+from brilliance_admin.schema import AdminSchema
 
 router = APIRouter()
 
 templates = Jinja2Templates(
     env=Environment(
-        loader=PackageLoader("admin_panel", "templates"),
+        loader=PackageLoader("brilliance_admin", "templates"),
         autoescape=select_autoescape(["html", "xml"]),
     )
 )
@@ -25,8 +27,13 @@ async def admin_index(request: Request, rest_of_path: str):
     The request responds with a pre-rendered SPA served as an HTML page.
     '''
 
-    path = "/" + rest_of_path
-    if path in EXACT_BLOCK or path.startswith(PREFIX_BLOCK):
+    path = PurePosixPath('/' + rest_of_path)
+
+    if '..' in path.parts:
+        raise HTTPException(status_code=404)
+
+    path_str = str(path)
+    if path_str in EXACT_BLOCK or path_str.startswith(PREFIX_BLOCK):
         raise HTTPException(status_code=404)
 
     schema: AdminSchema = request.app.state.schema

{admin_panel → brilliance_admin}/api/views/schema.py

@@ -1,9 +1,9 @@
 from fastapi import APIRouter, Request
 from fastapi.responses import JSONResponse
 
-from admin_panel.auth import AdminAuthentication
-from admin_panel.exceptions import AdminAPIException, APIError
-from admin_panel.schema import AdminSchema, AdminSchemaData
+from brilliance_admin.auth import AdminAuthentication
+from brilliance_admin.exceptions import AdminAPIException, APIError
+from brilliance_admin.schema import AdminSchema, AdminSchemaData
 
 router = APIRouter(prefix="/schema", tags=["Main admin schema"])
 

{admin_panel → brilliance_admin}/api/views/settings.py

@@ -1,9 +1,9 @@
 from fastapi import APIRouter, Request
 from fastapi.responses import JSONResponse
 
-from admin_panel.exceptions import AdminAPIException, APIError
-from admin_panel.schema.admin_schema import AdminSchema, AdminSettingsData
-from admin_panel.translations import LanguageManager
+from brilliance_admin.exceptions import AdminAPIException, APIError
+from brilliance_admin.schema.admin_schema import AdminSchema, AdminSettingsData
+from brilliance_admin.translations import LanguageContext
 
 router = APIRouter(tags=["Settings"])
 
@@ -19,8 +19,8 @@ async def get_settings(request: Request) -> AdminSettingsData:
     schema: AdminSchema = request.app.state.schema
 
     language_slug = request.headers.get('Accept-Language')
-    language_manager: LanguageManager = schema.get_language_manager(language_slug)
-    context = {'language_manager': language_manager}
+    language_context: LanguageContext = schema.get_language_context(language_slug)
+    context = {'language_context': language_context}
 
     try:
         admin_settings = await schema.get_settings(request)

{admin_panel → brilliance_admin}/api/views/table.py

@@ -3,14 +3,14 @@ from typing import Any
 from fastapi import APIRouter, HTTPException, Request
 from fastapi.responses import JSONResponse
 
-from admin_panel.api.utils import get_category
-from admin_panel.exceptions import AdminAPIException, APIError
-from admin_panel.schema import AdminSchema
-from admin_panel.schema.table.admin_action import ActionData, ActionResult
-from admin_panel.schema.table.category_table import CategoryTable
-from admin_panel.schema.table.table_models import CreateResult, ListData, RetrieveResult, TableListResult, UpdateResult
-from admin_panel.translations import LanguageManager
-from admin_panel.utils import get_logger
+from brilliance_admin.api.utils import get_category
+from brilliance_admin.exceptions import AdminAPIException, APIError
+from brilliance_admin.schema import AdminSchema
+from brilliance_admin.schema.table.admin_action import ActionData, ActionResult
+from brilliance_admin.schema.table.category_table import CategoryTable
+from brilliance_admin.schema.table.table_models import CreateResult, ListData, RetrieveResult, TableListResult, UpdateResult
+from brilliance_admin.translations import LanguageContext
+from brilliance_admin.utils import get_logger
 
 router = APIRouter(prefix="/table", tags=["Category - Table"])
 
@@ -25,11 +25,11 @@ async def table_list(request: Request, group: str, category: str, list_data: Lis
     schema_category, user = await get_category(request, group, category, check_type=CategoryTable)
 
     language_slug = request.headers.get('Accept-Language')
-    language_manager: LanguageManager = schema.get_language_manager(language_slug)
-    context = {'language_manager': language_manager}
+    language_context: LanguageContext = schema.get_language_context(language_slug)
+    context = {'language_context': language_context}
 
     try:
-        result: TableListResult = await schema_category.get_list(list_data, user, language_manager)
+        result: TableListResult = await schema_category.get_list(list_data, user, language_context)
     except AdminAPIException as e:
         return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
 
@@ -49,11 +49,11 @@ async def table_retrieve(request: Request, group: str, category: str, pk: Any) -
         raise HTTPException(status_code=404, detail=f"Category {group}.{category} is not allowed for retrive")
 
     language_slug = request.headers.get('Accept-Language')
-    language_manager: LanguageManager = schema.get_language_manager(language_slug)
-    context = {'language_manager': language_manager}
+    language_context: LanguageContext = schema.get_language_context(language_slug)
+    context = {'language_context': language_context}
 
     try:
-        result: RetrieveResult = await schema_category.retrieve(pk, user, language_manager)
+        result: RetrieveResult = await schema_category.retrieve(pk, user, language_context)
     except AdminAPIException as e:
         return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
 
@@ -72,11 +72,11 @@ async def table_create(request: Request, group: str, category: str) -> CreateRes
         raise HTTPException(status_code=404, detail=f"Category {group}.{category} is not allowed for create")
 
     language_slug = request.headers.get('Accept-Language')
-    language_manager: LanguageManager = schema.get_language_manager(language_slug)
-    context = {'language_manager': language_manager}
+    language_context: LanguageContext = schema.get_language_context(language_slug)
+    context = {'language_context': language_context}
 
     try:
-        result: CreateResult = await schema_category.create(await request.json(), user, language_manager)
+        result: CreateResult = await schema_category.create(await request.json(), user, language_context)
     except AdminAPIException as e:
         return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
 
@@ -95,11 +95,11 @@ async def table_update(request: Request, group: str, category: str, pk: Any) ->
         raise HTTPException(status_code=404, detail=f"Category {group}.{category} is not allowed for update")
 
     language_slug = request.headers.get('Accept-Language')
-    language_manager: LanguageManager = schema.get_language_manager(language_slug)
-    context = {'language_manager': language_manager}
+    language_context: LanguageContext = schema.get_language_context(language_slug)
+    context = {'language_context': language_context}
 
     try:
-        result: UpdateResult = await schema_category.update(pk, await request.json(), user, language_manager)
+        result: UpdateResult = await schema_category.update(pk, await request.json(), user, language_context)
     except AdminAPIException as e:
         return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
 
@@ -122,13 +122,13 @@ async def table_action(
     schema_category, user = await get_category(request, group, category, check_type=CategoryTable)
 
     language_slug = request.headers.get('Accept-Language')
-    language_manager: LanguageManager = schema.get_language_manager(language_slug)
-    context = {'language_manager': language_manager}
+    language_context: LanguageContext = schema.get_language_context(language_slug)
+    context = {'language_context': language_context}
 
     try:
         # pylint: disable=protected-access
         result: ActionResult = await schema_category._perform_action(
-            request, action, action_data, language_manager, user,
+            request, action, action_data, language_context, user,
         )
     except AdminAPIException as e:
         return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)

{admin_panel → brilliance_admin}/auth.py

@@ -2,7 +2,7 @@ import abc
 
 from pydantic import BaseModel
 from pydantic.dataclasses import dataclass
-from admin_panel.utils import DataclassBase
+from brilliance_admin.utils import DataclassBase
 
 
 @dataclass

{admin_panel → brilliance_admin}/exceptions.py

@@ -3,13 +3,12 @@ from typing import Dict
 from pydantic import Field
 from pydantic.dataclasses import dataclass
 
-from admin_panel.translations import TranslateText
-from admin_panel.utils import DataclassBase
+from brilliance_admin.utils import DataclassBase, SupportsStr
 
 
 @dataclass
 class FieldError(DataclassBase, Exception):
-    message: str | TranslateText = None
+    message: SupportsStr = None
     code: str | None = None
 
     def __post_init__(self):
@@ -20,7 +19,7 @@ class FieldError(DataclassBase, Exception):
 
 @dataclass
 class APIError(DataclassBase):
-    message: str | TranslateText | None = None
+    message: SupportsStr | None = None
     code: str | None = None
     field_errors: Dict[str, FieldError] | None = None
 

{admin_panel → 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

{admin_panel → brilliance_admin}/integrations/sqlalchemy/auth.py

@@ -1,7 +1,7 @@
-from admin_panel.auth import AdminAuthentication, AuthData, AuthResult, UserABC, UserResult
-from admin_panel.exceptions import AdminAPIException, APIError
-from admin_panel.translations import TranslateText as _
-from admin_panel.utils import get_logger
+from brilliance_admin.auth import AdminAuthentication, AuthData, AuthResult, UserABC, UserResult
+from brilliance_admin.exceptions import AdminAPIException, APIError
+from brilliance_admin.translations import TranslateText as _
+from brilliance_admin.utils import get_logger
 
 logger = get_logger()
 
@@ -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,

{admin_panel → brilliance_admin}/integrations/sqlalchemy/autocomplete.py

@@ -1,11 +1,11 @@
-from admin_panel.auth import UserABC
-from admin_panel.schema.table.table_models import AutocompleteData, AutocompleteResult
-from admin_panel.translations import LanguageManager
+from brilliance_admin.auth import UserABC
+from brilliance_admin.schema.table.table_models import AutocompleteData, AutocompleteResult
+from brilliance_admin.translations import LanguageContext
 
 
 class SQLAlchemyAdminAutocompleteMixin:
     async def autocomplete(
-            self, data: AutocompleteData, user: UserABC, language_manager: LanguageManager,
+            self, data: AutocompleteData, user: UserABC, language_context: LanguageContext,
     ) -> AutocompleteResult:
         form_schema = None
 
@@ -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)

{admin_panel → brilliance_admin}/integrations/sqlalchemy/fields.py

@@ -2,14 +2,14 @@ from typing import Any, List
 
 from pydantic.dataclasses import dataclass
 
-from admin_panel.auth import UserABC
-from admin_panel.exceptions import AdminAPIException, APIError, FieldError
-from admin_panel.schema.category import FieldSchemaData
-from admin_panel.schema.table.fields.base import TableField
-from admin_panel.schema.table.table_models import Record
-from admin_panel.translations import LanguageManager
-from admin_panel.translations import TranslateText as _
-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
+from brilliance_admin.schema.table.fields.base import TableField
+from brilliance_admin.schema.table.table_models import Record
+from brilliance_admin.translations import LanguageContext
+from brilliance_admin.translations import TranslateText as _
+from brilliance_admin.utils import DeserializeAction
 
 
 def get_pk(obj):
@@ -43,7 +43,7 @@ class SQLAlchemyRelatedField(TableField):
     # - для доступа к связи через ORM
     #   getattr(record, rel_name)
     # - для записи и чтения связанных объектов
-    rel_name: str | None = None
+    rel_name: str | None
 
     # Класс связанной SQLAlchemy-модели.
     # Откуда берётся:
@@ -58,8 +58,8 @@ class SQLAlchemyRelatedField(TableField):
     # Работает только если many=True
     dual_list: bool = False
 
-    def generate_schema(self, user: UserABC, field_slug, language_manager: LanguageManager) -> FieldSchemaData:
-        schema = super().generate_schema(user, field_slug, language_manager)
+    def generate_schema(self, user: UserABC, field_slug, language_context: LanguageContext) -> FieldSchemaData:
+        schema = super().generate_schema(user, field_slug, language_context)
         schema.many = self.many
         schema.rel_name = self.rel_name
         schema.dual_list = self.dual_list
@@ -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)}
 

{admin_panel → brilliance_admin}/integrations/sqlalchemy/fields_schema.py

@@ -1,12 +1,12 @@
 import datetime
 from typing import Any
 
-from admin_panel import schema
-from admin_panel.exceptions import AdminAPIException, APIError
-from admin_panel.integrations.sqlalchemy.fields import SQLAlchemyRelatedField
-from admin_panel.schema.table.fields.base import DateTimeField
-from admin_panel.translations import TranslateText as _
-from admin_panel.utils import DeserializeAction, humanize_field_name
+from brilliance_admin import schema
+from brilliance_admin.exceptions import AdminAPIException, APIError
+from brilliance_admin.integrations.sqlalchemy.fields import SQLAlchemyRelatedField
+from brilliance_admin.schema.table.fields.base import DateTimeField
+from brilliance_admin.translations import TranslateText as _
+from brilliance_admin.utils import DeserializeAction, humanize_field_name
 
 FIELD_FILTERS_NOT_FOUND = '{class_name} filter "{field_slug}" not found inside table_filters fields: {available_filters}'
 
@@ -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):

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

@@ -1,9 +1,9 @@
 from typing import Any
 
-from admin_panel.integrations.sqlalchemy.autocomplete import SQLAlchemyAdminAutocompleteMixin
-from admin_panel.integrations.sqlalchemy.fields_schema import SQLAlchemyFieldsSchema
-from admin_panel.schema.table.category_table import CategoryTable
-from admin_panel.translations import TranslateText as _
+from brilliance_admin.integrations.sqlalchemy.autocomplete import SQLAlchemyAdminAutocompleteMixin
+from brilliance_admin.integrations.sqlalchemy.fields_schema import SQLAlchemyFieldsSchema
+from brilliance_admin.schema.table.category_table import CategoryTable
+from brilliance_admin.translations import TranslateText as _
 
 EXCEPTION_REL_NAME = '''
 Model "{model_name}" doesn\'t contain rel_name:"{rel_name}" for field "{slug}"
@@ -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__,