quite-admin 0.4.1__py3-none-any.whl

quite_admin/__init__.py

@@ -0,0 +1,45 @@
+from .adapters.base import ADAPTER_API_VERSION
+from .adapters.delegating import DelegatingAdapter
+from .admin import TEMPLATE_API_VERSION, Admin, Page
+from .auth import AuthBackend, Identity, PasswordAuth, hash_password, verify_password
+from .concurrency import CheckedAdapter, WriteGuard
+from .config import FieldOptions, ModelOptions, RecordAction
+from .logging import LoggerProtocol
+from .operations import Operation, OperationHooks, current_operation
+from .relations import Junction, Relation, RelationAdapter
+from .schema import Field, Filter, ModelSchema, Query, RecordPage, RelatedFilter
+from .theme import Theme
+
+__version__ = "0.4.1"
+
+__all__ = [
+    "ADAPTER_API_VERSION",
+    "TEMPLATE_API_VERSION",
+    "Admin",
+    "CheckedAdapter",
+    "WriteGuard",
+    "AuthBackend",
+    "DelegatingAdapter",
+    "Field",
+    "FieldOptions",
+    "Filter",
+    "Identity",
+    "LoggerProtocol",
+    "ModelOptions",
+    "ModelSchema",
+    "Operation",
+    "OperationHooks",
+    "Page",
+    "PasswordAuth",
+    "Query",
+    "RecordPage",
+    "RecordAction",
+    "RelatedFilter",
+    "Junction",
+    "Relation",
+    "RelationAdapter",
+    "Theme",
+    "hash_password",
+    "verify_password",
+    "current_operation",
+]

quite_admin/adapters/__init__.py

@@ -0,0 +1,5 @@
+"""Adapters are imported explicitly, so unused ORMs are never required."""
+
+from .base import Adapter
+
+__all__ = ["Adapter"]

quite_admin/adapters/_gino_relations.py

