brilliance-admin 0.42.0__py3-none-any.whl

admin_panel/integrations/sqlalchemy/table/base.py

@@ -0,0 +1,141 @@
+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 _
+
+EXCEPTION_REL_NAME = '''
+Model "{model_name}" doesn\'t contain rel_name:"{rel_name}" for field "{slug}"
+Model fields = {model_attrs}
+'''
+
+
+class SQLAlchemyAdminBase(SQLAlchemyAdminAutocompleteMixin, CategoryTable):
+    model: Any
+    slug = None
+    ordering_fields = []
+
+    search_fields = []
+
+    table_schema: SQLAlchemyFieldsSchema
+
+    db_async_session: Any = None
+
+    def __init__(
+            self,
+            *args,
+            model=None,
+            table_schema=None,
+            db_async_session=None,
+            ordering_fields=None,
+            default_ordering=None,
+            search_fields=None,
+            **kwargs,
+    ):
+        if model:
+            self.model = model
+
+        if search_fields:
+            self.search_fields = search_fields
+
+        if self.search_fields:
+            self.search_enabled = True
+            self.search_help = _('sqlalchemy_search_help') % {'fields': ', '.join(self.search_fields)}
+
+        if default_ordering:
+            self.default_ordering = default_ordering
+
+        if ordering_fields:
+            self.ordering_fields = ordering_fields
+
+        self.validate_fields()
+
+        if table_schema:
+            self.table_schema = table_schema
+
+        if not self.table_schema:
+            self.table_schema = SQLAlchemyFieldsSchema(model=self.model)
+
+        if not issubclass(type(self.table_schema), SQLAlchemyFieldsSchema):
+            msg = f'{type(self).__name__}.table_schema {self.table_schema} must be subclass of SQLAlchemyFieldsSchema'
+            raise AttributeError(msg)
+
+        if not self.model:
+            msg = f'{type(self).__name__}.model is required for SQLAlchemy'
+            raise AttributeError(msg)
+
+        if not self.slug:
+            self.slug = self.model.__name__.lower()
+
+        if db_async_session:
+            self.db_async_session = db_async_session
+
+        if not self.db_async_session:
+            msg = f'{type(self).__name__}.db_async_session is required for SQLAlchemy'
+            raise AttributeError(msg)
+
+        # pylint: disable=import-outside-toplevel
+        from sqlalchemy import inspect
+        from sqlalchemy.sql.schema import Column
+
+        for attr in inspect(self.model).mapper.column_attrs:
+            col: Column = attr.columns[0]
+            if col.primary_key and not self.pk_name:
+                self.pk_name = attr.key
+                break
+
+        if not self.default_ordering and self.pk_name:
+            self.default_ordering = f'-{self.pk_name}'
+
+        super().__init__(*args, **kwargs)
+
+    def validate_fields(self):
+        # pylint: disable=import-outside-toplevel
+        from sqlalchemy.orm import InstrumentedAttribute
+
+        if self.search_fields:
+            for field in self.search_fields:
+                column = getattr(self.model, field, None)
+                if not isinstance(column, InstrumentedAttribute):
+                    raise AttributeError(
+                        f'{type(self).__name__}: search field "{field}" not found in model {self.model.__name__}'
+                    )
+
+        if self.ordering_fields:
+            for field in self.ordering_fields:
+                column = getattr(self.model, field, None)
+                if not isinstance(column, InstrumentedAttribute):
+                    raise AttributeError(
+                        f'{type(self).__name__}: ordering field "{field}" not found in model {self.model.__name__}'
+                    )
+
+    def get_queryset(self):
+        # pylint: disable=import-outside-toplevel
+        from sqlalchemy import select
+        from sqlalchemy.orm import selectinload
+
+        stmt = select(self.model).options(selectinload('*'))
+
+        # Eager-load related fields
+        for slug, field in self.table_schema.get_fields().items():
+
+            # 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):
+                    msg = EXCEPTION_REL_NAME.format(
+                        slug=slug,
+                        model_name=self.model.__name__,
+                        rel_name=field.rel_name,
+                        model_attrs=model_attrs,
+                    )
+                    raise AttributeError(msg)
+
+                stmt = stmt.options(selectinload(getattr(self.model, field.rel_name)))
+
+        return stmt

admin_panel/integrations/sqlalchemy/table/create.py

