brilliance-admin 0.42.0__py3-none-any.whl

admin_panel/integrations/sqlalchemy/autocomplete.py

@@ -0,0 +1,38 @@
+from admin_panel.auth import UserABC
+from admin_panel.schema.table.table_models import AutocompleteData, AutocompleteResult
+from admin_panel.translations import LanguageManager
+
+
+class SQLAlchemyAdminAutocompleteMixin:
+    async def autocomplete(
+            self, data: AutocompleteData, user: UserABC, language_manager: LanguageManager,
+    ) -> AutocompleteResult:
+        form_schema = None
+
+        if data.action_name is not None:
+            action_fn = self._get_action_fn(data.action_name)
+            if not action_fn:
+                raise Exception(f'Action "{data.action_name}" is not found')
+
+            if not action_fn.form_schema:
+                raise Exception(f'Action "{data.action_name}" form_schema is None')
+
+            form_schema = action_fn.form_schema
+
+        elif data.is_filter:
+            if not self.table_filters:
+                raise Exception(f'Action "{data.action_name}" table_filters is None')
+
+            form_schema = self.table_filters
+
+        else:
+            form_schema = self.table_schema
+
+        field = form_schema.get_field(data.field_slug)
+        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})
+
+        return AutocompleteResult(results=results)

admin_panel/integrations/sqlalchemy/fields.py

