funora 0.0.1.dev2__py3-none-any.whl

funora/_identity.py

@@ -0,0 +1,284 @@
+"""Сетевая идентичность: с какого адреса и через что идут запросы.
+
+Спецификация привязывает бюджет не к клиенту и не к аккаунту, а к сетевой
+идентичности - паре из исходящего адреса и целевого хоста. Именно её видит
+площадка, и именно по ней применяет ограничения.
+
+Отсюда всё устройство этого файла.
+
+Прокси меняет исходящий адрес, то есть даёт ДРУГУЮ идентичность. У неё своё
+ведро токенов, своё состояние остывания и свой счёт ограничений. Держать один
+бюджет на все прокси значило бы считать чужие запросы своими, а держать по
+бюджету на клиента - наоборот, не считать своих: два клиента одного процесса
+через один прокси видны площадке как один источник.
+
+Реестр общий на процесс намеренно. Изоляция возможна, но только явная: это
+решение публичного конструктора, и спецификация фиксирует его прямо -
+client_default: shared_runtime.
+
+Реакция на ограничение живёт здесь же, а не в политике повторов. Политика
+решает про ОДИН запрос: повторить ли его и когда. Ограничение частоты - про
+источник целиком: после него медленнее должны идти все запросы этой
+идентичности, а не только тот, который получил отказ.
+"""
+
+from __future__ import annotations
+
+import logging
+import threading
+from dataclasses import dataclass, field
+from fractions import Fraction
+from time import monotonic
+from typing import Final
+
+from ._budget import Budget, _exact
+from .budget import RATE_LIMIT_RESPONSE, RequestClass
+from .retry import RETRY_POLICIES
+
+__all__ = ["Identity", "IdentityRegistry", "REGISTRY", "identity_of"]
+
+_log = logging.getLogger("funora.identity")
+
+#: Имя идентичности при прямом соединении, без прокси.
+DIRECT: Final[str] = "direct"
+
+
+def identity_of(proxy: str | None, host: str) -> str:
+    """Собирает имя сетевой идентичности.
+
+    Имя, а не сам адрес прокси: адрес может нести пароль, а имя уходит в
+    журналы и в сообщения об ошибках. Поэтому берётся то, чем прокси назвали, а
+    если не назвали - его положение в перечне.
+
+    Args:
+        proxy (str | None): Имя прокси либо None при прямом соединении.
+        host (str): Целевой хост.
+
+    Returns:
+        str: Имя идентичности вида «имя@хост».
+    """
+    return f"{proxy or DIRECT}@{host}"
+
+
+@dataclass
+class Identity:
+    """Одна сетевая идентичность и её состояние.
+
+    Attributes:
+        name (str): Имя вида «прокси@хост».
+        budget (Budget): Вложенные вёдра токенов этой идентичности.
+        capacity_factor (float): Во сколько раз ёмкость урезана относительно
+            объявленной. Единица означает полную.
+        cooldown_until (float): До какого момента идентичность не используется,
+            монотонные секунды. Ноль означает, что она готова.
+        limits_seen (int): Сколько ограничений получено в текущем окне.
+        window_started_at (float): Начало окна учёта ограничений.
+        successes (int): Сколько успешных запросов подряд после последнего
+            ограничения. По ним идёт восстановление ёмкости.
+    """
+
+    name: str
+    budget: Budget = field(default_factory=Budget)
+    capacity_factor: float | Fraction = 1.0
+    cooldown_until: float | Fraction = 0.0
+    limits_seen: int = 0
+    window_started_at: float | Fraction | None = None
+    successes: int = 0
+
+    def is_cooling(self, now: float) -> bool:
+        """Сообщает, остывает ли идентичность сейчас.
+
+        Args:
+            now (float): Текущий момент, монотонные секунды.
+
+        Returns:
+            bool: True, если пользоваться ею пока нельзя.
+        """
+        return _exact(now) < _exact(self.cooldown_until)
+
+    def note_limit(self, now: float, *, retry_after_ms: int | None = None) -> None:
+        """Учитывает полученное ограничение частоты.
+
+        Правило объявлено спецификацией и до сих пор не применялось нигде.
+        Ответ 429 переводился в ошибку и уходил в политику повторов, но ёмкость
+        ведра при этом не менялась: следующий залп был ровно таким же, каким был
+        до ограничения. Это худший из возможных ответов на ограничение.
+
+        Три ступени, каждая строже предыдущей: первое ограничение вдвое режет
+        ёмкость и даёт остыть, второе останавливает наблюдение и автоматику,
+        третье переводит идентичность в состояние ограниченной.
+
+        Args:
+            now (float): Текущий момент, монотонные секунды.
+            retry_after_ms (int | None): Сколько просила подождать площадка,
+                если просила. Заголовок Retry-After, уже урезанный политикой.
+
+        Returns:
+            None
+        """
+        window_ms = RATE_LIMIT_RESPONSE.window_ms
+        moment = _exact(now)
+        if (
+            self.window_started_at is None
+            or (moment - _exact(self.window_started_at)) * 1000 > window_ms
+        ):
+            self.window_started_at = moment
+            self.limits_seen = 0
+
+        self.limits_seen += 1
+        self.successes = 0
+        self.capacity_factor = max(
+            _exact(RATE_LIMIT_RESPONSE.min_capacity_factor),
+            _exact(self.capacity_factor) * _exact(RATE_LIMIT_RESPONSE.capacity_multiplier),
+        )
+        # Дольшее из двух: собственное остывание и просьба площадки.
+        #
+        # Дольшее, а не своё. Заголовок Retry-After - это просьба, и ждать
+        # меньше просимого значит спорить с площадкой без единого довода: она
+        # знает свою нагрузку, а мы нет. Ждать дольше безопасно всегда.
+        #
+        # Прежде ждали только своё: площадка просила пять минут, клиент
+        # отступал на минуту и возвращался. Ровно поведение, из-за которого
+        # ограничение и переходит в блокировку.
+        cooldown_ms = RATE_LIMIT_RESPONSE.cooldown_ms * self.limits_seen
+        if retry_after_ms is not None:
+            # Заголовок ограничен и для общей паузы, иначе предел политики
+            # повтора обходится вторым ожиданием перед следующим запросом.
+            limit = RETRY_POLICIES["funora.transport.rate_limited"].max_retry_after_ms
+            cooldown_ms = max(cooldown_ms, min(max(0, retry_after_ms), limit))
+        self.cooldown_until = moment + Fraction(cooldown_ms, 1000)
+        self.budget.scale(self.capacity_factor)
+
+        # Вторая ступень. Классы monitoring и automation снимаются с очереди до
+        # конца остывания: первый отменяется, второй ждёт. Остаются interactive
+        # и poll - то, без чего клиент перестаёт быть клиентом.
+        #
+        # Ступень выражается через классы запросов и потому была невыполнима,
+        # пока классов не было: она так и стояла объявленной и не сделанной.
+        if self.limits_seen >= 2:
+            self.budget.suspend(
+                (RequestClass.MONITORING, RequestClass.AUTOMATION),
+                until=self.cooldown_until,
+            )
+
+        _log.warning(
+            "идентичность %s получила ограничение (%d-е в окне): ёмкость урезана "
+            "до %.2f от объявленной, остывание %d мс",
+            self.name,
+            self.limits_seen,
+            self.capacity_factor,
+            cooldown_ms,
+        )
+
+    def note_success(self) -> None:
+        """Учитывает успешный запрос и понемногу возвращает ёмкость.
+
+        Восстановление медленнее падения намеренно. Симметричное восстановление
+        даёт автоколебания: система отступает, тут же возвращается к прежней
+        частоте, получает ограничение снова и так по кругу.
+
+        Returns:
+            None
+        """
+        if self.capacity_factor >= 1.0:
+            return
+
+        self.successes += 1
+        if self.successes < RATE_LIMIT_RESPONSE.successes_per_step:
+            return
+
+        self.successes = 0
+        self.capacity_factor = min(
+            Fraction(1),
+            _exact(self.capacity_factor) * _exact(RATE_LIMIT_RESPONSE.recovery_multiplier),
+        )
+        self.budget.scale(self.capacity_factor)
+        _log.info(
+            "идентичность %s восстанавливается: ёмкость %.2f от объявленной",
+            self.name,
+            self.capacity_factor,
+        )
+
+
+class IdentityRegistry:
+    """Реестр сетевых идентичностей, общий на процесс.
+
+    Общий намеренно. Два клиента одного процесса, ходящие через один и тот же
+    адрес, видны площадке как один источник; изолированные бюджеты позволили бы
+    им вдвоём превысить предел, который каждый по отдельности соблюдает.
+
+    Реестр защищён замком: клиенты могут жить в разных потоках, а ведро токенов
+    - это счётчик, который два потока способны уменьшить дважды из одного
+    значения.
+    """
+
+    __slots__ = ("_by_name", "_lock")
+
+    def __init__(self) -> None:
+        self._by_name: dict[str, Identity] = {}
+        self._lock = threading.Lock()
+
+    def get(self, name: str) -> Identity:
+        """Возвращает идентичность по имени, заводя её при первом обращении.
+
+        Args:
+            name (str): Имя идентичности.
+
+        Returns:
+            Identity: Существующая либо только что заведённая.
+        """
+        with self._lock:
+            identity = self._by_name.get(name)
+            if identity is None:
+                identity = Identity(name=name)
+                self._by_name[name] = identity
+            return identity
+
+    def names(self) -> tuple[str, ...]:
+        """Перечисляет заведённые идентичности.
+
+        Returns:
+            tuple[str, ...]: Имена в порядке заведения.
+        """
+        with self._lock:
+            return tuple(self._by_name)
+
+    def reset(self) -> None:
+        """Забывает все идентичности.
+
+        Нужно проверкам: реестр общий на процесс, и состояние одной проверки
+        протекло бы в следующую.
+
+        Returns:
+            None
+        """
+        with self._lock:
+            self._by_name.clear()
+
+    def healthy(self, names: tuple[str, ...], now: float | None = None) -> str | None:
+        """Выбирает идентичность, которая сейчас не остывает.
+
+        Порядок перечня уважается: первый неостывающий и берётся. Перебирать по
+        кругу или случайно значило бы размазывать нагрузку ровным слоем по всем
+        адресам - а вызывающий назвал их в том порядке, в каком хочет ими
+        пользоваться.
+
+        Args:
+            names (tuple[str, ...]): Имена идентичностей в порядке предпочтения.
+            now (float | None): Момент. По умолчанию текущий.
+
+        Returns:
+            str | None: Имя пригодной идентичности либо None, если остывают все.
+        """
+        moment = monotonic() if now is None else now
+        for name in names:
+            if not self.get(name).is_cooling(moment):
+                return name
+        return None
+
+
+#: Реестр идентичностей, общий на процесс.
+#:
+#: Спецификация фиксирует это прямо: Client без явно переданного бюджета
+#: присоединяется к общему для процесса, изоляция только явная.
+REGISTRY: Final[IdentityRegistry] = IdentityRegistry()

