xync-schema 0.6.71__py3-none-any.whl → 0.6.73.dev3__py3-none-any.whl

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):
@@ -112,9 +114,7 @@ class ExAction(IntEnum):
     coins = 22  # Список торгуемых монет (с ограничениям по валютам, если есть)
     pairs = 23  # Список пар валюта/монет
     ads = 24  # Список объяв по покупке/продаже, валюте, монете, платежному методу (buy/sell, cur, coin, pm)
-    ad = 42  # Объява по id
-    cur_mins = 43  # Минимальные объемы валют в объявлении
-    coin_mins = 44  # Минимальные объемы монет в объявлении
+    ad = 42  # Чужая объява по id
     """ Agent: Fiat """
     my_fiats = 25  # Список реквизитов моих платежных методов
     fiat_new = 26  # Создание реквизита моего платежного метода
@@ -122,6 +122,7 @@ class ExAction(IntEnum):
     fiat_del = 28  # Удаление реквизита моего платежного метода
     """ Agent: Ad """
     my_ads = 29  # Список моих объявлений
+    my_ad = 43  # Моя объява по id
     ad_new = 30  # Создание объявления
     ad_upd = 31  # Редактирование объявления
     ad_del = 32  # Удаление объявления

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]
 
-    agents: fields.ReverseRelation["Agent"]
+    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)
@@ -159,7 +179,7 @@ class User(Model, TsTrait, UserInfoTrait):
 
     proteges: fields.BackwardFKRelation["User"]
     agents: fields.BackwardFKRelation["Agent"]
-    fiats: fields.BackwardFKRelation["Fiat"]
+    # fiats: fields.BackwardFKRelation["Fiat"]
     limits: fields.BackwardFKRelation["Limit"]
     # vpn: fields.BackwardOneToOneRelation["Vpn"]
     # invite_requests: fields.BackwardFKRelation["Invite"]
@@ -188,46 +208,49 @@ 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"]
-    taken_orders: fields.BackwardFKRelation["Order"]
+    creds: fields.BackwardFKRelation["Cred"]
     my_ads: fields.BackwardFKRelation["Ad"]
+    taken_orders: fields.BackwardFKRelation["Order"]
 
     class Meta:
-        table_description = "Agents"
+        table_description = "Actors"
         unique_together = (("ex", "exid"),)
 
 
-class Agent(Model):
+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)
@@ -241,7 +264,7 @@ class Agent(Model):
     #     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)
@@ -268,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()
@@ -277,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
@@ -285,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"
@@ -369,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 FiatBank(BaseModel):  # banks for SBP
-    pmexbank: fields.ForeignKeyRelation[PmexBank] = fields.ForeignKeyField("models.PmexBank", "fiatbanks")
-    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
@@ -402,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)
 
@@ -484,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)
@@ -528,7 +555,7 @@ class Order(Model):
     class PydanticMeta(Model.PydanticMeta):
         max_recursion: int = 0
         exclude_raw_fields: bool = False
-        exclude = ("taker", "ad", "fiat", "msgs")
+        exclude = ("taker", "ad", "cred", "msgs")
 
 
 class Msg(Model):

xync_schema/pydantic.py

@@ -1,9 +1,8 @@
 from datetime import datetime
+from pydantic import BaseModel
 
-from pydantic import BaseModel, model_validator
-
-from xync_schema.enums import AdStatus, PmType
-from xync_schema.models import Fiat, Agent, Direction, Pmcur, User, Ex
+from xync_schema.enums import AdStatus, PmType, OrderStatus
+from xync_schema.models import Direction, Pmcur, Cred, Actor, Pm, Ad
 
 
 class _CurCoin(BaseModel):
@@ -43,70 +42,59 @@ class PmPyd(BaseModel):
 #     cur_id: int
 
 
-class FiatUpd(BaseModel):
-    detail: str | None = None
+class FFiat(BaseModel):
+    detail: str
     name: str | None = None
-    amount: float | None = None
+    amount: float = 0
     target: int | None = None
+    banks: list[str] = []
 
 
-class FiatNew(FiatUpd):
+class FiatNew(FFiat):
     cur_id: int
     pm_id: int
-    detail: str
-    amount: float = 0
-    target: int | None = None
 
 
-class FiatPydIn(BaseModel):
-    # unq
-    id: int = None
-    user_id: int | None = None
-    user: User | None = None
-    pmcur_id: int | None = None
-    pmcur: Pmcur | None = None
-    # df
-    detail: str
-    name: str = ""
-    amount: float
-    target: float | None = None
+class FiatUpd(FFiat):
+    id: int
+    exid: int
 
-    banks: list[str] = []
+
+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
 
