xn-model 0.10.3.dev1__tar.gz → 0.11.0__tar.gz

{xn_model-0.10.3.dev1 → xn_model-0.11.0}/.env.sample

@@ -2,4 +2,5 @@ POSTGRES_USER=user
 POSTGRES_PASSWORD=password
 POSTGRES_DB=bd_name
 POSTGRES_HOST=127.0.0.1
-POSTGRES_PORT=5432
+POSTGRES_PORT=5432
+VENV=venv

{xn_model-0.10.3.dev1/xn_model.egg-info → xn_model-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xn-model
-Version: 0.10.3.dev1
+Version: 0.11.0
 Summary: Base model for xn-api
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 License: MIT
@@ -10,8 +10,6 @@ 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"

{xn_model-0.10.3.dev1 → xn_model-0.11.0}/makefile

@@ -1,5 +1,5 @@
+include .env
 PACKAGE := x_model
-VENV := venv
 VPYTHON := . $(VENV)/bin/activate && python
 
 .PHONY: all install pre-commit test clean build twine patch
@@ -8,20 +8,20 @@ all:
 	make install test clean build
 
 install: $(VENV)
-	$(VPYTHON) -m pip install -e .[dev]; make pre-commit
+	$(VPYTHON) -m pip install .[dev]; make pre-commit
 pre-commit: .pre-commit-config.yaml
 	pre-commit install -t pre-commit -t post-commit -t pre-push
 
-test:
+test: $(VENV)
 	$(VPYTHON) -m pytest
 
 clean: .pytest_cache dist $(PACKAGE).egg-info
 	rm -rf .pytest_cache dist/* $(PACKAGE).egg-info $(PACKAGE)/__pycache__ dist/__pycache__
 
-build:
+build: $(VENV)
 	$(VPYTHON) -m build; make twine
-twine: dist
+twine: $(VENV) dist
 	$(VPYTHON) -m twine upload dist/* --skip-existing
 
-patch:
+patch: $(VENV)
 	git tag `$(VPYTHON) -m setuptools_scm --strip-dev`; git push --tags --prune -f

{xn_model-0.10.3.dev1 → xn_model-0.11.0}/pyproject.toml

@@ -6,8 +6,6 @@ authors = [
 ]
 dependencies = [
     'tortoise-orm[accel,asyncpg]',
-    'passlib[bcrypt]',
-    'pydantic',
     "python-dotenv"
 ]
 keywords = ["tortoise", "model", "crud", "generator", "api", "admin"]

{xn_model-0.10.3.dev1 → xn_model-0.11.0}/x_model/__init__.py

@@ -3,25 +3,6 @@ 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:

xn_model-0.11.0/x_model/model.py

@@ -0,0 +1,172 @@
+from datetime import datetime
+from pydantic import create_model
+from tortoise import Model as TortoiseModel
+from tortoise.contrib.pydantic import pydantic_model_creator, PydanticModel
+from tortoise import fields
+from tortoise.models import MetaInfo
+from tortoise.queryset import QuerySet
+
+from x_model.field import DatetimeSecField
+from x_model.pydantic import PydList
+
+
+class BaseModel(TortoiseModel):
+    # todo: resolve ownable + add only own list method
+    # todo: refact: clean old garbage
+    id: int = fields.IntField(True)
+
+    _name: tuple[str] = {"name"}
+    _sorts: tuple[str] = ["-id"]
+
+    def repr(self, sep: str = " ") -> str:
+        if self._name in self._meta.db_fields:
+            return sep.join(getattr(self, name_fragment) for name_fragment in self._name)
+        return self.__repr__()
+
+    @classmethod
+    async def get_or_create_by_name(cls, name: str, attr_name: str = None, def_dict: dict = None) -> TortoiseModel:
+        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
+    def _page_query(cls, sorts: tuple[str], limit: int = 1000, offset: int = 0, q: str = None, **filters) -> QuerySet:
+        query = cls.filter(**filters).order_by(*sorts).limit(limit).offset(offset)
+        if q:
+            query = query.filter(**{f"{cls._name}__icontains": q})
+        return query
+
+    @classmethod
+    async def upsert(cls, data: dict, oid=None):
+        meta: MetaInfo = cls._meta
+
+        # pop fields for relations from general data dict # todo: add backwards fields for save
+        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, id=oid))[0] if oid else await cls.create(**data)
+
+        # save relations
+        for k, ids in m2ms.items():
+            if ids:
+                m2m_rel: fields.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
+
+    class Meta:
+        abstract = True
+
+
+class Model(BaseModel):
+    _pyd: type[PydanticModel] = None
+    _pydIn: type[PydanticModel] = None
+    _pydListItem: type[PydanticModel] = None
+
+    class PydanticMeta:
+        # include: tuple[str, ...] = ()
+        # exclude: tuple[str, ...] = ()
+        # 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
+
+    @classmethod
+    def pyd(cls) -> type[PydanticModel]:
+        cls._pyd = cls._pyd or pydantic_model_creator(cls)
+        return cls._pyd
+
+    @classmethod
+    def pyd_in(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 pyd_list_item(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 pyds_list(cls) -> type[PydList]:
+        return create_model(
+            cls.__name__ + "List",
+            data=(list[cls.pyd_list_item()], []),
+            total=(int, 0),
+            filtered=(int | None, None),
+            __base__=PydList[cls.pyd_list_item()],
+        )
+
+    # # # CRUD Methods # # #
+    @classmethod
+    async def one_pyd(cls, uid: int, **filters) -> PydanticModel:
+        q = cls.get(id=uid, **filters)
+        return await cls.pyd().from_queryset_single(q)
+
+    @classmethod
+    async def page_pyd(cls, sorts: tuple[str], limit: int = 1000, offset: int = 0, q: str = None, **filters) -> PydList:
+        filters = {k: v for k, v in filters.items() if v is not None}
+        pyd_item = cls.pyd_list_item()
+        query = cls._page_query(sorts, limit, offset, q, **filters)
+        data = await pyd_item.from_queryset(query)
+        if limit - (li := len(data)):
+            filtered = total = li + offset
+        else:
+            total = await cls.all().count()
+            filtered_query = cls.filter(**filters)
+            if q:
+                filtered_query = filtered_query.filter(**{f"{cls._name}__icontains": q})
+            filtered = await filtered_query.count()
+        pyds = cls.pyds_list()
+        return pyds(data=data, total=total, filtered=filtered)
+
+
+class TsTrait:
+    created_at: datetime | None = DatetimeSecField(auto_now_add=True)
+    updated_at: datetime | None = DatetimeSecField(auto_now=True)

{xn_model-0.10.3.dev1 → xn_model-0.11.0}/x_model/pydantic.py

@@ -1,8 +1,6 @@
 from typing import TypeVar, Generic
 from pydantic import BaseModel, ConfigDict
 
-from x_model.enum import UserStatus, UserRole
-
 
 RootModelType = TypeVar("RootModelType")
 
@@ -13,32 +11,6 @@ class PydList(BaseModel, Generic[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):

{xn_model-0.10.3.dev1 → xn_model-0.11.0/xn_model.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: xn-model
-Version: 0.10.3.dev1
+Version: 0.11.0
 Summary: Base model for xn-api
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 License: MIT
@@ -10,8 +10,6 @@ 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"

{xn_model-0.10.3.dev1 → xn_model-0.11.0}/xn_model.egg-info/SOURCES.txt

@@ -7,7 +7,6 @@ pyproject.toml
 tests/__init__.py
 tests/test_db.py
 x_model/__init__.py
-x_model/enum.py
 x_model/field.py
 x_model/func.py
 x_model/model.py

{xn_model-0.10.3.dev1 → xn_model-0.11.0}/xn_model.egg-info/requires.txt

@@ -1,6 +1,4 @@
 tortoise-orm[accel,asyncpg]
-passlib[bcrypt]
-pydantic
 python-dotenv
 
 [dev]

xn_model-0.10.3.dev1/x_model/enum.py

@@ -1,31 +0,0 @@
-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

xn_model-0.10.3.dev1/x_model/model.py

@@ -1,330 +0,0 @@
-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()