k1rl3s-maxo-345-348

-rw-r--r-- 1 root root   5254 Nov  6 07:36 CONTRIBUTING.md
-rw-r--r-- 1 root root  11376 Nov  6 07:36 LICENSE
-rw-r--r-- 1 root root  15383 Nov  6 07:36 README.md
-rw-r--r-- 1 root root  15095 Nov  6 07:36 THIRD_PARTY_LICENSES
drwxr-xr-x 1 root root   4096 Nov  6 07:37 butcher
-rw-r--r-- 1 root root   2
…[1688 chars omitted]…
examples/keyboards.py
./examples/send_attachments.py
./examples/swagger_watcher.py
./examples/text_formatting.py
./examples/webhook_aiohttp.py
./examples/webhook_fastapi.py
./examples/without_dp.py
./examples/__init__.py
./justfile
./LICENSE
./max-swagger.json
./noxfile.py
./pyproject.toml
./README.md
./tests/constants.py
./tests/factories.py
./tests/mocks.py
./tests/__init__.py
./THIRD_PARTY_LICENSES

src/maxo/dialogs/api/entities/update_event.py
src/maxo/dialogs/api/exceptions.py
src/maxo/dialogs/api/internal/__init__.py
src/maxo/dialogs/api/internal/fake_data.py
src/maxo/dialogs/api/internal/manager.py
src/maxo/dialogs/api/internal/middleware.py
src/maxo/dialogs/api/internal/widgets.py
src/maxo/dialogs/api/internal/window.py
src/maxo/dialogs/api/protocols/__init__.py
src/maxo/dialogs/api/protocols/dialog.py
src
…[3315 chars omitted]…
t__.py
src/maxo/dialogs/widgets/text/base.py
src/maxo/dialogs/widgets/text/format.py
src/maxo/dialogs/widgets/text/jinja.py
src/maxo/dialogs/widgets/text/list.py
src/maxo/dialogs/widgets/text/multi.py
src/maxo/dialogs/widgets/text/progress.py
src/maxo/dialogs/widgets/text/scrolling_text.py
src/maxo/dialogs/widgets/utils.py
src/maxo/dialogs/widgets/widget_event.py
src/maxo/dialogs/window.py
---TESTS---

tests/maxo/bot/test_attachment_retry_middleware.py
tests/maxo/bot/test_bot.py
tests/maxo/bot/test_state.py
tests/maxo/bot/test_upload.py
tests/maxo/errors/__init__.py
tests/maxo/errors/test_base.py
tests/maxo/errors/test_routing.py
tests/maxo/errors/test_subscriptions.py
tests/maxo/fsm/__init__.py
tests/maxo/fsm/storages/__init__.py
tests/maxo/fsm/storages/conftest.py
tests/maxo/fsm/storages/test_key_builder.py
tests/maxo/fsm/storages/test_memory.py
tests/maxo/fsm/storages/test_redis.py
tests/maxo/fsm/te
…[6809 chars omitted]…
bound_request.py
tests/maxo_webhook/fixtures/fixtures_checks.py
tests/maxo_webhook/test_aiohttp_adapter.py
tests/maxo_webhook/test_base_engine.py
tests/maxo_webhook/test_config.py
tests/maxo_webhook/test_engines.py
tests/maxo_webhook/test_fastapi_adapter.py
tests/maxo_webhook/test_routing.py
tests/maxo_webhook/test_secret_token.py
---
8b7e5a1 base
On branch master
nothing to commit, working tree clean

    DialogAction,
    DialogStartEvent,
    DialogSwitchEvent,
    DialogUpdateEvent,
    EventContext,
    ShowMode,
    StartMode,
)
from maxo.dialogs.api.entities.update_event import DialogFgEvent
from maxo.dialogs.api.internal import FakeUser
from maxo.dialogs.api.protocols import BaseDialogManager, BgManagerFactory
from maxo.dialogs.manager.updater import Updater
from maxo.dialogs.utils import is_user_loaded
from maxo.enums import ChatType
from maxo.fsm import State
from maxo.types import Chat, ChatMembersList, Recipient, User


class BgManager(BaseDialo
…[6491 chars omitted]…
it task
            raise
        try:
            yield manager
        except Exception as e:
            event.exited.set_exception(e)
            raise
        else:
            event.exited.set_result(None)
        finally:
            await task


class BgManagerFactoryImpl(BgManagerFactory):
    def __init__(self, router: Dispatcher) -> None:
        self._dp = router

    def bg(
        self,

            last_activity_time=datetime.now(UTC),
        )
        if stack_id is None:
            stack_id = DEFAULT_STACK_ID

        return BgManager(
            user=user,
            chat_id=chat_id,
            bot=bot,
            dp=self._dp,
            intent_id=None,
            stack_id=stack_id,
            load=load,
            chat_type=chat_type,
        )
=== manager.py ===
import itertools
from collections.abc import AsyncIterator
from contextlib import asynccontextmanager
from copy import deepcopy
from datetime import UTC, datetime
from typing i
…[8629 chars omitted]…
             f"but states idx should be positive"
                f"current state is {context.state}",
            )
        new_state = states[current_index - 1]
        await self.switch_to(new_state, show_mode)

    async def switch_to(
        self,
        state: State,
        show_mode: ShowMode | None = None,
    ) -> None:
        self.check_disabled()
        context = self.current_context()

        if not isinstance(dp, Dispatcher):
            raise TypeError("Root router must be Dispatcher.")
        self.dp = dp

    async def notify(self, bot: Bot, update: DialogUpdateEvent) -> None:
        asyncio.get_running_loop().call_soon(
            self.notify_task,
            bot,
            update,
            context=copy_context(),
        )

    def notify_task(self, bot: Bot, update: DialogUpdateEvent) -> Task[Any]:
        return asyncio.create_task(self._process_update(bot, update))

    async def _process_update(self, bot: Bot, update: DialogUpdateEvent) -> None:
       
…[1109 chars omitted]…
ogAction.UPDATE:
        if not dialog_manager.has_context():
            loggers.dialogs.warning("No context found")
            return
        if event.data:
            for k, v in event.data.items():
                dialog_manager.current_context().dialog_data[k] = v
        await dialog_manager.show()
    elif event.action is DialogAction.DONE:
        await dialog_manager.done(result=event.data)

MANAGER_KEY = "dialog_manager"
BG_FACTORY_KEY = "dialog_bg_factory"


class ManagerMiddleware(BaseMiddleware[MaxUpdate]):
    def __init__(
        self,
        dialog_manager_factory: DialogManagerFactory,
        registry: DialogRegistryProtocol,
        router: BaseRouter,
    ) -> None:
        super().__init__()
        self.dialog_manager_factory = dialog_manager_factory
        self.registry = registry
        self.router = router

    async def __call__(
        self,
  
…[2210 chars omitted]…
vent: ChatEvent,
        ctx: Ctx,
        registry: DialogRegistryProtocol,
        router: BaseRouter,
    ) -> DialogManager:
        return ManagerImpl(
            event=event,
            ctx=ctx,
            message_manager=self.message_manager,
            media_id_storage=self.media_id_storage,
            registry=registry,
            router=router,
            getter=self.getter,
        )

    MessageCallback,
    MessageCreated,
    User,
    UserAddedToChat,
    UserRemovedFromChat,
)

from .update_event import DialogUpdateEvent

ChatEvent = (
    MessageCreated
    | MessageCallback
    | BotStarted
    | BotStopped
    | DialogUpdateEvent
    | UserAddedToChat
    | UserRemovedFromChat
    | BotAddedToChat
    | BotRemovedFromChat
    | ErrorEvent[Any, Any]
)


@dataclass
class EventContext:
    bot: Bot
    chat_id: int | None
    user_id: int | None
    chat_type: ChatType | None
    user: User | None
    chat: Chat | None


EVENT_CONTEXT_KEY = "aiogd_event_context"
=== update_event ===
from asyncio import Future
from enum import 
…[2521 chars omitted]…
logsError):
    pass


class NoContextError(DialogsError):
    pass


# navigation
class UnregisteredDialogError(DialogsError):
    pass


class UnregisteredWindowError(DialogsError):
    pass


# widgets
class InvalidWidgetIdError(DialogsError):
    pass


class InvalidWidget(DialogsError):
    pass


class InvalidWidgetType(InvalidWidget):
    pass


class InvalidKeyboardType(DialogsError):
    pass

from maxo.dialogs.api.entities.update_event import DialogFgEvent
from maxo.dialogs.api.exceptions import (
    InvalidStackIdError,
    OutdatedIntent,
    StackAccessDeniedError,
    UnknownIntent,
    UnknownState,
)
from maxo.dialogs.api.internal import (
    CALLBACK_DATA_KEY,
    CONTEXT_KEY,
    PAYLOAD_KEY,
    STACK_KEY,
    STORAGE_KEY,
)
from maxo.dialogs.api.protocols import DialogRegistryProtocol, StackAccessValidator
from maxo.dialogs.context.storage import StorageProxy
from maxo.dialogs.utils import remove_intent_id
from maxo.enums import ChatType
from maxo.fsm.storages.base import BaseEventIsolation, BaseStorage
from maxo.routing.ctx import Ctx
from ma
…[8630 chars omitted]…
   events_isolation = _prepare_events_isolation(events_isolation)
    bg_manager_factory = BgManagerFactoryImpl(router)
    _register_middleware(
        router=router,
        dialog_manager_factory=dialog_manager_factory,
        bg_manager_factory=bg_manager_factory,
        stack_access_validator=stack_access_validator,
        events_isolation=events_isolation,
    )
    return bg_manager_factory

def event_context_from_error(event: ErrorEvent[Any, Any], ctx: Ctx) -> EventContext:
    if isinstance(event.event, MessageCreated):
        return event_context_from_message(event.event, ctx)
    if isinstance(event.event, MessageCallback):
        return event_context_from_callback(event.event, ctx)
    if isinstance(event.event, DialogUpdateEvent):
        return event_context_from_aiogd(event.event)
    if isinstance(event.event, BotStarted):
        return event_context_from_bot_started(event.event, ctx)
    if isinstance(event.event, BotStopped):
        return event_conte
…[8487 chars omitted]…
date, ctx)
        ctx[EVENT_CONTEXT_KEY] = event_context
        await self._load_default_context(update, ctx, event_context)
        return await next(ctx)

    async def process_user_added_to_chat(
        self,
        update: UserAddedToChat,
        ctx: Ctx,
        next: NextMiddleware[UserAddedToChat],
    ) -> Any:
        if UPDATE_CONTEXT_KEY not in ctx:
            return await next(ctx)

            return await next(ctx)

        event_context = event_context_from_user_removed_from_chat(update, ctx)
        ctx[EVENT_CONTEXT_KEY] = event_context
        await self._load_default_context(update, ctx, event_context)
        return await next(ctx)

    async def process_bot_added_to_chat(
        self,
        update: BotAddedToChat,
        ctx: Ctx,
        next: NextMiddleware[BotAddedToChat],
    ) -> Any:
        if UPDATE_CONTE
…[5580 chars omitted]…
are.
                # Иначе параллельный апдейт того же пользователя захватит лок
                # и прочитает ещё не сохранённые context/stack.
                context = ctx.get(CONTEXT_KEY)
                if context is not None:
                    await stored_proxy.save_context(context)
                await stored_proxy.save_stack(ctx.get(STACK_KEY))
                await stored_proxy.unlock()

    DialogUpdateEvent,
    ShowMode,
    StartMode,
)
from maxo.dialogs.api.internal import FakeUser
from maxo.dialogs.manager.bg_manager import BgManager, BgManagerFactoryImpl
from maxo.dialogs.manager.updater import Updater
from maxo.enums import ChatType
from maxo.fsm import State, StatesGroup
from maxo.types import Chat, ChatMembersList, User
from tests.constants import NOW


class SG(StatesGroup):
    first = State()


def real_user(user_id: int = 7) -> User:
    return User(
        user_id=user_id,
        is_bot=False,
        first_name="Real",
        last_activity_time=NOW,
    )


def fake_user(user_id: int = 7) -> Fa
…[7514 chars omitted]…
stance(manager, BgManager)
        assert manager.stack_id == DEFAULT_STACK_ID
        assert manager._event_context.chat_id == 6

    def test_keeps_explicit_stack_id(self) -> None:
        factory = BgManagerFactoryImpl(Dispatcher())

        manager = factory.bg(bot=MagicMock(), user_id=5, chat_id=6, stack_id="s")

        assert isinstance(manager, BgManager)
        assert manager.stack_id == "s"

    setup_dialogs,
)
from maxo.dialogs.api.entities import AccessSettings
from maxo.dialogs.api.exceptions import StackAccessDeniedError
from maxo.dialogs.api.protocols import BaseDialogManager
from maxo.dialogs.manager.bg_manager import BgManagerFactoryImpl
from maxo.dialogs.test_tools import BotClient, MockMessageManager
from maxo.dialogs.test_tools.keyboard import InlineButtonTextLocator
from maxo.dialogs.test_tools.memory_storage import JsonMemoryStorage
from maxo.dialogs.widgets.kbd import Button
from maxo.dialogs.widgets.text import Const, Format
from maxo.enums import ChatType
from maxo.fsm.state import State, StatesGroup
from maxo.routing.filters import CommandStart
…[4963 chars omitted]…
,
    client: BotClient,
    message_manager: MockMessageManager,
) -> None:
    bg_factory = await start_stack_for_first_user(dp, client, message_manager)

    stranger = bg_factory.bg(
        client.bot,
        user_id=2,
        chat_id=-1,
        stack_id=SHARED_STACK_ID,
    )
    with pytest.raises(StackAccessDeniedError):
        async with asyncio.timeout(1), stranger.fg():
            pass

from maxo.dialogs.test_tools import BotClient, MockMessageManager
from maxo.dialogs.test_tools.memory_storage import JsonMemoryStorage
from maxo.enums import ChatType
from maxo.fsm.key_builder import DefaultKeyBuilder
from maxo.routing.middlewares.update_context import (
    EVENT_FROM_USER_KEY,
    UPDATE_CONTEXT_KEY,
)
from maxo.types import Message, MessageBody, MessageCreated, Recipient
from maxo.types.update_context import UpdateContext


…[3972 chars omitted]…
d="default",
        access_settings=AccessSettings(user_ids=[1, 2, 3]),
    )
    ctx = Ctx(
        {
            UPDATE_CONTEXT_KEY: UpdateContext(type=ChatType.CHANNEL),
            EVENT_FROM_USER_KEY: None,
        },
    )

    allowed = await validator.is_allowed(
        stack=stack,
        context=None,
        event=event_message_created,
        ctx=ctx,
    )

    assert allowed is False

tests/maxo_dialog/manager/test_update_handler.py:100:    event = DialogFgEvent(
tests/maxo_dialog/test_fg.py:48:    async with dialog_manager.bg(user_id=2, chat_id=-1).fg() as manager:
tests/maxo_dialog/test_fg.py:211:        async with asyncio.timeout(1), stranger.fg():
tests/maxo_dialog/test_preview.py:231:    async with manager.fg() as fg_manager:

                recipient=current_message.recipient,
                message_id=current_message.body.mid,
                sequence_id=current_message.body.seq,
                attachments=current_message.body.attachments or [],
            )
        if not stack.last_message_id:
            return None
        return OldMessage(
            text=UnknownText.UNKNOWN,
            recipient=Recipient(
                user_id=event.callback.user.user_id,
                chat
…[5233 chars omitted]…
d=load,
            chat_type=new_event_context.chat_type or ChatType.CHAT,
        )

    @asynccontextmanager
    async def fg(self) -> AsyncIterator[DialogManager]:
        yield self

    async def close_manager(self) -> None:
        self.check_disabled()
        self.disabled = True
        del self.media_id_storage
        del self.message_manager
        del self._event
        # del self._ctx

    LaunchMode,
    MediaAttachment,
    MediaId,
    NewMessage,
    OldMessage,
    ShowMode,
    Stack,
    StartMode,
)
from maxo.dialogs.api.exceptions import (
    IncorrectBackgroundError,
    InvalidKeyboardType,
    NoContextError,
)
from maxo.dialogs.api.internal import CONTEXT_KEY, STACK_KEY, STORAGE_KEY
from maxo.dialogs.api.protocols import MessageNotModified
from maxo.dialogs.manager.bg_manager import BgManager
from maxo.dialogs.manager.manager import ManagerImpl
from maxo.enums import AttachmentType, ChatType
from maxo.fsm import State, StatesGroup
from maxo.routing.middlewares.update_contex
…[8629 chars omitted]…
manager.update()

        assert manager.current_context().dialog_data == {"d": 1}


class TestFind:
    def test_find_missing_widget(self) -> None:
        manager = make_manager()
        registry(manager).find_dialog.return_value = MagicMock(
            find=MagicMock(return_value=None),
        )

        assert manager.find("nope") is None

    def test_find_returns_managed_widget(self) -> None:

    async def test_load_data_with_getter(self) -> None:
        getter = AsyncMock(return_value={"extra": 1})

        data = await make_manager(getter=getter).load_data()

        assert data["extra"] == 1

    async def test_close_manager_disables(self) -> None:
        manager = make_manager()

        await manager.close_manager()

        assert manager.disabled is True

    async def test_fg_returns_self(self) -> None:
        manager = make_manager()

        async with manag