-    @classmethod
-    @model_validator(mode="before")
-    def check_at_least_one_field(cls, values):
-        if (values.get("pmcur") or values.get("pmcur_id")) and (values.get("user") or values.get("user_id")):
-            return values
-        raise ValueError("pmcur(_id) and user(_id) is required")
-
     def args(self) -> tuple[dict, dict]:
-        unq: tuple[str, ...] = "id", "user_id", "user", "pmcur_id", "pmcur"
-        df: tuple[str, ...] = "detail", "name", "amount", "target"
+        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 FiatexPydIn(BaseModel):
-    id: int | None = None
-    exid: str
-    ex: Ex | None = None
-    ex_id: int | None = None
-    fiat: Fiat | None = None
-    fiat_id: int | None = None
+class FiatPydIn(BaseModel):
+    # unq
+    id: int = None
+    cred: Cred
+    # df
+    amount: float
+    target: float | None = None
 
     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("fiat") or values.get("fiat_id")):
-            return values
-        raise ValueError("ex(_id) and fiat(_id) is required")
+    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):
@@ -114,31 +102,36 @@ class BaseAd(BaseModel):
     price: float
 
 
-class AdPydIn(BaseAd):
+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
-    agent_id: int | None = None
-    direction_id: int | None = None
-    agent: Agent | None = None
-    direction: Direction | None = None
-    pms_: list | None = None
-    fiats_: list | None = None
+    maker: Actor = None
+    direction: Direction
 
     class Config:
         arbitrary_types_allowed = True
 
-    @classmethod
-    @model_validator(mode="before")
-    def check_at_least_one_field(cls, values):
-        agent = values.get("agent") or values.get("agent_id")
-        direction = values.get("direction") or values.get("direction_id")
-        pms_or_fiats = values.get("pms_") or values.get("fiats_")
-        if agent and direction and pms_or_fiats:
-            return values
-        raise ValueError("(pms or fiats) and agent(_id) and direction(_id) is required")
+    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):
@@ -146,9 +139,9 @@ class OrderPyd(BaseModel):
     amount: float
     status: str
     actions: dict | None = {}
-    fiat: Fiat.pyd()
+    cred: Cred.pyd()
     is_sell: bool
-    contragent: int | None = None
+    actor: int | None = None
     created_at: datetime
     payed_at: datetime | None = None
     appealed_at: datetime | None = None
@@ -157,6 +150,31 @@ class OrderPyd(BaseModel):
     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.71.dist-info → xync_schema-0.6.73.dev3.dist-info}/METADATA

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

xync_schema-0.6.73.dev3.dist-info/RECORD

@@ -0,0 +1,8 @@
+xync_schema/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+xync_schema/enums.py,sha256=XlkpnQFBhrIQ11ZoufwAEKK4RmcOTUu5On1QjsoyrqA,12315
+xync_schema/models.py,sha256=jiyJ-5d2E0mmOHlsWWfc2coYttvsYN4YsH8MOGtbKUg,26409
+xync_schema/pydantic.py,sha256=CIX0n2VdFxRYCS3kMe8ee9Wfj2ZLe3lvFdiieu_9DZs,4259
+xync_schema-0.6.73.dev3.dist-info/METADATA,sha256=mUIuJzZVYlk81TH4xbrrd26DO1GST7tJbl8ZlIY2Spw,3990
+xync_schema-0.6.73.dev3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+xync_schema-0.6.73.dev3.dist-info/top_level.txt,sha256=jN8IBDfVY8b85Byyk8v0Gyj_0yLB8FO56WV4EvcXWY4,12
+xync_schema-0.6.73.dev3.dist-info/RECORD,,

xync_schema-0.6.71.dist-info/RECORD

@@ -1,8 +0,0 @@
-xync_schema/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-xync_schema/enums.py,sha256=zPdnf6J--qaBoyin_qXO3z_UnfpiHGXVHKs9v3ug1Qk,12428
-xync_schema/models.py,sha256=w3TOlAK9ESN0tOMb7Zbb6XK1PpsxT2j5Ck0qAY-ig3s,25512
-xync_schema/pydantic.py,sha256=2Gupluj7SfQs276mWH1SDzkxyOcst3naxlB4sULeU7U,4046
-xync_schema-0.6.71.dist-info/METADATA,sha256=xM-nC9Wbz15BWmejIJqIDrSQFLVNYwzNjAQlXBAiXhQ,3985
-xync_schema-0.6.71.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-xync_schema-0.6.71.dist-info/top_level.txt,sha256=jN8IBDfVY8b85Byyk8v0Gyj_0yLB8FO56WV4EvcXWY4,12
-xync_schema-0.6.71.dist-info/RECORD,,