xync-db 0.1.4__tar.gz → 0.2.0__tar.gz

{xync_db-0.1.4 → xync_db-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xync-db
-Version: 0.1.4
+Version: 0.2.0
 Summary: Xync DB schema: Tortoise ORM models, enums, pydantic DTOs.
 Author-email: Mike Artemiev <mixartemev@gmail.com>
 License: LicenseRef-EULA

{xync_db-0.1.4 → xync_db-0.2.0}/src/xync_db/migrations/models/0002_triggers.py

@@ -237,11 +237,9 @@ CREATE OR REPLACE FUNCTION cred_del() returns trigger as $cred_del_trg$
 DECLARE
     cxs jsonb;
 BEGIN
-    IF OLD.ovr_pm_id = 0 THEN
-        SELECT jsonb_agg(jsonb_build_array(ex_id, exid)) INTO cxs FROM credex WHERE cred_id = OLD.id;
-        IF cxs IS NOT NULL THEN
-            PERFORM pg_notify('creds_del', jsonb_build_array(OLD.person_id, cxs)::varchar);
-        END IF;
+    SELECT jsonb_agg(jsonb_build_array(ex_id, exid)) INTO cxs FROM credex WHERE cred_id = OLD.id;
+    IF cxs IS NOT NULL THEN
+        PERFORM pg_notify('creds_del', jsonb_build_array(OLD.person_id, cxs)::varchar);
     END IF;
     RETURN OLD;
 END

{xync_db-0.1.4 → xync_db-0.2.0}/src/xync_db/models/__init__.py

@@ -4,6 +4,7 @@ import logging
 import re
 import struct
 import sys
+from collections.abc import Collection
 from datetime import datetime
 from decimal import Decimal
 from time import time
@@ -40,6 +41,7 @@ from tortoise.functions import Sum
 from tortoise.migrations.constraints import CheckConstraint
 from tortoise.signals import pre_save
 from tortoise.timezone import now
+from tortoise.transactions import in_transaction
 
 # noinspection PyUnusedImports
 from x_auth.models import (  # noqa: F401
@@ -1163,6 +1165,64 @@ class Ad(Model, TsTrait):
         "price",
     }
 
+    @staticmethod
+    async def _sync_pms(ad: Ad, pms: Collection[Pm] | None) -> None:
+        """Синк m2m pms (clear+add), только если набор передан и отличается от текущего.
+        Дедуп и diff — по `pm.id`, НЕ через set[Pm]: XyncPay-Pm имеет id=0, а Tortoise.Model.__hash__
+        трактует pk=0 как unsaved (`not self.pk`) → набор с ним невозможно захэшировать."""
+        if pms is None:
+            return
+        new = {p.id: p for p in pms}  # dedup by id (Pm.id==0 → unhashable, нельзя set[Pm])
+        if {p.id for p in await ad.pms} != new.keys():
+            await ad.pms.clear()
+            if new:
+                await ad.pms.add(*new.values())
+
+    @classmethod
+    async def upsert(
+        cls,
+        *,
+        id: int | None = None,
+        since: datetime | None = None,
+        pms: Collection[Pm] | None = None,
+        **fields,
+    ) -> tuple[Ad, bool]:
+        """ЕДИНСТВЕННЫЙ writer строки Ad (single-writer-правило, как Cred.upsert). Три режима:
+          - правка по `id` (write-back exid 0→real, смена статуса) → fields пишутся через filter().update()
+            (без бампа updated_at — иначе сломали бы stale-guard синка ниже);
+          - синк с биржи (передан правдивый `exid`) → upsert по (exid, maker_id) со stale-guard `since`
+            (DB-first: если строку правили локально ПОЗЖЕ чтения биржи — биржевой снимок устарел, не
+            затираем, иначе летит «обратный» mads_upd);
+          - создание локальной заготовки (exid=0 — он НЕ уникален per maker, поэтому именно create,
+            а не upsert).
+        `pms` (Collection[Pm] | None) — m2m: синкаем только если передан (дедуп по id внутри _sync_pms —
+        НЕ set[Pm], XyncPay-Pm имеет id=0 и невхэшируем). Запись строки + clear+add pms всегда в
+        ОДНОЙ транзакции (и в синке, и в create), иначе AFTER INSERT/UPDATE-триггер (ads_new/ads_upd) шлёт
+        NOTIFY на коммите строки — до записи pms — и хэндлер прочитает объяву с пустым/промежуточным набором.
+        Внешние id (maker/pair_side/pms/cond) резолвит вызывающий (держит ex_client-контекст: e2x_actor/
+        e2x_pm); модель пишет скаляры."""
+        if id is not None:
+            await cls.filter(id=id).update(**fields)
+            return await cls.get(id=id), False
+        if fields.get("exid"):
+            unq = {"exid": fields.pop("exid"), "maker_id": fields.pop("maker_id")}
+            async with in_transaction():
+                if since is not None:
+                    existing = await cls.select_for_update().get_or_none(**unq)
+                    if existing and existing.updated_at and existing.updated_at >= since:
+                        logging.info(
+                            f"Ad.upsert: skip stale exchange overwrite ad#{existing.id} "
+                            f"(db updated_at {existing.updated_at} >= exchange read {since})"
+                        )
+                        return existing, False
+                ad, created = await cls.update_or_create(defaults=fields, **unq)
+                await cls._sync_pms(ad, pms)
+            return ad, created
+        async with in_transaction():  # create + pms одной транзакцией: ads_new (AFTER INSERT) доставляется
+            ad = await cls.create(**fields)  # на COMMIT — к этому моменту pms уже целиком видны хэндлеру
+            await cls._sync_pms(ad, pms)  # новая локальная заготовка exid=0
+        return ad, True
+
     class Meta:
         table_description = "P2P Advertisements"
         unique_together = (("exid", "maker"),)
@@ -1222,6 +1282,34 @@ class MyAd(Model):  # Road
             "ad__pair_side__pair__coin", "ad__pair_side__pair__cur", "ad__maker__ex"
         )
 
