xn-model 0.10.3.dev1__tar.gz

xn_model-0.10.3.dev1/.env.sample

@@ -0,0 +1,5 @@
+POSTGRES_USER=user
+POSTGRES_PASSWORD=password
+POSTGRES_DB=bd_name
+POSTGRES_HOST=127.0.0.1
+POSTGRES_PORT=5432

xn_model-0.10.3.dev1/.gitignore

@@ -0,0 +1,7 @@
+/dist
+/.idea
+/*.egg-info
+/.env
+/venv
+__pycache__
+/build

xn_model-0.10.3.dev1/.pre-commit-config.yaml

@@ -0,0 +1,44 @@
+repos:
+- repo: local
+  hooks:
+  - id: pytest
+    name: pytest
+    entry: pytest tests -v
+    language: python
+    types: [python]
+    verbose: true
+    stages: [pre-commit]
+
+  - id: tag
+    name: tag
+    ### make tag with next ver only if "fix" in commit_msg or starts with "feat"
+    entry: bash -c 'grep -e "^feat:" -e "^fix:" .git/COMMIT_EDITMSG && make patch || exit 0'
+    language: system
+    verbose: true
+    pass_filenames: false
+    always_run: true
+    stages: [post-commit]
+
+  - id: build
+    name: build
+    ### build & upload package only for "main" branch push
+    entry: bash -c 'echo $PRE_COMMIT_LOCAL_BRANCH | grep /master && make build || echo 0'
+    language: system
+    pass_filenames: false
+    verbose: true
+    require_serial: true
+    stages: [pre-push]
+
+- repo: https://github.com/astral-sh/ruff-pre-commit
+  ### Ruff version.
+  rev: v0.6.4
+  hooks:
+    ### Run the linter.
+    - id: ruff
+      args: [--fix, --unsafe-fixes]
+      stages: [pre-commit]
+    ### Run the formatter.
+    - id: ruff-format
+      types_or: [python, pyi]
+      verbose: true
+      stages: [pre-commit]

xn_model-0.10.3.dev1/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,22 @@
+## 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/makefile

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

xn_model-0.10.3.dev1/pyproject.toml

@@ -0,0 +1,43 @@
+[project]
+name = "xn-model"
+requires-python = ">=3.12"
+authors = [
+    {name = "Mike Artemiev", email = "mixartemev@gmail.com"},
+]
+dependencies = [
+    'tortoise-orm[accel,asyncpg]',
+    'passlib[bcrypt]',
+    'pydantic',
+    "python-dotenv"
+]
+keywords = ["tortoise", "model", "crud", "generator", "api", "admin"]
+description = 'Base model for xn-api'
+readme = "README.md"
+license = {text = "MIT"}
+dynamic = ["version"]
+
+[project.urls]
+Homepage = "https://github.com/XyncNet/x-model"
+Repository = "https://github.com/XyncNet/x-model"
+
+[build-system]
+requires = ["setuptools>=64", "setuptools-scm[toml]>=8"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["x_model"]
+
+[tool.setuptools_scm]
+version_scheme = "python-simplified-semver" # if "feature" in `branch_name` SEMVER_MINOR++ else SEMVER_PATCH++
+local_scheme = "no-local-version"
+
+[project.optional-dependencies]
+dev = [
+    "pytest",
+    "build",
+    "twine",
+    "setuptools_scm",
+]
+
+[tool.ruff]
+line-length = 120

xn_model-0.10.3.dev1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xn_model-0.10.3.dev1/tests/test_db.py

@@ -0,0 +1,14 @@
+from asyncio import run
+from os import getenv as env
+from dotenv import load_dotenv
+from tortoise.backends.asyncpg import AsyncpgDBClient
+
+from x_model import init_db, model
+
+load_dotenv()
+
+PG_DSN = f"postgres://{env('POSTGRES_USER')}:{env('POSTGRES_PASSWORD')}@{env('POSTGRES_HOST', 'xyncdbs')}:{env('POSTGRES_PORT', 5432)}/{env('POSTGRES_DB', env('POSTGRES_USER'))}"
+
+
+def test_init_db():
+    assert isinstance(run(init_db(PG_DSN, model)), AsyncpgDBClient), "DB corrupt"

xn_model-0.10.3.dev1/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

xn_model-0.10.3.dev1/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

xn_model-0.10.3.dev1/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

xn_model-0.10.3.dev1/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

xn_model-0.10.3.dev1/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()

xn_model-0.10.3.dev1/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/xn_model.egg-info/PKG-INFO

@@ -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/xn_model.egg-info/SOURCES.txt

@@ -0,0 +1,19 @@
+.env.sample
+.gitignore
+.pre-commit-config.yaml
+README.md
+makefile
+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
+x_model/pydantic.py
+xn_model.egg-info/PKG-INFO
+xn_model.egg-info/SOURCES.txt
+xn_model.egg-info/dependency_links.txt
+xn_model.egg-info/requires.txt
+xn_model.egg-info/top_level.txt

xn_model-0.10.3.dev1/xn_model.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

xn_model-0.10.3.dev1/xn_model.egg-info/requires.txt

@@ -0,0 +1,10 @@
+tortoise-orm[accel,asyncpg]
+passlib[bcrypt]
+pydantic
+python-dotenv
+
+[dev]
+pytest
+build
+twine
+setuptools_scm

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

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