@@ -0,0 +1,254 @@
+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
+
+
+def get_pk(obj):
+    pk_cols = obj.__mapper__.primary_key
+    if len(pk_cols) != 1:
+        raise NotImplementedError('Composite primary key is not supported')
+    return getattr(obj, pk_cols[0].key)
+
+
+@dataclass
+class SQLAlchemyRelatedField(TableField):
+    _type: str = 'related'
+
+    # Тип связи.
+    # Откуда берётся:
+    # - из SQLAlchemy relationship.uselist
+    #   rel.uselist == True  -> список связанных объектов
+    #   rel.uselist == False -> одиночная связь
+    #
+    # Зачем нужен:
+    # - чтобы понимать, ожидать list или один объект
+    # - влияет на логику update_related и serialize
+    many: bool = False
+
+    # Имя relationship-атрибута на модели.
+    # Откуда берётся:
+    # - из mapper.relationships: rel.key
+    # - либо через поиск relationship по FK колонке (col.local_columns)
+    #
+    # Зачем нужен:
+    # - для доступа к связи через ORM
+    #   getattr(record, rel_name)
+    # - для записи и чтения связанных объектов
+    rel_name: str | None = None
+
+    # Класс связанной SQLAlchemy-модели.
+    # Откуда берётся:
+    # - из relationship: rel.mapper.class_
+    #
+    # Зачем нужен:
+    # - для загрузки связанных записей из БД
+    #   session.get(target_model, pk)
+    #   select(target_model).where(target_model.id.in_(...))
+    target_model: Any | None = None
+
+    # Работает только если 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)
+        schema.many = self.many
+        schema.rel_name = self.rel_name
+        schema.dual_list = self.dual_list
+        return schema
+
+    def _get_target_model(self, model, field_slug):
+        # pylint: disable=import-outside-toplevel
+        from sqlalchemy import inspect
+
+        mapper = inspect(model).mapper
+        attr = mapper.attrs.get(field_slug)
+        if attr is None:
+            msg = f'Field "{field_slug}" is not found on model "{model}"'
+            raise AttributeError(msg)
+
+        # RelationshipProperty
+        if hasattr(attr, 'mapper'):
+            return attr.mapper.class_
+
+        # ColumnProperty (FK column). Try to resolve from foreign key target table.
+        col = getattr(model, field_slug).property.columns[0]
+        if not col.foreign_keys:
+            msg = f'Field "{field_slug}" is not a relationship and not a FK column'
+            raise AttributeError(msg)
+
+        fk = next(iter(col.foreign_keys))
+        target_table = fk.column.table
+
+        # Find a mapped class that uses this table in the same registry
+        for m in mapper.registry.mappers:
+            if getattr(m, 'local_table', None) is target_table:
+                return m.class_
+
+        msg = f'Cannot resolve target model for FK "{field_slug}"'
+        raise AttributeError(msg)
+
+    async def autocomplete(self, model, data, user, *, extra: dict | None = None) -> List[Record]:
+        # pylint: disable=import-outside-toplevel
+        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)'
+            raise AttributeError(msg)
+
+        session = extra['db_session']
+
+        results = []
+
+        target_model = self._get_target_model(model, data.field_slug)
+        limit = min(150, data.limit)
+        stmt = select(target_model).limit(limit)
+
+        if data.search_string:
+            if hasattr(target_model, 'id'):
+                stmt = stmt.where(getattr(target_model, 'id') == data.search_string)
+
+        # Add already selected choices
+        existed_choices = []
+        if data.existed_choices:
+            existed_choices = [i['key'] for i in data.existed_choices if 'key' in i]
+
+        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()
+        for record in records:
+            results.append(Record(key=getattr(record, 'id'), title=str(record)))
+
+        return results
+
+    async def serialize(self, value, extra: dict, *args, **kwargs) -> Any:
+        """
+        Сериализация related-поля.
+
+        Входные данные:
+        - value всегда scalar (None или int)
+        - ORM-объект доступен через extra["record"]
+        """
+        record = extra.get('record')
+        if record is None:
+            raise FieldError(f'Missing record in serialize context in value: {value}')
+
+        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)')
+
+            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 {'key': get_pk(related), 'title': str(related)}
+
+    async def deserialize(self, value, action: DeserializeAction, extra: dict, *args, **kwargs) -> Any:
+        value = await super().deserialize(value, action, extra, *args, **kwargs)
+        if not value:
+            return None
+
+        if isinstance(value, list):
+            result = []
+            for i in value:
+                i = i.get('key')
+                if not isinstance(i, (int, str)):
+                    raise FieldError(f'Value "{i}" is not supported for related field')
+                result.append(i)
+            return result
+
+        result = None
+        if isinstance(value, dict) and 'key' in value:
+            result = value['key']
+
+        if isinstance(value, (int, str)):
+            result = value
+
+        if not isinstance(result, (int, str)):
+            raise FieldError(f'Value "{result}" is not supported for related field')
+
+        return result
+
+    async def update_related(self, record, field_slug, value, session):
+        """
+        Обновление SQLAlchemy relationship.
+
+        Предположения:
+        - self.rel_name всегда имя relationship
+        - self.target_model задан
+        - self.many отражает тип связи
+        """
+
+        # pylint: disable=import-outside-toplevel
+
+        if value is None:
+            return
+
+        # При CREATE объект должен быть в session до работы с relationship
+        if record not in session:
+            session.add(record)
+
+        rel_attr = self.rel_name
+
+        if self.many:
+            assert isinstance(value, list)
+
+            if not value:
+                setattr(record, rel_attr, [])
+                return
+
+            result = []
+            for i in value:
+                obj = await session.get(self.target_model, i)
+                if obj is None:
+                    msg = _('related_not_found') % {
+                        'model': self.target_model.__name__,
+                        'pk': i,
+                        'field_slug': field_slug,
+                    }
+                    raise AdminAPIException(
+                        APIError(message=msg, code='related_not_found'),
+                        status_code=400,
+                    )
+                result.append(obj)
+
+            # getattr(record, rel_attr).clear()
+            getattr(record, rel_attr).extend(list(result))
+            return
+
+        obj = await session.get(self.target_model, value)
+        setattr(record, rel_attr, obj)
+
+    async def apply_filter(self, stmt, value, model, column):
+        # pylint: disable=import-outside-toplevel
+        from sqlalchemy import inspect
+
+        if value is None:
+            return stmt
+
+        rel = getattr(model, self.rel_name)
+        pk_col = inspect(self.target_model).primary_key[0]
+
+        # many=False: FK (many-to-one)
+        if not self.many:
+            if not isinstance(value, int):
+                raise FieldError(f'Expected int for filter {self.rel_name}')
+            return stmt.where(rel.has(pk_col == value))
+
+        # many=True: one-to-many / many-to-many
+        if not isinstance(value, list):
+            raise FieldError(f'Expected list[int] for filter {self.rel_name}')
+        return stmt.where(rel.any(pk_col.in_(value)))

admin_panel/integrations/sqlalchemy/fields_schema.py