@@ -0,0 +1,247 @@
+from __future__ import annotations
+
+from dataclasses import replace
+
+from sqlalchemy import and_, exists, false, select
+
+from quite_admin.concurrency import check_record, check_relation, guarded
+from quite_admin.errors import Conflict, NotFound
+from quite_admin.schema import RelatedFilter
+
+from ._sql_metadata import SQLRelationMetadata, related_predicates
+
+
+class GinoRelations:
+    def _links(self, model):
+        models = {self._table(item): item for item in self.discover()}
+        links = SQLRelationMetadata()._links(self._table(model))
+        result = {}
+        for name, link in links.items():
+            target = models.get(link.relation.target)
+            if target is None:
+                continue
+            local = tuple(self._attribute(model, column) for column in link.local)
+            remote = tuple(self._attribute(target, column) for column in link.remote)
+            relation = replace(
+                link.relation,
+                target=target,
+                source_fields=local if link.relation.source_fields else (),
+                target_fields=remote if link.relation.target_fields else (),
+                source_key_fields=local,
+                target_key_fields=remote,
+            )
+            if relation.junction is not None:
+                junction_model = models.get(link.through)
+                if junction_model is not None:
+                    junction = replace(
+                        relation.junction,
+                        model=junction_model,
+                        fields=self.describe(junction_model).fields,
+                        source_fields=tuple(
+                            self._attribute(junction_model, name)
+                            for name in relation.junction.source_fields
+                        ),
+                        target_fields=tuple(
+                            self._attribute(junction_model, name)
+                            for name in relation.junction.target_fields
+                        ),
+                    )
+                    relation = replace(relation, junction=junction)
+            result[name] = replace(link, relation=relation, local=local, remote=remote)
+        return result
+
+    def _filter_conditions(self, model, query):
+        if not query.related:
+            return ()
+        links = self._links(model)
+        physical = replace(
+            query,
+            related=tuple(
+                RelatedFilter(
+                    item.relation,
+                    {
+                        getattr(links[item.relation].relation.target, name).name: value
+                        for name, value in item.key.items()
+                    },
+                )
+                for item in query.related
+            ),
+        )
+        return related_predicates(
+            self._table(model), physical, SQLRelationMetadata()._links(self._table(model))
+        )
+
+    def relations(self, model):
+        return tuple(link.relation for link in self._links(model).values())
+
+    def _condition(self, link, parent):
+        target = link.relation.target
+        if not link.reverse and link.through is None:
+            if any(parent[name] is None for name in link.local):
+                return false()
+        if link.through is not None:
+            # Correlated EXISTS preserves cardinality, including composite/self junctions.
+            return self._composite_through(link, parent, link.through.alias())
+        return and_(
+            *(
+                getattr(target, remote) == parent[local]
+                for local, remote in zip(link.local, link.remote, strict=True)
+            )
+        )
+
+    def _composite_through(self, link, parent, through):
+        return exists(
+            select([1])
+            .select_from(through)
+            .where(
+                and_(
+                    *(
+                        through.c[column] == parent[local]
+                        for column, local in zip(link.through_local, link.local, strict=True)
+                    ),
+                    *(
+                        through.c[column] == getattr(link.relation.target, remote)
+                        for column, remote in zip(link.through_remote, link.remote, strict=True)
+                    ),
+                )
+            )
+            .correlate(self._table(link.relation.target))
+        )
+
+    async def related(self, model, name, key, query):
+        if query.related:
+            raise ValueError("Relationship filters are supported only in list().")
+        links = self._links(model)
+        if name not in links:
+            raise Conflict("Unknown relationship.")
+        parent = await self.get(model, key)
+        if parent is None:
+            raise NotFound("Record not found.")
+        link = links[name]
+        return await self._page(
+            link.relation.target, query, condition=self._condition(link, parent)
+        )
+
+    async def save_relations(self, model, values, selections, *, key=None):
+        schema = self.describe(model)
+        schema.validate_values(values, creating=key is None)
+        if key is not None:
+            schema.validate_key(key)
+        links = self._links(model)
+        if set(selections) - links.keys():
+            raise Conflict("Unknown relationship.")
+        for name, keys in selections.items():
+            link = links[name]
+            if link.relation.read_only:
+                raise Conflict("This relationship is read only.")
+            if link.relation.kind in {"one_to_one", "many_to_one"} and len(keys) > 1:
+                raise Conflict("Choose a single related record.")
+            for target_key in keys:
+                self.describe(link.relation.target).validate_key(target_key)
+
+        async with self._transaction() as connection:
+            if key is not None and guarded():
+                original = await connection.first(
+                    model.query.where(self._where(model, key)).with_for_update()
+                )
+                if original is None:
+                    raise NotFound("Record not found.")
+                check_record(model, self._record(model, original))
+                for relation_name in selections:
+                    link = links[relation_name]
+                    target = link.relation.target
+                    previous = await connection.all(
+                        target.query.where(
+                            self._condition(link, self._record(model, original))
+                        ).with_for_update()
+                    )
+                    check_relation(
+                        model,
+                        relation_name,
+                        self.describe(target),
+                        [self._record(target, row) for row in previous],
+                    )
+            changes = dict(values)
+            targets = {}
+            for name, keys in selections.items():
+                link = links[name]
+                target = link.relation.target
+                # Deduplicate selections without relying on driver-specific keys.
+                unique = {tuple(sorted(target_key.items())): target_key for target_key in keys}
+                rows = [
+                    await connection.first(
+                        target.query.where(self._where(target, target_key)).with_for_update()
+                    )
+                    for target_key in unique.values()
+                ]
+                if any(row is None for row in rows):
+                    raise NotFound("Related record not found.")
+                targets[name] = [self._record(target, row) for row in rows]
+                if not link.reverse and link.through is None:
+                    if not rows and not link.relation.can_detach:
+                        raise Conflict("A related record is required.")
+                    changes.update(
+                        {
+                            local: getattr(rows[0], remote) if rows else None
+                            for local, remote in zip(link.local, link.remote, strict=True)
+                        }
+                    )
+            parent = await self._persist(connection, model, changes, key=key)
+            for name, rows in targets.items():
+                link = links[name]
+                if not link.reverse and link.through is None:
+                    continue
+                target = link.relation.target
+                keys = tuple(field.name for field in self.describe(target).primary_keys)
+                previous = await connection.all(
+                    target.query.where(self._condition(link, parent)).with_for_update()
+                )
+                selected = {tuple(row[k] for k in keys) for row in rows}
+                removed = [
+                    row for row in previous if tuple(getattr(row, k) for k in keys) not in selected
+                ]
+                if removed and not link.relation.can_detach:
+                    raise Conflict("This relationship cannot be detached.")
+                if link.through is not None:
+                    await connection.status(
+                        link.through.delete().where(
+                            and_(
+                                *(
+                                    link.through.c[column] == parent[local]
+                                    for column, local in zip(
+                                        link.through_local, link.local, strict=True
+                                    )
+                                )
+                            )
+                        )
+                    )
+                    for row in rows:
+                        data = {
+                            column: parent[local]
+                            for column, local in zip(link.through_local, link.local, strict=True)
+                        }
+                        data.update(
+                            {
+                                column: row[remote]
+                                for column, remote in zip(
+                                    link.through_remote, link.remote, strict=True
+                                )
+                            }
+                        )
+                        await connection.status(link.through.insert().values(**data))
+                else:
+                    # Release a unique 1:1 FK before assigning its replacement.
+                    for row in removed:
+                        await row.update(**dict.fromkeys(link.remote)).apply(bind=connection)
+                    for row in rows:
+                        await self._persist(
+                            connection,
+                            target,
+                            {
+                                remote: parent[local]
+                                for local, remote in zip(link.local, link.remote, strict=True)
+                            },
+                            key={field: row[field] for field in keys},
+                        )
+            identity = {field.name: parent[field.name] for field in schema.primary_keys}
+            return await self._persist(connection, model, {}, key=identity)

