xn-model 0.10.3.dev1__py3-none-any.whl

x_model/__init__.py

@@ -0,0 +1,34 @@
+from types import ModuleType
+from tortoise import Tortoise, connections, ConfigurationError
+from tortoise.backends.asyncpg import AsyncpgDBClient
+from tortoise.exceptions import DBConnectionError
+
+from .enum import FieldType
+from .field import PointField, RangeField, PolygonField, CollectionField, ListField, DatetimeSecField
+from .model import Model, TsModel, User
+from .func import Array
+
+__all__ = [
+    "FieldType",
+    "PointField",
+    "RangeField",
+    "PolygonField",
+    "CollectionField",
+    "ListField",
+    "DatetimeSecField",
+    "Model",
+    "TsModel",
+    "User",
+    "Array",
+]
+
+
+async def init_db(dsn: str, models: ModuleType, create_tables: bool = False) -> AsyncpgDBClient | str:
+    try:
+        await Tortoise.init(db_url=dsn, modules={"models": [models]})
+        if create_tables:
+            await Tortoise.generate_schemas()
+        cn: AsyncpgDBClient = connections.get("default")
+    except (ConfigurationError, DBConnectionError) as ce:
+        return ce.args[0]
+    return cn

x_model/enum.py

@@ -0,0 +1,31 @@
+from enum import IntEnum
+
+
+class FieldType(IntEnum):
+    input = 1
+    checkbox = 2
+    select = 3
+    textarea = 4
+    collection = 5
+    list = 6
+
+
+class UserStatus(IntEnum):
+    BANNED = 0
+    WAIT = 1  # waiting for approve
+    TEST = 2  # trial
+    ACTIVE = 3
+    PREMIUM = 4
+
+
+class Scope(IntEnum):
+    READ = 4
+    WRITE = 2
+    ALL = 1  # not only my
+
+
+class UserRole(IntEnum):
+    CLIENT = Scope.READ  # 4
+    AUTHOR = Scope.WRITE  # 2
+    MANAGER = Scope.READ + Scope.WRITE  # 6
+    ADMIN = Scope.READ + Scope.WRITE + Scope.ALL  # 7

x_model/field.py

@@ -0,0 +1,95 @@
+from enum import IntEnum
+from typing import Any
+
+from asyncpg import Point, Polygon, Range, Box
+from tortoise import Model
+from tortoise.contrib.postgres.fields import ArrayField
+from tortoise.fields import Field, SmallIntField, IntField, FloatField, DatetimeField
+from tortoise.fields.base import VALUE
+
+
+class ListField(Field[VALUE]):
+    base_field = Field[VALUE]
+    labels: tuple
+
+    def to_python_value(self, value):
+        if value is not None and not isinstance(value, self.field_type):
+            value = self.field_type(*value)
+        self.validate(value)
+        return value
+
+
+class CollectionField(ListField[VALUE]):
+    labels: tuple
+    step: str = None
+
+    def __new__(cls, precision: int = 0, *args, **kwargs):
+        if precision:
+            cls.step = f"0.{'0'*(precision-1)}1"
+        cls.base_field = FloatField if precision else IntField
+        return super().__new__(cls)
+
+
+class RangeField(CollectionField[Range]):
+    field_type = Range
+    labels = ("from", "to")
+
+    def __new__(cls, precision: int = 0, *args, **kwargs):
+        cls.SQL_TYPE = "numrange" if precision else "int4range"
+        return super().__new__(cls)
+
+    def to_python_value(self, value: tuple):
+        if value is not None and not isinstance(value, self.field_type):
+            value = self.field_type(*[float(v) for v in value])
+        self.validate(value)
+        return (value.lower, value.upper) if value else None
+
+    def to_db_value(self, value: Any, instance: Model) -> Any:
+        if value is not None and not isinstance(value, self.field_type):
+            value = self.field_type(*value)  # pylint: disable=E1102
+        self.validate(value)
+        return value
+
+
+class PointField(CollectionField[Point]):
+    SQL_TYPE = "POINT"
+    field_type = Point
+    base_field = FloatField
+    labels = ("lat", "lon")
+
+
+class PolygonField(ListField[Polygon]):
+    SQL_TYPE = "POLYGON"
+    field_type = Polygon
+    base_field = PointField
+
+
+class BoxField(ListField[Box]):
+    SQL_TYPE = "BOX"
+    field_type = Box
+    base_field = PointField
+
+
+class DatetimeSecField(DatetimeField):
+    class _db_postgres:
+        SQL_TYPE = "TIMESTAMPTZ(0)"
+
+
+class SetField(ListField[IntEnum]):
+    SQL_TYPE = "smallint[]"
+    field_type = ArrayField
+    base_field = SmallIntField
+    enum_type: type[IntEnum]
+
+    def __init__(self, enum_type: type[IntEnum], **kwargs: Any):
+        super().__init__(**kwargs)
+        self.enum_type = enum_type
+        self.field_type = enum_type
+        self.base_field = enum_type
+
+    def to_python_value(self, value):
+        for val in value:
+            if val is not None and not isinstance(val, self.enum_type):
+                val = self.enum_type(val)
+            self.validate(val)
+        return value