…[6053 chars omitted]…
: int | None = None,
        chat_id: int | None = None,
        stack_id: str | None = None,
        load: bool = False,
    ) -> BaseDialogManager:
        return self.manager.bg(
            user_id=user_id,
            chat_id=chat_id,
            stack_id=stack_id,
            load=load,
        )

    @asynccontextmanager
    async def fg(self) -> AsyncIterator[DialogManager]:
        yield self

from maxo.dialogs.api.protocols import (
    BgManagerFactory,
    DialogProtocol,
    DialogRegistryProtocol,
    MediaIdStorageProtocol,
    MessageManagerProtocol,
    StackAccessValidator,
)
from maxo.dialogs.context.access_validator import DefaultAccessValidator
from maxo.dialogs.context.intent_middleware import (
    IntentErrorMiddleware,
    IntentMiddlewareFactory,
    context_saver_middleware,
    context_unlocker_middleware,
)
from maxo.dialogs.context.media_s
…[6014 chars omitted]…


    def answer(self, *_: Any, **__: Any) -> AnswerOnCallback:
        raise ValueError(
            "This callback query is generated from ReplyButton click. "
            "Support of `.answer()` call is impossible.",
        )


class FakeUser(User):
    fake: Literal[True] = True


class FakeRecipient(Recipient):
    fake: Literal[True] = True


class FakeChat(Chat):
    fake: Literal[True] = True

src/maxo/routing/routers/simple.py:167:            return UNHANDLED
src/maxo/routing/routers/simple.py:170:        if result is UNHANDLED:
src/maxo/routing/sentinels.py:32:    UNHANDLED = "<unhandled>"
src/maxo/routing/sentinels.py:36:UNHANDLED = Sentinels.UNHANDLED
src/maxo/routing/signals/update.py:9:class MaxoUpdate(BaseUpdate, Generic[_UpdateT]):

from maxo.routing.middlewares.error import ErrorMiddleware
from maxo.routing.middlewares.fsm_context import FSMContextMiddleware
from maxo.routing.middlewares.update_context import UpdateContextMiddleware
from maxo.routing.observers import UpdateObserver
from maxo.routing.routers.simple import Router
from maxo.routing.sentinels import UNHANDLED, SkipHandler
from maxo.routing.signals.base import BaseSignal
fro
…[8628 chars omitted]…
      observer.state = StartedObserverState()

            observer.middleware.inner.state = StartedMiddlewareManagerState()
            observer.middleware.outer.state = StartedMiddlewareManagerState()

    async def _emit_before_shutdown_handler(self) -> None:
        self._state = EmptyRouterState()

        for observer in self.observers.values():
            observer.state = EmptyObserverState()

tests/maxo_dialog/test_intent_middleware.py:374:        with pytest.raises(UnknownIntent):
tests/maxo_dialog/test_intent_middleware.py:504:            load_context=AsyncMock(side_effect=UnknownIntent("gone")),
tests/maxo_dialog/test_intent_middleware.py:560:            load_context=AsyncMock(side_effect=UnknownIntent("gone")),
tests/maxo_dialog/test_intent_middleware.py:566:        with pytest.raises(UnknownIntent):
tests/maxo_dialog/test_storage_proxy.py:6:from maxo.dialogs.api.exceptions import UnknownIntent, UnknownState
tests/maxo_dialog/test_storage_proxy.py:150:    with pytest.raises(UnknownIntent):

description = "Асинхронный Python-фреймворк для разработки ботов мессенджера MAX (max.ru) с поддержкой long-polling, вебхуков, FSM, диалогов, фильтров и DI"
version = "0.8.3"
readme = "README.md"
license = "Apache-2.0"
license-files = ["LICENSE", "THIRD_PARTY_LICENSES"]
keywords = [
    "max",
    "max.ru",
    "max-ru",
    "max-messenger",
    "max-messenger-api",
    "max-bot",
    "max-bot-api",
    "max-api",
    "max-api-python",
    "maxapi",
    "maxo",
    "messenger",
    "MAX Bot API",
    "max messenger",
    "max messenger bot",
    "python",
    "python-bot",
    "bot",
    "bots",
    "chatbot",
    "chat-bot",
    "bot-framework",
    "framework",
    "async",
    "chatbo
…[2568 chars omitted]…
                             |  201 +
 README.md                                          |  321 ++
 THIRD_PARTY_LICENSES                               |  273 +
 butcher/AGENTS.md                                  |  272 +
 butcher/CLAUDE.md                                  |    1 +
 butcher/__init__.py                                |    1 +
 butcher/__main__.py                                |   44 +

        chat_id: ID чата или канала. Как получить ID - в [разделе «Получение chat_id»](https://dev.max.ru/docs-api#Получение%20chat_id)
        chat_type: Тип чата:
             - `chat` - групповой чат
             - `channel` - канал или комментарий к посту (для вызовов методов группы `/comments`)
             - `dialog` - диалог
        post_id: Идентификатор поста в канале, к которому оставлен комментарий
        user_id: ID получателя сообщения в диалоге (пользователя или бота). Если сообщение отправлено в групповой чат или канал, то параметр отсу
…[1029 chars omitted]…
buteIsEmptyError(
            obj=self,
            attr="post_id",
        )

    @property
    def unsafe_user_id(self) -> int:
        if is_defined(self.user_id):
            return self.user_id

        raise AttributeIsEmptyError(
            obj=self,
            attr="user_id",
        )
src/maxo/types/base.py:52:class BaseUpdate(MaxoType):
src/maxo/types/base.py:52:class BaseUpdate(MaxoType):

class _MaxoTypeMetaClass(type):
    def __new__(
        cls,
        name: str,
        bases: tuple[Any, ...],
        namespace: dict[str, Any],
        slots: bool = True,
        **kwargs: Any,
    ) -> Any:
        class_ = super().__new__(cls, name, bases, namespace, **kwargs)
        if "__slots__" in namespace:
            return class_

        return dataclass(
            slots=slots,
            frozen=False,
            kw_only=True,
        )(class_)


class BaseMaxoType(metaclass=_MaxoTypeMetaClass):
    pass


# TODO: `MaxoType` наследует `BaseMethodsFacade` только ради слота 
…[1423 chars omitted]…
ype):
    """
    Контекст апдейта: идентификаторы чата и пользователя, при включённом обогащении -
    объекты чата и пользователя, полученные через Bot API.
    """

    chat_id: int | None = None
    user_id: int | None = None
    type: ChatType | None = None
    chat: Chat | None = None
    user: User | None = None

    @property
    def chat_type(self) -> ChatType | None:
        return self.type

from maxo.types.bot_stopped import BotStopped
from maxo.types.chat_title_changed import ChatTitleChanged
from maxo.types.comment_created import CommentCreated
from maxo.types.comment_edited import CommentEdited
from maxo.types.comment_removed import CommentRemoved
from maxo.types.dialog_cleared import DialogCleared
from maxo.types.dialog_muted import DialogMuted
from maxo.types.dialog_removed import DialogRemoved
fro
…[6135 chars omitted]…
ser_id = user.id
            chat_id = update.recipient.chat_id
            chat_type = update.recipient.chat_type

        update_context = UpdateContext(
            chat_id=chat_id,
            user_id=user_id,
            type=chat_type,
            user=user,
        )
        if do_enrich and "bot" in ctx:
            await self._enrich_context(ctx, update_context)

        return update_context

from maxo.utils.link import id_to_message_url


class Message(MaxoType, MessageMethodsFacade):
    """
    Содержит общую информацию о сообщении в чате или посте в канале: данные об отправителе и получателе, время создания сообщения, содержимое (текст и вложения), контекст связи с другими сообщениями (ответ или пересылка), а также публичную ссылку и статистику для постов в каналах

    Возвращается в ответ на вызовы ме
…[4152 chars omitted]…
o/types/message.py:27:        sender: Отправитель сообщения: пользователь или бот
src/maxo/types/message.py:49:    sender: Omittable[User | None] = Omitted()
src/maxo/types/message.py:78:    def unsafe_sender(self) -> User:
src/maxo/types/message.py:79:        if is_defined(self.sender):
src/maxo/types/message.py:80:            return self.sender
src/maxo/types/message.py:84:            attr="sender",

DEFAULT_STACK_ID = ""
GROUP_STACK_ID = "<->"
_STACK_LIMIT = 100
_ID_SYMS = string.digits + string.ascii_letters


def new_int_id() -> int:
    return int(time.time() * 1000) % 100_000_000 + random.randint(0, 99) * 100_000_000


def id_to_str(int_id: int) -> str:
    if not int_id:
        return _ID_SYMS[0]
    base = len(_ID_SYMS)
    res = ""
    while int_id:
        int_id, mod = divmod(int_id, base)
        res += _ID_SYMS[mod]
    return res


def new_id() -> str:
    return id_to_str(new_int_id())


@dataclass(slots=True, unsafe_hash=True)
class Stack:
    _id: str = field(compare=True, default_
…[8629 chars omitted]…
d)]

        if self.with_bot_id:
            parts.append(str(key.bot_id))

        if self.with_destiny:
            parts.append(key.destiny)
        elif key.destiny != DESTINY_DEFAULT:
            raise ValueError(
                f"Use `with_destiny=True` in for {self.__class__.__name__}",
            )

        if type_:
            parts.append(type_)

        return self.separator.join(parts)

…[1687 chars omitted]…
 bg_factory = BgManagerFactoryImpl(dp)
tests/maxo_dialog/test_fg.py:160:    owner = bg_factory.bg(client.bot, user_id=1, chat_id=-1, stack_id=SHARED_STACK_ID)
tests/maxo_dialog/test_fg.py:182:    stranger = bg_factory.bg(
tests/maxo_dialog/test_fg.py:189:    owner = bg_factory.bg(client.bot, user_id=1, chat_id=-1, stack_id=SHARED_STACK_ID)
tests/maxo_dialog/test_fg.py:204:    stranger = bg_factory.bg(

    Dialog,
    DialogManager,
    StartMode,
    Window,
    setup_dialogs,
)
from maxo.dialogs.api.entities import DialogAction, DialogStartEvent
from maxo.dialogs.api.protocols import BgManagerFactory
from maxo.dialogs.manager.bg_manager import BgManager, BgManagerFactoryImpl
from maxo.dialogs.test_tools import BotClient, MockMessageManager
from maxo.dialogs.test_tools.bot_client import FakeBot
from maxo.dialogs.test_tools.memory_storage import JsonMemo
…[8260 chars omitted]…
up(), client.bot)

    # Default ChatType.CHAT - wrong for 1:1 dialog
    bg = bg_factory.bg(client.bot, user_id, chat_id)
    await bg.start(ChatSG.active, mode=StartMode.RESET_STACK)

    await wait_for_messages(message_manager)

    message_manager.reset_history()
    await client.send("hello from user")

    # Message NOT handled - stack key mismatch ("<100>" vs "")
    assert received_texts == []

    ShowMode,
    StartMode,
)
from maxo.dialogs.api.entities.update_event import DialogFgEvent
from maxo.dialogs.api.protocols import DialogManager
from maxo.dialogs.manager.update_handler import handle_aiogd_update
from maxo.fsm.state import State, StatesGroup


class TestStates(StatesGroup):
    first = State()
    second = State()


@pytest.fixture
def mock_dialog_manager() -> MagicMock:
    manager = MagicMock(spec=DialogManager)
    manager.start = AsyncMock()
    manager.switch_to = AsyncMock()
    manager.show = AsyncMock()
    manager.done = AsyncMock()
    manager.has_context = Mock(return_value=True)

    context = Context(
…[7129 chars omitted]…
idget_data: WidgetData = {} if widget_data is None else widget_data

    def is_preview(self) -> bool:
        return self._preview

    def current_context(self) -> Context:
        return Context(
            dialog_data={},
            start_data={},
            widget_data=self.widget_data,
            state=State(),
            _stack_id="_stack_id",
            _intent_id="_intent_id",
        )

__________ ERROR collecting tests/maxo_dialog/widgets/test_common.py ___________
ImportError while importing test module '/repo/tests/maxo_dialog/widgets/test_common.py'.
Hint: make sure your test modules/package
…[1021 chars omitted]…
summary info ============================
ERROR tests/maxo_dialog/test_dishka_integration.py
ERROR tests/maxo_dialog/widgets/kbd/test_base.py
ERROR tests/maxo_dialog/widgets/media/test_base.py
ERROR tests/maxo_dialog/widgets/test_common.py
ERROR tests/maxo_dialog/widgets/test_filter_object.py
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 5 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
4 warnings, 5 errors in 7.88s

            "start_data": context.start_data,
            "middleware_data": self.middleware_data,
            "event": self.event,
            **data,
        }

    def is_preview(self) -> bool:
        return False

    def dialog(self) -> DialogProtocol:
        self.check_disabled()
        current = self.current_context()
        return self._registry.find_dialog(current.state)

    def current_context(self) -> Context:
        self.check_disabled()

…[8629 chars omitted]…
}")
            raise

    async def _load_cached_media(self, new_message: NewMessage) -> None:
        for attachment in new_message.media:
            if attachment.media_id:
                continue
            attachment.media_id = await self.media_id_storage.get_media_id(
                path=attachment.path,
                url=attachment.url,
                type=attachment.type,
            )

from maxo.dialogs.api.protocols import (
    MediaIdStorageProtocol,
    MessageManagerProtocol,
    MessageNotModified,
)
from maxo.enums import AttachmentType, UploadType
from maxo.errors import MaxBotApiError, MaxBotBadRequestError
from maxo.omit import Omitted
from maxo.types import (
    Attachments,
    AttachmentsRequests,
    AudioAttachmentRequest,
    Callback,
    FileAttachmentRequest,
    InlineButtons,
    MediaAttachments,
    Message,
    PhotoAttachmentRequest,
    VideoAttachmentRequest,
)
from maxo.types.facades.attachments import AttachmentsFacade, MediaInput
from maxo.utils.upload_media import FSInputFile

SEND_METHODS = {
    Attach
…[8629 chars omitted]…
(self, media: MediaAttachment) -> MediaInput | None:
        if media.media_id:
            token = media.media_id.token
            url = None
        elif media.url:
            if media.type != AttachmentType.IMAGE:
                raise ValueError(
                    f"URL is supported only for IMAGE media, got: {media.type}",
                )
            token = None
            url = media.url

:5:    EVENT_CONTEXT_KEY,
src/maxo/dialogs/window.py:150:        event_context: EventContext = manager.middleware_data[EVENT_CONTEXT_KEY]
src/maxo/dialogs/window.py:168:                    chat_type=event_context.chat_type or ChatType.CHAT,
src/maxo/dialogs/window.py:169:                    chat_id=event_context.chat_id,
src/maxo/dialogs/window.py:170:                    user_id=event_context.user_id,

            await self.on_process_result(start_data, result, manager)

    async def render(
        self,
        dialog: DialogProtocol,
        manager: DialogManager,
    ) -> NewMessage:
        loggers.dialogs.debug("Show window: %s", self)
        event_context: EventContext = manager.middleware_data[EVENT_CONTEXT_KEY]
        try:
            current_data = await self.load_data(dialog, manager)
        except Exception:
            loggers.dialogs.exception("Cannot get window data for state %s", self.state)
            raise
        tr
…[1748 chars omitted]…
ogs/context/intent_middleware.py:131:        user_id=event.user.user_id,
src/maxo/dialogs/manager/manager.py:526:            current_user = event.user
src/maxo/dialogs/tools/preview.py:107:            EVENT_FROM_USER_KEY: self._event.user,
src/maxo/dialogs/tools/preview.py:113:                user=self._event.user,
src/maxo/dialogs/tools/preview.py:114:                user_id=self._event.user.user_id,

class FakeManager(DialogManager):
    def __init__(self) -> None:
        self._event = DialogUpdateEvent(
            user=User(
                user_id=1,
                is_bot=False,
                first_name="Fake",
                last_activity_time=FAKE_TIME,
            ),
            recipient=Recipient(chat_type=ChatType.DIALOG, user_id=1),
            bot=Bot("", warming_up=False),
            action=DialogAction.UPDATE,
            data={},
            intent_id=None,
            stack_id=None,
        )
        self._context: Context | None = None
        self._dialog: DialogProtocol | None
…[2972 chars omitted]…
back(
        timestamp=FAKE_TIME,
        callback=Callback(
            callback_id="1",
            user=fake_user,
            timestamp=FAKE_TIME,
            payload=callback,
        ),
    )
    manager.set_state(state)
    try:
        await dialog._callback_handler(
            message_callback,
            ctx=cast(Ctx, manager.middleware_data),
            dialog_manager=manager,
        )

merge, publish, distribute, sublicense, and/or sell copies of the Software,
and to permit persons to whom the Software is furnished to do so, subject to the
following conditions:

The above copyright notice and this permission notice shall be included in all copies
or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WA
…[2211 chars omitted]…
outing.sentinels import UNHANDLED, CancelHandler, SkipHandler
src/maxo/routing/middlewares/error.py:19:        except (SkipHandler, CancelHandler):  # pragma: no cover
src/maxo/routing/observers/base.py:20:from maxo.routing.sentinels import UNHANDLED, SkipHandler
src/maxo/routing/observers/base.py:98:                    except SkipHandler:
src/maxo/routing/sentinels.py:40:class SkipHandler(Exception):

src/maxo/routing/middlewares/state.py
src/maxo/routing/middlewares/update_context.py
src/maxo/routing/utils/__pycache__/_resolving_inner_middlewares.cpython-312.pyc
src/maxo/routing/utils/_resolving_inner_middlewares.py
from co
…[3702 chars omitted]…
wares/state.py:13:class EmptyMiddlewareManagerState(MiddlewareManagerState):
src/maxo/routing/middlewares/state.py:18:class StartedMiddlewareManagerState(MiddlewareManagerState):
src/maxo/routing/observers/base.py:108:        chain_middlewares = self.middleware.inner.wrap_middlewares(handler)
src/maxo/routing/routers/simple.py:160:        chain_middlewares = observer.middleware.outer.wrap_middlewares(

   132	        update: MaxoUpdate[Any],
   133	        bot: Bot | None = None,
   134	    ) -> Any:
   135	        loop = asyncio.get_running_loop()
   136	        start_time = loop.time()
   137	
   138	        result = UNHANDLED
   139	        try:
   140	            result = await self.feed_update(update, bot)
   141	        except Exception:  # noqa: BLE001
   142	            duration = (loop.time() - start_time) * 1000
   143	            loggers.di
…[2945 chars omitted]…
= ErrorEvent(
    23	                exception=exception,
    24	                update=update,
    25	            ).as_(ctx.get("bot"))
    26	            new_ctx = Ctx(dict(ctx))
    27	            new_ctx["update"] = exception_event
    28	            result = await self._router.trigger(new_ctx)
    29	            if result is UNHANDLED:
    30	                raise
    31	            return result

FSM_CONTEXT_KEY = "fsm_context"
FSM_CONTEXT_STATE_KEY = "state"  # same as "fsm_context", Подражание aiogram
RAW_STATE_KEY = "raw_state"


class FSMContextMiddleware(BaseMiddleware[MaxoUpdate[Any]]):
    __slots__ = ("_events_isolation", "_storage")

    def __init__(
        self,
        storage: BaseStorage,
        events_isolation: BaseEventIsolation,
    ) -> None:
        self._storage = storag
…[842 chars omitted]…
ontext.get_state()

            return await next(ctx)

    def make_storage_key(
        self,
        bot_id: int,
        update_context: UpdateContext,
    ) -> StorageKey | None:
        chat_id, user_id = update_context.chat_id, update_context.user_id
        if chat_id is None or user_id is None:
            return None

        return StorageKey(bot_id=bot_id, chat_id=chat_id, user_id=user_id)

class MessageCallback(MaxUpdate, CallbackMethodsFacade, MessageMethodsFacade):  # type: ignore[misc]
    """
    Вы получите это событие, как только пользователь нажмёт кнопку

    Args:
        callback:
        message: Изначальное сообщение, содержащее встроенную клавиатуру. Может быть `null`, если оно было удалено к моменту, когда бот получил это событие
        type:
        user_locale: Текущий язык пользователя в формате IETF BCP 47
   
…[2156 chars omitted]…
lf.user_locale):
            return self.user_locale

        raise AttributeIsEmptyError(
            obj=self,
            attr="user_locale",
        )

    @property
    def text(self) -> str | None:
        return self.message.body.text

    @property
    def user_id(self) -> int | None:
        if is_defined(self.message.sender):
            return self.message.sender.user_id
        return None

    Stack,
    StartMode,
)
from maxo.enums import ChatType
from maxo.fsm import State