@@ -0,0 +1,73 @@
+from admin_panel import schema
+from admin_panel.auth import UserABC
+from admin_panel.exceptions import AdminAPIException, APIError
+from admin_panel.translations import LanguageManager
+from admin_panel.translations import TranslateText as _
+from admin_panel.utils import get_logger
+
+logger = get_logger()
+
+
+class SQLAlchemyAdminCreate:
+    has_create: bool = True
+
+    async def create(
+            self,
+            data: dict,
+            user: UserABC,
+            language_manager: LanguageManager,
+    ) -> schema.CreateResult:
+        if not self.has_create:
+            raise AdminAPIException(APIError(message=_('method_not_allowed')), status_code=500)
+
+        # pylint: disable=import-outside-toplevel
+        from sqlalchemy.exc import IntegrityError
+
+        try:
+            async with self.db_async_session() as session:
+                record = await self.table_schema.create(user, data, session)
+                pk_value = getattr(record, self.pk_name, None)
+
+        except AdminAPIException as e:
+            raise e
+
+        except ConnectionRefusedError as e:
+            logger.exception(
+                'SQLAlchemy %s create %s db error: %s',
+                type(self).__name__, self.table_schema.model.__name__, e,
+                extra={'data': data},
+            )
+            msg = _('connection_refused_error') % {'error': str(e)}
+            raise AdminAPIException(
+                APIError(message=msg, code='connection_refused_error'),
+                status_code=500,
+            ) from e
+
+        except IntegrityError as e:
+            logger.warning(
+                'SQLAlchemy %s create %s db error: %s',
+                type(self).__name__, self.table_schema.model.__name__, e,
+                extra={'data': data},
+            )
+            orig = e.orig
+            message = orig.args[0] if orig.args else type(orig).__name__
+            raise AdminAPIException(
+                APIError(message=message, code='db_integrity_error'), status_code=500,
+            ) from e
+
+        except Exception as e:
+            logger.exception(
+                'SQLAlchemy %s create %s db error: %s',
+                type(self).__name__, self.table_schema.model.__name__, e,
+                extra={'data': data},
+            )
+            raise AdminAPIException(
+                APIError(message=_('db_error_create'), code='db_error_create'), status_code=500,
+            ) from e
+
+        logger.info(
+            '%s model %s #%s created by %s',
+            type(self).__name__, self.table_schema.model.__name__, pk_value, user.username,
+            extra={'data': data},
+        )
+        return schema.CreateResult(pk=pk_value)

admin_panel/integrations/sqlalchemy/table/delete.py

@@ -0,0 +1,18 @@
+from admin_panel.exceptions import APIError, AdminAPIException
+from admin_panel.schema.table.admin_action import ActionData, ActionMessage, ActionResult, admin_action
+from admin_panel.translations import TranslateText as _
+
+
+class SQLAlchemyDeleteAction:
+    has_delete: bool = True
+
+    @admin_action(
+        title=_('delete'),
+        confirmation_text=_('delete_confirmation_text'),
+        base_color='red-lighten-2',
+        variant='outlined',
+    )
+    async def delete(self, action_data: ActionData):
+        if not self.has_delete:
+            raise AdminAPIException(APIError(message=_('method_not_allowed')), status_code=500)
+        return ActionResult(message=ActionMessage(_('deleted_successfully')))

admin_panel/integrations/sqlalchemy/table/list.py

