xync-schema 0.6.72__tar.gz → 0.6.73.dev3__tar.gz

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

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

{xync_schema-0.6.72 → xync_schema-0.6.73.dev3}/xync_schema/enums.py

@@ -57,11 +57,13 @@ class TradeType(IntEnum):
 
 class PmType(IntEnum):
     bank = 0
-    web_wallet = 1
+    emoney = 1
     cash = 2
+    card = 4
     gift_card = 3
-    credit_card = 4
     IFSC = 5
+    SBP = 6
+    phone = 7
 
 
 class TaskType(IntEnum):

{xync_schema-0.6.72 → xync_schema-0.6.73.dev3}/xync_schema/models.py

@@ -66,12 +66,12 @@ class Ex(Model):
 
     pms: fields.ManyToManyRelation["Pm"]
     curs: fields.ManyToManyRelation[Cur]
-    pmcurs: fields.ManyToManyRelation["Pmcur"] = fields.ManyToManyField("models.Pmcur", through="pmcurex")
+    # pmcurs: fields.ManyToManyRelation["Pmcur"] = fields.ManyToManyField("models.Pmcur", through="pmcurex")
     coins: fields.ManyToManyRelation[Coin]
 
-    contragents: fields.ReverseRelation["Contragent"]
+    actors: fields.ReverseRelation["Actor"]
     pmexs: fields.ReverseRelation["Pmex"]
-    pairs: fields.ReverseRelation["Pair"]
+    pairexs: fields.ReverseRelation["PairEx"]
     # deps: fields.ReverseRelation["Dep"]
     # tests: fields.ReverseRelation["TestEx"]
 
@@ -82,11 +82,11 @@ class Ex(Model):
     class PydanticMeta(Model.PydanticMeta):
         include = "name", "logo"
 
-    def client(self, agent: "Agent" = None):
+    def client(self):
         module_name = f"xync_client.{self.name}.ex"
         __import__(module_name)
         client = sys.modules[module_name].ExClient
-        return client(self, agent)
+        return client(self)
 
 
 class Curex(BaseModel):
@@ -117,37 +117,57 @@ class Coinex(BaseModel):
         unique_together = (("ex_id", "coin_id"), ("ex_id", "exid"))
 
 
-class Pair(Model, TsTrait):
+class Pair(Model):
     id = fields.SmallIntField(True)
     coin: fields.ForeignKeyRelation[Coin] = fields.ForeignKeyField("models.Coin", related_name="pairs")
     cur: fields.ForeignKeyRelation[Cur] = fields.ForeignKeyField("models.Cur", related_name="pairs")
+
+    _name = {"coin__ticker", "cur__ticker"}
+
+    class Meta:
+        table_description = "Coin/Currency pairs"
+        unique_together = (("coin", "cur"),)
+
+
+class PairEx(Model, TsTrait):
+    pair: fields.ForeignKeyRelation[Pair] = fields.ForeignKeyField("models.Pair", related_name="pairexs")
+    pair_id: int
     fee: float = fields.FloatField(default=0)
     ex: fields.ForeignKeyRelation[Ex] = fields.ForeignKeyField("models.Ex", related_name="pairs")
+    ex_id: int
     directions: fields.ReverseRelation["Direction"]
 
-    _name = {"coin__ticker", "cur__ticker"}
+    _name = {"pair__coin__ticker", "pair__cur__ticker", "ex__name"}
 
     class Meta:
-        table_description = "Coin/Currency pairs"
-        unique_together = (("coin", "cur", "ex"),)
+        table_description = "Pairs on Exs"
+        unique_together = (("pair", "ex"),)
 
 
 class Direction(Model):
     id = fields.SmallIntField(True)
-    pair: fields.ForeignKeyRelation[Pair] = fields.ForeignKeyField("models.Pair", related_name="directions")
+    pairex: fields.ForeignKeyRelation[PairEx] = fields.ForeignKeyField("models.PairEx", related_name="directions")
+    pairex_id: int
     sell: bool = fields.BooleanField()
     total: int = fields.IntField(null=True)
     ads: fields.ReverseRelation["Ad"]
 
-    _name = {"pair__coin__ticker", "pair__cur__ticker", "sell"}
+    _name = {"pairex__coin__ticker", "pairex__cur__ticker", "sell"}
 
     class Meta:
         table_description = "Trade directions"
-        unique_together = (("pair", "sell"),)
+        unique_together = (("pairex", "sell"),)
+
 
+class CredHolder(Model, TsTrait):
+    user: fields.BackwardOneToOneRelation["User"]
+    actor: fields.BackwardOneToOneRelation["Actor"]
 