x_model/func.py

@@ -0,0 +1,11 @@
+from pypika.terms import AggregateFunction
+from tortoise.expressions import Function
+
+
+class ArrayAgg(AggregateFunction):
+    def __init__(self, term, alias=None):
+        super(ArrayAgg, self).__init__("array_agg", term, alias=alias)
+
+
+class Array(Function):
+    database_func = ArrayAgg

x_model/model.py

@@ -0,0 +1,330 @@
+from datetime import datetime
+from passlib.context import CryptContext
+from pydantic import create_model
+from tortoise import Model as BaseModel
+from tortoise.contrib.postgres.fields import ArrayField
+from tortoise.contrib.pydantic import pydantic_model_creator, PydanticModel
+from tortoise.fields import (
+    Field,
+    CharField,
+    IntField,
+    SmallIntField,
+    BigIntField,
+    DecimalField,
+    FloatField,
+    TextField,
+    BooleanField,
+    DatetimeField,
+    DateField,
+    TimeField,
+    JSONField,
+    ForeignKeyRelation,
+    OneToOneRelation,
+    ManyToManyRelation,
+    ForeignKeyNullableRelation,
+    OneToOneNullableRelation,
+    IntEnumField,
+)
+from tortoise.fields.data import IntEnumFieldInstance, CharEnumFieldInstance
+from tortoise.fields.relational import (
+    BackwardFKRelation,
+    ForeignKeyFieldInstance,
+    ManyToManyFieldInstance,
+    OneToOneFieldInstance,
+    BackwardOneToOneRelation,
+    RelationalField,
+)
+from tortoise.models import MetaInfo
+from tortoise.queryset import QuerySet
+
+from x_model import FieldType, PointField, PolygonField, RangeField
+from x_model.enum import UserStatus, UserRole
+from x_model.field import DatetimeSecField, SetField
+from x_model.pydantic import PydList
+
+
+class Model(BaseModel):
+    id: int = IntField(pk=True)
+    _name: set[str] = {"name"}
+    _icon: str = ""  # https://unpkg.com/@tabler/icons@2.30.0/icons/icon_name.svg
+    _sorts: list[str] = ["-id"]
+    _ownable_fields: dict[str, str | None] = {"one": None, "list": None, "in": None}
+    _pydIn: type[PydanticModel] = None
+    _pyd: type[PydanticModel] = None
+    _pydListItem: type[PydanticModel] = None
+    _permissions: tuple[bool, bool, bool] = True, True, True
+
+    @classmethod
+    def cols(cls) -> list[dict]:
+        meta = cls._meta
+        return [
+            {"data": c, "orderable": c not in meta.fetch_fields or c in meta.fk_fields}
+            for c in meta.fields_map
+            if not c.endswith("_id")
+        ]
+
+    @classmethod
+    def pyd(cls) -> type[PydanticModel]:
+        cls._pyd = cls._pyd or pydantic_model_creator(cls)
+        return cls._pyd
+
+    @classmethod
+    def pydIn(cls) -> type[PydanticModel]:
+        if not cls._pydIn:
+            opts = tuple(k for k, v in cls._meta.fields_map.items() if not v.required)
+            cls._pydIn = pydantic_model_creator(
+                cls,
+                name=cls.__name__ + "In",
+                meta_override=cls.PydanticMetaIn,
+                optional=opts,
+                exclude_readonly=True,
+                exclude=("created_at", "updated_at"),
+            )
+            if m2ms := cls._meta.m2m_fields:  # hack for direct inserting m2m values
+                cls._pydIn = create_model(
+                    cls._pydIn.__name__, __base__=cls._pydIn, **{m2m: (list[int] | None, None) for m2m in m2ms}
+                )
+        return cls._pydIn
+
+    @classmethod
+    def pydListItem(cls) -> type[PydanticModel]:
+        if not cls._pydListItem:
+            cls._pydListItem = pydantic_model_creator(
+                cls, name=cls.__name__ + "ListItem", meta_override=cls.PydanticMetaListItem
+            )
+        return cls._pydListItem
+
+    @classmethod
+    def pydsList(cls) -> type[PydList]:
+        return create_model(
+            cls.__name__ + "List",
+            data=(list[cls.pydListItem()], []),
+            total=(int, 0),
+            filtered=(int | None, None),
+            __base__=PydList[cls.pydListItem()],
+        )
+
+    @classmethod
+    async def one(cls, uid: int, owner: int = None, **kwargs) -> PydanticModel:
+        if owner and (of := cls._ownable_fields.get("one")):
+            kwargs.update({of: owner})
+        q = cls.get(id=uid, **kwargs)
+        return await cls.pyd().from_queryset_single(q)
+
+    @classmethod
+    def pageQuery(
+        cls, sorts: list[str], limit: int = 1000, offset: int = 0, q: str = None, owner: int = None, **kwargs
+    ) -> QuerySet:
+        rels, keys = [], ["id"]
+        for nam in cls._name:
+            parts = nam.split("__")
+            if len(parts) > 1:
+                rels.append("__".join(parts[:-1]))
+            keys.append(nam)
+        query = (
+            cls.filter(**kwargs)
+            .order_by(*sorts)
+            .limit(limit)
+            .offset(offset)
+            .prefetch_related(*(cls._meta.fetch_fields & set(kwargs)), *rels)
+        )
+        if q:
+            query = query.filter(**{f"{cls._name}__icontains": q})
+        if owner and (of := cls._ownable_fields.get("list")):
+            query = query.filter(**{of: owner})
+        return query
+
+    @classmethod
+    async def pagePyd(
+        cls, sorts: list[str], limit: int = 1000, offset: int = 0, q: str = None, owner: int = None, **kwargs
+    ) -> PydList:
+        kwargs = {k: v for k, v in kwargs.items() if v is not None}
+        pyd = cls.pydListItem()
+        query = cls.pageQuery(sorts, limit, offset, q, owner, **kwargs)
+        await query
+        data = await pyd.from_queryset(query)
+        if limit - (li := len(data)):
+            filtered = total = li + offset
+        else:
+            total = await cls.all().count()
+            filtered_query = cls.filter(**kwargs)
+            if q:
+                filtered_query = filtered_query.filter(**{f"{cls._name}__icontains": q})
+            filtered = await filtered_query.count()
+        pyds = cls.pydsList()
+        return pyds(data=data, total=total, filtered=filtered)
+
+    def repr(self) -> str:
+        if self._name in self._meta.db_fields:
+            return " ".join(getattr(self, name_fragment) for name_fragment in self._name)
+        return self.__repr__()
+
+    @classmethod
+    async def getOrCreateByName(cls, name: str, attr_name: str = None, def_dict: dict = None) -> BaseModel:
+        attr_name = attr_name or list(cls._name)[0]
+        if not (obj := await cls.get_or_none(**{attr_name: name})):
+            next_id = (await cls.all().order_by("-id").first()).id + 1
+            obj = await cls.create(id=next_id, **{attr_name: name}, **(def_dict or {}))
+        return obj
+
+    @classmethod
+    async def upsert(cls, data: dict, oid=None):
+        meta: MetaInfo = cls._meta
+
+        # pop fields for relations from general data dict
+        m2ms = {k: data.pop(k) for k in meta.m2m_fields if k in data}
+        # bfks = {k: data.pop(k) for k in meta.backward_fk_fields if k in data}
+        # bo2os = {k: data.pop(k) for k in meta.backward_o2o_fields if k in data}
+
+        # save general model
+        # if pk := meta.pk_attr in data.keys():
+        #     unq = {pk: data.pop(pk)}
+        # else:
+        #     unq = {key: data.pop(key) for key, ft in meta.fields_map.items() if ft.unique and key in data.keys()}
+        # # unq = meta.unique_together
+        # obj, is_created = await cls.update_or_create(data, **unq)
+        obj = (await cls.update_or_create(data, **{meta.pk_attr: oid}))[0] if oid else await cls.create(**data)
+
+        # save relations
+        for k, ids in m2ms.items():
+            if ids:
+                m2m_rel: ManyToManyRelation = getattr(obj, k)
+                items = [await m2m_rel.remote_model[i] for i in ids]
+                await m2m_rel.clear()  # for updating, not just adding
+                await m2m_rel.add(*items)
+        # for k, ids in bfks.items():
+        #     bfk_rel: ReverseRelation = getattr(obj, k)
+        #     items = [await bfk_rel.remote_model[i] for i in ids]
+        #     [await item.update_from_dict({bfk_rel.relation_field: obj.pk}).save() for item in items]
+        # for k, oid in bo2os.items():
+        #     bo2o_rel: QuerySet = getattr(obj, k)
+        #     item = await bo2o_rel.model[oid]
+        #     await item.update_from_dict({obj._meta.db_table: obj}).save()
+
+        await obj.fetch_related(*cls._meta.fetch_fields)
+        return obj
+
+    @classmethod
+    def field_input_map(cls) -> dict:
+        def type2input(ft: type[Field]):
+            dry = {
+                "base_field": hasattr(ft, "base_field") and {**type2input(ft.base_field)},
+                "step": hasattr(ft, "step") and ft.step,
+                "labels": hasattr(ft, "labels") and ft.labels,
+            }
+            type2inputs: {Field: dict} = {
+                CharField: {"input": FieldType.input.name},
+                IntField: {"input": FieldType.input.name, "type": "number"},
+                SmallIntField: {"input": FieldType.input.name, "type": "number"},
+                BigIntField: {"input": FieldType.input.name, "type": "number"},
+                DecimalField: {"input": FieldType.input.name, "type": "number", "step": "0.01"},
+                FloatField: {"input": FieldType.input.name, "type": "number", "step": "0.001"},
+                TextField: {"input": FieldType.textarea.name, "rows": "2"},
+                BooleanField: {"input": FieldType.checkbox.name},
+                DatetimeField: {"input": FieldType.input.name, "type": "datetime"},
+                DatetimeSecField: {"input": FieldType.input.name, "type": "datetime"},
+                DateField: {"input": FieldType.input.name, "type": "date"},
+                TimeField: {"input": FieldType.input.name, "type": "time"},
+                JSONField: {"input": FieldType.input.name},
+                IntEnumFieldInstance: {"input": FieldType.select.name},
+                CharEnumFieldInstance: {"input": FieldType.select.name},
+                ForeignKeyFieldInstance: {"input": FieldType.select.name},
+                OneToOneFieldInstance: {"input": FieldType.select.name},
+                ManyToManyFieldInstance: {"input": FieldType.select.name, "multiple": True},
+                ForeignKeyRelation: {"input": FieldType.select.name, "multiple": True},
+                OneToOneRelation: {"input": FieldType.select.name},
+                BackwardOneToOneRelation: {"input": FieldType.select.name},
+                ManyToManyRelation: {"input": FieldType.select.name, "multiple": True},
+                ForeignKeyNullableRelation: {"input": FieldType.select.name, "multiple": True},
+                BackwardFKRelation: {"input": FieldType.select.name, "multiple": True},
+                ArrayField: {"input": FieldType.select.name, "multiple": True},
+                SetField: {"input": FieldType.select.name, "multiple": True},
+                OneToOneNullableRelation: {"input": FieldType.select.name},
+                PointField: {"input": FieldType.collection.name, **dry},
+                PolygonField: {"input": FieldType.list.name, **dry},
+                RangeField: {"input": FieldType.collection.name, **dry},
+            }
+            return type2inputs[ft]
+
+        def field2input(_key: str, field: Field):
+            attrs: dict = {"required": not field.null}
+            if isinstance(field, CharEnumFieldInstance):
+                attrs.update({"options": {en.name: en.value for en in field.enum_type}})
+            elif isinstance(field, IntEnumFieldInstance) or isinstance(field, SetField):
+                attrs.update({"options": {en.value: en.name.replace("_", " ") for en in field.enum_type}})
+            elif isinstance(field, RelationalField):
+                attrs.update({"source_field": field.source_field})  # 'table': attrs[key]['multiple'],
+            elif field.generated or ("auto_now" in field.__dict__ and (field.auto_now or field.auto_now_add)):  # noqa
+                attrs.update({"auto": True})
+            return {**type2input(type(field)), **attrs}
+
+        return {key: field2input(key, field) for key, field in cls._meta.fields_map.items() if not key.endswith("_id")}
+
+    class Meta:
+        abstract = True
+
+    class PydanticMeta:
+        #: If not empty, only fields this property contains will be in the pydantic model
+        # include: tuple[str, ...] = ()
+        # #: Fields listed in this property will be excluded from pydantic model
+        # exclude: tuple[str, ...] = ()
+        # #: Computed fields can be listed here to use in pydantic model
+        # computed: tuple[str, ...] = ()
+
+        exclude_raw_fields = False  # default: True
+        max_recursion: int = 1  # default: 3
+
+    class PydanticMetaIn:
+        max_recursion: int = 0  # default: 3
+        backward_relations: bool = False  # no need to disable when max_recursion=0  # default: True
+        exclude_raw_fields: bool = False  # default: True
+
+    class PydanticMetaListItem:
+        max_recursion: int = 0  # default: 3
+        backward_relations: bool = False  # default: True
+        exclude_raw_fields = False  # default: True
+        sort_alphabetically: bool = True  # default: False
+
+
+class TsModel(Model):
+    created_at: datetime | None = DatetimeSecField(auto_now_add=True)
+    updated_at: datetime | None = DatetimeSecField(auto_now=True)
+
+    class Meta:
+        abstract = True
+
+
+class User(TsModel):
+    status: UserStatus = IntEnumField(UserStatus, default=UserStatus.WAIT)
+    username: str | None = CharField(95, unique=True, null=True)
+    email: str | None = CharField(100, unique=True, null=True)
+    password: str | None = CharField(60, null=True)
+    phone: int | None = BigIntField(null=True)
+    role: UserRole = IntEnumField(UserRole, default=UserRole.CLIENT)
+
+    _icon = "user"
+    _name = {"username"}
+
+    class Meta:
+        table_description = "Users"
+
+
+class UserPasswordTrait(TsModel):
+    password: str | None = CharField(60, null=True)
+
+    __cc = CryptContext(schemes=["bcrypt"])
+
+    def pwd_vrf(self, pwd: str) -> bool:
+        return self.__cc.verify(pwd, self.password)
+
+    @classmethod
+    async def create(cls, using_db=None, **kwargs) -> "User":
+        user: "User" | Model = await super().create(using_db, **kwargs)
+        if pwd := kwargs.get("password"):
+            # noinspection PyUnresolvedReferences
+            await user.set_pwd(pwd)
+        return user
+
+    async def set_pwd(self, pwd: str = password) -> None:
+        self.password = self.__cc.hash(pwd)
+        await self.save()