@@ -0,0 +1,178 @@
+from admin_panel import auth, schema
+from admin_panel.exceptions import AdminAPIException, APIError, FieldError
+from admin_panel.integrations.sqlalchemy.fields_schema import SQLAlchemyFieldsSchema
+from admin_panel.translations import LanguageManager
+from admin_panel.translations import TranslateText as _
+from admin_panel.utils import get_logger
+
+logger = get_logger()
+
+
+class SQLAlchemyAdminListMixin:
+    table_schema: SQLAlchemyFieldsSchema
+    table_filters: SQLAlchemyFieldsSchema | None
+
+    def apply_ordering(self, stmt, list_data):
+        # pylint: disable=import-outside-toplevel
+        from sqlalchemy import asc, desc
+        from sqlalchemy.orm import InstrumentedAttribute
+
+        ordering = list_data.ordering or self.default_ordering
+
+        if not ordering:
+            return stmt
+
+        direction = asc
+
+        if ordering.startswith("-"):
+            ordering = ordering[1:]
+            direction = desc
+
+        if list_data.ordering and ordering not in self.ordering_fields:
+            msg = f'Ordering "{ordering}" is not allowed; available options: {self.ordering_fields} default_ordering: {self.default_ordering}'
+            raise FieldError(message=msg)
+
+        column = getattr(self.model, ordering, None)
+        if not isinstance(column, InstrumentedAttribute):
+            msg = f'{type(self).__name__} ordering field "{ordering}" not found in model {self.model}'
+            raise FieldError(message=msg)
+
+        return stmt.order_by(direction(column))
+
+    def apply_search(self, stmt, list_data: schema.ListData):
+        # pylint: disable=import-outside-toplevel
+        from sqlalchemy import String, cast, or_
+        from sqlalchemy.orm import InstrumentedAttribute
+
+        if not self.search_fields or not list_data.search:
+            return stmt
+
+        search = list_data.search
+        conditions = []
+
+        for field_slug in self.search_fields:
+            column = getattr(self.model, field_slug, None)
+            if not isinstance(column, InstrumentedAttribute):
+                msg = f'{type(self).__name__} filter "{field_slug}" not found as field inside model {self.model}'
+                raise AttributeError(msg)
+
+            conditions.append(cast(column, String).ilike(search))
+
+        if conditions:
+            stmt = stmt.where(or_(*conditions))
+
+        return stmt
+
+    async def apply_filters(self, stmt, list_data: schema.ListData):
+        if not self.table_filters or not list_data.filters:
+            return stmt
+
+        if not issubclass(type(self.table_filters), SQLAlchemyFieldsSchema):
+            msg = f'{type(self).__name__}.table_filters {type(self.table_filters)} must be SQLAlchemyFieldsSchema subclass'
+            raise AttributeError(msg)
+
+        return await self.table_filters.apply_filters(stmt, list_data.filters)
+
+    def apply_pagination(self, stmt, list_data: schema.ListData):
+        page = max(1, list_data.page or 1)
+        limit = min(150, max(1, list_data.limit or 25))
+
+        offset = (page - 1) * limit
+
+        return stmt.limit(limit).offset(offset)
+
+    # pylint: disable=too-many-arguments
+    # pylint: disable=too-many-locals
+    async def get_list(
+        self,
+        list_data: schema.ListData,
+        user: auth.UserABC,
+        language_manager: LanguageManager,
+    ) -> schema.TableListResult:
+        # pylint: disable=import-outside-toplevel
+        from sqlalchemy import exc, func, select
+
+        try:
+            stmt = self.get_queryset()
+            stmt = await self.apply_filters(stmt, list_data)
+            stmt = self.apply_search(stmt, list_data)
+
+            count_stmt = select(func.count()).select_from(stmt.subquery())
+            stmt = self.apply_pagination(stmt, list_data)
+            stmt = self.apply_ordering(stmt, list_data)
+
+        except FieldError as e:
+            logger.exception(
+                'SQLAlchemy %s list filters for %s field error: %s',
+                type(self).__name__, self.model.__name__, e,
+                extra={
+                    'list_data': list_data,
+                }
+            )
+            msg = _('filter_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 list filters for %s error: %s',
+                type(self).__name__, self.model.__name__, e,
+                extra={
+                    'list_data': list_data,
+                }
+            )
+            raise AdminAPIException(APIError(message=_('filters_exception'), code='filters_exception'), status_code=500) from e
+
+        data = []
+
+        try:
+            async with self.db_async_session() as session:
+                total_count = await session.scalar(count_stmt)
+                records = (await session.execute(stmt)).scalars().all()
+                for record in records:
+                    line = await self.table_schema.serialize(
+                        record,
+                        extra={"record": record, "user": user},
+                    )
+                    data.append(line)
+
+        except ConnectionRefusedError as e:
+            logger.exception(
+                'SQLAlchemy %s get_list db error: %s',
+                type(self).__name__, e,
+                extra={
+                    'list_data': list_data,
+                }
+            )
+            msg = _('connection_refused_error') % {'error': str(e)}
+            raise AdminAPIException(
+                APIError(message=msg, code='connection_refused_error'),
+                status_code=500,
+            ) from e
+
+        except (exc.IntegrityError, exc.StatementError) as e:
+            logger.exception(
+                'SQLAlchemy %s get_list db error: %s',
+                type(self).__name__, e,
+                extra={
+                    'list_data': list_data,
+                }
+            )
+            orig = e.orig
+            message = orig.args[0] if orig.args else type(orig).__name__
+            raise AdminAPIException(
+                APIError(message=message, code='db_exception'), status_code=500,
+            ) from e
+
+        except Exception as e:
+            logger.exception(
+                'SQLAlchemy %s get_list db error: %s',
+                type(self).__name__, e,
+                extra={
+                    'list_data': list_data,
+                }
+            )
+            raise AdminAPIException(
+                APIError(message=_('db_error_list'), code='db_error_list'), status_code=500,
+            ) from e
+
+        return schema.TableListResult(data=data, total_count=int(total_count or 0))

admin_panel/integrations/sqlalchemy/table/retrieve.py