if TYPE_CHECKING:
    from maxo.dialogs.api.internal.widgets import Widget


class UnsetId(Enum):
    UNSET = "UNSET"


class BaseDialogManager(Protocol):
    @abstractmethod
    async def done(
        self,
        result: Any = None,
        show_mode: ShowMode | None = None,
    ) -> None:
        """Закрыть текущий диалог и показать нижележащий в стеке."""
        raise NotImplementedError

    @abstractmethod
    async def start(
        self,
        state: State,
        data: Data = None,
        mo
…[8336 chars omitted]…
log/test_bg_manager_chat_type.py:133:        factory = BgManagerFactoryImpl(dp)
tests/maxo_dialog/test_bg_manager_chat_type.py:214:) -> tuple[Dispatcher, BgManagerFactory]:
tests/maxo_dialog/test_fg.py:18:from maxo.dialogs.manager.bg_manager import BgManagerFactoryImpl
tests/maxo_dialog/test_fg.py:155:) -> BgManagerFactoryImpl:
tests/maxo_dialog/test_fg.py:159:    bg_factory = BgManagerFactoryImpl(dp)

    BotInfo,
    Callback,
    CallbackButton,
    Chat,
    LinkedMessage,
    Message,
    MessageBody,
    MessageCallback,
    MessageCreated,
    MessageEdited,
    MessageRemoved,
    MessageStat,
    Recipient,
    SimpleQueryResult,
    User,
    UserAddedToChat,
)

from .keyboard import InlineButtonLocator


class FakeBot(Bot):
    def __init__(self) -> None:
        super().__init__("", warming_up=False)
        info = BotInfo(
            user_id=1000,
            first_name="bot",
            userna
…[7489 chars omitted]…
    return await self.dp.feed_update(
            MaxoUpdate(
                update=BotAddedToChat(
                    chat_id=self.chat.chat_id,
                    is_channel=self.chat.type == ChatType.CHANNEL,
                    user=self.user,
                    timestamp=datetime.fromtimestamp(1234567890, tz=UTC),
                ).as_(self.bot),
            ),
            self.bot,
        )

    DialogAction,
    DialogStartEvent,
    DialogSwitchEvent,
    DialogUpdateEvent,
    EventContext,
    ShowMode,
    StartMode,
)
from maxo.dialogs.api.entities.update_event import DialogFgEvent
from maxo.dialogs.api.exceptions import DialogsError
from maxo.dialogs.api.internal import FakeUser
from maxo.dialogs.api.protocols import BaseDialogManager, BgManagerFactory
from maxo.dialogs.manager.updater import Updater
from maxo.dialogs.utils import is_user_loaded
from maxo.enums import ChatType
from maxo.fsm import State
from maxo.types import Chat, ChatMem
…[2801 chars omitted]…
       chat_type=new_event_context.chat_type or ChatType.CHAT,
        )

    def _base_event_params(self) -> dict[str, Any]:
        return {
            "user": self._event_context.user,
            "recipient": Recipient(
                user_id=self._event_context.user_id,
                chat_id=self._event_context.chat_id,
                chat_type=self._event_context.chat_type or ChatType.CHAT,

        if not self.load:
            return

        user = self._event_context.user
        user_id = self._event_context.user_id
        if user is None or user_id is None:
            loggers.dialogs.debug(
                "cannot load user %s: user is unknown",
                user_id,
            )
            return

        if is_user_loaded(user):
            return

        chat_id = self._event_context.chat_id
        if chat_id is None:
            loggers.dialo
…[5750 chars omitted]…
ame="",
                last_activity_time=datetime.now(UTC),
            )
        )
        if stack_id is None:
            stack_id = DEFAULT_STACK_ID

        return BgManager(
            user=user,
            chat_id=chat_id,
            bot=bot,
            dp=self._dp,
            intent_id=None,
            stack_id=stack_id,
            load=load,
            chat_type=chat_type,
        )

ERROR test_issue_repro.py
!!!!!!!!!!!!!!!!!!!! Interrupted: 1 error during collection !!!!!!!!!!!!!!!!!!!!
1 error in 5.86s

    
        async def use():
            async with m.fg():
                entered_use.set()
    
        task = asyncio.create_task(use())
        await asyncio.sleep(0)
        task.cancel()
>       await asyncio.wait_for(task, 1)

test_issue_repro.py:145: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
/usr/local/lib/python3.12/asyncio/tasks.py:520: in wait_for
    r
…[1772 chars omitted]…
 for f in fs:
            f.add_done_callback(_on_completion)
    
        try:
>           await waiter
E           asyncio.exceptions.CancelledError

/usr/local/lib/python3.12/asyncio/tasks.py:550: CancelledError
=========================== short test summary info ============================
FAILED test_issue_repro.py::test_fg_cancel_before_entered - asyncio.exception...
1 failed, 8 passed in 6.95s

from maxo.types import (
    Attachments,
    Callback,
    InlineKeyboardAttachment,
    Keyboard,
    Message,
    MessageBody,
    PhotoAttachment,
    PhotoAttachmentPayload,
    Recipient,
)


class MockMessageManager(MessageManagerProtocol):
    def __init__(self) -> None:
        self.answered_callbacks: set[str] = set()
        self.sent_messages: list[Message] = []
        self.last_message_id = 0

    def reset_history(self) -> None:
        self.sent_messages.clear()
        self.answered_callbacks.clear()

    def assert_one_message(self) -> None:
        a
…[3558 chars omitted]…
      seq=message_id,
                    text=new_message.text,
                    attachments=converted_attachments,
                ),
            ),
        )

        return OldMessage(
            message_id=str(message_id),
            sequence_id=message_id,
            recipient=new_message.recipient,
            text=new_message.text,
            attachments=converted_attachments,
        )

------------------------------ Captured log call -------------------------------
WARNING  maxo.dialogs:manager.py:151 Trying to access current context, while no dialog is opened
ERROR    asyncio:base_events.py:1833 Task exception was never retrieved
future: <Task finished name='Task-47' coro=<Updater._process_update() done, defined at /repo/src/maxo/dialogs/manager/updater.py:28> exception=NoContextError()>
Traceback (most recent call last):
  File "/repo/src/m
…[6305 chars omitted]…
c/maxo/dialogs/manager/manager.py", line 154, in current_context
    raise NoContextError
maxo.dialogs.api.exceptions.NoContextError
=========================== short test summary info ============================
FAILED test_issue_repro.py::test_channel_direct_start_new_stack_and_switch - ...
FAILED test_issue_repro.py::test_channel_manager_created_outside_event - Asse...
2 failed, 10 passed in 9.19s

tests/maxo_dialog/test_bg_manager_chat_type.py:191:            stack_id=None,

ImportError while importing test module '/repo/tests/maxo_dialog/widgets/text/test_base.py'.
Hint: make sure your test modules/packa
…[919 chars omitted]…
t F
E   ModuleNotFoundError: No module named 'magic_filter'
=========================== short test summary info ============================
ERROR tests/maxo_dialog/widgets/test_link_preview.py
ERROR tests/maxo_dialog/widgets/text/test_base.py
ERROR tests/maxo_dialog/widgets/text/test_case.py
!!!!!!!!!!!!!!!!!!! Interrupted: 3 errors during collection !!!!!!!!!!!!!!!!!!!!
4 warnings, 3 errors in 5.40s

src/maxo/dialogs/api/protocols/manager.py:95:100:        """Получить фоновый менеджер для указанного чата."""

ImportError while importing test module '/repo/tests/maxo/routing/test_payload.py'.
Hint: make sure your test modules/packages hav
…[1027 chars omitted]…
duleNotFoundError: No module named 'redis'
E   * Please run `pip install maxo[redis]`
=========================== short test summary info ============================
ERROR tests/maxo/routing/filters/test_magic_filter.py
ERROR tests/maxo/routing/test_payload.py
ERROR tests/maxo/fsm/storages/test_redis.py
!!!!!!!!!!!!!!!!!!! Interrupted: 3 errors during collection !!!!!!!!!!!!!!!!!!!!
3 errors in 3.23s

     data: Any