funora/_json.py

@@ -0,0 +1,31 @@
+"""JSON без неоднозначных ключей и неконечных чисел."""
+
+import json
+from math import isfinite
+from typing import Any
+
+
+def _unique_fields(pairs: list[tuple[str, Any]]) -> dict[str, Any]:
+    result: dict[str, Any] = {}
+    for name, value in pairs:
+        if name in result:
+            raise ValueError("повтор поля JSON")
+        result[name] = value
+    return result
+
+
+def _finite_number(raw: str) -> float:
+    value = float(raw)
+    if not isfinite(value):
+        raise ValueError("неконечное число JSON")
+    return value
+
+
+def load_json(body: str) -> Any:
+    """Читает JSON; вызывающий переводит отказ в ошибку своей границы данных."""
+    return json.loads(
+        body,
+        object_pairs_hook=_unique_fields,
+        parse_float=_finite_number,
+        parse_constant=_finite_number,
+    )

funora/_listen.py

@@ -0,0 +1,312 @@
+"""Быстрый сигнал канала обновлений: узнать за секунды, что что-то изменилось.
+
+ЧТО ЗДЕСЬ РЕШАЕТСЯ. Наблюдение читало две полные страницы на каждом шаге и
+узнавало об изменении не раньше следующего чтения - от трёх секунд при
+активности до двух минут в тишине. Площадка держит собственный канал с
+промежутком в пять секунд, и он отвечает малым телом, когда менять нечего.
+
+ГЛАВНОЕ РЕШЕНИЕ, И ОНО НЕ ПРО СКОРОСТЬ. Канал здесь - СИГНАЛ, а не источник
+данных. Из ответа берётся ровно одно: изменилось что-нибудь или нет. Изменилось
+- страницы читаются тем же кодом, что и прежде, и события собираются из них же.
+
+Почему так, а не «читать данные прямо из канала». Канал отдаёт счётчики числами
+и готовую разметку сообщений, и соблазн собирать события прямо из него велик. Но
+поведения канала в двух случаях - при истёкшей сессии и при исчерпании предела -
+не наблюдал никто. Реализация, собирающая события из его данных, обязана была бы
+верить ему и в этих двух случаях тоже.
+
+Сигналом же верить ему не нужно ВОВСЕ. Ошибётся в сторону «изменилось» - лишнее
+чтение страниц, то есть ровно то, что было раньше. Ошибётся в сторону «тихо» -
+это ловится сторожевым сроком: молчание дольше него означает не тишину, а
+непонятность, и наблюдение возвращается к опросу страниц.
+
+ЧЕГО ЭТО НЕ ДЕЛАЕТ. Пропущенное за простой по-прежнему не восстанавливается:
+повтор по позиции не наблюдён, и метка отвечает на «изменилось ли», а не «что
+именно я пропустил». Канал ускоряет обнаружение, а полноту по-прежнему даёт
+чтение страниц.
+"""
+
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Final
+
+from ._runner import RunnerContext
+from ._updates import UpdatesAnswer
+
+__all__ = [
+    "CHANNEL_INTERVAL_MS",
+    "CHANNEL_COOLDOWN_MS",
+    "CHANNEL_WATCHDOG_MS",
+    "ChannelSignal",
+    "ChannelState",
+    "ORDERS_COUNTERS",
+    "CHAT_BOOKMARKS",
+    "classify_signal",
+    "seed_tags",
+    "wanted_objects",
+]
+
+_log = logging.getLogger("funora.listen")
+
+#: Вид объекта со счётчиками покупок и продаж.
+#:
+#: Наблюдён и в подписке, и в ответе. В ответе несёт buyer и seller целыми - то
+#: есть счётчик непрочитанного получается прямо, а не выводится из расхождения
+#: двух позиций разметки.
+ORDERS_COUNTERS: Final[str] = "orders_counters"
+
+#: Вид объекта со счётчиками переписки.
+#:
+#: Наблюдён и в подписке, и в ответе. В ответе несёт counter и message целыми
+#: плюс массив order длиной в число диалогов.
+CHAT_BOOKMARKS: Final[str] = "chat_bookmarks"
+
+#: С каким промежутком опрашивать канал.
+#:
+#: Пять секунд - СОБСТВЕННЫЙ темп площадки, наблюдённый, а не выбранный нами:
+#: spec/extraction/updates.yaml, interval_s. Опрашивать чаще - ходить к каналу
+#: чаще, чем ходит его же страница, то есть выделяться темпом без выигрыша:
+#: ответ всё равно соберётся не раньше, чем площадка его обновит.
+CHANNEL_INTERVAL_MS: Final[int] = 5000
+
+#: Сколько не трогать канал после того, как он ответил непонятным.
+#:
+#: Минута, и она не про вежливость. Отказ канала бывает разовым - сеть моргнула,
+#: - и бывает состоянием: истёкшая сессия, исчерпанный предел. Различить их в
+#: момент отказа нечем, потому что ни того, ни другого никто не наблюдал.
+#:
+#: Пробовать снова сразу означало бы стучаться в отказывающую точку четыре раза
+#: в минуту всё время, пока держится состояние. Ждать долго - терять скорость
+#: там, где отказ был разовым. Минута - середина, и цена ошибки в обе стороны
+#: здесь одна: опрос страниц, то есть прежнее поведение.
+CHANNEL_COOLDOWN_MS: Final[int] = 60_000
+
+#: Как долго доверять тишине канала, прежде чем перечитать страницы всё равно.
+#:
+#: СТОРОЖЕВОЙ СРОК - ТО, ЧТО ДЕЛАЕТ ВСЮ ЗАТЕЮ БЕЗОПАСНОЙ. Канал, замолчавший не
+#: потому, что менять нечего, а потому, что перестал отвечать по существу, от
+#: тишины неотличим: в обоих случаях объектов в ответе нет.
+#:
+#: Две минуты выбраны не наугад: это ПРЕЖНИЙ потолок интервала опроса
+#: (SCHEDULING.max_interval_ms). Тем самым худший случай нового поведения ровно
+#: равен обычному старому: даже канал, врущий тишину постоянно, не делает
+#: наблюдение медленнее, чем оно было до него.
+CHANNEL_WATCHDOG_MS: Final[int] = 120_000
+
+#: Сколько непонятных ответов подряд считать состоянием, а не случайностью.
+_FAILURES_BEFORE_COOLDOWN: Final[int] = 2
+
+
+class ChannelSignal(Enum):
+    """Что канал сказал о изменениях.
+
+    Attributes:
+        CHANGED: Что-то изменилось, страницы надо прочитать сейчас.
+        QUIET: Изменений нет, чтение страниц можно пропустить.
+        DEGRADED: Канал непригоден, дальше работает опрос страниц.
+    """
+
+    CHANGED = "changed"
+    QUIET = "quiet"
+    DEGRADED = "degraded"
+
+
+@dataclass
+class ChannelState:
+    """Состояние слушателя канала между шагами.
+
+    Attributes:
+        tags (dict[tuple[str, str], str]): Метки по объектам, НАКОПЛЕННЫЕ за все
+            ответы. Накопление обязательно: ответ несёт только изменившиеся
+            объекты, и метки молчавших в нём нет вовсе.
+        failures (int): Сколько непонятных ответов подряд.
+        cooling_until (float): До какого момента монотонных секунд канал не
+            трогать. Ноль означает, что канал доступен.
+        quiet_since (float | None): С какого момента канал не приносил
+            изменений. None означает, что тишины ещё не было.
+        reason (str): Отчего канал признан непригодным в последний раз.
+        degraded_announced (bool): Сказали ли уже вызывающему о переходе к
+            опросу страниц. Одно событие на один переход, а не на каждый шаг.
+    """
+
+    tags: dict[tuple[str, str], str] = field(default_factory=dict)
+    failures: int = 0
+    cooling_until: float = 0.0
+    quiet_since: float | None = None
+    reason: str = ""
+    degraded_announced: bool = False
+
+    def available(self, now: float) -> bool:
+        """Говорит, можно ли сейчас обращаться к каналу.
+
+        Args:
+            now (float): Текущий момент, монотонные секунды.
+
+        Returns:
+            bool: True, если остывание кончилось.
+        """
+        return now >= self.cooling_until
+
+    def note_failure(self, reason: str, now: float) -> bool:
+        """Записывает непонятный ответ и решает, уходить ли в остывание.
+
+        ОДИН ОТКАЗ - ЕЩЁ НЕ СОСТОЯНИЕ. Сеть моргает, и уходить с быстрого пути
+        на минуту из-за одного моргания значило бы терять скорость чаще, чем
+        нужно. Два подряд - уже похоже на состояние.
+
+        Args:
+            reason (str): Машиночитаемая причина.
+            now (float): Текущий момент, монотонные секунды.
+
+        Returns:
+            bool: True, если канал переведён в остывание этим отказом.
+        """
+        self.failures += 1
+        self.reason = reason
+        if self.failures < _FAILURES_BEFORE_COOLDOWN:
+            return False
+        self.cooling_until = now + CHANNEL_COOLDOWN_MS / 1000
+        self.quiet_since = None
+        return True
+
+    def note_success(self, now: float, *, changed: bool) -> None:
+        """Записывает понятный ответ.
+
+        Args:
+            now (float): Текущий момент, монотонные секунды.
+            changed (bool): Принёс ли ответ изменения.
+
+        Returns:
+            None
+        """
+        self.failures = 0
+        self.reason = ""
+        self.degraded_announced = False
+        self.quiet_since = None if changed else (self.quiet_since or now)
+
+    def watchdog_expired(self, now: float) -> bool:
+        """Говорит, что тишина канала длится дольше сторожевого срока.
+
+        Тишина здесь не доказательство отсутствия изменений: канал, перестающий
+        отвечать по существу, выглядит точно так же. По истечении срока страницы
+        читаются независимо от того, что сказал канал.
+
+        Args:
+            now (float): Текущий момент, монотонные секунды.
+
+        Returns:
+            bool: True, если пора перечитать страницы всё равно.
+        """
+        if self.quiet_since is None:
+            return False
+        return (now - self.quiet_since) * 1000 >= CHANNEL_WATCHDOG_MS
+
+
+def wanted_objects(own_user_id: str) -> list[tuple[str, str]]:
+    """Перечисляет объекты, на которые подписывается наблюдение.
+
+    ДВА, А НЕ N. Подписаться можно и на каждый диалог порознь, но объектов в
+    подписке принимается десять, а обрезка молчалива: продавец с пятнадцатью
+    диалогами не узнал бы, что пять из них не слушаются вовсе.
+
+    Эти два объекта - глобальные счётчики аккаунта, и их ровно столько же при
+    одном диалоге и при тысяче. Ответ по ним говорит «в продажах что-то
+    изменилось» и «в переписке что-то изменилось», а что именно - выяснит
+    чтение страниц, которое и без канала умеет это точно.
+
+    Args:
+        own_user_id (str): Собственный идентификатор, он же идентификатор обоих
+            объектов подписки: наблюдено, что оба берут id из data-user.
+
+    Returns:
+        list[tuple[str, str]]: Вид и идентификатор по объекту.
+    """
+    return [(ORDERS_COUNTERS, own_user_id), (CHAT_BOOKMARKS, own_user_id)]
+
+
+def seed_tags(context: RunnerContext) -> dict[tuple[str, str], str]:
+    """Берёт со страницы те метки, которые на ней вправду видно.
+
+    ЧТО ЗДЕСЬ НАБЛЮДЕНО, А ЧТО НЕТ, и почему это не мешает.
+
+    Метка orders_counters наблюдена: она РАВНА значению data-orders, сверено в
+    живой вкладке 29.08.2026.
+
+    Метка chat_bookmarks не наблюдена. Кандидат - data-bookmarks-tag того же
+    узла - объявлен носителем метки подписки, но в перечень сверки не входил.
+    Он берётся здесь, и вот почему это безопасно: НЕУГАДАННАЯ МЕТКА НЕ ЛОМАЕТ
+    НИЧЕГО. Площадка принимает любую, в том числе выдуманную, и отвечает на неё
+    всем, что изменилось, - наблюдено 30.08.2026. То есть худший исход ошибки
+    здесь - один лишний полный ответ на первом опросе, после которого настоящая
+    метка приезжает в ответе и накапливается.
+
+    Ненаблюдённого поля не берётся: у объекта без метки её место займёт
+    UNSEEN_TAG при сборке подписки, и это тот же самый безопасный исход.
+
+    Args:
+        context (RunnerContext): Что прочитано со страницы.
+
+    Returns:
+        dict[tuple[str, str], str]: Метки, годные для первой подписки.
+    """
+    if not context.own_user_id.is_observed:
+        return {}
+
+    own = context.own_user_id.value
+    tags: dict[tuple[str, str], str] = {}
+    if context.orders_tag.is_observed and context.orders_tag.value:
+        tags[(ORDERS_COUNTERS, own)] = context.orders_tag.value
+    if context.bookmarks_tag.is_observed and context.bookmarks_tag.value:
+        tags[(CHAT_BOOKMARKS, own)] = context.bookmarks_tag.value
+    return tags
+
+
+def classify_signal(answer: UpdatesAnswer) -> tuple[ChannelSignal, str]:
+    """Решает, что ответ канала означает для наблюдения.
+
+    ПОРЯДОК ШАГОВ ВАЖЕН, и он тот же, что у разбора ответа на отправку: сперва
+    объявленная ошибка, потом содержимое. Ответ с непустой ошибкой и пустыми
+    объектами иначе прочитался бы тишиной - то есть отказ выглядел бы
+    подтверждением, что менять нечего.
+
+    Args:
+        answer (UpdatesAnswer): Разобранный ответ канала.
+
+    Returns:
+        tuple[ChannelSignal, str]: Сигнал и машиночитаемая причина. Причина
+        пуста, когда объяснять нечего.
+    """
+    if answer.error is not None:
+        # Что именно площадка кладёт в это поле при неудаче, не наблюдал никто:
+        # пустым оно наблюдалось, непустым - ни разу. Поэтому непустое читается
+        # как «канал непригоден», а не толкуется по содержимому.
+        return ChannelSignal.DEGRADED, "channel_reported_error"
+
+    if answer.is_quiet:
+        return ChannelSignal.QUIET, ""
+
+    return ChannelSignal.CHANGED, ""
+
+
+def unexpected_shape(answer: UpdatesAnswer) -> str:
+    """Называет то, чего в ответе быть не должно.
+
+    Опрос идёт БЕЗ ДЕЙСТВИЯ, и площадка отвечает на такой запрос логическим, а
+    не объектом - наблюдено. Объект в ответе означает, что мы получили ответ на
+    чужой запрос либо канал устроен не так, как наблюдался.
+
+    Ответ на это не «разобрать поаккуратнее», а вернуться к опросу страниц:
+    страницы читаются кодом, чьё поведение установлено.
+
+    Args:
+        answer (UpdatesAnswer): Разобранный ответ канала.
+
+    Returns:
+        str: Причина непригодности либо пустая строка, если ответ ожидаемый.
+    """
+    if answer.answered_action:
+        return "channel_answered_an_action_we_did_not_send"
+    return ""