x_model/pydantic.py

@@ -0,0 +1,54 @@
+from typing import TypeVar, Generic
+from pydantic import BaseModel, ConfigDict
+
+from x_model.enum import UserStatus, UserRole
+
+
+RootModelType = TypeVar("RootModelType")
+
+
+class PydList(BaseModel, Generic[RootModelType]):
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+    data: list[RootModelType]
+    total: int
+
+
+class UserPwd(BaseModel):
+    password: str
+
+
+class UserReg(UserPwd):
+    username: str
+    email: str | None = None
+    phone: int | None = None
+
+
+class UserUpdate(BaseModel):
+    username: str
+    status: UserStatus
+    email: str | None
+    phone: int | None
+    role: UserRole
+
+
+class UserAuth(UserUpdate):
+    id: int
+    username: str
+    status: UserStatus
+    role: UserRole
+    # ref_id: int | None
+
+
+class Names(BaseModel):
+    # models for name endpoint for select2 inputs
+    class Name(BaseModel):
+        id: int
+        text: str
+        logo: str | None = None
+        selected: bool | None = None
+
+    class Pagination(BaseModel):
+        more: bool
+
+    results: list[Name]
+    pagination: Pagination

xn_model-0.10.3.dev1.dist-info/METADATA

@@ -0,0 +1,43 @@
+Metadata-Version: 2.1
+Name: xn-model
+Version: 0.10.3.dev1
+Summary: Base model for xn-api
+Author-email: Mike Artemiev <mixartemev@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/XyncNet/x-model
+Project-URL: Repository, https://github.com/XyncNet/x-model
+Keywords: tortoise,model,crud,generator,api,admin
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: tortoise-orm[accel,asyncpg]
+Requires-Dist: passlib[bcrypt]
+Requires-Dist: pydantic
+Requires-Dist: python-dotenv
+Provides-Extra: dev
+Requires-Dist: pytest ; extra == 'dev'
+Requires-Dist: build ; extra == 'dev'
+Requires-Dist: twine ; extra == 'dev'
+Requires-Dist: setuptools-scm ; extra == 'dev'
+
+## INSTALL
+```bash
+# Create python virtual environment
+python3 -m venv venv
+# Activate this environment
+source venv/bin/activate
+# Install dependencies
+pip install .
+
+# Create pg db
+createdb --U username -W dbname
+## set password for db user
+
+# Copy .env file from sample template
+cp .env.sample .env
+## set your pg creds in .env file
+```
+
+## TEST
+```bash
+pytest
+```