+    @classmethod
+    async def upsert(
+        cls,
+        *,
+        id: int | None = None,
+        ad_id: int | None = None,
+        credexs: list[CredEx] | None = None,
+        **fields,
+    ) -> tuple[MyAd, bool]:
+        """ЕДИНСТВЕННЫЙ writer строки MyAd (single-writer-правило, как CredEx.upsert для CredEx). Режимы:
+          - правка по `id` (hex/shared_at от ad_share, blocked, target_place) → fields через filter().update();
+          - upsert по `ad_id` (1:1 с Ad) → fields в defaults.
+        `credexs` (list[CredEx] | None) — m2m: синкаем (clear+add), только если передан НЕПУСТОЙ список
+        (пустой бы вайпнул связь — этот случай вызывающий обрабатывает сам, не передавая credexs). Запись
+        строки my_ad + clear+add credexs идут в ОДНОЙ транзакции: иначе AFTER INSERT-триггер my_ad шлёт
+        my_ads_new на коммите строки — до записи credexs — и my_ad_new (фронт-создание, exid=0) запостит
+        объяву на биржу с пустым набором PM."""
+        async with in_transaction():  # строка + credexs одной транзакцией: my_ads_new (AFTER INSERT)
+            if id is not None:  # доставляется на COMMIT → my_ad_new прочитает уже полные credexs, а не
+                await cls.filter(id=id).update(**fields)  # пустые (иначе объява улетит на биржу без PM)
+                mad, created = await cls.get(id=id), False
+            else:
+                mad, created = await cls.update_or_create(defaults=fields, ad_id=ad_id)
+            if credexs:
+                await mad.credexs.clear()
+                await mad.credexs.add(*credexs)
+        return mad, created
+
     @classmethod
     #
     def new(cls, coin_id: int, cur_id: int, min_fiat: int, is_hot: bool = False): ...
@@ -1407,30 +1495,66 @@ class Cred(Model):
         name = f", имя: {self.name}" if self.name else ""
         return f"`{self.detail}`{name}{xtr}"
 