-class User(Model, TsTrait, UserInfoTrait):
+
+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)
@@ -188,11 +208,13 @@ class User(Model, TsTrait, UserInfoTrait):
     # computed = ["balance"]
 
 
-class Contragent(Model):
+class Actor(Model):
     exid: int = fields.BigIntField()
     name: int = fields.CharField(63)
-    ex: fields.ForeignKeyRelation[Ex] = fields.ForeignKeyField("models.Ex", related_name="contragents")
+    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)
 
     agent: fields.BackwardOneToOneRelation["Agent"]
@@ -201,34 +223,34 @@ class Contragent(Model):
     taken_orders: fields.BackwardFKRelation["Order"]
 
     class Meta:
-        table_description = "Agents"
+        table_description = "Actors"
         unique_together = (("ex", "exid"),)
 
 
 class Agent(Model, TsTrait):
     auth: dict[str, str] = fields.JSONField(null=True)
-    contragent: fields.OneToOneRelation[Contragent] = fields.OneToOneField("models.Contragent", "agent")
-    contragent_id: int
+    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 = {"contragent__name"}
+    _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 = (("contragent", "user"),)
+        unique_together = (("actor", "user"),)
 
     class PydanticMeta(Model.PydanticMeta):
         # max_recursion = 3
-        include = "id", "contragent__ex", "assets", "auth", "updated_at"
+        include = "id", "actor__ex", "assets", "auth", "updated_at"
         computed = ["balance"]
 
     def client(self):
-        module_name = f"xync_client.{self.contragent.ex.name}.agent"
+        module_name = f"xync_client.{self.actor.ex.name}.agent"
         __import__(module_name)
         client = sys.modules[module_name].AgentClient
         return client(self)
@@ -242,7 +264,7 @@ class Agent(Model, TsTrait):
     #     return client(self)
 
     def asset_client(self):
-        module_name = f"xync_client.{self.contragent.ex.name}.asset"
+        module_name = f"xync_client.{self.actor.ex.name}.asset"
         __import__(module_name)
         client = sys.modules[module_name].AssetClient
         return client(self)
@@ -269,7 +291,7 @@ class Adpm(Model):
 
 
 class Ad(Model, TsTrait):
-    id: int = fields.BigIntField(True)
+    exid: int = fields.BigIntField()
     direction: fields.ForeignKeyRelation[Direction] = fields.ForeignKeyField("models.Direction", related_name="ads")
     price: float = fields.FloatField()
     max_fiat: float = fields.FloatField()
@@ -278,7 +300,7 @@ class Ad(Model, TsTrait):
     auto_msg: str | None = fields.CharField(255, null=True)
     status: AdStatus = fields.IntEnumField(AdStatus, defaut=AdStatus.active)
 
-    maker: fields.ForeignKeyRelation[Contragent] = fields.ForeignKeyField("models.Contragent", "my_ads")
+    maker: fields.ForeignKeyRelation[Actor] = fields.ForeignKeyField("models.Actor", "my_ads")
     maker_id: int
 
     pms: fields.ManyToManyRelation["Pm"] = fields.ManyToManyField("models.Pm", through="adpm")  # only root pms
@@ -286,7 +308,7 @@ class Ad(Model, TsTrait):
     orders: fields.ReverseRelation["Order"]
 
     _icon = "ad"
-    _name = {"direction__pair__coin__ticker", "direction__pair__cur__ticker", "direction__sell", "price"}
+    _name = {"direction__pairex__coin__ticker", "direction__pairex__cur__ticker", "direction__sell", "price"}
 
     class Meta:
         table_description = "P2P Advertisements"
@@ -370,18 +392,20 @@ class PmexBank(BaseModel):  # banks for SBP
     exid: str = fields.CharField(63)
     name: str = fields.CharField(63)
 
+    creds: fields.ManyToManyRelation["Cred"]
+
     class Meta:
         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 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
@@ -403,25 +427,27 @@ class Cred(Model):
     # country_id: int
     detail: str = fields.CharField(127)
     name: str | None = fields.CharField(127, null=True)
-    contragent: fields.ForeignKeyRelation[Contragent] = fields.ForeignKeyField("models.Contragent", "creds")
-    contragent_id: int
+    ch: fields.ForeignKeyRelation[CredHolder] = fields.ForeignKeyField("models.CredHolder", "creds")
+    ch_id: int
+
+    banks: fields.ManyToManyRelation[PmexBank] = fields.ManyToManyField("models.PmexBank", related_name="creds")
 
     fiat: fields.BackwardOneToOneRelation["Fiat"]
-    ads: fields.BackwardFKRelation[Ad]
+    ads: fields.ManyToManyRelation[Ad]
     orders: fields.BackwardFKRelation["Order"]
 
     _name = {"exid"}
 
     class Meta:
         table_description = "Currency accounts"
