xync-schema 0.6.73.dev3__tar.gz → 0.6.73.dev6__tar.gz

{xync_schema-0.6.73.dev3/xync_schema.egg-info → xync_schema-0.6.73.dev6}/PKG-INFO

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

{xync_schema-0.6.73.dev3 → xync_schema-0.6.73.dev6}/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.dev3 → xync_schema-0.6.73.dev6}/xync_schema/models.py

@@ -1,36 +1,35 @@
 import sys
 from datetime import datetime
+
 from tortoise import fields
 from tortoise.queryset import QuerySet
 from tortoise import Model as BaseModel
-from x_auth.enums import Role
-from x_auth.models import Model
+from tortoise.signals import pre_save
+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
 
 
-# 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)
     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"}
 
@@ -95,9 +94,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"
@@ -159,26 +158,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)
+
     user: fields.BackwardOneToOneRelation["User"]
-    actor: fields.BackwardOneToOneRelation["Actor"]
+    creds: fields.BackwardFKRelation["Cred"]
+    actors: fields.BackwardFKRelation["Actor"]
 
 
-class User(Model, UserInfoTrait):
-    id: int = fields.BigIntField(True)
-    ch: fields.OneToOneRelation[CredHolder] = fields.OneToOneField("models.CredHolder", "users")
-    ch_id: int
-    forum: int = fields.BigIntField()
-    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"]
@@ -199,13 +202,27 @@ class User(Model, UserInfoTrait):
     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"]
+
+
+@pre_save(User)
+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 PydanticMeta(Model.PydanticMeta):
-    # max_recursion = 0
-    # include = "role", "status"
-    # computed = ["balance"]
+
+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):
@@ -213,41 +230,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"
@@ -269,15 +274,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):
@@ -329,7 +339,11 @@ 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)
+    alias: str | None = fields.CharField(63, unique=True, null=True)
+    country: fields.ForeignKeyRelation[Country] = fields.ForeignKeyField(
+        "models.Country", related_name="pms", null=True
+    )
+    # type_: PmType | None = fields.IntEnumField(PmType, null=True)  # todo: get back
     type_: int | None = fields.SmallIntField(null=True)
     logo: str | None = fields.CharField(127, null=True)
 
@@ -398,16 +412,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
@@ -420,15 +424,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")
 
@@ -436,18 +437,30 @@ 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)
 

xync_schema-0.6.73.dev3/xync_schema/pydantic.py → xync_schema-0.6.73.dev6/xync_schema/types.py

@@ -1,8 +1,9 @@
 from datetime import datetime
+
 from pydantic import BaseModel
 
-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):
@@ -11,32 +12,32 @@ class _CurCoin(BaseModel):
     rate: float | None = None
 
 
-class CoinEpyd(_CurCoin):
+class CoinE(_CurCoin):
     p2p: bool = True
     minimum: float | None = None
 
 
-class CurEpyd(_CurCoin):
+class CurE(_CurCoin):
     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
+class Pm(BaseModel):
+    id: int = None
     name: str
     identifier: str | None = None
     type_: PmType | None = None
     logo: str | None = None
-    banks: list[PmexBankPyd] | None = None
+    banks: list[PmexBank] | None = None
 
 
-# class PmcurPyd(BaseModel):
+# class Pmcur(BaseModel):
 #     id: int | None = None
 #     pm_id: int
 #     cur_id: int
@@ -60,11 +61,11 @@ class FiatUpd(FFiat):
     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
@@ -73,16 +74,16 @@ class CredPydIn(BaseModel):
         arbitrary_types_allowed = True
 
     def args(self) -> tuple[dict, dict]:
-        unq: tuple[str, ...] = "id", "exid", "actor", "pmcur"
+        unq: tuple[str, ...] = "id", "exid", "ch", "pmcur"
         df: tuple[str, ...] = "detail", "name"
         d = self.model_dump()
         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 +103,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 +123,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):
+class AdBuyIn(BaseAdIn):
     pms_: list[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.pyd()
     is_sell: bool
     actor: int | None = None
     created_at: datetime
@@ -150,7 +151,7 @@ class OrderPyd(BaseModel):
     topic: int
 
 
-class OrderPydIn(BaseModel):
+class OrderIn(BaseModel):
     id: int = None
     exid: int
     amount: float
@@ -161,9 +162,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.dev3 → xync_schema-0.6.73.dev6/xync_schema.egg-info}/PKG-INFO

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

{xync_schema-0.6.73.dev3 → xync_schema-0.6.73.dev6}/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