@@ -0,0 +1,61 @@
+from typing import Any
+
+from admin_panel import auth, schema
+from admin_panel.exceptions import AdminAPIException, APIError
+from admin_panel.translations import LanguageManager
+from admin_panel.translations import TranslateText as _
+from admin_panel.utils import get_logger
+
+logger = get_logger()
+
+
+class SQLAlchemyAdminRetrieveMixin:
+    has_retrieve: bool = True
+
+    async def retrieve(
+            self,
+            pk: Any,
+            user: auth.UserABC,
+            language_manager: LanguageManager,
+    ) -> schema.RetrieveResult:
+        if not self.has_delete:
+            raise AdminAPIException(APIError(message=_('method_not_allowed')), status_code=500)
+
+        # pylint: disable=import-outside-toplevel
+        from sqlalchemy import inspect
+
+        col = inspect(self.model).mapper.columns[self.pk_name]
+        python_type = col.type.python_type
+
+        assert self.pk_name
+        stmt = self.get_queryset().where(getattr(self.model, self.pk_name) == python_type(pk))
+
+        try:
+            async with self.db_async_session() as session:
+                record = (await session.execute(stmt)).scalars().first()
+                data = await self.table_schema.serialize(
+                    record,
+                    extra={"record": record, "user": user},
+                )
+
+        except Exception as e:
+            logger.exception(
+                'SQLAlchemy %s retrieve db error: %s', type(self).__name__, e,
+            )
+            raise AdminAPIException(
+                APIError(message=_('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}
+            raise AdminAPIException(
+                APIError(message=msg, code='record_not_found'),
+                status_code=400,
+            )
+
+        logger.debug(
+            '%s model %s #%s retrieved by %s',
+            type(self).__name__, self.table_schema.model.__name__, pk, user.username,
+            extra={'data': data},
+        )
+        return schema.RetrieveResult(data=data)

admin_panel/integrations/sqlalchemy/table/update.py

@@ -0,0 +1,95 @@
+from typing import Any
+
+from admin_panel import auth, schema
+from admin_panel.exceptions import AdminAPIException, APIError
+from admin_panel.translations import LanguageManager
+from admin_panel.translations import TranslateText as _
+from admin_panel.utils import get_logger
+
+logger = get_logger()
+
+
+class SQLAlchemyAdminUpdate:
+    has_update: bool = True
+
+    # pylint: disable=too-many-locals
+    async def update(
+            self,
+            pk: Any,
+            data: dict,
+            user: auth.UserABC,
+            language_manager: LanguageManager,
+    ) -> schema.UpdateResult:
+        if not self.has_update:
+            raise AdminAPIException(APIError(message=_('method_not_allowed')), status_code=500)
+
+        # pylint: disable=import-outside-toplevel
+        from sqlalchemy import inspect
+        from sqlalchemy.exc import IntegrityError
+
+        if pk is None:
+            raise AdminAPIException(
+                APIError(message=_('pk_not_found') % {'pk_name': self.pk_name}, code='pk_not_found'),
+                status_code=400,
+            )
+
+        col = inspect(self.table_schema.model).mapper.columns[self.pk_name]
+        python_type = col.type.python_type
+
+        stmt = self.get_queryset().where(getattr(self.model, self.pk_name) == python_type(pk))
+
+        try:
+            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}
+                    raise AdminAPIException(
+                        APIError(message=msg, code='record_not_found'),
+                        status_code=400,
+                    )
+
+                await self.table_schema.update(record, user, data, session)
+
+        except AdminAPIException as e:
+            raise e
+
+        except ConnectionRefusedError as e:
+            logger.exception(
+                'SQLAlchemy %s update %s #%s db connection error: %s',
+                type(self).__name__, self.table_schema.model.__name__, pk, e,
+                extra={'data': data},
+            )
+            msg = _('connection_refused_error') % {'error': str(e)}
+            raise AdminAPIException(
+                APIError(message=msg, code='connection_refused_error'),
+                status_code=400,
+            ) from e
+
+        except IntegrityError as e:
+            logger.warning(
+                'SQLAlchemy %s update %s #%s db error: %s',
+                type(self).__name__, self.table_schema.model.__name__, pk, e,
+                extra={'data': data},
+            )
+            orig = e.orig
+            message = orig.args[0] if orig.args else type(orig).__name__
+            raise AdminAPIException(
+                APIError(message=message, code='db_integrity_error'), status_code=500,
+            ) from e
+
+        except Exception as e:
+            logger.exception(
+                'SQLAlchemy %s update %s #%s db error: %s',
+                type(self).__name__, self.table_schema.model.__name__, pk, e,
+                extra={'data': data}
+            )
+            raise AdminAPIException(
+                APIError(message=_('db_error_update'), code='db_error_update'), status_code=500,
+            ) from e
+
+        logger.info(
+            '%s model %s #%s updated by %s',
+            type(self).__name__, self.table_schema.model.__name__, pk, user.username,
+            extra={'data': data},
+        )
+        return schema.UpdateResult(pk=pk)

admin_panel/schema/__init__.py

@@ -0,0 +1,7 @@
+# pylint: disable=wildcard-import, unused-wildcard-import, unused-import
+# flake8: noqa: F405
+from .admin_schema import AdminSchema, AdminSchemaData
+from .category import Category
+from .graphs import *
+from .group import Group
+from .table import *