-        unique_together = (("pmcur_id", "detail"), ("contragent", "exid"))
+        # unique_together = (("actor", "exid"), ("actor_id", "pmcur_id", "detail"))
 
 
 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.contragent.agent.user_id
+    # user_id: int  # cred.actor.agent.user_id
     amount: float | None = fields.FloatField(default=0)
     target: float | None = fields.FloatField(default=None, null=True)
 
@@ -485,16 +511,16 @@ class Asset(Model):
 
 
 class Order(Model):
-    id: int = fields.BigIntField(True)
+    exid: int = fields.BigIntField()
     ad: fields.ForeignKeyRelation[Ad] = fields.ForeignKeyField("models.Ad", related_name="ads")
     ad_id: int
     amount: float = fields.FloatField()
     cred: fields.ForeignKeyRelation[Cred] = fields.ForeignKeyField("models.Cred", related_name="orders", null=True)
     cred_id: int | None
-    taker: fields.ForeignKeyRelation[Contragent] = fields.ForeignKeyField("models.Contragent", "taken_orders")
+    taker: fields.ForeignKeyRelation[Actor] = fields.ForeignKeyField("models.Actor", "taken_orders")
     taker_id: int
-    maker_topic: int = fields.IntField()
-    taker_topic: int = fields.IntField()
+    maker_topic: int = fields.IntField(null=True)  # todo: remove nullability
+    taker_topic: int = fields.IntField(null=True)
     status: OrderStatus = fields.IntEnumField(OrderStatus)
     created_at: datetime | None = DatetimeSecField(auto_now_add=True)
     payed_at: datetime | None = DatetimeSecField(null=True)

xync_schema-0.6.73.dev3/xync_schema/pydantic.py