xn_model-0.10.3.dev1.dist-info/RECORD

@@ -0,0 +1,10 @@
+x_model/__init__.py,sha256=LrDAUX7IsIS0HvdPAyefqzNknvnn3-3XVk-UDLBukwA,1007
+x_model/enum.py,sha256=yrTIzMVnqG-kAD4ifhJhMSnYI-DIDLkB236w-Ol2I-M,543
+x_model/field.py,sha256=S461M94ryQG7yu8lreXtWnZo3YdCP97xhbcCJ3BzXsY,2751
+x_model/func.py,sha256=E7jDoHJGaFpKvxbHnT_lyBxUZeMo-GRd5gv9dLw7B9s,289
+x_model/model.py,sha256=rzKwyk6Uu9c6hYCuVFbB4DHgYaMrGUkwIK1Zq0jCwwE,13856
+x_model/pydantic.py,sha256=lTQ4eGNg_jsyGNLu8B1fTO-Ky8C3F057abhyAdhmVoQ,1047
+xn_model-0.10.3.dev1.dist-info/METADATA,sha256=yQ4EovBcmvABOeff2zdqiwpxYxvSaIuMVEJKQaP7MQY,1062
+xn_model-0.10.3.dev1.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+xn_model-0.10.3.dev1.dist-info/top_level.txt,sha256=QCYyfv5AA_8jPPtCpShkBXzQRUCGuuW7Ro0mqysDE8E,8
+xn_model-0.10.3.dev1.dist-info/RECORD,,

xn_model-0.10.3.dev1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.1.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

xn_model-0.10.3.dev1.dist-info/top_level.txt

@@ -0,0 +1 @@
+x_model