-    async def set_ovr_pm(self) -> bool:
-        """Вывести «оверрайд-PM» по detail/extra и проставить его. XyncPay-кред → ovr_pm_id=0 (hot,
-        размножается по биржам); Volet/AdvCash (или его R/E/U/T/L/D-карточный паттерн) → Pm `volet`.
-        Идемпотентно — пишет только при реальном изменении, поэтому безопасно звать на КАЖДОМ create И
-        update креда без зацикливания триггера `creds_upd`. Возвращает True, если ovr_pm_id поменялся."""
-        extra = self.extra or ""
-        if "XyncPay" in self.detail or "XyncPay" in extra:
-            ovr: int | None = 0
-        elif (
-            "volet" in self.detail.lower()
-            or "advcash" in self.detail.lower()
-            or "volet" in extra.lower()
-            or "advcash" in extra.lower()
-            or re.match(r"[REUTLD]\d{4} ?\d{4} ?\d{4}\b", self.detail)
+    _UNSET: ClassVar = object()  # sentinel: «поле не передано» (отличаем от явного None, который НУЛЯЕТ)
+
+    @staticmethod
+    async def _classify_ovr_pm(detail: str, extra: str | None) -> int | None:
+        """Вывести «оверрайд-PM» по detail/extra — ЧИСТЫЙ расчёт, без записи. XyncPay → 0 (hot,
+        размножается по биржам); Volet/AdvCash (или его R/E/U/T/L/D-карточный паттерн) → Pm `volet`;
+        иначе None. Зовётся ТОЛЬКО из `upsert`, чтобы ovr_pm писался в той же записи, что и сам Cred
+        (а не отдельным self-write/реактивным хендлером — см. single-writer-правило)."""
+        extra = extra or ""
+        if "XyncPay" in detail or "XyncPay" in extra:
+            return 0
+        low_d, low_e = detail.lower(), extra.lower()
+        if (
+            "volet" in low_d
+            or "advcash" in low_d
+            or "volet" in low_e
+            or "advcash" in low_e
+            or re.match(r"[REUTLD]\d{4} ?\d{4} ?\d{4}\b", detail)
             or re.match(r"[REUTLD]\d{4} ?\d{4} ?\d{4}\b", extra)
         ):
-            ovr = (await Pm.get(norm="volet")).id
-        else:
-            return False
-        if self.ovr_pm_id == ovr:
-            return False
-        self.ovr_pm_id = ovr
-        await self.save(update_fields=["ovr_pm_id"])
-        return True
+            return (await Pm.get(norm="volet")).id
+        return None
+
+    @classmethod
+    async def upsert(
+        cls,
+        *,
+        id: int | None = None,
+        pmcur_id: int | None = None,
+        pm_id: int | None = None,
+        cur_id: int | None = None,
+        person_id: int | None = None,
+        detail: str,
+        name: str | None = None,
+        extra: str | None = _UNSET,
+        qr: bytes | None = _UNSET,
+    ) -> tuple[Cred, bool]:
+        """ЕДИНСТВЕННЫЙ writer строки Cred (single-writer-правило). Классифицирует ovr_pm и пишет его
+        В ТОЙ ЖЕ записи. Два режима:
+          - правка существующего: передан `id` → обновляем detail/name(/extra/qr) + пере-классификация;
+          - создание/upsert: person_id + (pmcur_id ИЛИ pm_id+cur_id) → ключ (person, pmcur, detail).
+        Внешние id (pmcur/pm/cur/person) резолвит вызывающий (он держит ex_client-контекст: e2x_actor/
+        e2x_pm); модель принимает готовые скаляры и только пишет. extra/qr с дефолтом-сентинелом: не
+        переданы — не трогаем (иначе случайно занулили бы существующий qr при правке detail с фронта)."""
+        df: dict = {
+            "name": name,
+            "ovr_pm_id": await cls._classify_ovr_pm(detail, None if extra is cls._UNSET else extra),
+        }
+        if extra is not cls._UNSET:
+            df["extra"] = extra
+        if qr is not cls._UNSET:
+            df["qr"] = qr
+        if id is not None:
+            df["detail"] = detail
+            cred = await cls.get(id=id)
+            cred.update_from_dict(df)
+            await cred.save()
+            return cred, False
+        pmcur_id = pmcur_id or (await PmCur.get(pm_id=pm_id, cur_id=cur_id)).id
+        return await cls.update_or_create(df, pmcur_id=pmcur_id, person_id=person_id, detail=detail)
 
     class Meta:
         table_description = "Currency accounts"
@@ -1446,6 +1570,14 @@ class CredEx(Model):
 
     _name: ClassVar = {"exid"}
 
+    @classmethod
+    async def upsert(cls, *, cred_id: int, ex_id: int, exid: int) -> CredEx:
+        """ЕДИНСТВЕННЫЙ writer CredEx (single-writer-правило): ключ (cred, ex), ставит exid. Покрывает
+        и стаб exid=0 (реактивный фанаут на биржи), и реальный exid (parse в `credex_save` / ответ биржи
+        в хендлере `credex_new`). Больше НИКТО не пишет CredEx напрямую."""
+        credex, _ = await cls.update_or_create({"exid": exid}, cred_id=cred_id, ex_id=ex_id)
+        return credex
+
     class Meta:
         table_description = "Credential on Exchange"
         unique_together = (("ex", "exid"),)
@@ -1472,6 +1604,18 @@ class Fiat(Model):
         __import__(module_name)
         return sys.modules[module_name].FiatEpyd
 
+    @classmethod
+    async def upsert(cls, cred_id: int, amount: int, target: int | None = None, min_deposit: int | None = None) -> Fiat:
+        """ЕДИНСТВЕННЫЙ writer Fiat-баланса (single-writer-правило, как Asset.upsert). Апсертит по
+        cred_id (OneToOne), ставя amount (+ target/min_deposit, если переданы). Резолв cred остаётся
+        у вызывающего; модель только пишет."""
+        defaults = {"amount": amount}
+        if target is not None:
+            defaults["target"] = target
+        if min_deposit is not None:
+            defaults["min_deposit"] = min_deposit
+        return (await cls.update_or_create(defaults, cred_id=cred_id))[0]
+
 
 class Limit(Model):
     pmcur: ForeignKeyRelation[PmCur] = ForeignKeyField("models.PmCur", on_update=CASCADE)
@@ -1528,6 +1672,18 @@ class Asset(Model):
         __import__(module_name)
         return sys.modules[module_name].AssetEpyd
 
+    @classmethod
+    async def upsert(
+        cls, actor_id: int, coin_id: int, agent_id: int, free: int, freeze: int | None = None, typ: AddrExType = None
+    ) -> Asset:
+        """ЕДИНСТВЕННЫЙ writer Asset-баланса (single-writer-правило). Резолвит Addr по (actor, coin),
+        создаёт при отсутствии, апсертит Asset по натуральному ключу (addr, agent, typ), ставя free
+        (и freeze, если передан). Резолв actor/agent остаётся у вызывающего (client держит контекст)."""
+        addr, _ = await Addr.get_or_create(actor_id=actor_id, coin_id=coin_id)
+        defaults = {"free": free} if freeze is None else {"free": free, "freeze": freeze}
+        asset, _ = await cls.update_or_create(defaults, addr=addr, agent_id=agent_id, typ=typ or AddrExType.found)
+        return asset
+
 
 class PayReq(Model, TsTrait):
     pay_until: datetime = DatetimeSecField()
@@ -1633,6 +1789,32 @@ class Order(Model, TsTrait):
         )
         return not is_cold
 