quite_admin/adapters/_peewee_relations.py

@@ -0,0 +1,228 @@
+from __future__ import annotations
+
+import peewee as pw
+
+from quite_admin.concurrency import check_record, check_relation, guarded
+from quite_admin.errors import Conflict, NotFound
+from quite_admin.relations import Junction, Relation
+from quite_admin.schema import RecordPage
+
+from ._queries import ordering as order_expressions
+from ._queries import predicates, search_predicate
+
+
+class PeeweeRelations:
+    def _relation_fields(self, model):
+        result = {field.name: ("forward", field) for field in model._meta.refs}
+        result.update(
+            {
+                field.backref: ("reverse", field)
+                for field in model._meta.backrefs
+                if field.backref != "!"
+            }
+        )
+        result.update({name: ("many", field) for name, field in model._meta.manytomany.items()})
+        return result
+
+    def relations(self, model):
+        result = []
+        for name, (direction, field) in self._relation_fields(model).items():
+            if direction == "many":
+                source_fk = field.through_model._meta.model_refs[model][0]
+                target_fk = field.through_model._meta.model_refs[field.rel_model][0]
+                result.append(
+                    Relation(
+                        name,
+                        field.rel_model,
+                        "many_to_many",
+                        source_key_fields=(source_fk.rel_field.name,),
+                        target_key_fields=(target_fk.rel_field.name,),
+                        through=field.through_model._meta.table_name,
+                        junction=Junction(
+                            field.through_model._meta.table_name,
+                            self.describe(field.through_model).fields,
+                            (source_fk.name,),
+                            (target_fk.name,),
+                            field.through_model,
+                        ),
+                    )
+                )
+                continue
+            reverse = direction == "reverse"
+            target = field.model if reverse else field.rel_model
+            result.append(
+                Relation(
+                    name,
+                    target,
+                    "one_to_one" if field.unique else "one_to_many" if reverse else "many_to_one",
+                    source_fields=() if reverse else (field.name,),
+                    source_key_fields=(field.rel_field.name,) if reverse else (field.name,),
+                    target_key_fields=(field.name,) if reverse else (field.rel_field.name,),
+                    target_fields=(field.name,) if reverse else (),
+                    can_detach=field.null,
+                    mutates_target=reverse,
+                    read_only=field.primary_key,
+                )
+            )
+        return tuple(result)
+
+    def _filter_conditions(self, model, query):
+        fields = self._relation_fields(model) if query.related else {}
+        for item in query.related:
+            direction, field = fields[item.relation]
+            target_model = field.model if direction == "reverse" else field.rel_model
+            target = target_model.alias()
+            statement = target.select(pw.SQL("1"))
+            conditions = [getattr(target, name) == value for name, value in item.key.items()]
+            if direction == "many":
+                source_fk = field.through_model._meta.model_refs[model][0]
+                target_fk = field.through_model._meta.model_refs[target_model][0]
+                through = field.through_model.alias()
+                statement = statement.join(
+                    through,
+                    on=(
+                        getattr(through, target_fk.name)
+                        == getattr(target, target_fk.rel_field.name)
+                    ),
+                )
+                conditions.append(
+                    getattr(through, source_fk.name) == getattr(model, source_fk.rel_field.name)
+                )
+            elif direction == "reverse":
+                conditions.append(
+                    getattr(target, field.name) == getattr(model, field.rel_field.name)
+                )
+            else:
+                conditions.append(
+                    getattr(target, field.rel_field.name) == getattr(model, field.name)
+                )
+            yield pw.fn.EXISTS(statement.where(*conditions))
+
+    def _related_query(self, parent, name):
+        direction, field = self._relation_fields(type(parent))[name]
+        if direction == "many":
+            return getattr(parent, name)
+        if direction == "reverse":
+            return field.model.select().where(field == parent.__data__[field.rel_field.name])
+        value = parent.__data__.get(field.name)
+        return field.rel_model.select().where(
+            field.rel_field == value if value is not None else False
+        )
+
+    async def related(self, model, name, key, query):
+        relation = next(item for item in self.relations(model) if item.name == name)
+        self.describe(model).validate_key(key)
+        query.validate(self.describe(relation.target))
+
+        def operation():
+            parent = model.get_or_none(self._where(model, key))
+            if parent is None:
+                raise NotFound("Record not found.")
+            statement = self._related_query(parent, name)
+            if query.filters:
+                statement = statement.where(
+                    *predicates(query, lambda field: getattr(relation.target, field), peewee=True)
+                )
+            if query.search and query.search_fields:
+                statement = statement.where(
+                    search_predicate(
+                        query, lambda field: getattr(relation.target, field), peewee=True
+                    )
+                )
+            total = statement.count()
+            statement = statement.order_by(
+                *order_expressions(
+                    query,
+                    self.describe(relation.target),
+                    lambda field: getattr(relation.target, field),
+                )
+            )
+            return RecordPage(
+                [
+                    query.project(self._record(relation.target, row))
+                    for row in statement.offset(query.offset).limit(query.limit)
+                ],
+                total,
+            )
+
+        return await self._run(model, operation)
+
+    async def save_relations(self, model, values, selections, *, key=None):
+        self.describe(model).validate_values(values, creating=key is None)
+        if key is not None:
+            self.describe(model).validate_key(key)
+        available_targets = {item.name: item.target for item in self.relations(model)}
+        for relation_name, selected_keys in selections.items():
+            if relation_name in available_targets:
+                target_schema = self.describe(available_targets[relation_name])
+                for selected_key in selected_keys:
+                    target_schema.validate_key(selected_key)
+        available = {item.name: item for item in self.relations(model)}
+        fields = self._relation_fields(model)
+        if set(selections) - available.keys():
+            raise Conflict("Unknown relationship.")
+
+        def operation():
+            parent = self._locked_get(model, key) if key is not None else model()
+            if parent is None:
+                raise NotFound("Record not found.")
+            if key is not None and guarded():
+                check_record(model, self._record(model, parent))
+                for relation_name in selections:
+                    target = available[relation_name].target
+                    query = self._related_query(parent, relation_name)
+                    if guarded() and not isinstance(model._meta.database, pw.SqliteDatabase):
+                        query = query.for_update()
+                    check_relation(
+                        model,
+                        relation_name,
+                        self.describe(target),
+                        [self._record(target, row) for row in query],
+                    )
+            for name, value in values.items():
+                setattr(parent, name, value)
+            selected = {}
+            for name, keys in selections.items():
+                relation = available[name]
+                if relation.read_only:
+                    raise Conflict("This relationship is read only.")
+                if relation.kind in {"one_to_one", "many_to_one"} and len(keys) > 1:
+                    raise Conflict("Choose a single related record.")
+                targets = [
+                    relation.target.get_or_none(self._where(relation.target, target_key))
+                    for target_key in keys
+                ]
+                if any(target is None for target in targets):
+                    raise NotFound("Related record not found.")
+                selected[name] = targets
+                direction, field = fields[name]
+                if direction == "forward":
+                    if not targets and not relation.can_detach:
+                        raise Conflict("A related record is required.")
+                    setattr(parent, name, targets[0] if targets else None)
+            parent.save(force_insert=key is None)
+            for name, targets in selected.items():
+                direction, field = fields[name]
+                if direction == "forward":
+                    continue
+                previous = list(self._related_query(parent, name))
+                removed = [item for item in previous if item not in targets]
+                if removed and not available[name].can_detach:
+                    raise Conflict("This relationship cannot be detached.")
+                if direction == "many":
+                    manager = getattr(parent, name)
+                    if removed:
+                        manager.remove(removed)
+                    added = [item for item in targets if item not in previous]
+                    if added:
+                        manager.add(added)
+                else:
+                    for item in removed:
+                        setattr(item, field.name, None)
+                        item.save(only=[field])
+                    for item in targets:
+                        setattr(item, field.name, parent)
+                        item.save(only=[field])
+            return self._record(model, parent)
+
+        return await self._run(model, operation, write=True)

