k1rl3s-maxo-348

max-swagger.json
noxfile.py
pyproject.toml
src
tests
/repo/src/maxo/dialogs/api/protocols/manager.py:79:    def fg(self) -> AbstractAsyncContextManager["DialogManager"]:
/repo/src/maxo/dialogs/manager/bg_manager.py:225:    async def fg(self) -> AsyncIterator[DialogManager]:
/repo/src/maxo/dialogs/manager/manager.py:602:    async def fg(self) -> AsyncIterator[DialogManager]:
/repo/src/maxo/dialogs/manager/sub_manager.py:161:    async def fg(self) -> AsyncIterator[DialogManager]:
/repo/src/maxo/dialogs/tools/preview.py:268:    async def fg(self) -> AsyncIterator[DialogManager]:

    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
…[7303 chars omitted]…
   first_name="",
                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,
        )

    def event_type(self) -> str:
        return DIALOG_EVENT_NAME


class DialogStartEvent(DialogUpdateEvent):
    new_state: State
    mode: StartMode
    access_settings: AccessSettings | None = None


class DialogSwitchEvent(DialogUpdateEvent):
    new_state: State


class DialogFgEvent(DialogUpdateEvent):
    entered: Future["DialogManager"]
    exited: Future[None]

async def handle_aiogd_update(
    event: DialogUpdateEvent,
    dialog_manager: DialogManager,
) -> None:
    dialog_manager.show_mode = event.show_mode or ShowMode.AUTO
    if isinstance(event, DialogStartEvent):
        await dialog_manager.start(
            state=event.new_state,
            data=event.data,
            mode=event.mode,
            show_mode=event.show_mode,
            access_settings=event.access_settings,
        )
    elif isinstance(event, DialogSwitchEvent):
        await dialog_manager.switch_to(state=event.new_state)
        await dialog_manager.show()
    elif isinstance(e
…[3420 chars omitted]…
       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:
        await self.dp.feed_update(MaxoUpdate(update=update), bot)

    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
…[8091 chars omitted]…
manager().bg()

        assert isinstance(child, BgManager)
        assert child.stack_id == "stack"
        assert child.intent_id == "intent"
        assert child._event_context.chat_id == 1

    def test_resets_stack_for_other_context(self) -> None:
        child = make_manager().bg(user_id=99, chat_id=2)

        assert isinstance(child, BgManager)
        assert child.stack_id == DEFAULT_STACK_ID

        if UPDATE_CONTEXT_KEY not in ctx:
            return False
        if EVENT_FROM_USER_KEY not in ctx:  # noqa: SIM103
            return False
        return True

    async def _fix_broken_stack(
        self,
        storage: StorageProxy,
        stack: Stack,
    ) -> None:
        while not stack.empty():
            await storage.remove_context(stack.pop())
        await storage.save_stack(stack)

    async def _load_last_context(
        self,
        storage: StorageProxy,
        stack: Stack,
    ) -> Context | N
…[1494 chars omitted]…
] = proxy
            stack = await self._load_stack(proxy, update.error)
            if stack.empty() or isinstance(error, UnknownState):
                context = None
            else:
                context = await self._load_last_context(
                    storage=proxy,
---
1:class DialogsError(RuntimeError):
10:class UnknownIntent(DialogsError):
28:class StackAccessDeniedError(DialogsError):

utils

        clear_subscriptions: bool = False,
        **workflow_data: Any,
    ) -> None:
        asyncio.run(
            self.start_polling(
                bot,
                backoff_config=backoff_config,
                timeout=timeout,
                limit=limit,
                marker=marker,
                types=types,
                auto_close_bot=auto_close_bot,
                drop_pending_updates=drop_pending_updates,
                clear_subscriptions=clear_subscriptions,
                **workflow
…[2096 chars omitted]…
ewares/error.py:7:from maxo.types.error_event import ErrorEvent
/repo/src/maxo/routing/middlewares/error.py:22:            exception_event = ErrorEvent(
/repo/src/maxo/routing/routers/simple.py:40:from maxo.types.error_event import ErrorEvent
/repo/src/maxo/routing/routers/simple.py:69:            ErrorEvent[Any, Any]
/repo/src/maxo/routing/routers/simple.py:101:            ErrorEvent: self.exception,

    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(dict(ctx))
            new_ctx["update"] = exception_event
            result = await self._router.trigger(new_ctx)
            if result is UNHANDLED:
                raise
            return result

class OutdatedIntent(DialogsError):
    def __init__(self, stack_id: str, text: str) -> None:
        super().__init__(text)
        self.stack_id = stack_id


class UnknownState(DialogsError):
    pass


class DialogStackOverflow(DialogsError):
    pass


class StackAccessDeniedError(DialogsError):
    pass


# manager
class IncorrectBackgroundError(DialogsError):
    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 InvalidKeyboardTy
…[636 chars omitted]…
_manager
        del self._event
        # del self._ctx
        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

            assert fg_manager is inner

    async def test_fg_propagates_exception(self) -> None:
        manager = make_manager()
        events: list[Any] = []

        def notify_task(bot: Any, update: Any) -> Any:
            events.append(update)
            update.entered.set_result(MagicMock())
            return asyncio.sleep(0)

        manager._updater.notify_task = MagicMock(side_effect=notify_task)  # type: ignore[method-assign]

        wit
…[477 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"

    AccessSettings,
    Data,
    DialogAction,
    DialogStartEvent,
    DialogSwitchEvent,
    DialogUpdateEvent,
    EventContext,
    ShowMode,

           ^^^^^^^^^^^^^^^
  File "/tmp/repro.py", line 135, in main
    await test_handler_error()
  File "/tmp/repro.py", line 50, in test_handler_error
    with pytest.raises(RuntimeError, match="boom"):
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/site-packages/_pytest/raises.py", line 699, in __exit__
    fail(f"DID NOT RAISE {self.expected_exceptions[0].__name__}")
  File "/usr/local/lib/python3.12/site-packages/_pytest/outcomes.py", line 162, in __call__
    raise Failed(msg=reason, pytrace=pytrace)
Failed: DID NOT RAISE RuntimeError

              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/maxo/dialogs/manager/bg_manager.py", line 232, in _wait_entered
    await asyncio.wait(
  File "/usr/local/lib/python3.12/asyncio/tasks.py", line 464, in wait
    return await _wait(fs, timeout, return_when, loop)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/asyncio/tasks.py", line 550, 
…[621 chars omitted]…
    return future.result()
           ^^^^^^^^^^^^^^^
  File "/tmp/repro.py", line 137, in main
    await test_cancel_before_prepared()
  File "/tmp/repro.py", line 78, in test_cancel_before_prepared
    async with asyncio.timeout(2), m.fg():
               ^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/asyncio/timeouts.py", line 115, in __aexit__
    raise TimeoutError from exc_val
TimeoutError

              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/maxo/dialogs/manager/bg_manager.py", line 232, in _wait_entered
    await asyncio.wait(
  File "/usr/local/lib/python3.12/asyncio/tasks.py", line 464, in wait
    return await _wait(fs, timeout, return_when, loop)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/asyncio/tasks.py", line 550, 
…[621 chars omitted]…
    return future.result()
           ^^^^^^^^^^^^^^^
  File "/tmp/repro.py", line 138, in main
    await test_cancel_before_prepared()
  File "/tmp/repro.py", line 78, in test_cancel_before_prepared
    async with asyncio.timeout(2), m.fg():
               ^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/asyncio/timeouts.py", line 115, in __aexit__
    raise TimeoutError from exc_val
TimeoutError

    "timeout",
    "timeout_at",
)


class _State(enum.Enum):
    CREATED = "created"
    ENTERED = "active"
    EXPIRING = "expiring"
    EXPIRED = "expired"
    EXITED = "finished"


@final
class Timeout:
    """Asynchronous context manager for cancelling overdue coroutines.

    Use `timeout()` or `timeout_at()` rather than instantiating this class directly.
    """

    def __init__(self, when: Optional[float]) -> None:
        """Schedule a timeout that will trigger at a given loop time.

        - If `when` is `None`, the timeout will never trigger.
        - If `when < loop.time()`, the timeout will trigger on the next
          iteration of the event loop.
        """
        self._state = _State.C
…[3032 chars omitted]…
one


def timeout(delay: Optional[float]) -> Timeout:
    """Timeout async context manager.

    Useful in cases when you want to apply timeout logic around block
    of code or in cases when asyncio.wait_for is not suitable. For example:

    >>> async with asyncio.timeout(10):  # 10 seconds timeout
    ...     await long_running_task()


    delay - value in seconds or None to disable timeout logic

           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/asyncio/tasks.py", line 550, in _wait
    await waiter
asyncio.exceptions.CancelledError

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "<stdin>", line 20, in main
  File "/usr/local/lib/python3.12/asyncio/timeouts.py", line 115, in __aexit__
    raise TimeoutError from exc_val
TimeoutError

ERROR tests/maxo_dialog/test_dishka_integration.py
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
1 error in 3.43s

>       with pytest.raises((UnknownIntent, DialogsError)):
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E       Failed: DID NOT RAISE any of (UnknownIntent, DialogsError)

tests/maxo_dialog/test_fg_tmp_repro.py:47: Failed
=========================== short test summary info ============================
FAILED tests/maxo_dialog/test_fg_tmp_repro.py::test_unhandled_event - Failed:...
1 failed, 1 passed in 2.71s

 
 from maxo import Bot, Dispatcher, loggers
 from maxo.dialogs import DialogManager
+from maxo.dialogs.api.exceptions import DialogsError
 from maxo.dialogs.api.entities import (
     DEFAULT_STACK_ID,
     AccessSettings,
@@ -221,6 +223,36 @@ class BgManager(BaseDialogManager):
             ),
         )
 
+    async def _wait_entered(
+        self,
+        event: DialogFgEvent,
+        task: "Task[Any]",
+    ) -> 
…[3203 chars omitted]…
         event.entered.set_result(dialog_manager)
-        await event.exited
+        try:
+            await event.exited
+        except asyncio.CancelledError:
+            # The foreground context was cancelled, nothing to do here.
+            pass
     elif event.action is DialogAction.UPDATE:
         if not dialog_manager.has_context():
             loggers.dialogs.warning("No context found")