+    _terminal_statuses: ClassVar = frozenset({OrderStatus.completed, OrderStatus.canceled})
+
+    async def set_status(self, status: OrderStatus, *, force: bool = False) -> bool:
+        """ЕДИНСТВЕННЫЙ writer Order.status (single-writer-правило, как Cred/Ad.upsert).
+        Идемпотентен (тот же статус → no-op, False) и защищает терминальные статусы:
+        из completed/canceled никуда без force — это снимает дублированные guard'ы из всех
+        listener'ов (Htx/Mexc «не откатывай completed→paid», Bybit «игнор эха canceled→paid»,
+        «status != current»). Возвращает True, если статус изменён и записан в БД."""
+        if self.status == status:
+            return False
+        if not force and self.status in self._terminal_statuses:
+            logging.info(f"Order#{self.exid}: skip {self.status.name}→{status.name} (terminal, no force)")
+            return False
+        self.status = status
+        await self.save(update_fields=["status", "updated_at"])  # updated_at auto_now
+        return True
+
+    async def set_hot(self, user: User) -> Hot:
+        """ЕДИНСТВЕННЫЙ writer Order.hot_id (single-writer-правило, как set_status).
+        Привязывает ордер к последнему открытому прогреву юзера (get_last_hot) — назначение
+        hot-сессии шло одинаково из 3 мест (api-хендлер на created, контроллер is-you, бот is_you):
+        order.hot = await user.get_last_hot(); save(["hot_id"]). Возвращает назначенный Hot."""
+        self.hot = await user.get_last_hot()
+        await self.save(update_fields=["hot_id"])
+        return self.hot
+
     # когда прилетел новый ордер, и мы уже знаем юзера которому он принадлежит, и его последний hot # noqa: RUF003
     async def hot_process(self) -> OrderResult:
         await self.fetch_related(
@@ -1672,8 +1854,7 @@ class Order(Model, TsTrait):
                 ) or OrderErr.maker_balance_deficit
                 res.data = (self.amount - payment) * 0.01
             elif self.ad.pair_side.is_sell:  # успех и мы продавец - отпускаем (ордер уже paid: покупатель оплатил)