quite_admin/adapters/_queries.py

@@ -0,0 +1,113 @@
+"""Native query expressions, called only after Query.validate()."""
+
+import operator
+
+from quite_admin.schema import TEXT_FILTER_OPERATORS
+
+
+def predicates(query, column, *, peewee=False, text_column=None):
+    for item in query.filters:
+        field = column(item.field)
+        if item.operator == "is_null":
+            if peewee:
+                yield field.is_null(item.value)
+            else:
+                yield field.is_(None) if item.value else field.isnot(None)
+        elif item.operator in TEXT_FILTER_OPERATORS:
+            field = (text_column or column)(item.field)
+            method = {
+                "icontains": "contains",
+                "not_icontains": "contains",
+                "istartswith": "startswith",
+                "iendswith": "endswith",
+            }[item.operator]
+            if peewee:
+                expression = getattr(field, method)(item.value)
+            else:
+                literal = item.value.replace("!", "!!").replace("%", "!%").replace("_", "!_")
+                pattern = ("%" if method != "startswith" else "") + literal
+                pattern += "%" if method != "endswith" else ""
+                expression = field.ilike(pattern, escape="!")
+            yield ~expression if item.operator == "not_icontains" else expression
+        elif item.operator == "in":
+            yield field.in_(item.value)
+        else:
+            operation = {
+                "eq": operator.eq,
+                "ne": operator.ne,
+                "lt": operator.lt,
+                "lte": operator.le,
+                "gt": operator.gt,
+                "gte": operator.ge,
+            }[item.operator]
+            yield operation(field, item.value)
+
+
+def search_predicate(query, column, *, peewee=False, text_column=None):
+    expressions = []
+    if query.search:
+        for name in query.search_fields:
+            field = (text_column or column)(name)
+            if peewee:
+                expressions.append(field.contains(query.search))
+            else:
+                literal = query.search.replace("!", "!!").replace("%", "!%").replace("_", "!_")
+                expressions.append(field.ilike("%" + literal + "%", escape="!"))
+    if query.search_key is not None:
+        key_parts = [column(name) == value for name, value in query.search_key.items()]
+        key_match = key_parts[0]
+        for part in key_parts[1:]:
+            key_match = key_match & part
+        expressions.append(key_match)
+    if not expressions:
+        return None
+    search = expressions[0]
+    for expression in expressions[1:]:
+        search = search | expression
+    return search
+
+
+def ordering(query, schema, column):
+    order = query.order_by or schema.primary_keys[0].name
+    yield column(order).desc() if query.descending else column(order).asc()
+    for field in schema.primary_keys:
+        if field.name != order:
+            yield column(field.name).asc()
+
+
+def tortoise_filters(statement, query):
+    for item in query.filters:
+        if item.operator == "not_icontains":
+            statement = statement.exclude(**{item.field + "__icontains": item.value}).filter(
+                **{item.field + "__isnull": False}
+            )
+            continue
+        suffix = {
+            "eq": "",
+            "ne": "__not",
+            "icontains": "__icontains",
+            "istartswith": "__istartswith",
+            "iendswith": "__iendswith",
+            "lt": "__lt",
+            "lte": "__lte",
+            "gt": "__gt",
+            "gte": "__gte",
+            "in": "__in",
+            "is_null": "__isnull",
+        }[item.operator]
+        statement = statement.filter(**{item.field + suffix: item.value})
+        if item.operator == "ne":
+            statement = statement.filter(**{item.field + "__isnull": False})
+    return statement
+
+
+def validate_query(adapter, model, query):
+    schemas = {}
+    if query.related:
+        names = {item.relation for item in query.related if hasattr(item, "relation")}
+        schemas = {
+            relation.name: adapter.describe(relation.target)
+            for relation in adapter.relations(model)
+            if relation.name in names
+        }
+    query.validate(adapter.describe(model), related_schemas=schemas)