diff --git a/src/maxo/dialogs/api/protocols/manager.py b/src/maxo/dialogs/api/protocols/manager.py
index 8eb6755..da6a67d 100644
--- a/src/maxo/dialogs/api/protocols/manager.py
+++ b/src/maxo/dialogs/api/protocols/manager.py
@@ -86,7 +86,7 @@ class BgManagerFactory(Protocol):
     def bg(
         self,
         bot: Bot,
-        user_id: int,
+        user_id: int | None,
         chat_id: int,
         stack_id: str | None = None,
         load: bool = Fals
…[8629 chars omitted]…
 @@ class UpdateContextMiddleware(BaseMiddleware[MaxoUpdate[Any]]):
             user_id = update.user_id
         elif isinstance(update, DialogUpdateEvent):
             user = update.user
-            user_id = user.id
+            user_id = user.id if user is not None else update.recipient.user_id
             chat_id = update.recipient.chat_id
             chat_type = update.recipient.chat_type

    @property
    def error(self) -> _ExceptionT:
        return self.exception

    @property
    def event(self) -> _UpdateT:
        return self.update.update

    """
    Объект, описывающий один из вариантов наследования:
        - [`User`](https://dev.max.ru/docs-api/objects/User) - объект содержит общую информацию о пользователе или боте без аватара
        - [`UserWithPhoto`](https://dev.max.ru/docs-api/objects/UserWithPhoto) - объект с общей информацией о пользователе или боте, дополнительно содержит URL аватара и описание
        - [`BotInfo`](https://dev.max.ru/docs-api/objects/BotInfo) - объект включает общую информацию о боте, URL аватара и описание. Дополнительно содержит список команд, поддерживаемых ботом. Во
…[2846 chars omitted]…
        attr="last_name",
        )

    @property
    def unsafe_name(self) -> str:
        if is_defined(self.name):
            return self.name

        raise AttributeIsEmptyError(
            obj=self,
            attr="name",
        )

    @property
    def unsafe_username(self) -> str:
        if is_defined(self.username):
            return self.username

        raise AttributeIsEmptyError(

16 passed in 5.93s

…[360 chars omitted]…
c/maxo/dialogs/api/protocols/message_manager.py:7:from maxo.dialogs.api.exceptions import DialogsError
src/maxo/dialogs/api/protocols/message_manager.py:11:class MessageNotModified(DialogsError):
src/maxo/dialogs/manager/bg_manager.py:22:from maxo.dialogs.api.exceptions import DialogsError
src/maxo/dialogs/manager/bg_manager.py:297:                raise DialogsError("Foreground event was not handled")

 src/maxo/dialogs/manager/update_handler.py     |   5 +-
 src/maxo/routing/middlewares/update_context.py |   2 +-
 7 files changed, 141 insertions(+), 45 deletions(-)

                and not update.exited.cancelled()
            ):
                update.entered.set_exception(
                    StackAccessDeniedError(
                        f"Stack is not allowed for user {update.recipient.user_id}",
                    ),
                )
            return UNHANDLED
        return await next(ctx)

    async def process_callback(
        self,
        update: MessageCallback,
        ctx: Ctx,
            state=event.new_state,
    
…[3722 chars omitted]…
at.id,
        )

        if stack_id is None:
            if event_context == new_event_context:
                stack_id = self.current_stack().id
                if self.has_context():
                    intent_id = self.current_context().id
            else:
                stack_id = DEFAULT_STACK_ID

        return BgManager(
            user=user,
            chat_id=new_event_context.chat_id,

                f"Context not found for intent id: {intent_id}",
            )
E           maxo.dialogs.api.exceptions.UnknownIntent: Context not found for intent id: awDZN7

src/maxo/dialogs/context/storage.py:49: UnknownIntent
=========================== short test summary info ============================
FAILED tests/maxo_dialog/test_nested_transitions.py::test_start - maxo.dialog...
1 failed, 717 passed, 4 warnings in 9.99s
........................................................................ [ 26%]
........................................................................ [ 53%]
........................................................................ [ 80%]
....................................................                     [100%]
268 passed in 5.14s

from maxo.dialogs import (
    Dialog,
    DialogManager,
    StartMode,
    Window,
    setup_dialogs,
)
from maxo.dialogs.test_tools import BotClient, MockMessageManager
from maxo.dialogs.test_tools.keyboard import InlineButtonTextLocator
from maxo.dialogs.test_tools.memory_storage import JsonMemoryStorage
from maxo.dialogs.widgets.kbd import Cancel
from maxo.dialogs.widgets.text import Const, Format
from maxo.fsm.state import State, StatesGroup
from maxo.routing.filters import CommandStart
from maxo.routing.signals import AfterStartup, BeforeStartup
from maxo.types import MessageCrea
…[3255 chars omitted]…
r.reset_history()
        await client.click(candidate, InlineButtonTextLocator("Cancel"))
        if message_manager.sent_messages:
            second_message = message_manager.last_message()
            if second_message.body.text == "First":
                break

    assert second_message is not None
    assert second_message.body.text == "First"
    assert second_message.body.reply_markup is None

lrwxrwxrwx 1 root root     11 Nov  3 15:55 CLAUDE.md -> ./AGENTS.md
-rw-r--r-- 1 root root   5254 Nov  3 15:55 CONTRIBUTING.md
-rw-r--r-- 1 root root  11376 Nov  3 15:55 LICENSE
-rw-r--r-- 1 root root  15383 Nov  3 15:55 README.md
-rw-r--r-- 1 root root  15095 Nov  3 15:55 THIRD_PARTY_LICENSES
drwxr-xr-x 1 root root   4096 Nov  3 15:55 butcher
-rw-r--r-- 1 root ro
…[1694 chars omitted]…
fsm_basic.py
./examples/fsm_router.py
./examples/html_markdown.py
./examples/keyboards.py
./examples/send_attachments.py
./examples/swagger_watcher.py
./examples/text_formatting.py
./examples/webhook_aiohttp.py
./examples/webhook_fastapi.py
./examples/without_dp.py
./justfile
./max-swagger.json
./noxfile.py
./pyproject.toml
./tests/__init__.py
./tests/constants.py
./tests/factories.py
./tests/mocks.py

src/maxo/bot/defaults.py
src/maxo/bot/methods/__init__.py
src/maxo/bot/methods/base.py
src/maxo/bot/methods/bots/__init__.py
src/maxo/bot/methods/bots/edit_bot_info.py
src/maxo/bot/methods/bots/edit_my_commands.py
src/maxo/bot/methods/bots/get_my_info.py
src/maxo/bot/methods/chats/__init__.py
src/maxo/bot/methods/chats/add_members.py
src/maxo/bot/methods/chats/delete_admin.py
src/maxo/bot/methods/chats/delete_admins.py
src/maxo/bot/methods/chats/delete_chat.py
src/maxo/bot/methods/chats/edit_chat.py
src/maxo/bot/
…[8629 chars omitted]…
nager/test_bg_manager.py:101:        other = manager._get_fake_user(99)
tests/maxo_dialog/manager/test_manager_impl.py:462:    def test_get_fake_user_for_other_id(self) -> None:
tests/maxo_dialog/manager/test_manager_impl.py:467:    def test_get_fake_user_unwraps_error_event(self) -> None:
tests/maxo_dialog/manager/test_manager_impl.py:475:        assert manager._get_fake_user() is inner.callback.user

`AGENTS.md` - базовый и обязательный источник правил для всех AI-агентов.
`CLAUDE.md` должен оставаться симлинком на `./AGENTS.md`.

Не выноси обязательные правила в Claude-only skills или другие инструменты,
которые не читают Codex, Cursor, Copilot, Gemini и похожие агенты. Если
инструкции разрастутся, добавляй вложенные `AGENTS.md` ближе к области
ответственности - так уже сделано для кодоге
…[8629 chars omitted]…
xo_dialog/widgets/text/__init__.py
tests/maxo_dialog/widgets/text/test_base.py
tests/maxo_dialog/widgets/text/test_case.py
tests/maxo_dialog/widgets/text/test_format.py
tests/maxo_dialog/widgets/text/test_jinja.py
tests/maxo_dialog/widgets/text/test_list.py
tests/maxo_dialog/widgets/text/test_multi.py
tests/maxo_dialog/widgets/text/test_progress.py
tests/maxo_dialog/widgets/text/test_scrolling_text.py

    DialogAction,
    DialogStartEvent,
    DialogSwitchEvent,
    DialogUpdateEvent,
    EventContext,
    ShowMode,
    StartMode,
)
from maxo.dialogs.api.entities.update_event import DialogFgEvent
from maxo.dialogs.api.internal import FakeUser
from maxo.dialogs.api.protocols import BaseDialogManager, BgManagerFactory
from maxo.dialogs.manager.updater import Updater
from maxo.dialogs.utils import is_user_loaded
from maxo.enums import ChatType
from maxo.fsm import State
from maxo.types import Chat, ChatMembersList, Recipient, User


class BgManager(BaseDialo
…[8629 chars omitted]…
geCallback
    | BotStarted
    | BotStopped
    | DialogUpdateEvent
    | UserAddedToChat
    | UserRemovedFromChat
    | BotAddedToChat
    | BotRemovedFromChat
    | ErrorEvent[Any, Any]
)


@dataclass
class EventContext:
    bot: Bot
    chat_id: int | None
    user_id: int | None
    chat_type: ChatType | None
    user: User | None
    chat: Chat | None


EVENT_CONTEXT_KEY = "aiogd_event_context"

    DialogAction,
    DialogStartEvent,
    DialogSwitchEvent,
    DialogUpdateEvent,
    EventContext,
    ShowMode,
    StartMode,
)
from maxo.dialogs.api.entities.update_event import DialogFgEvent
from maxo.dialogs.api.internal import FakeUser
from maxo.dialogs.api.protocols import BaseDialogManager, BgManagerFactory
from maxo.dialogs.manager.updater import Updater
from maxo.dialogs.utils import is_user_loaded
from maxo.enums import ChatType
from maxo.fsm import State
from maxo.types import Chat, ChatMembersList, Recipient, User


class BgManager(BaseDialo
…[8630 chars omitted]…
,
    client: BotClient,
    message_manager: MockMessageManager,
) -> None:
    bg_factory = await start_stack_for_first_user(dp, client, message_manager)

    stranger = bg_factory.bg(
        client.bot,
        user_id=2,
        chat_id=-1,
        stack_id=SHARED_STACK_ID,
    )
    with pytest.raises(StackAccessDeniedError):
        async with asyncio.timeout(1), stranger.fg():
            pass

    DialogAction,
    DialogStartEvent,
    DialogSwitchEvent,
    DialogUpdateEvent,
    EventContext,
    ShowMode,
    StartMode,
)
from maxo.dialogs.api.entities.update_event import DialogFgEvent
from maxo.dialogs.api.internal import FakeUser
from maxo.dialogs.api.protocols import BaseDialogManager, BgManagerFactory
from maxo.dialogs.manager.updater import Updater
from maxo.dialogs.utils import is_user_loaded
from maxo.enums import ChatType
from maxo.fsm import State
from maxo.types import Chat, ChatMembersList, Recipient, User


class BgManager(BaseDialo
…[8629 chars omitted]…
called, contexts are removed from storage.
        """
        raise NotImplementedError

    @abstractmethod
    async def load_data(self) -> dict[Any, Any]:
        """Load data for current state."""
        raise NotImplementedError

    @abstractmethod
    async def close_manager(self) -> None:
        """Release all resources and disable usage of many methods."""
        raise NotImplementedError

        # `BgManager.__init__` требует `user`, а `user_id` берёт из него.
        assert user is not None  # noqa: S101
        assert user_id is not None  # noqa: S101

        if is_user_loaded(user):
            return

        chat_id = self._event_context.chat_id
        if chat_id is None:
            loggers.dialogs.debug(
                "cannot load user %s: chat_id is unknown",
                user_id,
            )
            return

        bot = self._event_context.bot
        loggers.dialogs.debug("load user %s from chat %s", user_id, cha
…[6856 chars omitted]…
logsError):
    pass


class NoContextError(DialogsError):
    pass


# navigation
class UnregisteredDialogError(DialogsError):
    pass


class UnregisteredWindowError(DialogsError):
    pass


# widgets
class InvalidWidgetIdError(DialogsError):
    pass


class InvalidWidget(DialogsError):
    pass


class InvalidWidgetType(InvalidWidget):
    pass


class InvalidKeyboardType(DialogsError):
    pass

,
tests/maxo_dialog/test_intent_middleware.py:560:            load_context=AsyncMock(side_effect=UnknownIntent("gone")),
tests/maxo_dialog/test_intent_middleware.py:566:        with pytest.raises(UnknownIntent):
tests/maxo_dialog/test_storage_proxy.py:6:from maxo.dialogs.api.exceptions import UnknownIntent, UnknownState
tests/maxo_dialog/test_storage_proxy.py:150:    with pytest.raises(UnknownIntent):

        chat_type: Тип чата:
             - `chat` - групповой чат
             - `channel` - канал или комментарий к посту (для вызовов методов группы `/comments`)
             - `dialog` - диалог
        post_id: Идентификатор поста в канале, к которому оставлен комментарий
        user_id: ID получателя сообщения в диалоге (пользователя или бота). Если сообщение отправлено в групповой чат или канал, то параметр отсутствует
    """

    chat_type: ChatType
    """
    Тип 
…[8630 chars omitted]…
d="default",
        access_settings=AccessSettings(user_ids=[1, 2, 3]),
    )
    ctx = Ctx(
        {
            UPDATE_CONTEXT_KEY: UpdateContext(type=ChatType.CHANNEL),
            EVENT_FROM_USER_KEY: None,
        },
    )

    allowed = await validator.is_allowed(
        stack=stack,
        context=None,
        event=event_message_created,
        ctx=ctx,
    )

    assert allowed is False

    setup_dialogs,
)
from maxo.dialogs.api.entities import AccessSettings
from maxo.dialogs.api.exceptions import StackAccessDeniedError
from maxo.dialogs.api.protocols import BaseDialogManager
from maxo.dialogs.manager.bg_manager import BgManagerFactoryImpl
from maxo.dialogs.test_tools import BotClient, MockMessageManager
from maxo.dialogs.test_tools.keyboard import InlineButtonTextLocator
from maxo.dialogs.test_tools.memory_storage import JsonMemoryStorage
from maxo.dialogs.widgets.kbd import Button
from maxo.dialogs.widgets.text import Const, Format
from maxo.enums import ChatType
from maxo.fsm.state import State, StatesGroup
from maxo.routing.filters import CommandStart
…[8629 chars omitted]…
 "GROUP_STACK_ID",
    "AccessSettings",
    "ChatEvent",
    "Context",
    "Data",
    "DialogAction",
    "DialogStartEvent",
    "DialogSwitchEvent",
    "DialogUpdateEvent",
    "EventContext",
    "LaunchMode",
    "LinkPreviewOptions",
    "MarkupVariant",
    "MediaAttachment",
    "MediaId",
    "NewMessage",
    "OldMessage",
    "ShowMode",
    "Stack",
    "StartMode",
    "UnknownText",
)

   132	        chat=None,
   133	        chat_id=event.recipient.chat_id,
   134	        chat_type=event.recipient.chat_type,
   135	    )
   136	
   137	
   138	def event_context_from_error(event: ErrorEvent[Any, Any], ctx: Ctx) -> EventContext:
   139	    if isinstance(event.event, MessageCreated):
   140	        return event_context_from_message(event.event, ctx)
   141	    if isins
…[8630 chars omitted]…
xt():
    34	            loggers.dialogs.warning("No context found")
    35	            return
    36	        if event.data:
    37	            for k, v in event.data.items():
    38	                dialog_manager.current_context().dialog_data[k] = v
    39	        await dialog_manager.show()
    40	    elif event.action is DialogAction.DONE:
    41	        await dialog_manager.done(result=event.data)

        proxy: StorageProxy,
        stack_id: str | None,
        ctx: Ctx,
    ) -> None:
        loggers.dialogs.debug(
            "Loading context for stack: `%s`, user: `%s`, chat: `%s`",
            stack_id,
            proxy.user_id,
            proxy.chat_id,
        )
        stack = await self._load_stack(stack_id, proxy)
        if not stack:
            return
        if stack.empty():
            context = None
        else:
            try:
                context = await proxy.load_context(stack.last_intent_id())
    
…[8629 chars omitted]…
rc/maxo/routing/routers/simple.py:150:            if result is UNHANDLED:
src/maxo/routing/routers/simple.py:153:        return UNHANDLED
src/maxo/routing/routers/simple.py:167:            return UNHANDLED
src/maxo/routing/routers/simple.py:170:        if result is UNHANDLED:
src/maxo/routing/sentinels.py:32:    UNHANDLED = "<unhandled>"
src/maxo/routing/sentinels.py:36:UNHANDLED = Sentinels.UNHANDLED

from maxo.routing.middlewares.error import ErrorMiddleware
from maxo.routing.middlewares.fsm_context import FSMContextMiddleware
from maxo.routing.middlewares.update_context import UpdateContextMiddleware
from maxo.routing.observers import UpdateObserver
from maxo.routing.routers.simple import Router
from maxo.routing.sentinels import UNHANDLED, SkipHandler
from maxo.routing.signals.base import BaseSignal
fro
…[8630 chars omitted]…
is UNHANDLED and ctx.get(FORBIDDEN_STACK_KEY):
            # Гасим "часики" на кнопке: чужой/протухший стек хендлер не обработает.
            await update.callback_answer(notification="")
        return result

    async def process_bot_started(
        self,
        update: BotStarted,
        ctx: Ctx,
        next: NextMiddleware[BotStarted],
    ) -> Any:
        if UPDATE_CONTEXT_KEY not in ctx:

from maxo.types import Attachments

_retort = create_retort(warming_up=False)


class StorageProxy:
    def __init__(
        self,
        storage: BaseStorage,
        events_isolation: BaseEventIsolation,
        user_id: int | None,
        chat_id: int | None,
        chat_type: ChatType | None,
        bot: Bot,
        state_groups: dict[str, type[StatesGroup]],
    ) -> None:
        self.storage =
…[8629 chars omitted]…
  "CALLBACK_DATA_KEY",
    "CONTEXT_KEY",
    "EVENT_SIMULATED",
    "PAYLOAD_KEY",
    "STACK_KEY",
    "STORAGE_KEY",
    "ButtonVariant",
    "DataGetter",
    "DialogManagerFactory",
    "FakeRecipient",
    "FakeUser",
    "InputWidget",
    "KeyboardWidget",
    "LinkPreviewWidget",
    "MediaWidget",
    "RawKeyboard",
    "ReplyCallback",
    "TextWidget",
    "Widget",
    "WindowProtocol",
)

139:    if isinstance(event.event, MessageCreated):
140:        return event_context_from_message(event.event, ctx)
142:        return event_context_fro
…[2948 chars omitted]…
 self._load_default_context(update, ctx, event_context)
470:    MessageCreated,
583:            event_context = event_context_from_error(update, ctx)
584:            ctx[EVENT_CONTEXT_KEY] = event_context
586:                bot=event_context.bot,
590:                user_id=event_context.user_id,
591:                chat_id=event_context.chat_id,
592:                chat_type=event_context.chat_type,

merge, publish, distribute, sublicense, and/or sell copies of the Software,
and to permit persons to whom the Software is furnished to do so, subject to the
following conditions:

The above copyright notice and this permission notice shall be included in all copies
or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTI
…[6492 chars omitted]…
g_manager.py:277:        return BgManager(
src/maxo/dialogs/manager/manager.py:593:        return BgManager(
tests/maxo_dialog/manager/test_bg_manager.py:70:    manager = BgManager(
tests/maxo_dialog/test_bg_manager_chat_type.py:84:        bg = BgManager(
tests/maxo_dialog/test_bg_manager_chat_type.py:96:        bg = BgManager(
tests/maxo_dialog/test_bg_manager_chat_type.py:109:        bg = BgManager(

        event_context = event_context_from_bot_started(update, ctx)
        ctx[EVENT_CONTEXT_KEY] = event_context
        await self._load_default_context(update, ctx, event_context)
        return await next(ctx)

    async def process_bot_stopped(
        self,
        update: BotStopped,
        ctx: Ctx,
        next: NextMiddleware[BotStopped],
    ) -> Any:
        if UPDATE_CONTEXT_KEY not in ctx:
            return await next(ctx)

        event_context = event_context_from_bot_stopped(upd
…[8629 chars omitted]…
r = handler  # Подражание aiogram

    if TYPE_CHECKING:

        async def execute_handler(
            self,
            ctx: Ctx,
            handler: UpdateHandler[_UpdateT, _ReturnT_co],
        ) -> _ReturnT_co: ...
src/maxo/dialogs/setup.py:138:    router.exception.middleware.inner(
src/maxo/dialogs/setup.py:181:    router.exception.middleware.inner(manager_middleware)  # type: ignore[arg-type]

            attachments=[],
        )

        manager._save_last_message(message)

        assert stack.last_message_id == "55"
        assert stack.last_sequence_id == 55


class TestBackground:
    def test_bg_resets_stack_because_event_context_never_matches(self) -> None:
        # `bg()` кладёт в новый EventContext FakeChat с текущим временем,
        # поэтому он не равен исходному и стек всегда сбрасывается
       
…[5670 chars omitted]…

    )


def registry(manager: ManagerImpl) -> MagicMock:
    # _registry типизирован как Protocol, в этих тестах используется MagicMock
    return cast(MagicMock, manager._registry)


def message_manager(manager: ManagerImpl) -> MagicMock:
    # message_manager типизирован как Protocol, в этих тестах используется MagicMock
    return cast(MagicMock, manager.message_manager)


class TestContextAccess:

    )
    intent_middleware = IntentMiddlewareFactory(
        registry=registry,
        access_validator=stack_access_validator,
        events_isolation=events_isolation,
    )
    # delayed configuration of middlewares
    router.after_startup.handler(_startup_callback(registry))

    dialog_updates_handler = router.observers[DialogUpdateEvent]

    router.exception.middleware.inner(
        IntentErrorMiddleware(
            registry=registry,
            even
…[8629 chars omitted]…
update это первый аргумент в хендлерах
        update = ctx.pop("update")
        wrapped = partial(self._handler_fn, update, **self._prepare_kwargs(ctx))
        ctx["update"] = update
        if self._awaitable:
            return await wrapped()
        # В этой ветке хендлер синхронный, несмотря на async-сигнатуру протокола.
        return await asyncio.to_thread(wrapped)  # type: ignore[arg-type]

            user_id=self.chat_id,  # Неожиданно, но это нужно для работы в группах
            destiny=f"aiogd:stack:{stack_id}",
        )

    def _state(self, state: str) -> State:
        group, *_ = state.partition(":")
        try:
            for real_state in self.state_groups[group].__states__:
                if real_state.state == state:
                    return real_state
        except KeyError:
            raise UnknownState(f"Unkn
…[3551 chars omitted]…
/dialogs/manager/message_manager.py:296:        user_id = Omitted() if recipient.user_id is None else recipient.user_id
src/maxo/dialogs/test_tools/mock_message_manager.py:77:                user_id=old_message.recipient.user_id,
src/maxo/dialogs/tools/preview.py:104:                user_id=self._event.recipient.user_id,
src/maxo/dialogs/window.py:170:                    user_id=event_context.user_id,

from maxo.routing.observers import SignalObserver, UpdateObserver
from maxo.routing.observers.state import EmptyObserverState, StartedObserverState
from maxo.routing.routers.state import EmptyRouterState, StartedRouterState
from maxo.routing.sentinels import UNHANDLED
from maxo.routing.signals.shutdown import AfterShutdown, BeforeShutdown
from maxo.routing.signals.startup import AfterStartup, BeforeStartup
from maxo.routing.utils.get_default_name import get_ro
…[8404 chars omitted]…
    update: ErrorEvent[Any, Any],
src/maxo/dialogs/context/intent_middleware.py:576:        next: NextMiddleware[ErrorEvent[Any, Any]],
src/maxo/dialogs/manager/manager.py:56:    ErrorEvent,
src/maxo/dialogs/manager/manager.py:463:        if isinstance(self.event, ErrorEvent):
src/maxo/dialogs/manager/manager.py:522:        event = self.event.event if isinstance(self.event, ErrorEvent) else self.event

    return isinstance(value, Omitted)


def is_not_omitted(value: Omittable[_OmittedValueT]) -> TypeIs[_OmittedValueT]:
    return not is_omitted(value)


def is_defined(value: Omittable[_OmittedValueT | None]) -> TypeIs[_OmittedValueT]:
    return not isinstance(value, Omitted) and value is not None


def is_not_defined(value: Omittable[_OmittedValueT | None]) -> TypeIs[Omittable[None]]:
    return not is_defined(value)


__all__ = (
    "Omittable",
    "Omitted",
    "is_defined",
    "is_not_defined",
    "is_not_omitted",
    "is_omitted",
)
src/maxo/dialogs/context/intent_middleware.py:98: 
…[1280 chars omitted]…
vent(
tests/maxo_dialog/manager/test_update_handler.py:145:    event = DialogUpdateEvent(
tests/maxo_dialog/manager/test_update_handler.py:165:    event = DialogUpdateEvent(
tests/maxo_dialog/manager/test_update_handler.py:182:    event = DialogUpdateEvent(
tests/maxo_dialog/test_entities.py:78:    event = DialogUpdateEvent(
tests/maxo_dialog/test_intent_middleware.py:114:    return DialogUpdateEvent(

    Dialog,
    DialogManager,
    StartMode,
    Window,
    setup_dialogs,
)
from maxo.dialogs.api.entities import DialogAction, DialogStartEvent
from maxo.dialogs.api.protocols import BgManagerFactory
from maxo.dialogs.manager.bg_manager import BgManager, BgManagerFactoryImpl
from maxo.dialogs.test_tools import BotClient, MockMessageManager
from maxo.dialogs.test_tools.bot_client import FakeBot
from maxo.dialogs.test_tools.memory_storage import JsonMemo
…[8628 chars omitted]…
src/maxo/dialogs/manager/bg_manager.py:71:        user_id: int | None = None,
src/maxo/dialogs/manager/bg_manager.py:262:        user_id: int,
src/maxo/dialogs/manager/manager.py:519:    def _get_fake_user(self, user_id: int | None = None) -> User:
src/maxo/dialogs/manager/manager.py:564:        user_id: int | None = None,
src/maxo/dialogs/manager/sub_manager.py:148:        user_id: int | None = None,

        self,
        registry: DialogRegistryProtocol,
        access_validator: StackAccessValidator,
        events_isolation: BaseEventIsolation,
    ) -> None:
        super().__init__()
        self.registry = registry
        self.events_isolation = events_isolation
        self.access_validator = access_validator

    def _is_error_supported(
        self,
        event: ErrorEvent[Any, Any],
        ctx: Ctx,
    ) -> bool:
        update = event.update.update
        if isinstance(update, InvalidStackIdError):
            return False
        if not isinstance(update, SUPPORTED_ERROR_EVENTS):

…[8629 chars omitted]…
rt BaseUpdate

_UpdateT = TypeVar("_UpdateT", bound=BaseUpdate)
_ExceptionT = TypeVar("_ExceptionT", bound=Exception)


class ErrorEvent(BaseUpdate, Generic[_ExceptionT, _UpdateT]):
    exception: _ExceptionT
    update: MaxoUpdate[_UpdateT]

    @property
    def error(self) -> _ExceptionT:
        return self.exception

    @property
    def event(self) -> _UpdateT:
        return self.update.update

REPLY_CALLBACK_SYMBOLS: str = (
    "\u200c"
    "\u200d"
    "\u2060"
    "\u2061"
    "\u2062"
    "\u2063"
    "\u2064"
    "\u00ad"
    "\U0001d173"
    "\U0001d174"
    "\U0001d175"
    "\U0001d176"
    "\U0001d177"
    "\U0001d178"
    "\U0001d179"
    "\U0001d17a"
)


def _encode_reply_callback_byte(byte: int) -> str:
    return (
        REPLY_CALLBACK_SYMBOLS[byte % len(REPLY_CALLBACK_SYMBOLS)]
        + REPLY_CALLBACK_SYMBOLS[byte // len(REPLY_CALLBACK_SYMBOLS)]
    )


def encode_reply_callback(data: str) -> str:
    bytes_data = data.encode("utf-8")
    return "".join(_encode_reply_callback_byte(byte) f
…[8629 chars omitted]…
: int | None = None,
        chat_id: int | None = None,
        stack_id: str | None = None,
        load: bool = False,
    ) -> BaseDialogManager:
        return self.manager.bg(
            user_id=user_id,
            chat_id=chat_id,
            stack_id=stack_id,
            load=load,
        )

    @asynccontextmanager
    async def fg(self) -> AsyncIterator[DialogManager]:
        yield self

            raise IncorrectBackgroundError(
                "Detected background access to dialog manager. "
                "Please use background manager available via `manager.bg()` "
                "method to access methods from background tasks",
            )

    async def load_data(self) -> dict[Any, Any]:
        context = self.current_context()
        if self._getter:
            data = await self._getter(**self.middleware_data)
        else:
            data = {}
        return {
            "dialog_data": context.dialog_data,
            "start_
…[5314 chars omitted]…
tart dialog on top of one with launch_mode==SINGLE",
                )

        new_dialog = self._registry.find_dialog(state)
        await self._process_launch_mode(old_dialog, new_dialog)
        if self.has_context():
            await self.storage().save_context(self.current_context())
            if access_settings is None:
                access_settings = self.current_context().access_settings

    async def _process_launch_mode(
        self,
        old_dialog: DialogProtocol | None,
        new_dialog: DialogProtocol,
    ) -> None:
        if new_dialog.launch_mode in (LaunchMode.EXCLUSIVE, LaunchMode.ROOT):
            await self.reset_stack(remove_keyboard=False)
        if new_dialog.launch_mode is LaunchMode.SINGLE_TOP:  # noqa: SIM102
            if new_dialog is old_d
…[8242 chars omitted]…
sed = False
        if self._need_refresh(processed, old_context, dialog_manager):
            await dialog_manager.show()

    async def _callback_handler(
        self,
        callback: MessageCallback,
        ctx: Ctx,
        dialog_manager: DialogManager,
    ) -> None:
        old_context = dialog_manager.current_context()
        _, payload = remove_intent_id(callback.callback.unsafe_payload)

class MessageCallback(MaxUpdate, CallbackMethodsFacade, MessageMethodsFacade):  # type: ignore[misc]
    """
    Вы получите это событие, как только пользователь нажмёт кнопку

    Args:
        callback:
        message: Изначальное сообщение, содержащее встроенную клавиатуру. Может быть `null`, если оно было удалено к моменту, когда бот получил это событие
        type:
        user_locale: Текущий язык пользователя в формате IETF BCP 47
   
…[2120 chars omitted]…
ack_id

    @property
    def unsafe_payload(self) -> str:
        if is_defined(self.payload):
            return self.payload

        raise AttributeIsEmptyError(
            obj=self,
            attr="payload",
        )

    # Подражание aiogram
    @property
    def data(self) -> Omittable[str]:
        return self.payload

    unsafe_data = unsafe_payload  # Подражание aiogram
22:ChatEvent = (

    ChatEvent,
    Context,
    Data,
    EventContext,
    LaunchMode,
    NewMessage,
    OldMessage,
    ShowMode,
    Stack,
    StartMode,
    UnknownText,
)
from maxo.dialogs.api.exceptions import (
    IncorrectBackgroundError,
    InvalidKeyboardType,
    NoContextError,
)
from maxo.dialogs.api.internal import (
    CONTEXT_KEY,
    EVENT_SIMULATED,
    STACK_KEY,
    STORAGE_KEY,
    DataGetter,
    FakeUser,
    Widget,
)
from maxo.dialogs.api.internal.fake_data import FakeChat
from maxo.dialogs.api.protocols import (
    BaseDialogManager,

…[1814 chars omitted]…
geCallback
    | BotStarted
    | BotStopped
    | DialogUpdateEvent
    | UserAddedToChat
    | UserRemovedFromChat
    | BotAddedToChat
    | BotRemovedFromChat
    | ErrorEvent[Any, Any]
)


@dataclass
class EventContext:
    bot: Bot
    chat_id: int | None
    user_id: int | None
    chat_type: ChatType | None
    user: User | None
    chat: Chat | None


EVENT_CONTEXT_KEY = "aiogd_event_context"

      and distribution as defined by Sections 1 through 9 of this document.

      "Licensor" shall mean the copyright owner or entity authorized by
      the copyright owner that is granting the License.

      "Legal Entity" shall mean the union of the acting entity and all
      other entities that control, are controlled by, or are under common
      control with that entity. For the purposes of this definition,
      "control" means (i) the power, direct or indirect, to cause the
      direction or management of such e
…[8629 chars omitted]…
ndow import Window

__all__ = (
    "DEFAULT_STACK_ID",
    "GROUP_STACK_ID",
    "AccessSettings",
    "BaseDialogManager",
    "BgManagerFactory",
    "CancelEventProcessing",
    "ChatEvent",
    "Data",
    "Dialog",
    "DialogManager",
    "DialogProtocol",
    "LaunchMode",
    "ShowMode",
    "StartMode",
    "SubManager",
    "UnsetId",
    "Window",
    "setup_dialogs",
)
62:class BotClient:

    DialogAction,
    DialogStartEvent,
    DialogSwitchEvent,
    DialogUpdateEvent,
    EventContext,
    ShowMode,
    StartMode,
)
from maxo.dialogs.api.entities.update_event import DialogFgEvent
from maxo.dialogs.api.internal import FakeUser
from maxo.dialogs.api.protocols import BaseDialogManager, BgManagerFactory
from maxo.dialogs.manager.updater import Updater
from maxo.dialogs.utils import is_user_loaded
from maxo.enums import ChatType
from maxo.fsm import State
from maxo.types import Chat, ChatMembersList, Recipient, User


def _consume_task_excepti
…[8628 chars omitted]…
cel()
                task.add_done_callback(_consume_task_exception)
            else:
                try:
                    await task
                except BaseException:
                    if body_error is None:
                        raise



class BgManagerFactoryImpl(BgManagerFactory):
    def __init__(self, router: Dispatcher) -> None:
        self._dp = router

    def bg(
        self,

     data: Any
diff --git a/src/maxo/dialogs/api/protocols/manager.py b/src/maxo/dialogs/api/protocols/manager.py
index 8eb6755..da6a67d 100644
--- a/src/maxo/dialogs/api/protocols/manager.py
+++ b/src/maxo/dialogs/api/protocols/manager.py
@@ -86,7 +86,7 @@ class BgManagerFactory(Protocol):
     def bg(
         self,
         bot: Bot,
-        user_id: int,
+        user_id: int | None,
         chat_id: int,
         stack_id: str | None = None,
         load: bool = Fals
…[8629 chars omitted]…
ate[Any]]):
             user_id = update.user_id
         elif isinstance(update, DialogUpdateEvent):
             user = update.user
-            user_id = user.id
+            user_id = update.recipient.user_id
+            if user_id is None and user is not None:
+                user_id = user.id
             chat_id = update.recipient.chat_id
             chat_type = update.recipient.chat_type

            recipient=MagicMock(),
            action=DialogAction.FG,
            data=None,
            intent_id=None,
            stack_id=None,
            bot=MagicMock(),
            entered=entered,
            exited=exited,
        )
    
        # Завершаем exited сразу, чтобы не повис тест
        exited.set_result(None)
   
…[186 chars omitted]…
 object at 0x76c55bd31120>()
E        +    where <built-in method done of _asyncio.Future object at 0x76c55bd31120> = <Future pending>.done

tests/maxo_dialog/manager/test_update_handler.py:117: AssertionError
=========================== short test summary info ============================
FAILED tests/maxo_dialog/manager/test_update_handler.py::test_handle_dialog_fg_event
1 failed, 51 passed in 2.80s

    BotInfo,
    Callback,
    CallbackButton,
    Chat,
    LinkedMessage,
    Message,
    MessageBody,
    MessageCallback,
    MessageCreated,
    MessageEdited,
    MessageRemoved,
    MessageStat,
    Recipient,
    SimpleQueryResult,
    User,
    UserAddedToChat,
)

from .keyboard import InlineButtonLocator


class FakeBot(Bot):
    def __init__(self) -> None:
        super().__init__("", warming_up=False)
        info = BotInfo(
            user_id=1000,
            first_name="bot",
            userna
…[6029 chars omitted]…
else widget_data

    def is_preview(self) -> bool:
        return self._preview

    def current_context(self) -> Context:
        return Context(
            dialog_data={},
            start_data={},
            widget_data=self.widget_data,
            state=State(),
            _stack_id="_stack_id",
            _intent_id="_intent_id",
        )
<class 'maxo.dialogs.api.exceptions.DialogsError'>

  File "/usr/local/lib/python3.12/asyncio/base_events.py", line 691, in run_until_complete
    return future.result()
           ^^^^^^^^^^^^^^^
  File "<stdin>", line 34, in main
TypeError: object method can't be used in 'await' expression

TypeError: JsonMemoryStorage.__init__() got an unexpected keyword argument 'key_builder'

@dataclass
class MemoryStorageRecord:
    data: str = "{}"
    state: str | None = None


class JsonMemoryStorage(BaseStorage):
    storage: dict[StorageKey, MemoryStorageRecord]

    def __init__(self) -> None:
        self.storage = defaultdict(MemoryStorageRecord)

    async def close(self) -> None:
        pass

    async def set_state(
        self,
        key: StorageKey,
        state: StateType = None,
    ) -> None:
        state_value = state.state if isinstance(state, State) else state
        self.storage[key].state = state_value

    async def get_state(self, key: Stora
…[42 chars omitted]…
storage[key].state

    async def set_data(
        self,
        key: StorageKey,
        data: MutableMapping[str, Any],
    ) -> None:
        self.storage[key].data = json.dumps(dict(data))

    async def get_data(self, key: StorageKey) -> dict[str, Any]:
        return cast(dict[str, Any], json.loads(self.storage[key].data))
(key_builder: maxo.fsm.key_builder.BaseKeyBuilder | None = None) -> None

…[347 chars omitted]…
xo/dialogs/context/intent_middleware.py:134:        user_id = event.user.id
src/maxo/dialogs/context/intent_middleware.py:137:        user=event.user,
src/maxo/dialogs/tools/preview.py:107:            EVENT_FROM_USER_KEY: self._event.user,
src/maxo/dialogs/tools/preview.py:113:                user=self._event.user,
src/maxo/dialogs/tools/preview.py:114:                user_id=self._event.user.user_id,

    DialogAction,
    DialogStartEvent,
    DialogSwitchEvent,
    DialogUpdateEvent,
    EventContext,
    ShowMode,
    StartMode,
)
from maxo.dialogs.api.entities.update_event import DialogFgEvent
from maxo.dialogs.api.exceptions import DialogsError
from maxo.dialogs.api.internal import FakeUser
from maxo.dialogs.api.protocols import BaseDialogManager, BgManagerFactory
from maxo.dialogs.manager.updater import Updater
from maxo.dialogs.utils import is_user_loaded
from maxo.enums import ChatType
from maxo.fsm import State
from maxo.types import Chat, ChatMem
…[8629 chars omitted]…
ogAction.UPDATE:
        if not dialog_manager.has_context():
            loggers.dialogs.warning("No context found")
            return
        if event.data:
            for k, v in event.data.items():
                dialog_manager.current_context().dialog_data[k] = v
        await dialog_manager.show()
    elif event.action is DialogAction.DONE:
        await dialog_manager.done(result=event.data)

            registry=registry,
            events_isolation=events_isolation,
            access_validator=stack_access_validator,
        ),
    )
    router.message_created.middleware.outer(intent_middleware.process_message)
    router.message_callback.middleware.outer(intent_middleware.process_callback)
    router.bot_started.middleware.outer(intent_middleware.process_bot_started)
    router.bot_stopped.middleware.outer(intent_middleware.process_bot_stopped)
    router.user
…[7349 chars omitted]…
stamp=NOW,
        payload=payload,
    )


def make_message_callback(payload: str = "data") -> MessageCallback:
    return MessageCallback(
        timestamp=NOW,
        message=Message(
            timestamp=NOW,
            recipient=Recipient(chat_type=ChatType.DIALOG, chat_id=10, user_id=1),
            body=MessageBody(mid="m", seq=1),
        ),
        callback=make_callback(payload),
    )

580:            user_id=1,
599:            user_id=1,
620:            user_id=1,
11

) -> DialogUpdateEvent:
    return DialogUpdateEvent(
        user=make_user(),
        recipient=Recipient(chat_type=ChatType.DIALOG, chat_id=10, user_id=1),
        bot=MagicMock(),
        action=DialogAction.UPDATE,
        data={},
        intent_id=intent_id,
        stack_id=stack_id,
    )


def make_bot_started() -> BotStarted:
        )

        context = event_context_from_user_added_to_chat(event, make_ctx())  # type: ignore[arg-type]

        assert context.chat_type is ChatType.CHAT

    
…[1769 chars omitted]…
axo/dialogs/context/intent_middleware.py:135:    return EventContext(
src/maxo/dialogs/manager/bg_manager.py:50:        self._event_context = EventContext(
src/maxo/dialogs/manager/bg_manager.py:89:        new_event_context = EventContext(
src/maxo/dialogs/manager/manager.py:587:        new_event_context = EventContext(
src/maxo/dialogs/tools/preview.py:108:            EVENT_CONTEXT_KEY: EventContext(

ImportError while importing test module '/repo/tests/maxo_dialog/widgets/kbd/test_base.py'.
…[5651 chars omitted]…
/maxo_dialog/widgets/media/test_base.py
ERROR tests/maxo_dialog/widgets/test_common.py
ERROR tests/maxo_dialog/widgets/test_filter_object.py
ERROR tests/maxo_dialog/widgets/test_link_preview.py
ERROR tests/maxo_dialog/widgets/text/test_base.py
ERROR tests/maxo_dialog/widgets/text/test_case.py
!!!!!!!!!!!!!!!!!!! Interrupted: 8 errors during collection !!!!!!!!!!!!!!!!!!!!
4 warnings, 8 errors in 5.34s

        return stack_access_validator
    return DefaultAccessValidator()


def _prepare_events_isolation(
    events_isolation: BaseEventIsolation | None,
) -> BaseEventIsolation:
    if events_isolation:
        return events_isolation
    return SimpleEventIsolation(DefaultKeyBuilder(with_destiny=True))


def collect_dialogs(router: BaseRouter) -> Iterable[DialogProtocol]:
    if isinstance(router, DialogProtocol):
        yield router
    for sub_router in router.children_routers:
        yield from collect_dia
…[1003 chars omitted]…
       router=router,
        dialog_manager_factory=dialog_manager_factory,
        bg_manager_factory=bg_manager_factory,
        stack_access_validator=stack_access_validator,
        events_isolation=events_isolation,
    )
    return bg_manager_factory
45:def _setup_event_observer(router: Router) -> None:
53:def _register_event_handler(
252:    _register_event_handler(router, handle_aiogd_update)

    DEFAULT_STACK_ID,
    AccessSettings,
    Data,
    DialogAction,
    DialogStartEvent,
    DialogSwitchEvent,
    DialogUpdateEvent,
    EventContext,
    ShowMode,
    StartMode,
)
from maxo.dialogs.api.entities.update_event import DialogFgEvent
from maxo.dialogs.api.exceptions import DialogsError
from maxo.dialogs.api.internal import FakeUser
from maxo.dialogs.api.protoco
…[3911 chars omitted]…
/ruff/rules/non-pep695-generic-function/
    "PLR0904", # https://docs.astral.sh/ruff/rules/too-many-public-methods/
    "PLR0911", # https://docs.astral.sh/ruff/rules/too-many-return-statements/
    "PLR0912", # https://docs.astral.sh/ruff/rules/too-many-branches/
    "PLR0913", # https://docs.astral.sh/ruff/rules/too-many-arguments/
    "PLR0914", # https://docs.astral.sh/ruff/rules/too-many-locals/

    def __init__(self, calls: list[str]) -> None:
        self.calls = calls
        self.user_id = 1

    async def save_context(self, context: Any) -> None:
        self.calls.append("save_context")

    async def save_stack(self, stack: Any) -> None:
        self.calls.append("save_stack")

    async def unlock(self) -> None:
        self.calls.append("unlock")


async def run_middleware(*, stack_empty: bool) -> list[str]:
    calls: list[str] = []
    proxy = RecordingProxy(calls)

…[1419 chars omitted]…
st_saves_stack_before_unlock_without_context() -> None:
    calls = await run_middleware(stack_empty=True)

    assert calls == ["save_stack", "unlock"]


@pytest.mark.parametrize("stack_empty", [True, False])
async def test_unlock_is_always_last(stack_empty: bool) -> None:
    calls = await run_middleware(stack_empty=stack_empty)

    assert calls[-1] == "unlock"
    assert "unlock" not in calls[:-1]

524-        if isinstance(event, MessageCreated):
525-            current_user = (
526-                event.message.sender if is_defined(event.message.sender) else None
527-            )
528-        else:
529-      
…[1172 chars omitted]…
  intent_id = None
577-        event_context = cast(
578-            EventContext,
579-            self.middleware_data.get(EVENT_CONTEXT_KEY),
580-        )
581-        effective_user_id = user_id
582-        if effective_user_id is None:
583-            effective_user_id = event_context.user_id
584-        if effective_user_id is None and user is not None:
585-            effective_user_id = user.id

    ChatEvent,
    Context,
    Data,
    EventContext,
    LaunchMode,
    NewMessage,
    OldMessage,
    ShowMode,
    Stack,
    StartMode,
    UnknownText,
)
from maxo.dialogs.api.exceptions import (
    IncorrectBackgroundError,
    InvalidKeyboardType,
    NoContextError,
)
from maxo.dialogs.api.internal import (
    CONTEXT_KEY,
    EVENT_SIMULATED,
    STACK_KEY,
    STORAGE_KEY,
    DataGetter,
    FakeUser,
    Widget,
)
from maxo.dialogs.api.internal.fake_data import FakeChat
from maxo.dialogs.api.protocols import (
    BaseDialogManager,

…[309 chars omitted]…
ort ChatStatus, ChatType
from maxo.fsm import State
from maxo.routing.interfaces import BaseRouter
from maxo.routing.middlewares.update_context import UPDATE_CONTEXT_KEY
from maxo.types import (
    ErrorEvent,
    Message,
    MessageButton,
    MessageCallback,
    MessageCreated,
    Recipient,
    User,
)


class ManagerImpl(DialogManager):
    def __init__(
        self,
        event: ChatEvent,

@@ -25,7 +25,7 @@ class DialogAction(Enum):
 
 
 class DialogUpdateEvent(BaseUpdate):
-    user: User
+    user: User | None
     recipient: Recipient
     action: DialogAction
 
…[8629 chars omitted]…
ate[Any]]):
             user_id = update.user_id
         elif isinstance(update, DialogUpdateEvent):
             user = update.user
-            user_id = user.id
+            user_id = update.recipient.user_id
+            if user_id is None and user is not None:
+                user_id = user.id
             chat_id = update.recipient.chat_id
             chat_type = update.recipient.chat_type

        """Эмулирует пост в канале: MessageCreated без sender (бот-админ)."""
        message_seq = self._new_message_id()
        msg = Message(
            recipient=Recipient(
                chat_type=ChatType.CHANNEL,
                user_id=self.bot.state.info.user_id,
                chat_id=self.chat.chat_id,
            ),
            timestamp=datetime.fromtimestamp(1234567890, tz=UTC),
            body=MessageBody(
                mid=str(message_seq),
           
…[1983 chars omitted]…
Button,
    ) -> Callback:
        if not button.payload:
            raise ValueError("Button has no callback data")
        return Callback(
            timestamp=datetime.fromtimestamp(1234567890, tz=UTC),
            callback_id=str(uuid.uuid4()),
            payload=button.payload,
            user=self.user,
        )

56:            recipient=Recipient(chat_type=ChatType.CHANNEL, chat_id=-100),

    "
…[4889 chars omitted]…
 "ANN401", # https://docs.astral.sh/ruff/rules/any-type/
    "ASYNC109", # own timeout implementation
    "TC001", # https://docs.astral.sh/ruff/rules/typing-only-first-party-import/
    "TC006", # https://docs.astral.sh/ruff/rules/runtime-cast-value/
    "UP046", # https://docs.astral.sh/ruff/rules/non-pep695-generic-class/
    "UP047", # https://docs.astral.sh/ruff/rules/non-pep695-generic-function/

xo/dialogs/context/intent_middleware.py:134:        user_id = event.user.id
src/maxo/dialogs/context/intent_middleware.py:137:        user=event.user,
src/maxo/dialogs/tools/preview.py:107:            EVENT_FROM_USER_KEY: self._event.user,
src/maxo/dialogs/tools/preview.py:113:                user=self._event.user,
src/maxo/dialogs/tools/preview.py:114:                user_id=self._event.user.user_id,

                # Prefer an exception raised by the notification itself over a
                # result delivered by another part of the event pipeline.
                task.result()
            if event.entered.done():
                manager = event.entered.result()
            else:
                raise DialogsError(
                    "Foreground dialog event was not handled",
                )
        except BaseException:
            if not event.entered.done():
                event.entered.cancel()
            elif no
…[7197 chars omitted]…
   chat=None,
                chat_type=self._event.recipient.chat_type,
                chat_id=self._event.recipient.chat_id,
                user=self._event.user,
                user_id=self._event.user.user_id,
            ),
        }

    async def next(self, show_mode: ShowMode | None = None) -> None:
        assert self._dialog is not None  # noqa: S101
        states = self._dialog.states()

src/
…[6962 chars omitted]…
e NoContextError
src/maxo/dialogs/manager/manager.py:253:            raise ValueError(f"Unknown start mode: {mode}")
src/maxo/dialogs/manager/manager.py:292:                raise ValueError(
src/maxo/dialogs/manager/manager.py:331:            raise ValueError(
src/maxo/dialogs/manager/manager.py:346:            raise ValueError(
234:    "TRY003", # https://docs.astral.sh/ruff/rules/raise-vanilla-args/

     data: Any
diff --git a/src/maxo/dialogs/api/protocols/manager.py b/src/maxo/dialogs/api/protocols/manager.py
index 8eb6755..da6a67d 100644
--- a/src/maxo/dialogs/api/protocols/manager.py
+++ b/src/maxo/dialogs/api/protocols/manager.py
@@ -86,7 +86,7 @@ class BgManagerFactory(Protocol):
     def bg(
         self,
         bot: Bot,
-        user_id: int,
+        user_id: int | None,
         chat_id: int,
         stack_id: str | None = None,
         load: bool = Fals
…[8629 chars omitted]…
_id = update.recipient.chat_id
             chat_type = update.recipient.chat_type
 
 M src/maxo/dialogs/api/entities/update_event.py
 M src/maxo/dialogs/api/protocols/manager.py
 M src/maxo/dialogs/context/intent_middleware.py
 M src/maxo/dialogs/manager/bg_manager.py
 M src/maxo/dialogs/manager/manager.py
 M src/maxo/dialogs/manager/update_handler.py
 M src/maxo/routing/middlewares/update_context.py

            update=MaxoUpdate(update=inner),
        )
        manager = make_manager(event=error_event)
    
>       assert manager._get_fake_user() is inner.callback.us
…[1593 chars omitted]…
me.timezone.utc), last_name=<Omitted>, name=<Omitted>), payload='p'), message=None, user_locale=<Omitted>).callback

tests/maxo_dialog/manager/test_manager_impl.py:475: AssertionError
=========================== short test summary info ============================
FAILED tests/maxo_dialog/manager/test_manager_impl.py::TestBackground::test_get_fake_user_unwraps_error_event
1 failed, 176 passed in 3.79s

336-        ctx[EVENT_CONTEXT_KEY] = event_context
337-
338-        try:
339-            if update.intent_id:
340-                await self._load_context_by_intent(
341-                    event=update,
342-                    proxy=self.storage_proxy(event_context, ctx[FSM_STORAGE_KEY]),
343-                    intent_id=update.intent_id,
344-                    ctx=ctx,
345-                )
346-            else:
347-                await self._load_context_b
…[1279 chars omitted]…
 next(ctx)
378-
379-        event_context = event_context_from_callback(update, ctx)
 M src/maxo/dialogs/api/entities/update_event.py
 M src/maxo/dialogs/api/protocols/manager.py
 M src/maxo/dialogs/context/intent_middleware.py
 M src/maxo/dialogs/manager/bg_manager.py
 M src/maxo/dialogs/manager/manager.py
 M src/maxo/dialogs/manager/update_handler.py
 M src/maxo/routing/middlewares/update_context.py

        fake_user = User(
            user_id=1,
            is_bot=False,
            first_name="Fake",
            last_activity_time=FAKE_TIME,
        )
        self._event = DialogUpdateEvent(
            user=fake_user,
            recipient=Recipient(chat_type=ChatType.DIALOG, user_id=1),
            bot=Bot("", warming_up=False),
            action=DialogAction.UPDATE,
            data={},
            intent_id=None,
         
…[983 chars omitted]…
_context().state)
        if current_index + 1 >= len(states):
            raise ValueError(
                f"Cannot go to a non-existent state."
                f"The state of {current_index + 1} idx is requested, "
                f"but there are only {len(states)} states"
                f"current state is {self.current_context().state}",
            )
        new_state = states[current_index + 1]

   247	            entered=loop.create_future(),
   248	            exited=loop.create_future(),
   249	            **self._base_event_params(),
   250	        )
   251	        bot = self._event_context.bot
   252	        task = asyncio.ensure_future(
   253	            self._updater.notify_task(bot=bot, update=event),
   254	        )
   255	
   256	        try:
   257	            done, _ = await asyncio.wait(
   258	                (event.entered, task)
…[6847 chars omitted]…
context/storage.py            |   2 +-
 src/maxo/dialogs/manager/bg_manager.py         | 127 ++++++++++++++++++-------
 src/maxo/dialogs/manager/manager.py            |  27 ++++--
 src/maxo/dialogs/manager/update_handler.py     |   4 +
 src/maxo/dialogs/tools/preview.py              |  19 ++--
 src/maxo/routing/middlewares/update_context.py |   2 +-
 9 files changed, 170 insertions(+), 69 deletions(-)

 
diff --git a/src/maxo/dialogs/manager/bg_manager.py b/src/maxo/dialogs/manager/bg_manager.py
index d98335d..fca67c2 100644
--- a/src/maxo/dialogs/manager/bg_manager.py
+++ b/src/maxo/dialogs/manager/bg_manager.py
@@ -19,6 +19,7 @@ from maxo.dialogs.api.entities import (
     StartMode,
 )
 from maxo.dialogs.api.e
…[8628 chars omitted]…
ONTEXT_KEY: EventContext(
                 bot=self._event.bot,
                 chat=None,
                 chat_type=self._event.recipient.chat_type,
                 chat_id=self._event.recipient.chat_id,
-                user=self._event.user,
-                user_id=self._event.user.user_id,
+                user=fake_user,
+                user_id=fake_user.user_id,
             ),
         }

tests/maxo_dialog/test_fg.py:182:    stranger = bg_factory.bg(
tests/maxo_dialog/test_fg.py:189:    owner = bg_factory.bg(client.bot, user_id=1, chat_id=-1, stack_id=SHARED_STACK_ID)
tests/maxo_dialog/test_fg.py:204:    stranger = bg_factory.bg(

213 passed in 3.49s

 
 from .access import AccessSettings
 from .modes import ShowMode, StartMode
 
 if TYPE_CHECKING:
     from maxo.dialogs.api.protocols.manager import DialogManager
 
 
 DIALOG_EVENT_NAME = "aiogd_update"
 
 
 class DialogAction(Enum):
     DONE = "DONE"
     START = "START"
     UPDATE = "UPDATE"
     SWITCH = "SWITCH"
     FG = "FG"
 
 
 class DialogUpdateEvent(BaseUpdate):
-    user: User
+    user: User | None
     recipient: Recipient

…[8630 chars omitted]…
_id
             chat_id = update.recipient.chat_id
             chat_type = update.recipient.chat_type
 
         update_context = UpdateContext(
             chat_id=chat_id,
             user_id=user_id,
             type=chat_type,
             user=user,
         )
         if do_enrich and "bot" in ctx:
             await self._enrich_context(ctx, update_context)
 
         return update_context

    def dialog(self) -> DialogProtocol:
        self.check_disabled()
        current = self.current_context()
        return self._registry.find_dialog(current.state)

    def current_context(self) -> Context:
        self.check_disabled()
        context = self._current_context_unsafe()
        if not context:
            loggers.dialogs.warning(
                "Trying to access current context, while no dialog is opened",
            )
            raise NoContextError
        return context

    def _current_context_unsafe(self) -> Context | None:
        return self._ctx.get(CONT
…[1096 chars omitted]…
79-        self.message_manager = message_manager
80-        self.media_id_storage = media_id_storage
81-        self._event = event
82-        self._ctx = ctx
623:    async def close_manager(self) -> None:
624-        self.check_disabled()
625-        self.disabled = True
626-        del self.media_id_storage
627-        del self.message_manager
628-        del self._event
629-        # del self._ctx

src/maxo/dialogs/manager/bg_manager.py:64:    def _get_fake_user(self, user_id: int | None = None) -> User | None:
src/maxo/dialogs/manager/bg_manager.py:77:        user_id: int | None = None,
src/maxo/dialogs/manager/bg_manager.py:320:        user_id: 
…[7340 chars omitted]…
event)

    async def _load(self) -> None:
        if not self.load:
            return

        user = self._event_context.user
        user_id = self._event_context.user_id
        if user is None or user_id is None:
            loggers.dialogs.debug(
                "cannot load user: user information is unknown",
            )
            return

        if is_user_loaded(user):
            return

max-swagger.json
noxfile.py
pyproject.toml
src
tests
22019a6 base
.
./.agents
./.agents/skills
./.claude
./.git
./.git/branches
./.git/hooks
./.git/info
./.git/logs
./.git/objects
./.git/refs
./.github
./.github/ISSUE_TEMPLATE
./.github/workflows
./butcher
./butcher/render
./butcher/tests
./docs
./docs/pages
./docs/_extra
./docs/_static
./examples
./examples/files
./examples/mega
./examples/multi_file_bot
./examples/tg_max_one_fsm
./src
./src/maxo
./tests
./tests/maxo
./tests/maxo_dialog
./tests/maxo_webhook

src/maxo/dialogs/api/entities/update_event.py
src/maxo/dialogs/api/exceptions.py
src/maxo/dialogs/api/internal/__init__.py
src/maxo/dialogs/api/internal/fake_data.py
src/maxo/dialogs/api/internal/manager.py
src/maxo/dialogs/api/internal/middleware.py
src/maxo/dialogs/api/internal/widgets.py
src/maxo/dialogs/api/internal/window.py
src/maxo/dialogs/api/protocols/__init__.py
src/maxo/dialogs/api/protocols/dialog.py
src
…[7233 chars omitted]…
xo_dialog/widgets/text/__init__.py
tests/maxo_dialog/widgets/text/test_base.py
tests/maxo_dialog/widgets/text/test_case.py
tests/maxo_dialog/widgets/text/test_format.py
tests/maxo_dialog/widgets/text/test_jinja.py
tests/maxo_dialog/widgets/text/test_list.py
tests/maxo_dialog/widgets/text/test_multi.py
tests/maxo_dialog/widgets/text/test_progress.py
tests/maxo_dialog/widgets/text/test_scrolling_text.py

    ChatEvent,
    Context,
    Data,
    EventContext,
    LaunchMode,
    NewMessage,
    OldMessage,
    ShowMode,
    Stack,
    StartMode,
    UnknownText,
)
from maxo.dialogs.api.exceptions import (
    IncorrectBackgroundError,
    InvalidKeyboardType,
    NoContextError,
)
from maxo.dialogs.api.internal import (
    CONTEXT_KEY,
    EVENT_SIMULATED,
    STACK_KEY,
    STORAGE_KEY,
    DataGetter,
    FakeUser,
    Widget,
)
from maxo.dialogs.api.internal.fake_data import FakeChat
from maxo.dialogs.api.protocols import (
    BaseDialogManager,

…[8628 chars omitted]…
show()

    async def _process_launch_mode(
        self,
        old_dialog: DialogProtocol | None,
        new_dialog: DialogProtocol,
    ) -> None:
        if new_dialog.launch_mode in (LaunchMode.EXCLUSIVE, LaunchMode.ROOT):
            await self.reset_stack(remove_keyboard=False)
        if new_dialog.launch_mode is LaunchMode.SINGLE_TOP:  # noqa: SIM102
            if new_dialog is old_dialog:

    from maxo.dialogs.api.protocols.manager import DialogManager


DIALOG_EVENT_NAME = "aiogd_update"


class DialogAction(Enum):
    DONE = "DONE"
    START = "START"
    UPDATE = "UPDATE"
    SWITCH = "SWITCH"
    FG = "FG"


class DialogUpdateEvent(BaseUpdate):
    user: User
    recipient: Recipient
    action: DialogAction
    data: Any
    intent_id: str | None
    stack_id: str | None
    show_mode: ShowMode | None = None
    bot: Bot  # type: ignore[override]

    # Для частичной совместимости с `MaxUpdate`
    @property
    def event_type(self) -> str:
        return DIALOG_EVENT_NAME


class DialogS
…[1677 chars omitted]…
logsError):
    pass


class NoContextError(DialogsError):
    pass


# navigation
class UnregisteredDialogError(DialogsError):
    pass


class UnregisteredWindowError(DialogsError):
    pass


# widgets
class InvalidWidgetIdError(DialogsError):
    pass


class InvalidWidget(DialogsError):
    pass


class InvalidWidgetType(InvalidWidget):
    pass


class InvalidKeyboardType(DialogsError):
    pass

            recipient=Recipient(
                user_id=event.callback.user.user_id,
                chat_id=None,
                chat_type=ChatType.CHAT,  # TODO: Узнать тип чата?
            ),
            message_id=stack.last_message_id,
            sequence_id=stack.last_sequence_id or 0,
            attachments=stack.last_attachments,
        )

    def _get_last_message(self) -> OldMessag
…[4939 chars omitted]…
d=load,
            chat_type=new_event_context.chat_type or ChatType.CHAT,
        )

    @asynccontextmanager
    async def fg(self) -> AsyncIterator[DialogManager]:
        yield self

    async def close_manager(self) -> None:
        self.check_disabled()
        self.disabled = True
        del self.media_id_storage
        del self.message_manager
        del self._event
        # del self._ctx

class DefaultManagerFactory(DialogManagerFactory):
    def __init__(
        self,
        message_manager: MessageManagerProtocol,
        media_id_storage: MediaIdStorageProtocol,
        getter: DataGetter | None,
    ) -> None:
        self.message_manager = message_manager
        self.media_id_storage = media_id_storage
        self.getter = getter

    def __call__(
        self,
        event: ChatEvent,
        ctx: Ctx,
        registry: DialogRegistryProtocol,
        router: BaseRouter,
    ) -> DialogManager:

…[6605 chars omitted]…
: int | None = None,
        chat_id: int | None = None,
        stack_id: str | None = None,
        load: bool = False,
    ) -> BaseDialogManager:
        return self.manager.bg(
            user_id=user_id,
            chat_id=chat_id,
            stack_id=stack_id,
            load=load,
        )

    @asynccontextmanager
    async def fg(self) -> AsyncIterator[DialogManager]:
        yield self

    DialogUpdateEvent,
    ShowMode,
    StartMode,
)
from maxo.dialogs.api.internal import FakeUser
from maxo.dialogs.manager.bg_manager import BgManager, BgManagerFactoryImpl
from maxo.dialogs.manager.updater import Updater
from maxo.enums import ChatType
from maxo.fsm import State, StatesGroup
from maxo.types import Chat, ChatMembersList, User
from tests.constants import NOW


class SG(StatesGroup):
    first = State()


def real_user(user_id: int = 7) -> User:
    return User(
        user_id=user_id,
        is_bot=False,
        first_name="Real",
        last_activity_time=NOW,
    )


def fake_user(user_id: int = 7) -> Fa
…[7514 chars omitted]…
stance(manager, BgManager)
        assert manager.stack_id == DEFAULT_STACK_ID
        assert manager._event_context.chat_id == 6

    def test_keeps_explicit_stack_id(self) -> None:
        factory = BgManagerFactoryImpl(Dispatcher())

        manager = factory.bg(bot=MagicMock(), user_id=5, chat_id=6, stack_id="s")

        assert isinstance(manager, BgManager)
        assert manager.stack_id == "s"

from maxo.dialogs.api.entities.update_event import DialogFgEvent
from maxo.dialogs.api.exceptions import (
    InvalidStackIdError,
    OutdatedIntent,
    StackAccessDeniedError,
    UnknownIntent,
    UnknownState,
)
from maxo.dialogs.api.internal import (
    CALLBACK_DATA_KEY,
    CONTEXT_KEY,
    PAYLOAD_KEY,
    STACK_KEY,
    STORAGE_KEY,
)
from maxo.dialogs.api.protocols import DialogRegistryProtocol, StackAccessValidator
from maxo.dialogs.context.storage import StorageProxy
from maxo.dialogs.utils import remove_intent_id
from maxo.enums import ChatType
from maxo.fsm.storages.base import BaseEventIsolation, BaseStorage
from maxo.routing.ctx import Ctx
from ma
…[8630 chars omitted]…
   events_isolation = _prepare_events_isolation(events_isolation)
    bg_manager_factory = BgManagerFactoryImpl(router)
    _register_middleware(
        router=router,
        dialog_manager_factory=dialog_manager_factory,
        bg_manager_factory=bg_manager_factory,
        stack_access_validator=stack_access_validator,
        events_isolation=events_isolation,
    )
    return bg_manager_factory

342:        if ctx.get(FORBIDDEN_STACK_KEY):
343:            if isinstance(update, DialogFgEvent):
344:                update.entered.set_exception(
362:        ctx[EVENT_CONTEXT_KEY] = event_context
379:        if result is UNHANDLED and ctx.get(FORBIDDEN_STACK_KEY):
394:        ctx[EVENT_CONTEXT_KE
…[8628 chars omitted]…
date, ctx)
        ctx[EVENT_CONTEXT_KEY] = event_context
        await self._load_default_context(update, ctx, event_context)
        return await next(ctx)

    async def process_user_added_to_chat(
        self,
        update: UserAddedToChat,
        ctx: Ctx,
        next: NextMiddleware[UserAddedToChat],
    ) -> Any:
        if UPDATE_CONTEXT_KEY not in ctx:
            return await next(ctx)

            intent_id,
            proxy.user_id,
            proxy.chat_id,
        )
        context = await proxy.load_context(intent_id)
        stack = await self._load_stack(context.stack_id, proxy)
        if not stack:
            return
        try:
            self._check_outdated(intent_id, stack)
        except:
            await proxy.unlock()
            raise

        if not await self.access_validator.is_allowed(
            stack,
            context,
            event,
            ctx,
        ):
            loggers.dialogs.debug(
       
…[6487 chars omitted]…
are.
                # Иначе параллельный апдейт того же пользователя захватит лок
                # и прочитает ещё не сохранённые context/stack.
                context = ctx.get(CONTEXT_KEY)
                if context is not None:
                    await stored_proxy.save_context(context)
                await stored_proxy.save_stack(ctx.get(STACK_KEY))
                await stored_proxy.unlock()

from maxo.types import Attachments

_retort = create_retort(warming_up=False)


class StorageProxy:
    def __init__(
        self,
        storage: BaseStorage,
        events_isolation: BaseEventIsolation,
        user_id: int | None,
        chat_id: int | None,
        chat_type: ChatType | None,
        bot: Bot,
        state_groups: dict[str, type[StatesGroup]],
    ) -> None:
        self.storage =
…[5184 chars omitted]…
gs(
            user_ids=raw.get("user_ids") or [],
            custom=raw.get("custom"),
        )

    def _dump_access_settings(
        self,
        access_settings: AccessSettings | None,
    ) -> dict[Any, Any] | None:
        if not access_settings:
            return None
        return {
            "user_ids": access_settings.user_ids,
            "custom": access_settings.custom,
        }

        chat_type: Тип чата:
             - `chat` - групповой чат
             - `channel` - канал или комментарий к посту (для вызовов методов группы `/comments`)
             - `dialog` - диалог
        post_id: Идентификатор поста в канале, к которому оставлен комментарий
        user_id: ID получателя сообщения в диалоге (пользователя или бота). Если сообщение отправлено в групповой чат или канал, то параметр отсутствует
    """

    chat_type: ChatType
    """
    Тип 
…[8629 chars omitted]…
safe_name(self) -> str:
        if is_defined(self.name):
            return self.name

        raise AttributeIsEmptyError(
            obj=self,
            attr="name",
        )

    @property
    def unsafe_username(self) -> str:
        if is_defined(self.username):
            return self.username

        raise AttributeIsEmptyError(
            obj=self,
            attr="username",
        )

from maxo.types.simple_query_result import SimpleQueryResult
from maxo.utils.helpers.calculating import calculate_chat_id_and_user_id

if TYPE_CHECKING:
    from maxo.types.message import Message


class MessageMethodsFacade(ChatMethodsFacade):
    __slots__ = ()

    if TYPE_CHECKING:

        @property
        @abstractmethod
        def message(self) -> "Mes
…[8280 chars omitted]…
ogs/test_tools/bot_client.py:262:                    user=self.user,
src/maxo/dialogs/test_tools/bot_client.py:275:                    user=self.user,
src/maxo/dialogs/tools/preview.py:107:            EVENT_FROM_USER_KEY: self._event.user,
src/maxo/dialogs/tools/preview.py:113:                user=self._event.user,
src/maxo/dialogs/tools/preview.py:114:                user_id=self._event.user.user_id,

class _MaxoTypeMetaClass(type):
    def __new__(
        cls,
        name: str,
        bases: tuple[Any, ...],
        namespace: dict[str, Any],
        slots: bool = True,
        **kwargs: Any,
    ) -> Any:
        class_ = super().__new__(cls, name, bases, namespace, **kwargs)
        if "__slots__" in namespace:
            return class_

        return dataclass(
            slots=slots,
            frozen=False,
            kw_only=True,
        )(class_)


class BaseMaxoType(metaclass=_MaxoTypeMetaClass):
    pass


# TODO: `MaxoType` наследует `BaseMethodsFacade` только ради слота 
…[1237 chars omitted]…
pe
src/maxo/dialogs/api/internal/fake_data.py:25:class FakeChat(Chat):
src/maxo/dialogs/api/entities/media.py:11:    def __eq__(self, other: object) -> bool:
src/maxo/dialogs/api/entities/media.py:51:    def __eq__(self, other: object) -> bool:
src/maxo/dialogs/test_tools/bot_client.py:58:    def __eq__(self, other: object) -> bool:
src/maxo/fsm/state.py:82:    def __eq__(self, other: object) -> bool:

    Stack,
    StartMode,
)
from maxo.enums import ChatType
from maxo.fsm import State

if TYPE_CHECKING:
    from maxo.dialogs.api.internal.widgets import Widget


class UnsetId(Enum):
    UNSET = "UNSET"


class BaseDialogManager(Protocol):
    @abstractmethod
    async def done(
        self,
        result: Any = None,
        show_mode: ShowMode | None = None,
    ) -> None:
        """Закрыть текущий диалог и показать нижележащий в стеке."""
        raise NotImplementedError

    @abstractmethod
    async def start(
        self,
        state: State,
        data: Data = None,
        mo
…[6818 chars omitted]…
 "GROUP_STACK_ID",
    "AccessSettings",
    "ChatEvent",
    "Context",
    "Data",
    "DialogAction",
    "DialogStartEvent",
    "DialogSwitchEvent",
    "DialogUpdateEvent",
    "EventContext",
    "LaunchMode",
    "LinkPreviewOptions",
    "MarkupVariant",
    "MediaAttachment",
    "MediaId",
    "NewMessage",
    "OldMessage",
    "ShowMode",
    "Stack",
    "StartMode",
    "UnknownText",
)

462:    def test_get_fake_user_for_other_id(self) -> None:
463:        user = make_manager().bg(user_id=42)
467:    def test_get_fake_user_unwraps_error_event(self) -> None:
475:        assert m
…[5882 chars omitted]…
led is True

    async def test_fg_returns_self(self) -> None:
        manager = make_manager()

        async with manager.fg() as fg:
            assert fg is manager


class TestNavigation:
    async def test_next(self) -> None:
        manager = make_manager()
        registry(manager).find_dialog.return_value = MagicMock(
            states=MagicMock(return_value=[SG.first, SG.second]),
        )

        assert manager._calc_show_mode() is ShowMode.EDIT

    def test_message_created_sends(self) -> None:
        assert make_manager()._calc_show_mode() is ShowMode.SEND

    def test_callback_edits(self) -> None:
        assert make_manager(event=make_callback())._calc_show_mode() is ShowMode.EDIT


class TestLastMessage:
    def test_save_and_restore_last_message(self) -> None:
        stack = Stack(_id=DEFAUL
…[4622 chars omitted]…
idget_data: WidgetData = {} if widget_data is None else widget_data

    def is_preview(self) -> bool:
        return self._preview

    def current_context(self) -> Context:
        return Context(
            dialog_data={},
            start_data={},
            widget_data=self.widget_data,
            state=State(),
            _stack_id="_stack_id",
            _intent_id="_intent_id",
        )

tests/maxo/bot/test_bot.py:154:            assert entered is bot
tests/maxo/fsm/storages/test_memory.py:88:    entered = False
tests/maxo/fsm/stora
…[3498 chars omitted]…
ler.py:29:    elif isinstance(event, DialogFgEvent):
src/maxo/dialogs/manager/update_handler.py:30:        event.entered.set_result(dialog_manager)
src/maxo/dialogs/manager/update_handler.py:31:        await event.exited
src/maxo/dialogs/setup.py:10:from maxo.dialogs.api.entities.update_event import DialogFgEvent
src/maxo/dialogs/setup.py:50:    router.observers[DialogFgEvent] = dialog_events_observer

    ShowMode,
    StartMode,
)
from maxo.dialogs.api.entities.update_event import DialogFgEvent
from maxo.dialogs.api.protocols import DialogManager
from maxo.dialogs.manager.update_handler import handle_aiogd_update
from maxo.fsm.state import State, StatesGroup


class TestStates(StatesGroup):
    first = State()
    second = State()


@pytest.fixture
def mock_dialog_manager() -> MagicMock:
    manager = MagicMock(spec=DialogManager)
    manager.start = AsyncMock()
    manager.switch_to = AsyncMock()
    manager.show = AsyncMock()
    manager.done = AsyncMock()
    manager.has_context = Mock(return_value=True)

    context = Context(
…[7338 chars omitted]…
artup_callback(
    registry: DialogRegistry,
) -> Callable[..., Any]:
    async def _setup_dialogs(ctx: Ctx) -> None:
        registry.refresh()

    return _setup_dialogs


def _register_middleware(
    router: Router,
    dialog_manager_factory: DialogManagerFactory,
    bg_manager_factory: BgManagerFactory,
    stack_access_validator: StackAccessValidator,
    events_isolation: BaseEventIsolation,

from maxo.routing.flags import HANDLER_KEY
from maxo.routing.middlewares.error import ErrorMiddleware
from maxo.routing.middlewares.fsm_context import FSMContextMiddleware
from maxo.routing.middlewares.update_context import UpdateContextMiddleware
from maxo.routing.observers import UpdateObserver
from maxo.routing.routers.simple impor
…[5691 chars omitted]…
x_copy.pop(HANDLER_KEY, None)

        result = await self.trigger(ctx_copy)
        if result is UNHANDLED:
            raise SkipHandler

        return result

    async def _emit_before_startup_handler(self) -> None:
        validate_router_graph(self)
        resolve_middlewares(self)

        await super()._emit_before_startup_handler()
src/maxo/routing/dispatcher.py:26:class Dispatcher(Router):

    def __init__(self, router: BaseRouter) -> None:
        self._router = router

    async def __call__(self, update: Any, ctx: Ctx, next: NextMiddleware[Any]) -> Any:
        try:
            return await next(ctx)
        except (SkipHandler, CancelHandler):  # pragma: no cover
            raise
        except Exception as exception:
            exception_event = ErrorEvent(
                exception=exception,
                update=update,
            ).as_(ctx.get("bot"))
            new_ctx = Ctx(dic
…[398 chars omitted]…
rt BaseUpdate

_UpdateT = TypeVar("_UpdateT", bound=BaseUpdate)
_ExceptionT = TypeVar("_ExceptionT", bound=Exception)


class ErrorEvent(BaseUpdate, Generic[_ExceptionT, _UpdateT]):
    exception: _ExceptionT
    update: MaxoUpdate[_UpdateT]

    @property
    def error(self) -> _ExceptionT:
        return self.exception

    @property
    def event(self) -> _UpdateT:
        return self.update.update

/manager/manager.py:528:        if user_id is None or user_id == current_user.id:
src/maxo/dialogs/manager/manager.py:579:            user_id=user.id,
src/maxo/dialogs/tools/preview.py:107:            EVENT_FROM_USER_KEY: self._event.user,
src/maxo/dialogs/tools/preview.py:113:                user=self._event.user,
src/maxo/dialogs/tools/preview.py:114:                user_id=self._event.user.user_id,

524:            current_user = event.message.unsafe_sender
526:            current_user = event.user
528:        if user_id is None or user_id == current_user.id:
531:            user_id=user_id,
564:        user_id: int | None = None,
569:        use
…[8629 chars omitted]…
:
        if self._need_two_step_media_edit(new_message, old_message):
            await self._edit(bot, new_message, old_message, media=[])
        await self._edit(bot, new_message, old_message, media=new_message.media)
        message = await bot.get_message_by_id(message_id=old_message.message_id)
        await self._save_media_ids(new_message, message)
        return message

    async def _edit(

            if new_message.show_mode is ShowMode.AUTO:
                new_message.show_mode = self._calc_show_mode()

            await self._load_cached_media(new_message)

            self._ensure_stack_compatible(stack, new_message)

            try:
                sent_message = await self.message_manager.show_message(
                    bot,
                    new_mes
…[6799 chars omitted]…
ld_message: OldMessage | None,
    ) -> None:
        if not old_message or old_message.keyboard is None:
            return
        loggers.dialogs.debug("remove_inline_kbd in %s", old_message.recipient)
        try:
            new_attachments = [
                attach.to_request()
                for attach in old_message.attachments
                if attach.type != AttachmentType.INLINE_KEYBOARD

    InlineKeyboardAttachment,
    MaxoType,
    MediaAttachments,
    NewMessageLink,
    Recipient,
)

MarkupVariant = list[list[InlineButtons]]


class UnknownText(Enum):
    UNKNOWN = object()


class OldMessage(MaxoType):
    recipient: Recipient
    message_id: str
    sequence_id: int
    text: str | None | UnknownText
    attachments: list[Attachments]

    @property
    def keyboard(self) -> MarkupVarian
…[877 chars omitted]…
er(self, manager: DialogManager) -> NewMessage:
src/maxo/dialogs/window.py:69:    async def render_text(
src/maxo/dialogs/window.py:76:    async def render_media(
src/maxo/dialogs/window.py:85:    async def render_kbd(
src/maxo/dialogs/window.py:97:    async def render_link_preview(
src/maxo/dialogs/window.py:144:    async def render(
src/maxo/dialogs/window.py:167:                recipient=Recipient(

            current_data = await self.load_data(dialog, manager)
        except Exception:
            loggers.dialogs.exception("Cannot get window data for state %s", self.state)
            raise
        try:
            media = await self.render_media(current_data, manager)

            keyboard: MarkupVariant | None = await self.render_kbd(
                current_data,
                manager,
            )
            if keyboard is not None and not any(row for row in keyboard):
                
…[5643 chars omitted]…
tachmentType.IMAGE:
            return PhotoAttachmentRequest.factory(token=token, url=url)
        assert token is not None  # noqa: S101
        if media.type == AttachmentType.VIDEO:
            return VideoAttachmentRequest.factory(token=token)
        if media.type == AttachmentType.AUDIO:
            return AudioAttachmentRequest.factory(token=token)
        if media.type == AttachmentType.FILE:

    async def send_message(self, bot: Bot, new_message: NewMessage) -> Message:
        if new_message.link_preview_options:
            disable_link_preview = new_message.link_preview_options.is_disabled
        else:
            disable_link_preview = Omitted()

        attachments = await self._build_attachments(
            bot,
            new_message.keyboard,
            new_message.media,
        )
        recipient = new_message.recipient
        chat_id = Omitted() if recipient.chat_id is None else recipient.chat_id
…[461 chars omitted]…
   disable_link_preview=disable_link_preview,
        )
        await self._save_media_ids(new_message, result.message)
        return result.message

    async def _build_attachments(
        self,
        bot: Bot,
        keyboard: Sequence[Sequence[InlineButtons]] | None,
        media: list[MediaAttachment],
    ) -> Sequence[AttachmentsRequests]:
        converted_media = [
            converted

REPLY_CALLBACK_SYMBOLS: str = (
    "\u200c"
    "\u200d"
    "\u2060"
    "\u2061"
    "\u2062"
    "\u2063"
    "\u2064"
    "\u00ad"
    "\U0001d173"
    "\U0001d174"
    "\U0001d175"
    "\U0001d176"
    "\U0001d177"
    "\U0001d178"
    "\U0001d179"
    "\U0001d17a"
)


def _encode_reply_callback_byte(byte: int) -> str:
    return (
        REPLY_CALLBACK_SYMBOLS[byte % len(REPLY_CALLBACK_SYMBOLS)]
        + REPLY_CALLBACK_SYMBOLS[byte // len(REPLY_CALLBACK_SYMBOLS)]
    )


def encode_reply_callback(data: str) -> str:
    bytes_data = data.encode("utf-8")
    return "".join(_encode_reply_callback_byte(byte) f
…[3792 chars omitted]…
maxo_dialog/test_utils.py:13:    is_user_loaded,
tests/maxo_dialog/test_utils.py:42:def test_is_user_loaded() -> None:
tests/maxo_dialog/test_utils.py:43:    assert is_user_loaded(
tests/maxo_dialog/test_utils.py:51:    assert not is_user_loaded(
tests/maxo_dialog/test_utils.py:125:    assert is_user_loaded(user) is True
tests/maxo_dialog/test_utils.py:126:    assert is_user_loaded(fake_user) is False

    Data,
    DialogAction,
    DialogStartEvent,
    DialogSwitchEvent,
    DialogUpdateEvent,
    EventContext,
    ShowMode,
    StartMode,
)
from maxo.dialogs.api.entities.update_event import DialogFgEvent
from maxo.dialogs.api.exceptions import DialogsError
from maxo.dialogs.api.internal import FakeUser
from maxo.dialogs.api.protocols import BaseDialogManager, BgManagerFactory
from maxo.dialogs.manager.updater import Updater
from maxo.dialogs.utils import is_user_loaded
from maxo.enums import ChatType
from maxo.fsm import State
from maxo.types im
…[4616 chars omitted]…
TC),
            )
            if user_id is not None
            else None
        )
        if stack_id is None:
            stack_id = DEFAULT_STACK_ID

        return BgManager(
            user=user,
            chat_id=chat_id,
            bot=bot,
            dp=self._dp,
            intent_id=None,
            stack_id=stack_id,
            load=load,
            chat_type=chat_type,
        )

            chat_id=chat_id,
            user_id=user_id,
            chat_type=self._event_context.chat_type,
            chat=None,
        )
        if stack_id is None:
            if self._event_context == new_event_context:
                stack_id = self.stack_id
                intent_id = self.intent_id
            else:
                stack_id = DEFAULT_STACK_ID
                intent_id = None
        else:
            intent_id = None

        return BgManager(
            user=user,
            chat_id=new_event_context.chat_id,
    
…[617 chars omitted]…
 "bot": self._event_context.bot,
            "intent_id": self.intent_id,
            "stack_id": self.stack_id,
        }

    async def _notify(self, event: DialogUpdateEvent) -> None:
        bot = self._event_context.bot
        await self._updater.notify(bot=bot, update=event)

    async def _load(self) -> None:
        if not self.load:
            return

        user = self._event_context.user

src/maxo/dialogs/api/protocols/manager.py:89:        user_id: int | None,

        )
        manager = make_manager(event=error_event)
    
>       assert manager._get_fake_user() is inner.callback.user
E       AssertionError: assert User(first_name='U', is_bot=False, user_id=1, 
…[1513 chars omitted]…
me.timezone.utc), last_name=<Omitted>, name=<Omitted>), payload='p'), message=None, user_locale=<Omitted>).callback

tests/maxo_dialog/manager/test_manager_impl.py:475: AssertionError
=========================== short test summary info ============================
FAILED tests/maxo_dialog/manager/test_manager_impl.py::TestBackground::test_get_fake_user_unwraps_error_event
1 failed, 104 passed in 4.04s

    BotInfo,
    Callback,
    CallbackButton,
    Chat,
    LinkedMessage,
    Message,
    MessageBody,
    MessageCallback,
    MessageCreated,
    MessageEdited,
    MessageRemoved,
    MessageStat,
    Recipient,
    SimpleQueryResult,
    User,
    UserAddedToChat,
)

from .keyboard import InlineButtonLocator


class FakeBot(Bot):
    def __init__(self) -> None:
        super().__init__("", warming_up=False)
        info = BotInfo(
            user_id=1000,
            first_name="bot",
            userna
…[7489 chars omitted]…
    return await self.dp.feed_update(
            MaxoUpdate(
                update=BotAddedToChat(
                    chat_id=self.chat.chat_id,
                    is_channel=self.chat.type == ChatType.CHANNEL,
                    user=self.user,
                    timestamp=datetime.fromtimestamp(1234567890, tz=UTC),
                ).as_(self.bot),
            ),
            self.bot,
        )

  File "/tmp/repro_channel.py", line 34, in main
    dp.message_created.handler(start)
  File "/repo/src/maxo/routing/observers/update.py", line 28, in handler
    self.state.ensure_add_handler()
  File "/repo/src/maxo/routing/observers/state.py", line 15, in ensure_add_handler
    raise StateError("Can't add handler after startup")
maxo.errors.state.StateError: Can't add handler after startup

    return await middleware(ctx["update"], ctx, next)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File
…[427 chars omitted]…
olve_update_context(
                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/maxo/routing/middlewares/update_context.py", line 189, in _resolve_update_context
    user_id = user.id
              ^^^^^^^
AttributeError: 'NoneType' object has no attribute 'id'
messages after start ['stub']
bg user None user_id None stack 
messages after switch ['stub']
messages after bg start ['stub']

from maxo.types.bot_stopped import BotStopped
from maxo.types.chat_title_changed import ChatTitleChanged
from maxo.types.comment_created import CommentCreated
from maxo.types.comment_edited import CommentEdited
from maxo.types.comment_removed import CommentRemoved
from maxo.types.dialog_cleared import DialogCleared
from maxo.types.dialog_muted import DialogMuted
from maxo.types.dialog_removed import DialogRemoved
fro
…[6135 chars omitted]…
ser_id = user.id
            chat_id = update.recipient.chat_id
            chat_type = update.recipient.chat_type

        update_context = UpdateContext(
            chat_id=chat_id,
            user_id=user_id,
            type=chat_type,
            user=user,
        )
        if do_enrich and "bot" in ctx:
            await self._enrich_context(ctx, update_context)

        return update_context

tests/maxo_dialog/widgets/text/test_case.py:4: in <module>
    from magic_filter import F
E   ModuleNotFoundError: No module named 'magic_filter'
_________ ERROR collecting 
…[2501 chars omitted]…
/maxo_dialog/widgets/test_common.py
ERROR tests/maxo_dialog/widgets/test_filter_object.py
ERROR tests/maxo_dialog/widgets/test_link_preview.py
ERROR tests/maxo_dialog/widgets/text/test_base.py
ERROR tests/maxo_dialog/widgets/text/test_case.py
ERROR tests/maxo_webhook/test_fastapi_adapter.py
!!!!!!!!!!!!!!!!!!! Interrupted: 14 errors during collection !!!!!!!!!!!!!!!!!!!
4 warnings, 14 errors in 15.27s

…[981 chars omitted]…
est_transitions.py:203
  /repo/tests/maxo_dialog/test_transitions.py:203: PytestUnknownMarkWarning: Unknown pytest.mark.flaky - is this a typo?  You can register custom marks to avoid this warning - for details, see https://docs.pytest.org/en/stable/how-to/mark.html
    @pytest.mark.flaky(reruns=2)

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
718 passed, 4 warnings in 8.17s

@@ -25,7 +25,7 @@ class DialogAction(Enum):
 
 
 class DialogUpdateEvent(BaseUpdate):
-    user: User
+    user: User | None
     recipient: Recipient
     action: DialogAction
    
…[8629 chars omitted]…
 @@ class UpdateContextMiddleware(BaseMiddleware[MaxoUpdate[Any]]):
             user_id = update.user_id
         elif isinstance(update, DialogUpdateEvent):
             user = update.user
-            user_id = user.id
+            user_id = user.id if user is not None else update.recipient.user_id
             chat_id = update.recipient.chat_id
             chat_type = update.recipient.chat_type

        data: dict[Any, Any] | None = None,
        show_mode: ShowMode | None = None,
    ) -> None:
        pass

    def bg(
        self,
        user_id: int | None = None,
        chat_id: int | None = None,
        stack_id: str | None = None,
        load: bool = False,
    ) -> BaseDialogManager:
        return self

    @asynccontextmanager
    async def fg(self) -> AsyncIterator[DialogManager]:
        yield self

    async def answer_callback(self) -> None:
        pass


def create_photo(media: MediaAtt
…[1624 chars omitted]…
en(states):
            raise ValueError(
                f"Cannot go to a non-existent state."
                f"The state of {current_index + 1} idx is requested, "
                f"but there are only {len(states)} states"
                f"current state is {self.current_context().state}",
            )
        new_state = states[current_index + 1]
        await self.switch_to(new_state, show_mode)

task fail -> RuntimeError boom
unhandled -> DialogsError Foreground event was not handled by any dialog
unknown -> UnknownIntent gone
cancel inside -> CancelledError, exited cancelled True
cancel before -> CancelledError promptly
timeout -> TimeoutError
messages after start ['stub']
bg user None user_id None stack 
messages after switch ['stub', 'second']
messages after bg start ['stub']

     data: Any
diff --git a/src/maxo/dialogs/api/protocols/manager.py b/src/maxo/dialogs/api/protocols/manager.py
index 8eb6755..da6a67d 100644
--- a/src/maxo/dialogs/api/protocols/manager.py
+++ b/src/maxo/dialogs/api/protocols/manager.py
@@ -86,7 +86,7 @@ class BgManagerFactory(Protocol):
     def bg(
         self,
         bot: Bot,
-        user_id: int,
+        user_id: int | None,
         chat_id: int,
         stack_id: str | None = None,
         load: bool = Fals
…[8629 chars omitted]…
 @@ class UpdateContextMiddleware(BaseMiddleware[MaxoUpdate[Any]]):
             user_id = update.user_id
         elif isinstance(update, DialogUpdateEvent):
             user = update.user
-            user_id = user.id
+            user_id = user.id if user is not None else update.recipient.user_id
             chat_id = update.recipient.chat_id
             chat_type = update.recipient.chat_type