-                self.status = OrderStatus.completed
-                await self.save(update_fields=["status"])
+                await self.set_status(OrderStatus.completed)
                 res.data = payment.amount * 0.01
             else:  # успех и мы покупатель - ждем когда продавец отпустит
                 res.data = OrderResult.Order.load(self)
@@ -1714,16 +1895,15 @@ class Order(Model, TsTrait):
             tsf = await Transfer.create(
                 amount=tx.amount, order_id=self.id, pmid=tx.id.hex, sender_acc=buyer.username_id
             )
-            self.status = OrderStatus.paid  # todo: запрещать ставить paid, если у ордера нет трансферов на сумму amount  # noqa: RUF003 - intentional Russian
-            await self.save(update_fields=["status", "updated_at"])
+            # todo: запрещать ставить paid, если у ордера нет трансферов на сумму amount  # noqa: RUF003 - intentional Russian
+            await self.set_status(OrderStatus.paid)
             return tsf
 
         raise NotImplementedError("Pay method implemented now only for XyncPay pm")
 
     async def cancel_request(self):
         if not (payments := await self.fetch_related("transfers")):
-            self.status = OrderStatus.canceled
-            await self.save(update_fields=["status", "updated_at"])
+            await self.set_status(OrderStatus.canceled)
             return {"err": 0}
         return {"err": payments}
 
@@ -1993,6 +2173,29 @@ class Msg(Model):
     order: ForeignKeyRelation[Order] = ForeignKeyField("models.Order", "msgs", on_update=CASCADE)
     sent_at: datetime | None = DatetimeSecField()
 
+    @classmethod
+    async def upsert(
+        cls,
+        order_id: int,
+        *,
+        to_maker: bool,
+        txt: str | None = None,
+        file_id: int | None = None,
+        read: bool = False,
+        sent_at: datetime | None = None,
+        tg_mid: int | None = None,
+    ) -> tuple[Msg, bool]:
+        """ЕДИНСТВЕННЫЙ writer Msg (single-writer-правило). Натуральный ключ (order, txt, file) —
+        апсертит чат-сообщение ордера из всех источников: исходящее через бота, входящее по WS,
+        импорт истории. Раньше 3 расходящихся пути с разными стратегиями конфликта (bot Msg.create /
+        Bybit bulk_create(ignore_conflicts) / in_agent update_or_create)."""
+        return await cls.update_or_create(
+            {"to_maker": to_maker, "read": read, "sent_at": sent_at or now(), "tg_mid": tg_mid},
+            order_id=order_id,
+            txt=txt,
+            file_id=file_id,
+        )
+
     # todo: required txt or file
     class PydanticMeta(Model.PydanticMeta):
         max_recursion: int = 0

{xync_db-0.1.4 → xync_db-0.2.0}/src/xync_db/typs/db/ad.py

@@ -66,7 +66,7 @@ class AdXIn(_Ad):
     maker_id: int
     pair_side_id: int
 
-    pms: set[Pm]
+    pms: list[Pm]  # НЕ set[Pm]: XyncPay-Pm имеет id=0 → Model.__hash__ трактует pk=0 как unsaved (unhashable)
 
 
 class AdXUpd(_Ad, XExidUpd, XUpd):