@@ -0,0 +1,180 @@
+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
+
+
+class _CurCoin(BaseModel):
+    exid: int | str
+    ticker: str
+    rate: float | None = None
+
+
+class CoinEpyd(_CurCoin):
+    p2p: bool = True
+    minimum: float | None = None
+
+
+class CurEpyd(_CurCoin):
+    rounding_scale: int | None = None
+    minimum: int | None = None
+
+
+class PmexBankPyd(BaseModel):
+    id: int | None = None
+    exid: str
+    name: str
+
+
+class PmPyd(BaseModel):
+    id: int | None = None
+    name: str
+    identifier: str | None = None
+    type_: PmType | None = None
+    logo: str | None = None
+    banks: list[PmexBankPyd] | None = None
+
+
+# class PmcurPyd(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):
+    id: int | None = None
+    exid: int
+    pmcur: Pmcur
+    actor: Actor
+    detail: str = ""
+    name: str = ""
+    banks: list[str] | None = None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def args(self) -> tuple[dict, dict]:
+        unq: tuple[str, ...] = "id", "exid", "actor", "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):
+    # unq
+    id: int = None
+    cred: Cred
+    # df
+    amount: float
+    target: float | None = None
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def args(self) -> tuple[dict, dict]:
+        unq: tuple[str, ...] = "id", "cred"
+        df: tuple[str, ...] = "amount", "target"
+        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 BaseAd(BaseModel):
+    id: int | None = None
+    price: float
+
+
+class BaseAdPydIn(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
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def args(self) -> tuple[dict, dict]:
+        unq: tuple[str, ...] = "id", "exid", "maker", "direction"
+        df: tuple[str, ...] = "price", "price", "min_fiat", "max_fiat", "detail", "auto_msg", "status"
+        d = self.model_dump(exclude_none=True)
+        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 AdSalePydIn(BaseAdPydIn):
+    creds_: list[Cred]
+
+
+class BaseOrder(BaseModel):
+    id: int | None = None
+
+
+class OrderPyd(BaseModel):
+    id: int
+    amount: float
+    status: str
+    actions: dict | None = {}
+    cred: Cred.pyd()
+    is_sell: bool
+    actor: int | None = None
+    created_at: datetime
+    payed_at: datetime | None = None
+    appealed_at: datetime | None = None
+    confirmed_at: datetime | None = None
+    msgs: int = 0
+    topic: int
+
+
+class OrderPydIn(BaseModel):
+    id: int = None
+    exid: int
+    amount: float
+    maker_topic: int | None = None
+    taker_topic: int | None = None
+    status: OrderStatus = OrderStatus.created
+    created_at: datetime
+    payed_at: datetime | None = None
+    confirmed_at: datetime | None = None
+    appealed_at: datetime | None = None
+    ad: Ad
+    cred: Cred
+    taker: Actor
+
+    class Config:
+        arbitrary_types_allowed = True
+
+    def args(self) -> tuple[dict, dict]:
+        unq: tuple[str, ...] = "id", "exid", "amount", "maker_topic", "taker_topic", "ad", "cred", "taker"
+        df: tuple[str, ...] = "status", "created_at", "payed_at", "confirmed_at", "appealed_at"
+        d = self.model_dump(exclude_none=True)
+        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 UreadMsgs(BaseModel):
+    order_id: int
+    unread_cnt: int

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

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

xync_schema-0.6.72/xync_schema/pydantic.py

@@ -1,159 +0,0 @@
-from datetime import datetime
-from pydantic import BaseModel, model_validator
-
-from xync_schema.enums import AdStatus, PmType
-from xync_schema.models import Direction, Pmcur, Ex, Cred, Contragent
-
-
-class _CurCoin(BaseModel):
-    exid: int | str
-    ticker: str
-    rate: float | None = None
-
-
-class CoinEpyd(_CurCoin):
-    p2p: bool = True
-    minimum: float | None = None
-
-
-class CurEpyd(_CurCoin):
-    rounding_scale: int | None = None
-    minimum: int | None = None
-
-
-class PmexBankPyd(BaseModel):
-    id: int | None = None
-    exid: str
-    name: str
-
-
-class PmPyd(BaseModel):
-    id: int | None = None
-    name: str
-    identifier: str | None = None
-    type_: PmType | None = None
-    logo: str | None = None
-    banks: list[PmexBankPyd] | None = None
-
-
-# class PmcurPyd(BaseModel):
-#     id: int | None = None
-#     pm_id: int
-#     cur_id: int
-
-
-class FiatUpd(BaseModel):
-    detail: str | None = None
-    name: str | None = None
-    amount: float | None = None
-    target: int | None = None
-
-
-class FiatNew(FiatUpd):
-    cur_id: int
-    pm_id: int
-    detail: str
-    amount: float = 0
-    target: int | None = None
-
-
-class CredPydIn(BaseModel):
-    id: int | None = None
-    exid: str
-    ex: Ex | None = None
-    ex_id: int | None = None
-    pmcur_id: int | None = None
-    pmcur: Pmcur | None = None
-    detail: str
-    name: str = ""
-
-    class Config:
-        arbitrary_types_allowed = True
-
-    @classmethod
-    @model_validator(mode="before")
-    def check_at_least_one_field(cls, values):
-        if (values.get("ex") or values.get("ex_id")) and (values.get("pmcur") or values.get("pmcur_id")):
-            return values
-        raise ValueError("ex(_id) and pmcur(_id) is required")
-
-
-class FiatPydIn(BaseModel):
-    # unq
-    id: int = None
-    cred_id: int | None = None
-    cred: Cred | None = None
-    # df
-    amount: float
-    target: float | None = None
-
-    banks: list[str] = []
-
-    class Config:
-        arbitrary_types_allowed = True
-
-    @classmethod
-    @model_validator(mode="before")
-    def check_at_least_one_field(cls, values):
-        if values.get("cred") or values.get("cred_id"):
-            return values
-        raise ValueError("cred(_id) is required")
-
-    def args(self) -> tuple[dict, dict]:
-        unq: tuple[str, ...] = "id", "cred_id", "cred"
-        df: tuple[str, ...] = "amount", "target"
-        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 BaseAd(BaseModel):
-    id: int | None = None
-    price: float
-
-
-class AdPydIn(BaseAd):
-    min_fiat: float
-    max_fiat: float | None = None
-    detail: str | None = None
-    auto_msg: str | None = None
-    status: AdStatus = AdStatus.active
-    maker_id: int | None = None
-    maker: Contragent | None = None
-    direction_id: int | None = None
-    direction: Direction | None = None
-    pms_: list | None = None
-    fiats_: list | None = None
-
-    class Config:
-        arbitrary_types_allowed = True
-
-    @classmethod
-    @model_validator(mode="before")
-    def check_at_least_one_field(cls, values):
-        maker = values.get("maker") or values.get("maker_id")
-        direction = values.get("direction") or values.get("direction_id")
-        pms_or_fiats = values.get("pms_") or values.get("fiats_")
-        if maker and direction and pms_or_fiats:
-            return values
-        raise ValueError("(pms or fiats) and maker(_id) and direction(_id) is required")
-
-
-class OrderPyd(BaseModel):
-    id: int
-    amount: float
-    status: str
-    actions: dict | None = {}
-    cred: Cred.pyd()
-    is_sell: bool
-    contragent: int | None = None
-    created_at: datetime
-    payed_at: datetime | None = None
-    appealed_at: datetime | None = None
-    confirmed_at: datetime | None = None
-    msgs: int = 0
-    topic: int
-
-
-class UreadMsgs(BaseModel):
-    order_id: int
-    unread_cnt: int