@@ -0,0 +1,316 @@
+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
+
+FIELD_FILTERS_NOT_FOUND = '{class_name} filter "{field_slug}" not found inside table_filters fields: {available_filters}'
+
+
+class SQLAlchemyFieldsSchema(schema.FieldsSchema):
+    model: Any
+
+    def __init__(self, *args, model=None, **kwargs):
+        if model:
+            self.model = model
+
+        super().__init__(*args, **kwargs)
+
+    def generate_fields(self, kwargs) -> dict:
+        generated_fields = super().generate_fields(kwargs)
+
+        # pylint: disable=import-outside-toplevel
+        from sqlalchemy import inspect
+        from sqlalchemy.dialects.postgresql import ARRAY
+        from sqlalchemy.ext.mutable import Mutable
+        from sqlalchemy.sql import sqltypes
+        from sqlalchemy.sql.schema import Column
+
+        mapper = inspect(self.model).mapper
+
+        for attr in mapper.column_attrs:
+            col: Column = attr.columns[0]
+            field_slug = attr.key
+
+            if field_slug in generated_fields:
+                continue
+
+            field_data = {}
+            info = col.info or {}
+            field_data["label"] = info.get('label', humanize_field_name(field_slug))
+            field_data["help_text"] = info.get('help_text')
+
+            field_data["read_only"] = col.primary_key
+
+            # Whether the field is required on input (best-effort heuristic)
+            field_data["required"] = (
+                not col.nullable
+                and col.default is None
+                and col.server_default is None
+                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
+            except Exception:
+                py_t = None
+
+            impl = getattr(attr, 'impl', None)
+            is_mutable = isinstance(impl, Mutable)
+
+            # Foreign key column
+            if col.foreign_keys:
+                continue
+
+            elif isinstance(col_type, (sqltypes.BigInteger, sqltypes.Integer)) or py_t is int:
+                field_class = schema.IntegerField
+
+            elif isinstance(col_type, sqltypes.Numeric):
+                field_class = schema.IntegerField
+                field_data["inputmode"] = "decimal"
+                field_data["precision"] = col_type.precision
+                field_data["scale"] = col_type.scale
+
+            elif isinstance(col_type, sqltypes.String) or py_t is str:
+                field_class = schema.StringField
+                # Max length is usually stored as String(length=...)
+                if getattr(col_type, "length", None):
+                    field_data["max_length"] = col_type.length
+
+            elif isinstance(col_type, sqltypes.DateTime) or py_t is datetime:
+                field_class = schema.DateTimeField
+
+            elif isinstance(col_type, sqltypes.Boolean) or py_t is bool:
+                field_class = schema.BooleanField
+
+            elif isinstance(col_type, sqltypes.JSON):
+                field_class = schema.JSONField
+
+            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
+
+            elif isinstance(col_type, sqltypes.NullType):
+                continue
+
+            elif not self.fields:
+                msg = f'SQLAlchemy autogenerate ORM field {self.model.__name__}.{field_slug} is not supported for type: {col_type}'
+                raise AttributeError(msg)
+
+            schema_field = field_class(**field_data)
+
+            if col.primary_key:
+                generated_fields = {field_slug: schema_field, **generated_fields}
+            else:
+                generated_fields[field_slug] = schema_field
+
+        for field_slug, field in self.generate_related_fields():
+            generated_fields[field_slug] = field
+
+        return generated_fields
+
+    def generate_related_fields(self):
+        # pylint: disable=import-outside-toplevel
+        from sqlalchemy import inspect
+
+        mapper = inspect(self.model).mapper
+
+        # relationship-поля
+        for rel in mapper.relationships:
+            field_slug = rel.key
+
+            field_data = {}
+
+            info = rel.info or {}
+            field_data["label"] = info.get('label', humanize_field_name(field_slug))
+            field_data["help_text"] = info.get('help_text')
+
+            field_data["read_only"] = rel.viewonly
+            field_data["required"] = (
+                not rel.uselist
+                and all(not col.nullable for col in rel.local_columns)
+            )
+
+            field_data["rel_name"] = rel.key
+            field_data["many"] = rel.uselist
+            field_data["dual_list"] = rel.uselist
+            field_data["target_model"] = rel.mapper.class_
+
+            yield field_slug, SQLAlchemyRelatedField(**field_data)
+
+        # FK-поля
+        for attr in mapper.column_attrs:
+            col = attr.columns[0]
+
+            if not col.foreign_keys:
+                continue
+
+            rel_obj = None
+            for rel in mapper.relationships:
+                if col in rel.local_columns:
+                    rel_obj = rel
+                    break
+
+            if not rel_obj:
+                continue
+
+            field_slug = attr.key
+
+            field_data = {}
+
+            info = col.info or {}
+            field_data["label"] = info.get('label', humanize_field_name(rel_obj.key))
+            field_data["help_text"] = info.get('help_text')
+
+            field_data["read_only"] = False
+            field_data["required"] = (
+                not col.nullable
+                and col.default is None
+                and col.server_default is None
+                and not col.primary_key
+            )
+
+            field_data["rel_name"] = rel_obj.key
+            field_data["many"] = rel_obj.uselist
+            field_data["target_model"] = rel_obj.mapper.class_
+
+            yield field_slug, SQLAlchemyRelatedField(**field_data)
+
+    async def apply_filters(self, stmt, filters: dict):
+        # pylint: disable=import-outside-toplevel
+        from sqlalchemy import String, cast
+
+        for field_slug in filters.keys():
+            field = self.get_field(field_slug)
+
+            if not field:
+                available_filters = list(self.get_fields().keys())
+                msg = FIELD_FILTERS_NOT_FOUND.format(
+                    class_name=type(self).__name__,
+                    field_slug=field_slug,
+                    available_filters=available_filters,
+                )
+                raise AttributeError(msg)
+
+        deserialized_filters = await self.deserialize(
+            filters,
+            DeserializeAction.FILTERS,
+            extra={'model': self.model},
+        )
+
+        for field_slug, value in deserialized_filters.items():
+            field = self.get_field(field_slug)
+            column = getattr(self.model, field_slug, None)
+
+            apply_filter = getattr(field, 'apply_filter', None)
+            if apply_filter and callable(apply_filter):
+                stmt = await apply_filter(stmt, value, self.model, column)
+
+            elif issubclass(type(field), DateTimeField) and field.range:
+                stmt = stmt.where(column >= value['from'])
+                stmt = stmt.where(column <= value['to'])
+
+            elif isinstance(value, list):
+                stmt = stmt.where(column.in_(value))
+
+            elif isinstance(value, str):
+                stmt = stmt.where(
+                    cast(column, String).like(value)
+                )
+
+            else:
+                stmt = stmt.where(column == value)
+
+        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)
+        }
+        return await super().serialize(record_data, extra, *args, **kwargs)
+
+    def validate_incoming_data(self, data):
+        '''
+        Validate that all fields keys has their schema
+
+        for create, update
+        '''
+        for field_slug in data.keys():
+            field = self.get_field(field_slug)
+            if not field:
+                available = list(self.get_fields().keys())
+                msg = _('field_not_found_in_schema') % {'field_slug': field_slug, 'available': available}
+                raise AdminAPIException(
+                    APIError(message=msg, code='field_not_found_in_schema '),
+                    status_code=400,
+                )
+
+    async def create(self, user, data, session):
+        self.validate_incoming_data(data)
+
+        record = self.model()
+
+        deserialized_data = await self.deserialize(
+            data,
+            DeserializeAction.CREATE,
+            extra={'model': self.model},
+        )
+
+        # сначала простые поля
+        for field_slug, value in deserialized_data.items():
+            field = self.get_field(field_slug)
+
+            if isinstance(field, SQLAlchemyRelatedField):
+                continue
+
+            setattr(record, field_slug, value)
+
+        session.add(record)
+
+        # затем related под no_autoflush
+        for field_slug, value in deserialized_data.items():
+            field = self.get_field(field_slug)
+
+            if isinstance(field, SQLAlchemyRelatedField):
+                with session.no_autoflush:
+                    await field.update_related(record, field_slug, value, session)
+
+        await session.commit()
+        await session.refresh(record)
+        return record
+
+    async def update(self, record, user, data, session):
+        self.validate_incoming_data(data)
+
+        deserialized_data = await self.deserialize(
+            data,
+            DeserializeAction.UPDATE,
+            extra={'model': self.model},
+        )
+
+        for field_slug, value in deserialized_data.items():
+            field = self.get_field(field_slug)
+
+            if isinstance(field, SQLAlchemyRelatedField):
+                await field.update_related(record, field_slug, value, session)
+                continue
+
+            setattr(record, field_slug, value)
+
+        await session.commit()
+        return record

admin_panel/integrations/sqlalchemy/table/__init__.py

@@ -0,0 +1,19 @@
+# pylint: disable=wildcard-import, unused-wildcard-import, unused-import, too-many-ancestors
+# flake8: noqa: F405
+from .base import SQLAlchemyAdminBase
+from .create import SQLAlchemyAdminCreate
+from .delete import SQLAlchemyDeleteAction
+from .list import SQLAlchemyAdminListMixin
+from .retrieve import SQLAlchemyAdminRetrieveMixin
+from .update import SQLAlchemyAdminUpdate
+
+
+class SQLAlchemyAdmin(
+        SQLAlchemyAdminUpdate,
+        SQLAlchemyAdminCreate,
+        SQLAlchemyDeleteAction,
+        SQLAlchemyAdminListMixin,
+        SQLAlchemyAdminRetrieveMixin,
+        SQLAlchemyAdminBase,
+):
+    pass