xync-schema 0.6.73.dev4__tar.gz → 0.6.73.dev7__tar.gz

{xync_schema-0.6.73.dev4/xync_schema.egg-info → xync_schema-0.6.73.dev7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xync-schema
-Version: 0.6.73.dev4
+Version: 0.6.73.dev7
 Summary: XyncNet project database model schema
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 License: EULA

{xync_schema-0.6.73.dev4 → xync_schema-0.6.73.dev7}/tests/test_db.py

@@ -7,7 +7,7 @@ from tortoise.backends.asyncpg import AsyncpgDBClient
 from x_model import init_db
 
 from xync_schema import models
-from xync_schema.models import Cur
+from xync_schema.models import Ex
 
 load_dotenv()
 
@@ -25,5 +25,5 @@ async def test_init_db(dbc):
 
 
 async def test_models(dbc):
-    c = await Cur.all()
-    assert isinstance(c, list), "No currencies"
+    c = await Ex.first()
+    assert isinstance(c, Ex), "No exs"

{xync_schema-0.6.73.dev4 → xync_schema-0.6.73.dev7}/xync_schema/enums.py

@@ -1,6 +1,18 @@
 from enum import IntEnum
 
 
+class PersonStatus(IntEnum):
+    VIP = 2
+    DEFAULT = 1
+    BLOCKED = 0
+
+
+class UserStatus(IntEnum):
+    SLEEP = 0
+    PAY = 1
+    ACTIVE = 2
+
+
 class AdStatus(IntEnum):
     defActive = 0
     active = 1

{xync_schema-0.6.73.dev4 → xync_schema-0.6.73.dev7}/xync_schema/models.py

@@ -5,34 +5,42 @@ from tortoise import fields
 from tortoise.queryset import QuerySet
 from tortoise import Model as BaseModel
 from tortoise.signals import pre_save
-from x_auth.enums import Role
-from x_auth.models import Model
+from x_auth.models import Model, UserTg
 from x_model.models import TsTrait, DatetimeSecField
-from tg_auth.models import UserStatus, AuthUser, UserInfoTrait
 
-from xync_schema.enums import ExType, AdStatus, AssetType, OrderStatus, ExAction, ExStatus
+from xync_schema.enums import (
+    ExType,
+    AdStatus,
+    AssetType,
+    OrderStatus,
+    ExAction,
+    ExStatus,
+    PersonStatus,
+    UserStatus,
+    PmType,
+)
 
 
-# class Country(Model):
-#     id = fields.SmallIntField(True)
-#     code: int | None = fields.IntField(null=True)
-#     short: str | None = fields.CharField(3, unique=True, null=True)
-#     name: str | None = fields.CharField(63, unique=True, null=True)
-#     cur: fields.ForeignKeyRelation["Cur"] = fields.ForeignKeyField("models.Cur", related_name="countries")
-#     curexs: fields.ManyToManyRelation["Curex"]
-#     fiats: fields.BackwardFKRelation["Fiat"]
+class Country(Model):
+    id = fields.SmallIntField(True)
+    code: int | None = fields.IntField(null=True)
+    short: str | None = fields.CharField(3, null=True)
+    name: str | None = fields.CharField(63, unique=True, null=True)
+    cur: fields.ForeignKeyRelation["Cur"] = fields.ForeignKeyField("models.Cur", related_name="countries")
+    curexs: fields.ManyToManyRelation["Curex"]
+    fiats: fields.BackwardFKRelation["Fiat"]
 
 
 class Cur(Model):
     id = fields.SmallIntField(True)
     ticker: str = fields.CharField(3, unique=True)
+    scale: int = fields.SmallIntField(default=0)
     rate: float | None = fields.FloatField(default=0, null=True)
-    # country: str | None = fields.CharField(63, null=True)
 
     pms: fields.ManyToManyRelation["Pm"] = fields.ManyToManyField("models.Pm", through="pmcur")
     exs: fields.ManyToManyRelation["Ex"] = fields.ManyToManyField("models.Ex", through="curex")
     pairs: fields.ReverseRelation["Pair"]
-    # countries: fields.ReverseRelation[Country]
+    countries: fields.ReverseRelation[Country]
 
     _name = {"ticker"}
 
@@ -43,6 +51,7 @@ class Cur(Model):
 class Coin(Model):
     id: int = fields.SmallIntField(True)
     ticker: str = fields.CharField(15, unique=True)
+    scale: int = fields.SmallIntField(default=0)
     rate: float | None = fields.FloatField(default=0)
     is_fiat: bool = fields.BooleanField(default=False)
     exs: fields.ManyToManyRelation["Ex"] = fields.ManyToManyField("models.Ex", through="coinex")
@@ -97,9 +106,9 @@ class Curex(BaseModel):
     exid: str = fields.CharField(31)
     minimum: float = fields.FloatField(null=True)
     rounding_scale: int = fields.SmallIntField(null=True)
-    # countries: fields.ManyToManyRelation[Country] = fields.ManyToManyField(
-    #     "models.Country", through="curexcountry", backward_key="curexs"
-    # )
+    countries: fields.ManyToManyRelation[Country] = fields.ManyToManyField(
+        "models.Country", through="curexcountry", backward_key="curexs"
+    )
 
     class Meta:
         table_description = "Currency in Exchange"
@@ -161,26 +170,30 @@ class Direction(Model):
         unique_together = (("pairex", "sell"),)
 
 
-class CredHolder(Model, TsTrait):
+class Person(Model, TsTrait):
+    status: PersonStatus = fields.IntEnumField(PersonStatus, default=PersonStatus.DEFAULT)
+    name: str | None = fields.CharField(127, null=True)
+
     user: fields.BackwardOneToOneRelation["User"]
-    actor: fields.BackwardOneToOneRelation["Actor"]
+    creds: fields.BackwardFKRelation["Cred"]
+    actors: fields.BackwardFKRelation["Actor"]
 
 
-class User(Model, UserInfoTrait, TsTrait):
-    id: int = fields.BigIntField(True)
-    ch: fields.OneToOneRelation[CredHolder] = fields.OneToOneField("models.CredHolder", "users")
-    ch_id: int
-    role: Role = fields.IntEnumField(Role, default=Role.READER)
-    status: UserStatus = fields.IntEnumField(UserStatus, default=UserStatus.RESTRICTED)
-    username: str | None = fields.CharField(95, unique=True, null=True)
+class User(UserTg, TsTrait):
+    status: UserStatus = fields.IntEnumField(UserStatus, default=UserStatus.SLEEP)
+
+    person: fields.OneToOneRelation[Person] = fields.OneToOneField("models.Person", related_name="user")
+    person_id: int
     ref: fields.ForeignKeyNullableRelation["User"] = fields.ForeignKeyField(
         "models.User", related_name="proteges", null=True
     )
     ref_id: int | None
 
     forum: fields.BackwardOneToOneRelation["Forum"]
+    created_forums: fields.BackwardFKRelation["Forum"]
     proteges: fields.BackwardFKRelation["User"]
-    agents: fields.BackwardFKRelation["Agent"]
+    creds: fields.BackwardFKRelation["Cred"]
+    actors: fields.BackwardFKRelation["Actor"]
     # fiats: fields.BackwardFKRelation["Fiat"]
     limits: fields.BackwardFKRelation["Limit"]
     # vpn: fields.BackwardOneToOneRelation["Vpn"]
@@ -201,25 +214,27 @@ class User(Model, UserInfoTrait, TsTrait):
     async def balance(self) -> float:
         return await self.free_assets() + await self.fiats_sum()
 
-    def get_auth(self) -> AuthUser:
-        return AuthUser.model_validate(self, from_attributes=True)
+    def name(self):
+        return f"{self.first_name} {self.last_name}".rstrip()
 
-    # class PydanticMeta(Model.PydanticMeta):
-    # max_recursion = 0
-    # include = "role", "status"
-    # computed = ["balance"]
+    class PydanticMeta(Model.PydanticMeta):
+        max_recursion = 0
+        include = "role", "status"
+        # computed = ["balance"]
 
 
 @pre_save(User)
-async def ch(_meta, user: User, _db, _updated: dict) -> None:
-    if not user.ch_id:
-        user.ch = await CredHolder.create()
+async def person(_meta, user: User, _db, _updated: dict) -> None:
+    if not user.person_id:
+        user.person = await Person.create(name=f"{user.first_name} {user.last_name}".strip())
 
 
 class Forum(Model, TsTrait):
     id: int = fields.BigIntField(True)
     joined: bool = fields.BooleanField(default=False)
     user: fields.OneToOneRelation[User] = fields.OneToOneField("models.User", "forum")
+    user_id: int
+    # created_by: fields.BackwardFKRelation[User] = fields.ForeignKeyField("models.User", "created_forums")
 
 
 class Actor(Model):
@@ -227,41 +242,29 @@ class Actor(Model):
     name: int = fields.CharField(63)
     ex: fields.ForeignKeyRelation[Ex] = fields.ForeignKeyField("models.Ex", related_name="actors")
     ex_id: int
-    ch: fields.OneToOneNullableRelation[CredHolder] = fields.OneToOneField("models.CredHolder", "actor", null=True)
-    ch_id: int
-    updated_at: datetime | None = DatetimeSecField(auto_now=True)
+    person: fields.ForeignKeyRelation[Person] = fields.ForeignKeyField("models.Person", related_name="actors")
+    person_id: int
 
     agent: fields.BackwardOneToOneRelation["Agent"]
-    creds: fields.BackwardFKRelation["Cred"]
-    my_ads: fields.BackwardFKRelation["Ad"]
+    ads: fields.BackwardFKRelation["Ad"]
     taken_orders: fields.BackwardFKRelation["Order"]
 
     class Meta:
         table_description = "Actors"
-        unique_together = (("ex", "exid"),)
+        unique_together = (("ex", "exid"), ("ex", "person"))
 
 
 class Agent(Model, TsTrait):
-    auth: dict[str, str] = fields.JSONField(null=True)
+    auth: dict[str, str] = fields.JSONField(default={})
     actor: fields.OneToOneRelation[Actor] = fields.OneToOneField("models.Actor", "agent")
     actor_id: int
-    user: fields.ForeignKeyRelation[User] = fields.ForeignKeyField("models.User", related_name="agents")
-    user_id: int
+
     assets: fields.ReverseRelation["Asset"]
 
     _name = {"actor__name"}
 
-    def balance(self) -> int:
-        return sum(asset.free * (asset.coin.rate or 0) for asset in self.assets)
-
-    class Meta:
-        table_description = "Agents"
-        unique_together = (("actor", "user"),)
-
-    class PydanticMeta(Model.PydanticMeta):
-        # max_recursion = 3
-        include = "id", "actor__ex", "assets", "auth", "updated_at"
-        computed = ["balance"]
+    # def balance(self) -> int:
+    #     return sum(asset.free * (asset.coin.rate or 0) for asset in self.assets)
 
     def client(self):
         module_name = f"xync_client.{self.actor.ex.name}.agent"
@@ -283,15 +286,20 @@ class Agent(Model, TsTrait):
         client = sys.modules[module_name].AssetClient
         return client(self)
 
+    # class PydanticMeta(Model.PydanticMeta):
+    # max_recursion = 3
+    # include = "id", "actor__ex", "auth", "updated_at"
+    # computed = ["balance"]
 
-class Adpm(Model):
-    ad: fields.ForeignKeyRelation["Ad"] = fields.ForeignKeyField("models.Ad")
-    pm: fields.ForeignKeyRelation["Pm"] = fields.ForeignKeyField("models.Pm")
-
-    _name = {"ad__id", "pm__name"}
 
-    class Meta:
-        table_description = "P2P Advertisements - Payment methods"
+# class Adpm(Model):
+#     ad: fields.ForeignKeyRelation["Ad"] = fields.ForeignKeyField("models.Ad")
+#     pm: fields.ForeignKeyRelation["Pm"] = fields.ForeignKeyField("models.Pm")
+#
+#     _name = {"ad__id", "pm__name"}
+#
+#     class Meta:
+#         table_description = "P2P Advertisements - Payment methods"
 
 
 # class AdCred(Model):
@@ -341,11 +349,17 @@ class Ad(Model, TsTrait):
 
 
 class Pm(Model):
-    name: str = fields.CharField(63, unique=True)
-    identifier: str | None = fields.CharField(63, unique=True, null=True)
-    # type_: PmType | None = fields.IntEnumField(PmType, null=True)
-    type_: int | None = fields.SmallIntField(null=True)
-    logo: str | None = fields.CharField(127, null=True)
+    # name: str = fields.CharField(63)  # mv to pmex cause it diffs on each ex
+    norm: str | None = fields.CharField(63)
+    acronym: str | None = fields.CharField(7, unique=True, null=True)
+    country: fields.ForeignKeyRelation[Country] = fields.ForeignKeyField("models.Country", "pms", null=True)
+    alias: str | None = fields.CharField(63, null=True)
+    extra: str | None = fields.CharField(63, null=True)
+    ok: bool = fields.BooleanField(default=True)
+    bank: bool = fields.BooleanField(null=True)
+
+    type_: PmType | None = fields.IntEnumField(PmType, null=True)
+    logo: str | None = fields.CharField(119, null=True)
 
     ads: fields.ManyToManyRelation[Ad]
     curs: fields.ManyToManyRelation[Cur]
@@ -356,6 +370,7 @@ class Pm(Model):
 
     class Meta:
         table_description = "Payment methods"
+        unique_together = (("norm", "country"), ("alias", "country"))
 
     # class PydanticMeta(Model.PydanticMeta):
     #     max_recursion = 3
@@ -387,17 +402,21 @@ class Pmcur(Model):  # for fiat with no exs tie
 
 
 class Pmex(BaseModel):  # existence pm in ex with no cur tie
-    pm: fields.ForeignKeyRelation[Pm] = fields.ForeignKeyField("models.Pm", "pmexs")
-    pm_id: int
     ex: fields.ForeignKeyRelation[Ex] = fields.ForeignKeyField("models.Ex", "pmexs")
     ex_id: int
+    pm: fields.ForeignKeyRelation[Pm] = fields.ForeignKeyField("models.Pm", "pmexs")
+    pm_id: int
     exid: str = fields.CharField(63)
     name: str = fields.CharField(63)
+    name_: str = fields.CharField(63, null=True)
 
     banks: fields.BackwardFKRelation["PmexBank"]
 
     class Meta:
-        unique_together = (("ex_id", "exid"),)
+        unique_together = (
+            ("ex", "exid"),
+            ("ex", "name_"),
+        )  # , ("ex", "pm"), ("ex", "name")  # todo: tmp removed for HTX duplicates
 
 
 class PmexBank(BaseModel):  # banks for SBP
@@ -412,16 +431,6 @@ class PmexBank(BaseModel):  # banks for SBP
         unique_together = (("pmex", "exid"),)
 
 
-# class CredBank(BaseModel):  # banks for SBP
-#     pmexbank: fields.ForeignKeyRelation[PmexBank] = fields.ForeignKeyField("models.PmexBank", "credbanks")
-#     pmexbank_id: int
-#     cred: fields.ForeignKeyRelation["Cred"] = fields.ForeignKeyField("models.Cred", "credbanks")
-#     cred_id: int
-#
-#     class Meta:
-#         unique_together = (("cred_id", "pmexbank_id"),)
-
-
 # class Pmcurex(BaseModel):  # existence pm in ex for exact cur, with "blocked" flag
 #     pmcur: fields.ForeignKeyRelation[Pmcur] = fields.ForeignKeyField("models.Pmcur")
 #     pmcur_id: int
@@ -434,15 +443,12 @@ class PmexBank(BaseModel):  # banks for SBP
 
 
 class Cred(Model):
-    exid: int = fields.BigIntField()
     pmcur: fields.ForeignKeyRelation[Pmcur] = fields.ForeignKeyField("models.Pmcur")
     pmcur_id: int
-    # country: fields.ForeignKeyRelation[Country] = fields.ForeignKeyField("models.Country", related_name="fiats")
-    # country_id: int
     detail: str = fields.CharField(127)
     name: str | None = fields.CharField(127, null=True)
-    ch: fields.ForeignKeyRelation[CredHolder] = fields.ForeignKeyField("models.CredHolder", "creds")
-    ch_id: int
+    person: fields.ForeignKeyRelation[Person] = fields.ForeignKeyField("models.Person", "creds")
+    person_id: int
 
     banks: fields.ManyToManyRelation[PmexBank] = fields.ManyToManyField("models.PmexBank", related_name="creds")
 
@@ -450,20 +456,32 @@ class Cred(Model):
     ads: fields.ManyToManyRelation[Ad]
     orders: fields.BackwardFKRelation["Order"]
 
-    _name = {"exid"}
+    _name = {"detail"}
 
     class Meta:
         table_description = "Currency accounts"
-        # unique_together = (("actor", "exid"), ("actor_id", "pmcur_id", "detail"))
+        unique_together = (("person", "pmcur", "detail"),)
+
+
+class CredEx(Model):
+    exid: int = fields.BigIntField()
+    cred: fields.ForeignKeyRelation[Cred] = fields.ForeignKeyField("models.Cred", "credexs")
+    cred_id: int
+    ex: fields.ForeignKeyRelation[Ex] = fields.ForeignKeyField("models.Ex", "credexs")
+    ex_id: int
+
+    _name = {"exid"}
+
+    class Meta:
+        table_description = "Credential on Exchange"
+        unique_together = (("ex", "exid"),)
 
 
 class Fiat(Model):
     cred: fields.OneToOneRelation[Cred] = fields.OneToOneField("models.Cred", "fiat")
     cred_id: int
-    # user: fields.ForeignKeyRelation[User] = fields.ForeignKeyField("models.User", "fiats")
-    # user_id: int  # cred.actor.agent.user_id
     amount: float | None = fields.FloatField(default=0)
-    target: float | None = fields.FloatField(default=None, null=True)
+    target: float = fields.FloatField(default=0)
 
     class Meta:
         table_description = "Currency balances"

xync_schema-0.6.73.dev4/xync_schema/pydantic.py → xync_schema-0.6.73.dev7/xync_schema/types.py

@@ -1,70 +1,60 @@
 from datetime import datetime
+
 from pydantic import BaseModel
+from x_model.types import New, Upd
 
-from xync_schema.enums import AdStatus, PmType, OrderStatus
-from xync_schema.models import Direction, Pmcur, Cred, Actor, Pm, Ad
+from xync_schema.enums import AdStatus, OrderStatus, PmType
+from xync_schema import models
 
 
-class _CurCoin(BaseModel):
+class UnitEx(BaseModel):
     exid: int | str
     ticker: str
-    rate: float | None = None
+    scale: int
 
 
-class CoinEpyd(_CurCoin):
-    p2p: bool = True
+class CoinEx(UnitEx):
+    p2p: bool = None
     minimum: float | None = None
 
 
-class CurEpyd(_CurCoin):
+class CurEx(UnitEx):
     rounding_scale: int | None = None
     minimum: int | None = None
 
 
-class PmexBankPyd(BaseModel):
+class PmexBank(BaseModel):
     id: int | None = None
     exid: str
     name: str
 
 
-class PmPyd(BaseModel):
-    id: int | None = None
-    name: str
-    identifier: str | None = None
+class PmIn(New):
+    norm: str
+    acronym: str | None = None
+    alias: str | None = None
+    extra: str | None = None
+    bank: bool | None = None
+    country_id: int | None = None
     type_: PmType | None = None
     logo: str | None = None
-    banks: list[PmexBankPyd] | None = None
 
 
-# class PmcurPyd(BaseModel):
+class PmOut(PmIn, Upd):
+    banks: list[PmexBank] | None = None
+
+
+# class Pmcur(BaseModel):
 #     id: int | None = None
 #     pm_id: int
 #     cur_id: int
 
 
-class FFiat(BaseModel):
-    detail: str
-    name: str | None = None
-    amount: float = 0
-    target: int | None = None
-    banks: list[str] = []
-
-
-class FiatNew(FFiat):
-    cur_id: int
-    pm_id: int
-
-
-class FiatUpd(FFiat):
-    id: int
-    exid: int
-
-
-class CredPydIn(BaseModel):
+class CredIn(BaseModel):
     id: int | None = None
     exid: int
-    pmcur: Pmcur
-    actor: Actor
+    pmcur: models.Pmcur
+    actor: models.Actor
     detail: str = ""
     name: str = ""
     banks: list[str] | None = None
@@ -79,10 +69,10 @@ class CredPydIn(BaseModel):
         return {k: getattr(self, k) for k in df if d.get(k)}, {k: getattr(self, k) for k in unq if d.get(k)}
 
 
-class FiatPydIn(BaseModel):
+class FiatIn(BaseModel):
     # unq
     id: int = None
-    cred: Cred
+    cred: models.Cred
     # df
     amount: float
     target: float | None = None
@@ -102,15 +92,15 @@ class BaseAd(BaseModel):
     price: float
 
 
-class BaseAdPydIn(BaseAd):
+class BaseAdIn(BaseAd):
     exid: int
     min_fiat: float
     max_fiat: float | None = None
     detail: str | None = None
     auto_msg: str | None = None
     status: AdStatus = AdStatus.active
-    maker: Actor = None
-    direction: Direction
+    maker: models.Actor = None
+    direction: models.Direction
 
     class Config:
         arbitrary_types_allowed = True
@@ -122,24 +112,24 @@ class BaseAdPydIn(BaseAd):
         return {k: getattr(self, k) for k in df if d.get(k)}, {k: getattr(self, k) for k in unq if d.get(k)}
 
 
-class AdBuyPydIn(BaseAdPydIn):
-    pms_: list[Pm]
+class AdBuyIn(BaseAdIn):
+    pms_: list[models.Pm]
 
 
-class AdSalePydIn(BaseAdPydIn):
-    creds_: list[Cred]
+class AdSaleIn(BaseAdIn):
+    creds_: list[models.Cred]
 
 
 class BaseOrder(BaseModel):
     id: int | None = None
 
 
-class OrderPyd(BaseModel):
+class Order(BaseModel):
     id: int
     amount: float
     status: str
     actions: dict | None = {}
-    cred: Cred.pyd()
+    cred: models.Cred.out_type()
     is_sell: bool
     actor: int | None = None
     created_at: datetime
@@ -150,7 +140,7 @@ class OrderPyd(BaseModel):
     topic: int
 
 
-class OrderPydIn(BaseModel):
+class OrderIn(BaseModel):
     id: int = None
     exid: int
     amount: float
@@ -161,9 +151,9 @@ class OrderPydIn(BaseModel):
     payed_at: datetime | None = None
     confirmed_at: datetime | None = None
     appealed_at: datetime | None = None
-    ad: Ad
-    cred: Cred
-    taker: Actor
+    ad: models.Ad
+    cred: models.Cred
+    taker: models.Actor
 
     class Config:
         arbitrary_types_allowed = True

{xync_schema-0.6.73.dev4 → xync_schema-0.6.73.dev7/xync_schema.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: xync-schema
-Version: 0.6.73.dev4
+Version: 0.6.73.dev7
 Summary: XyncNet project database model schema
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 License: EULA

{xync_schema-0.6.73.dev4 → xync_schema-0.6.73.dev7}/xync_schema.egg-info/SOURCES.txt

@@ -9,7 +9,7 @@ tests/test_db.py
 xync_schema/__init__.py
 xync_schema/enums.py
 xync_schema/models.py
-xync_schema/pydantic.py
+xync_schema/types.py
 xync_schema.egg-info/PKG-INFO
 xync_schema.egg-info/SOURCES.txt
 xync_schema.egg-info/dependency_links.txt