funora 0.0.1.dev2__py3-none-any.whl

funora/_money.py

@@ -0,0 +1,279 @@
+"""Денежная сумма как доменный тип.
+
+Тип объявлен спецификацией давно и не был построен ни разу: цена заказа
+отдавалась текстом, а арифметики не существовало вовсе. Вызывающий складывал
+цены своим кодом - в котором нет ни проверки валют, ни защиты от плавающей
+точки, ради которых тип и объявлен.
+
+СБОРКА ИЗ ЗНАКА ПОЯВИЛАСЬ 31.08.2026, и появилась не потому, что мы передумали
+осторожничать. Появилось НАБЛЮДЕНИЕ, которого не хватало.
+
+Прежде здесь стояло: «придуманная таблица символов молча приписала бы чужую
+валюту чужому заказу». Это верно, пока набор валют ОТКРЫТ: знак доллара носят
+полтора десятка валют, и выбирать из них наугад нельзя.
+
+Набор оказался ЗАМКНУТ, и замкнутость наблюдена ДВАЖДЫ НЕЗАВИСИМО.
+
+  ПЕРВОЕ. Область вывода средств несёт настройки объектом, и ключи объекта
+  сохраняются дословно: currencies.eur, currencies.rub, currencies.usd. Ровно
+  три, и это перечень самой площадки, а не наш.
+
+  ВТОРОЕ. Переключатель в шапке перечисляет ПРОЧИЕ валюты, не текущую, и всякий
+  раз их ровно две: {USD, EUR} при рублёвой настройке, {RUB, EUR} после
+  переключения на доллары. Две альтернативы при трёх валютах - то же число с
+  другой стороны.
+
+Знаков в span.unit наблюдалось тоже ровно три - ₽, $, € - на 877 вхождениях
+шести разных страниц. Столкновений в таблице нет: три знака, три кода, взаимно
+однозначно.
+
+ЧТО ОСТАЛОСЬ ВЕРНЫМ ИЗ ПРЕЖНЕГО. Переключатель говорит о НАСТРОЙКЕ ПОКАЗА, и
+сумма заказа за ней не следует: после переключения список продаж остался с теми
+же тридцатью четырьмя рублёвыми знаками. Сумма заказа показана в валюте ЗАКАЗА.
+
+Поэтому код берётся ИЗ ЗНАКА РЯДОМ С САМОЙ СУММОЙ, а не из шапки. Шапка годится
+только там, где суммы за настройкой следуют, - на витрине продавца это
+наблюдено трижды, по одному разу на каждое положение переключателя, 164-165 цен
+в каждом.
+
+ЧЕТВЁРТАЯ ВАЛЮТА ОТКАЗЫВАЕТ ГРОМКО. Заведи площадка ещё одну - появится
+четвёртый знак, и таблица его не найдёт. Это ровно то, чего мы хотим: молчаливая
+подстановка приписала бы сумме чужую валюту, а отказ виден сразу.
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Final
+
+from .errors import CurrencyMismatchError, ValidationError
+from .extraction import CURRENCY_BY_SYMBOL, MONEY_MAX_MINOR, MONEY_MAX_SCALE, MONEY_MIN_MINOR
+
+__all__ = ["Money", "CURRENCY_BY_SYMBOL", "currency_of_symbol"]
+
+#: Знак валюты -> код ISO 4217.
+#:
+#: ТАБЛИЦА ПОЛНАЯ, А НЕ ПРИМЕРНАЯ, и это её главное свойство. Набор валют
+#: площадки наблюдён замкнутым дважды независимо (см. шапку модуля), знаков в
+#: span.unit наблюдалось ровно три, столкновений нет.
+#:
+#: Замкнутость - не украшение: именно она отличает эту таблицу от выдумки.
+#: Знак доллара носят полтора десятка валют мира, и выбор среди них наугад был
+#: бы гаданием. Выбор среди ТРЁХ объявленных площадкой - чтение.
+
+
+def currency_of_symbol(symbol: str) -> str:
+    """Переводит наблюдённый знак валюты в код ISO 4217.
+
+    ОТКАЗЫВАЕТ ГРОМКО НА НЕЗНАКОМОМ. Заведи площадка четвёртую валюту - появится
+    четвёртый знак, и здесь будет отказ. Подставить вместо него что-нибудь
+    правдоподобное значило бы приписать сумме чужую валюту, а увидел бы это не
+    разработчик, а продавец.
+
+    Аргументы:
+        symbol (str): Знак, прочитанный рядом с суммой.
+
+    Возвращает:
+        str: Код ISO 4217.
+
+    Raises:
+        ValidationError: Если знак не из наблюдённого набора.
+    """
+    code = CURRENCY_BY_SYMBOL.get(symbol.strip())
+    if code is None:
+        known = ", ".join(sorted(CURRENCY_BY_SYMBOL))
+        raise ValidationError(
+            f"знак валюты {symbol!r} не из наблюдённого набора ({known}). "
+            "Площадка объявляет три валюты, и четвёртой мы не видели; "
+            "подставить код наугад значило бы приписать сумме чужую валюту"
+        )
+    return code
+
+
+#: Код валюты по ISO 4217: ровно три заглавные латинские буквы.
+_CURRENCY: Final[re.Pattern[str]] = re.compile(r"^[A-Z]{3}$")
+
+
+@dataclass(frozen=True, slots=True)
+class Money:
+    """Денежная сумма в минорных единицах.
+
+    Целое число, а не дробное. Дробное представление не воспроизводится
+    одинаково в разных языках: 0.1 + 0.2 даёт 0.30000000000000004 всюду, где
+    считают двоичной дробью, и сумма двух заказов расходится с той, что видит
+    площадка.
+
+    Attributes:
+        amount_minor (int): Сумма в минорных единицах, в границах int64. Знак допустим: возвраты
+            и корректировки бывают отрицательными.
+        currency (str): Код валюты по ISO 4217, три заглавные латинские буквы.
+        scale (int): Степень десяти от 0 до 6 для перевода в минорные единицы.
+            Двойка означает копейки: 123410 при scale 2 это 1234.10.
+    """
+
+    amount_minor: int
+    currency: str
+    scale: int = 2
+
+    def __post_init__(self) -> None:
+        """Проверяет, что сумма выразима.
+
+        Returns:
+            None
+
+        Raises:
+            ValidationError: Если код валюты неверен, сумма не целая либо
+                выходит за int64, разрядность не целая или вне диапазона 0-6.
+        """
+        if not isinstance(self.currency, str) or not _CURRENCY.fullmatch(self.currency):
+            raise ValidationError(
+                f"код валюты {self.currency!r} не по ISO 4217: нужны ровно три "
+                "заглавные латинские буквы. Символ валюты кодом не является - "
+                "один и тот же знак носят несколько валют"
+            )
+        if isinstance(self.amount_minor, bool) or not isinstance(self.amount_minor, int):
+            raise ValidationError(
+                f"сумма {self.amount_minor!r} не целая. Минорные единицы целы по "
+                "определению, а дробное представление не воспроизводится одинаково "
+                "в разных языках"
+            )
+        if not MONEY_MIN_MINOR <= self.amount_minor <= MONEY_MAX_MINOR:
+            raise ValidationError("сумма выходит за границы int64")
+        if type(self.scale) is not int or not 0 <= self.scale <= MONEY_MAX_SCALE:
+            raise ValidationError(f"разрядность должна быть целым числом от 0 до {MONEY_MAX_SCALE}")
+
+    def _same_kind(self, other: Money) -> None:
+        """Проверяет, что суммы одного рода.
+
+        Args:
+            other (Money): Вторая сумма.
+
+        Returns:
+            None
+
+        Raises:
+            CurrencyMismatchError: Если валюты разные.
+            ValidationError: Если валюта одна, а разрядность разная.
+        """
+        if self.currency != other.currency:
+            raise CurrencyMismatchError(
+                f"арифметика между {self.currency} и {other.currency} запрещена. "
+                "Курс - величина, меняющаяся ежеминутно и здесь неизвестная; "
+                "сложить их значило бы выдать выдуманное число за сумму"
+            )
+        if self.scale != other.scale:
+            raise ValidationError(
+                f"одна валюта {self.currency} с разной разрядностью: {self.scale} и "
+                f"{other.scale}. Складывать копейки с сотыми копейки нельзя - "
+                "разойдётся на два порядка"
+            )
+
+    def __add__(self, other: Money) -> Money:
+        """Складывает две суммы одной валюты.
+
+        Args:
+            other (Money): Вторая сумма.
+
+        Returns:
+            Money: Сумма.
+
+        Raises:
+            CurrencyMismatchError: Если валюты разные.
+        """
+        self._same_kind(other)
+        return Money(self.amount_minor + other.amount_minor, self.currency, self.scale)
+
+    def __sub__(self, other: Money) -> Money:
+        """Вычитает сумму той же валюты.
+
+        Args:
+            other (Money): Вычитаемое.
+
+        Returns:
+            Money: Разность. Отрицательная разность допустима.
+
+        Raises:
+            CurrencyMismatchError: Если валюты разные.
+        """
+        self._same_kind(other)
+        return Money(self.amount_minor - other.amount_minor, self.currency, self.scale)
+
+    def __mul__(self, times: int) -> Money:
+        """Умножает сумму на целое число.
+
+        Умножение только на целое. Умножение на дробное - это доля, а доля
+        требует правила округления, которого спецификация не задаёт: округлять
+        вверх, вниз либо к ближайшему - три разных ответа на один вопрос, и
+        выбрать за вызывающего нельзя.
+
+        Args:
+            times (int): Множитель, например число единиц товара.
+
+        Returns:
+            Money: Произведение.
+
+        Raises:
+            ValidationError: Если множитель не целый.
+        """
+        if isinstance(times, bool) or not isinstance(times, int):
+            raise ValidationError(
+                f"множитель {times!r} не целый. Дробный множитель - это доля, а "
+                "доля требует правила округления, которого контракт не задаёт"
+            )
+        return Money(self.amount_minor * times, self.currency, self.scale)
+
+    def __lt__(self, other: Money) -> bool:
+        """Сравнивает суммы одной валюты.
+
+        Args:
+            other (Money): Вторая сумма.
+
+        Returns:
+            bool: True, если эта сумма меньше.
+
+        Raises:
+            CurrencyMismatchError: Если валюты разные. Сравнение здесь не
+                безобиднее сложения: «дешевле» между валютами так же требует
+                курса.
+        """
+        self._same_kind(other)
+        return self.amount_minor < other.amount_minor
+
+    def __le__(self, other: Money) -> bool:
+        """Сравнивает суммы одной валюты.
+
+        Args:
+            other (Money): Вторая сумма.
+
+        Returns:
+            bool: True, если эта сумма не больше.
+        """
+        self._same_kind(other)
+        return self.amount_minor <= other.amount_minor
+
+    def __str__(self) -> str:
+        """Показывает сумму человеку.
+
+        Returns:
+            str: Мажорные единицы с разделителем и код валюты.
+        """
+        if self.scale == 0:
+            return f"{self.amount_minor} {self.currency}"
+        units, minor = divmod(abs(self.amount_minor), 10**self.scale)
+        sign = "-" if self.amount_minor < 0 else ""
+        return f"{sign}{units}.{minor:0{self.scale}d} {self.currency}"
+
+
+_DISPLAY_PRICE: Final[re.Pattern[str]] = re.compile(
+    rf"(?:[0-9]+|[1-9][0-9]{{0,2}}(?: [0-9]{{3}})+)(?:\.[0-9]{{1,{MONEY_MAX_SCALE}}})?"
+)
+
+
+def parse_display_price(text: str, symbol: str) -> Money:
+    """Нормализует наблюдённую цену рынка в scale 6, без float и округления."""
+    if len(text) > 128 or _DISPLAY_PRICE.fullmatch(text) is None:
+        raise ValidationError("неподдерживаемый формат показанной цены")
+    units, _, fraction = text.replace(" ", "").partition(".")
+    amount = int(units) * 10**MONEY_MAX_SCALE + int(fraction.ljust(MONEY_MAX_SCALE, "0"))
+    return Money(amount, currency_of_symbol(symbol), MONEY_MAX_SCALE)

funora/_monitoring.py

@@ -0,0 +1,396 @@
+"""Описание наблюдений и чистое продвижение истории публичной выдачи."""
+
+from __future__ import annotations
+
+import json
+import math
+import re
+from dataclasses import asdict, dataclass
+from fractions import Fraction
+from typing import Any
+
+from ._diff import Event, make_event
+from ._money import Money
+from ._snapshot import MarketSnapshot, fingerprint_of
+from ._watch import incomplete, primed
+from .budget import MARKET_ABSENCES, MARKET_HISTORY_LIMIT, MARKET_INTERVAL_MS
+from .errors import ConfigurationError, ValidationError
+from .events import EventType
+from .operations import OPERATIONS
+
+
+@dataclass(frozen=True, slots=True)
+class MarketWatch:
+    """Одна выдача /lots/: устойчивое имя, раздел и интервал между чтениями.
+
+    interval_ms принадлежит политике клиента, а не лимитам FunPay.
+    Допуск набора проверяет monitoring.plan; фактические запросы - Budget.
+    """
+
+    watch_id: str
+    node_id: str
+    interval_ms: int = MARKET_INTERVAL_MS
+
+    def __post_init__(self) -> None:
+        if not isinstance(self.watch_id, str) or not re.fullmatch(
+            r"[A-Za-z0-9_.-]{1,128}", self.watch_id
+        ):
+            raise ValidationError("watch_id: нужны 1-128 латинских букв, цифр, _, . или -")
+        if not isinstance(self.node_id, str) or not re.fullmatch(r"[0-9]{1,128}", self.node_id):
+            raise ValidationError("node_id: нужны 1-128 цифр ASCII")
+        if type(self.interval_ms) is not int or self.interval_ms <= 0:
+            raise ValidationError("interval_ms должен быть положительным целым числом")
+        try:
+            finite = math.isfinite(self.interval_ms / 1000)
+        except OverflowError:
+            finite = False
+        if not finite:
+            raise ValidationError("interval_ms не представим часами runtime")
+
+    @property
+    def requests_per_second(self) -> Fraction:
+        """Прогноз одного тика из профиля операции адаптера, без округления."""
+        return Fraction(OPERATIONS["market.snapshot"].cost_hint * 1000, self.interval_ms)
+
+
+@dataclass(frozen=True, slots=True)
+class MonitoringLimit:
+    """Прогноз для сетевого ведра, включая уже зарегистрированные наблюдения."""
+
+    bucket: str
+    requests_per_second: Fraction
+    available_per_second: Fraction
+
+
+@dataclass(frozen=True, slots=True)
+class MonitoringPlan:
+    """Проверка набора без HTTP и расхода токенов; это не резервирование."""
+
+    admitted: bool
+    requests_per_second: Fraction
+    limits: tuple[MonitoringLimit, ...]
+    rejected_watch_ids: tuple[str, ...]
+    reason: str | None = None
+
+
+def validate_watches(watches: tuple[MarketWatch, ...]) -> None:
+    if not watches or any(not isinstance(one, MarketWatch) for one in watches):
+        raise ValidationError("нужен непустой набор MarketWatch")
+    if len({one.watch_id for one in watches}) != len(watches):
+        raise ValidationError("watch_id не должны повторяться")
+
+
+def initial_cursor(watches: tuple[MarketWatch, ...]) -> dict[str, Any]:
+    return {
+        "market": {
+            one.watch_id: {
+                "config": asdict(one),
+                "sequence": 0,
+                "baseline": False,
+                "offers": {},
+                "absences": {},
+            }
+            for one in watches
+        }
+    }
+
+
+def validate_market_cursor(value: Any) -> dict[str, Any]:
+    """Повреждение истории не превращается в холодный старт."""
+    if not isinstance(value, dict) or set(value) != {"market"}:
+        raise ValueError("неверный состав курсора рынка")
+    watches = value["market"]
+    if not isinstance(watches, dict) or not watches:
+        raise ValueError("пустой набор наблюдений")
+    for watch_id, record in watches.items():
+        if not isinstance(record, dict) or set(record) != {
+            "config",
+            "sequence",
+            "baseline",
+            "offers",
+            "absences",
+        }:
+            raise ValueError("неверный состав истории")
+        config = record["config"]
+        if not isinstance(config, dict) or set(config) != {"watch_id", "node_id", "interval_ms"}:
+            raise ValueError("неверный состав наблюдения")
+        try:
+            watch = MarketWatch(**config)
+        except ValidationError as exc:
+            raise ValueError("неверное наблюдение") from exc
+        if (
+            watch.watch_id != watch_id
+            or type(record["sequence"]) is not int
+            or record["sequence"] < 0
+        ):
+            raise ValueError("неверный владелец или номер снимка")
+        if type(record["baseline"]) is not bool:
+            raise ValueError("неверный признак полного основания")
+        offers, absences = record["offers"], record["absences"]
+        if (
+            not isinstance(offers, dict)
+            or not isinstance(absences, dict)
+            or set(absences) - set(offers)
+        ):
+            raise ValueError("неверный состав предложений или отсутствий")
+        for offer_id, entry in offers.items():
+            if (
+                not isinstance(offer_id, str)
+                or not offer_id
+                or not isinstance(entry, dict)
+                or set(entry) != {"price", "seller_id"}
+            ):
+                raise ValueError("неверное предложение")
+            if entry["seller_id"] is not None and (
+                not isinstance(entry["seller_id"], str)
+                or not re.fullmatch(r"[0-9]{1,128}", entry["seller_id"])
+            ):
+                raise ValueError("неверный продавец")
+            money = entry["price"]
+            if money is not None:
+                if not isinstance(money, dict) or set(money) != {
+                    "amount_minor",
+                    "currency",
+                    "scale",
+                }:
+                    raise ValueError("неверный состав цены")
+                try:
+                    Money(**money)
+                except ValidationError as exc:
+                    raise ValueError("неверная цена") from exc
+        if any(
+            type(count) is not int or not 1 <= count < MARKET_ABSENCES
+            for count in absences.values()
+        ):
+            raise ValueError("неверный счётчик отсутствий")
+        if record["sequence"] == 0 and (offers or absences or record["baseline"]):
+            raise ValueError("состояние до первого снимка не пусто")
+    return value
+
+
+def history_size(cursor: dict[str, Any]) -> int:
+    """Считает записи всех наблюдений; один offer_id в двух выдачах - две записи."""
+    return sum(len(record["offers"]) for record in cursor["market"].values())
+
+
+def check_history_limit(size: int, limit: int) -> None:
+    """Переполнение останавливает работу; сохранённые данные не вытесняются."""
+    if type(limit) is not int or limit <= 0:
+        raise ConfigurationError("history_limit должен быть положительным целым числом")
+    if size > limit:
+        raise ConfigurationError(
+            f"история рынка: {size} записей превышают history_limit={limit}; "
+            "увеличьте предел и продолжите наблюдение с прежним файлом состояния"
+        )
+
+
+def observe_market(
+    cursor: dict[str, Any],
+    watch: MarketWatch,
+    snapshot: MarketSnapshot,
+    *,
+    account_id: str,
+    read_interval_ms: int | None = None,
+    history_limit: int = MARKET_HISTORY_LIMIT,
+) -> tuple[dict[str, Any], tuple[Event, ...]]:
+    """Положительные наблюдения дополняют историю; отсутствие требует полноты."""
+    if snapshot.node_id != watch.node_id or snapshot.query_fingerprint != fingerprint_of(
+        watch.node_id
+    ):
+        raise ValidationError("снимок принадлежит другой выдаче")
+    if read_interval_ms is not None and (type(read_interval_ms) is not int or read_interval_ms < 0):
+        raise ValidationError("интервал чтения должен быть неотрицательным целым")
+    previous = cursor["market"][watch.watch_id]
+    size = history_size(cursor) + sum(
+        offer_id not in previous["offers"] for offer_id in snapshot.offers
+    )
+    if snapshot.is_complete:
+        size -= sum(
+            offer_id not in snapshot.offers and count + 1 >= MARKET_ABSENCES
+            for offer_id, count in previous["absences"].items()
+        )
+    check_history_limit(size, history_limit)
+    # Новая независимая позиция; прежняя остаётся до подтверждения доставки.
+    target = json.loads(json.dumps(cursor, ensure_ascii=True, allow_nan=False))
+    record = target["market"][watch.watch_id]
+    sequence = record["sequence"] + 1
+    revision = json.dumps([watch.watch_id, sequence], ensure_ascii=True, separators=(",", ":"))
+    events: list[Event] = []
+    if sequence == 1:
+        events.append(primed(account_id, snapshot.taken_at, ("market",), watch_id=watch.watch_id))
+    elif read_interval_ms is not None and read_interval_ms >= 2 * watch.interval_ms:
+        events.append(
+            make_event(
+                account_id=account_id,
+                event_type=EventType.WATCH_DEGRADED,
+                entity_id=watch.watch_id,
+                revision=revision,
+                observed_at=snapshot.taken_at,
+                key_field="watch_id",
+                key_value=watch.watch_id,
+                payload={
+                    "watch_id": watch.watch_id,
+                    "requested_interval_ms": watch.interval_ms,
+                    "effective_interval_ms": read_interval_ms,
+                    "reason_code": "schedule_overrun",
+                },
+            )
+        )
+    if not snapshot.is_complete:
+        events.append(
+            incomplete(
+                account_id,
+                snapshot.taken_at,
+                entity="market",
+                entity_ref=watch.node_id,
+                reason=snapshot.reason or "incomplete",
+                rows_total=snapshot.rows_total,
+                rows_accepted=snapshot.rows_accepted,
+                watch_id=watch.watch_id,
+            )
+        )
+        record["absences"] = {}
+
+    def emit(kind: EventType, offer_id: str, payload: dict[str, Any]) -> None:
+        events.append(
+            make_event(
+                account_id=account_id,
+                event_type=kind,
+                entity_id=offer_id,
+                revision=revision,
+                observed_at=snapshot.taken_at,
+                key_field="watch_id",
+                key_value=watch.watch_id,
+                payload={"watch_id": watch.watch_id, "offer_id": offer_id, **payload},
+            )
+        )
+
+    offers = record["offers"]
+    for offer_id, entry in snapshot.offers.items():
+        previous = offers.get(offer_id)
+        price = asdict(entry.price.value) if entry.price.is_observed else None
+        seller = re.fullmatch(r"(?:https://funpay\.com)?/users/([0-9]{1,128})/", entry.seller_href)
+        seller_id = seller[1] if seller else None
+        if previous is None:
+            if record["baseline"] and price is not None and seller_id is not None:
+                emit(
+                    EventType.MARKET_OFFER_APPEARED,
+                    offer_id,
+                    {
+                        "seller_id": seller_id,
+                        "price": price,
+                        "query_fingerprint": snapshot.query_fingerprint,
+                    },
+                )
+        elif price is not None and previous["price"] is not None and price != previous["price"]:
+            emit(
+                EventType.MARKET_PRICE_CHANGED,
+                offer_id,
+                {"before": previous["price"], "latest": price, "aggregate": None},
+            )
+        offers[offer_id] = {
+            "price": price if price is not None else previous["price"] if previous else None,
+            "seller_id": seller_id
+            if seller_id is not None
+            else previous["seller_id"]
+            if previous
+            else None,
+        }
+        record["absences"].pop(offer_id, None)
+
+    if snapshot.is_complete:
+        for offer_id in sorted(set(offers) - set(snapshot.offers)):
+            count = record["absences"].get(offer_id, 0) + 1
+            if count >= MARKET_ABSENCES:
+                emit(
+                    EventType.MARKET_OFFER_DISAPPEARED,
+                    offer_id,
+                    {
+                        "query_fingerprint": snapshot.query_fingerprint,
+                        "consecutive_absences": count,
+                        "filters_affect_visibility": False,
+                    },
+                )
+                del offers[offer_id]
+                record["absences"].pop(offer_id, None)
+            else:
+                record["absences"][offer_id] = count
+        record["baseline"] = True
+    record["sequence"] = sequence
+    return target, tuple(events)
+
+
+def validate_market_transition(
+    before: dict[str, Any],
+    after: dict[str, Any],
+    events: tuple[Event, ...],
+) -> str:
+    """Одна непринятая партия подтверждает ровно один следующий снимок."""
+    previous: dict[str, Any] = before["market"]
+    latest = after.get("market", {})
+    if set(previous) != set(latest) or any(
+        one["config"] != latest[key]["config"] for key, one in previous.items()
+    ):
+        raise ValueError("другой набор наблюдений")
+    changed = [key for key in previous if previous[key] != latest[key]]
+    if len(changed) != 1:
+        raise ValueError("партия должна продвигать один снимок")
+    watch_id = changed[0]
+    if latest[watch_id]["sequence"] != previous[watch_id]["sequence"] + 1:
+        raise ValueError("пропущен номер снимка")
+    if any(event.payload.get("watch_id") != watch_id for event in events):
+        raise ValueError("партия и снимок принадлежат разным наблюдениям")
+    return watch_id
+
+
+def validate_market_payload(kind: EventType, payload: dict[str, Any], watch: MarketWatch) -> None:
+    """Восстановленная цена и ссылка должны соблюдать тот же контракт, что новые."""
+    if kind is EventType.WATCH_DEGRADED:
+        if (
+            set(payload)
+            != {"watch_id", "requested_interval_ms", "effective_interval_ms", "reason_code"}
+            or payload["watch_id"] != watch.watch_id
+            or type(payload["requested_interval_ms"]) is not int
+            or payload["requested_interval_ms"] != watch.interval_ms
+            or type(payload["effective_interval_ms"]) is not int
+            or payload["effective_interval_ms"] < 2 * watch.interval_ms
+            or payload["reason_code"] != "schedule_overrun"
+        ):
+            raise ValueError("неверное ухудшение интервала наблюдения")
+        return
+    fields = {
+        EventType.MARKET_OFFER_APPEARED: {"seller_id", "price", "query_fingerprint"},
+        EventType.MARKET_OFFER_DISAPPEARED: {
+            "query_fingerprint",
+            "consecutive_absences",
+            "filters_affect_visibility",
+        },
+        EventType.MARKET_PRICE_CHANGED: {"before", "latest", "aggregate"},
+    }[kind]
+    if set(payload) != fields | {"watch_id", "offer_id"}:
+        raise ValueError("неверный состав рыночного события")
+    if "query_fingerprint" in fields and payload["query_fingerprint"] != fingerprint_of(
+        watch.node_id
+    ):
+        raise ValueError("событие другой выдачи")
+    if kind is EventType.MARKET_OFFER_APPEARED and (
+        not isinstance(payload["seller_id"], str)
+        or not re.fullmatch(r"[0-9]{1,128}", payload["seller_id"])
+    ):
+        raise ValueError("неверный продавец события")
+    if kind is EventType.MARKET_PRICE_CHANGED and payload["aggregate"] is not None:
+        raise ValueError("сжатая партия не поддерживается")
+    if kind is EventType.MARKET_OFFER_DISAPPEARED and (
+        type(payload["consecutive_absences"]) is not int
+        or payload["consecutive_absences"] < 1
+        or payload["filters_affect_visibility"] is not False
+    ):
+        raise ValueError("неверное подтверждение отсутствия")
+    for name in fields & {"price", "before", "latest"}:
+        money = payload[name]
+        if not isinstance(money, dict) or set(money) != {"amount_minor", "currency", "scale"}:
+            raise ValueError("неверный состав цены события")
+        try:
+            Money(**money)
+        except ValidationError as exc:
+            raise ValueError("неверная цена события") from exc