microagent 1.8.1__tar.gz → 1.8.2__tar.gz

{microagent-1.8.1 → microagent-1.8.2}/CHANGELOG.rst

@@ -3,6 +3,13 @@ Changelog
 =========
 
 
+1.8.2 (2026-06-11)
+==================
+
+- Receiver/bus graceful cancellation
+- Fix exception handling
+
+
 1.8.1 (2026-06-06)
 ==================
 

{microagent-1.8.1 → microagent-1.8.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microagent
-Version: 1.8.1
+Version: 1.8.2
 Summary: Tool for agent ecosystem
 Author-email: Dmitriy Vlasov <scailer@yandex.ru>
 License: MIT License

{microagent-1.8.1 → microagent-1.8.2}/docs/conf.py

@@ -8,6 +8,7 @@
 
 # -- Path setup --------------------------------------------------------------
 
+import pathlib
 # If extensions (or modules to document with autodoc) are in another directory,
 # add these directories to sys.path here. If the directory is relative to the
 # documentation root, use os.path.abspath to make it absolute, like shown here.
@@ -17,8 +18,6 @@
 # sys.path.insert(0, os.path.abspath('.'))
 # mypy: ignore-errors
 import re
-import pathlib
-
 
 try:
     version = re.findall(r"^__version__ = '([^']+)'\r?$",

{microagent-1.8.1 → microagent-1.8.2}/examples/comment_agent.py

@@ -1,8 +1,9 @@
 # mypy: ignore-errors
-import os
 import asyncio
+import os
 from collections import defaultdict
-from microagent import MicroAgent, on, receiver, load_stuff
+
+from microagent import MicroAgent, load_stuff, on, receiver
 
 cur_dir = os.path.dirname(os.path.realpath(__file__))
 signals, queues = load_stuff('file://' + os.path.join(cur_dir, 'signals.json'))

{microagent-1.8.1 → microagent-1.8.2}/examples/email_agent.py

@@ -1,6 +1,7 @@
 # mypy: ignore-errors
 import os
-from microagent import MicroAgent, on, consumer, load_stuff
+
+from microagent import MicroAgent, consumer, load_stuff, on
 
 cur_dir = os.path.dirname(os.path.realpath(__file__))
 signals, queues = load_stuff('file://' + os.path.join(cur_dir, 'signals.json'))

{microagent-1.8.1 → microagent-1.8.2}/examples/redis_server.py

@@ -1,12 +1,13 @@
 # mypy: ignore-errors
-import sys
 import asyncio
 import logging
-from microagent.tools.redis import RedisSignalBus, RedisBroker
+import sys
 
-from user_agent import UserAgent
 from comment_agent import CommentAgent
 from email_agent import EmailAgent
+from user_agent import UserAgent
+
+from microagent.tools.redis import RedisBroker, RedisSignalBus
 
 logging.basicConfig(format=(
     '%(levelname)-8s [pid#%(process)d] %(asctime)s %(name)s '

{microagent-1.8.1 → microagent-1.8.2}/examples/user_agent.py

@@ -1,6 +1,7 @@
 # mypy: ignore-errors
 import os
-from microagent import MicroAgent, on, periodic, receiver, cron, load_stuff
+
+from microagent import MicroAgent, cron, load_stuff, on, periodic, receiver
 
 cur_dir = os.path.dirname(os.path.realpath(__file__))
 signals, queues = load_stuff('file://' + os.path.join(cur_dir, 'signals.json'))

{microagent-1.8.1 → microagent-1.8.2}/microagent/__init__.py

@@ -1,4 +1,4 @@
-__version__ = '1.8.1'
+__version__ = '1.8.2'
 
 import importlib
 import json
@@ -44,7 +44,7 @@ def load_stuff(source: str) -> tuple[Any, Any]:
 
     if source.startswith('file://'):
         with open(source.replace('file://', ''), encoding='utf8') as f:
-            data.update(json.loads(f.read().replace('\n', '')))
+            data.update(json.load(f))
     else:
         with urllib.request.urlopen(source) as response:
             data.update(json.loads(response.read()))

{microagent-1.8.1 → microagent-1.8.2}/microagent/agent.py

@@ -208,6 +208,8 @@ class MicroAgent:
             periodic_task.cancel()
         for cron_task in self.cron_tasks:
             cron_task.cancel()
+        if self.bus:
+            await self.bus.close()
         await self.hook.pre_stop()
 
     @staticmethod

{microagent-1.8.1 → microagent-1.8.2}/microagent/bus.py

@@ -110,13 +110,18 @@ class AbstractSignalBus(BusProtocol):
 
     receivers: dict[str, list[Receiver]] = field(default_factory=lambda: defaultdict(list))
     _responses: dict[str, IterQueue] = field(default_factory=dict)
+    _tasks: set[asyncio.Task] = field(default_factory=set)
 
     def __post_init__(self) -> None:
         response_signal = Signal(name='response', providing_args=[])
-        asyncio.create_task(self.bind(response_signal.make_channel_name(self.prefix)))
+        task = asyncio.create_task(
+            self.bind(response_signal.make_channel_name(self.prefix))
+        )
+        self._tasks.add(task)
+        task.add_done_callback(self._tasks.discard)
         self.log.debug('%s initialized', self)
 
-    def __repr__(self) -> str:
+    def __str__(self) -> str:
         return f'<Bus {self.__class__.__name__} {self.dsn} {self.prefix}#{self.uid}>'
 
     def __getattr__(self, name: str) -> 'BoundSignal':
@@ -230,10 +235,20 @@ class AbstractSignalBus(BusProtocol):
         if diff_args:
             self.log.warning('Pubsub mismatch arguments %s %s', channel, diff_args)
 
-        asyncio.create_task(self.handle_signal(signal, sender, signal_id, data))
+        task = asyncio.create_task(
+            self.handle_signal(signal, sender, signal_id, data)
+        )
+        self._tasks.add(task)
+        task.add_done_callback(self._tasks.discard)
 
         return None
 
+    async def close(self) -> None:
+        for task in self._tasks:
+            task.cancel()
+        if self._tasks:
+            await asyncio.wait(self._tasks)
+
     def handle_response(self, signal_id: str, message: dict[str, int | str | None]) -> None:
         if queue := self._responses.get(signal_id):
             queue.put_nowait(message)
@@ -272,13 +287,13 @@ class AbstractSignalBus(BusProtocol):
             if isinstance(response, int | str):
                 return response
 
-        except TypeError:
-            self.log.exception('Call %s failed', signal.name)
-
         except asyncio.TimeoutError:
             self.log.error(
                 'TimeoutError: %s %.2f', receiver.handler, time.monotonic() - timer)
 
+        except Exception:
+            self.log.exception('Call %s failed', signal.name)
+
         return None
 
 
@@ -295,7 +310,7 @@ class BoundSignal(SignalProtocol):
             self.signal.make_channel_name(self.bus.prefix, sender),
             self.signal.serialize(kwargs))
 
-    async def call(self, sender: str, timeout: int = 60, **kwargs: Any
+    async def call(self, sender: str, *, timeout: int = 60, **kwargs: Any
             ) -> dict[str, int | str | None]:
 
         if self.signal.type_map:
@@ -313,7 +328,7 @@ class BoundSignal(SignalProtocol):
 
         return {}
 
-    def waiter(self, sender: str, timeout: int = 60, **kwargs: Any
+    def waiter(self, sender: str, *, timeout: int = 60, **kwargs: Any
                 ) -> contextlib.AbstractAsyncContextManager:
         '''
             async with bus.iter(sender='name', a=1, timeout=10) as queue:

{microagent-1.8.1 → microagent-1.8.2}/microagent/timer.py

@@ -24,7 +24,7 @@ import inspect
 import re
 import time
 from collections.abc import Callable
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from datetime import datetime, timedelta, timezone
 from typing import TYPE_CHECKING, ClassVar, NamedTuple, TypedDict
 
@@ -54,12 +54,16 @@ class CRON(NamedTuple):
         return f'[{self.spec}]'
 
 
+class PeriodicState(TypedDict, total=False):
+    timer_handle: asyncio.TimerHandle
+    running_task: asyncio.Task
+
+
 class PeriodicMixin:
     agent: 'MicroAgent'
     handler: Callable
     timeout: float
-    _timer_handle: asyncio.TimerHandle | None = None
-    _running_task: asyncio.Task | None = None
+    _state: PeriodicState
 
     async def call(self) -> None:
         try:
@@ -75,13 +79,14 @@ class PeriodicMixin:
             self.agent.log.exception(f'Periodic Exception: {exc}')
 
     def start(self, start_after: float) -> None:
-        self._timer_handle = asyncio.get_running_loop().call_later(start_after, _periodic, self)  # type: ignore[arg-type]
+        self._state['timer_handle'] = asyncio.get_running_loop().call_later(
+            start_after, _periodic, self)  # type: ignore[arg-type]
 
     def cancel(self) -> None:
-        if self._timer_handle is not None:
-            self._timer_handle.cancel()
-        if self._running_task is not None and not self._running_task.done():
-            self._running_task.cancel()
+        if (timer_handle := self._state.get('timer_handle')) is not None:
+            timer_handle.cancel()
+        if (running_task := self._state.get('running_task')) is not None and not running_task.done():
+            running_task.cancel()
 
 
 class PeriodicArgs(TypedDict):
@@ -97,6 +102,7 @@ class PeriodicTask(PeriodicMixin):
     period: float
     timeout: float
     start_after: float
+    _state: PeriodicState = field(default_factory=PeriodicState)
 
     _register: ClassVar[dict[BoundKey, PeriodicArgs]] = {}
 
@@ -115,6 +121,7 @@ class CRONTask(PeriodicMixin):
     handler: PeriodicFunc
     cron: CRON
     timeout: float
+    _state: PeriodicState = field(default_factory=PeriodicState)
 
     _register: ClassVar[dict[BoundKey, CRONArgs]] = {}
 
@@ -135,9 +142,9 @@ class CRONTask(PeriodicMixin):
 
 
 def _periodic(task: PeriodicTask | CRONTask) -> asyncio.Task:
-    task._timer_handle = asyncio.get_running_loop().call_later(task.period, _periodic, task)
+    task._state['timer_handle'] = asyncio.get_running_loop().call_later(task.period, _periodic, task)
     running = asyncio.create_task(task.call())
-    task._running_task = running
+    task._state['running_task'] = running
     return running
 
 

{microagent-1.8.1 → microagent-1.8.2}/microagent/tools/mocks.py

@@ -39,12 +39,13 @@ class BusMock(MagicMock):
         self.bind_signal = AsyncMock()
         self.send = AsyncMock()
         self.call = AsyncMock()
+        self.close = AsyncMock()
 
     def __str__(self) -> str:
-        return f'<BusMock id={id(self)}'
+        return f'<BusMock id={id(self)}>'
 
     def __getattr__(self, name: str) -> BoundSignalMock:
-        if name.startswith('_') or name in {'bind_signal', 'send', 'call'}:
+        if name.startswith('_') or name in {'bind_receiver', 'bind_signal', 'send', 'call', 'close'}:
             return super().__getattr__(name)
         self._stuff[name] = self._stuff.get(name, BoundSignalMock())
         return self._stuff[name]

{microagent-1.8.1 → microagent-1.8.2}/microagent/tools/redis.py

@@ -49,7 +49,9 @@ class RedisSignalBus(AbstractSignalBus):
     async def bind(self, channel: str) -> None:
         async with self._pubsub_lock:
             pubsub = self.connection.pubsub()
-            asyncio.create_task(self._receiver(pubsub, channel))
+            task = asyncio.create_task(self._receiver(pubsub, channel))
+            self._tasks.add(task)
+            task.add_done_callback(self._tasks.discard)
 
     async def _receiver(self, pubsub: client.PubSub, channel: str) -> None:
         async with pubsub as psub:

{microagent-1.8.1 → microagent-1.8.2}/microagent.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microagent
-Version: 1.8.1
+Version: 1.8.2
 Summary: Tool for agent ecosystem
 Author-email: Dmitriy Vlasov <scailer@yandex.ru>
 License: MIT License

{microagent-1.8.1 → microagent-1.8.2}/tests/test_bus.py

@@ -348,3 +348,108 @@ async def test_Bus_broadcast_fail_timeout(bus, test_signal):
 
     assert ret is None
     bus.log.error.assert_called()
+
+
+async def test_Bus_broadcast_fail_broad_exception(bus, test_signal):
+    handler = MagicMock(return_value=1, **{'__qualname__': 'qname'})
+    receiver = Receiver(agent=None, handler=handler, signal=test_signal, timeout=60)
+    receiver.handler.side_effect = ValueError('something went wrong')
+
+    ret = await bus.broadcast(receiver, test_signal, 'test', {'uuid': 1})
+
+    assert ret is None
+    bus.log.exception.assert_called()
+
+
+async def test_Bus_broadcast_fail_cancelled_propagates(bus, test_signal):
+    handler = MagicMock(return_value=1, **{'__qualname__': 'qname'})
+    receiver = Receiver(agent=None, handler=handler, signal=test_signal, timeout=60)
+
+    async def cancelled(*args, **kwargs):
+        raise asyncio.CancelledError()
+
+    receiver.handler.side_effect = cancelled
+
+    with pytest.raises(asyncio.CancelledError):
+        await bus.broadcast(receiver, test_signal, 'test', {'uuid': 1})
+
+
+async def test_Bus_broadcast_fail_runtime_error(bus, test_signal):
+    handler = MagicMock(return_value=1, **{'__qualname__': 'qname'})
+    receiver = Receiver(agent=None, handler=handler, signal=test_signal, timeout=60)
+
+    async def runtime_error(*args, **kwargs):
+        raise RuntimeError('unexpected')
+
+    receiver.handler.side_effect = runtime_error
+
+    ret = await bus.broadcast(receiver, test_signal, 'test', {'uuid': 1})
+
+    assert ret is None
+    bus.log.exception.assert_called()
+
+
+async def test_Bus_close_ok():
+    class SlowBindBus(AbstractSignalBus):
+        started = False
+
+        async def send(self, channel: str, message: str) -> None:
+            pass
+
+        async def bind(self, channel: str) -> None:
+            self.started = True
+            await asyncio.Event().wait()
+
+    bus = SlowBindBus(dsn=DSN)
+    await asyncio.sleep(0.01)
+    assert bus.started
+    assert bus._tasks
+
+    await bus.close()
+
+    assert not bus._tasks
+
+
+async def test_Bus_close_idempotent():
+    bus = Bus(dsn=DSN)
+    await bus.close()
+    await bus.close()
+
+
+async def test_Bus_close_ok_all_tasks_cancelled():
+    bus = Bus(dsn=DSN, prefix='TEST')
+    bus.bind = AsyncMock()
+    bus.send = AsyncMock()
+
+    async def slow_handler(*args, **kwargs):
+        await asyncio.sleep(10)
+
+    bus.handle_signal = slow_handler
+
+    signal = Signal(name='test_signal', providing_args=['a'])
+    bus.receiver('TEST:test_signal:sender', signal.serialize({'a': 1}))
+    await asyncio.sleep(0.01)
+
+    assert bus._tasks
+
+    await bus.close()
+
+    assert not bus._tasks
+
+
+async def test_Bus_close_cancels_receiver_task(bus, test_signal):
+    async def slow_handler(*args, **kwargs):
+        await asyncio.sleep(10)
+
+    receiver = Receiver(agent=None, handler=slow_handler, signal=test_signal, timeout=60)
+    await bus.bind_receiver(receiver)
+
+    bus.receiver('TEST:test_signal:test', test_signal.serialize({'uuid': 1}))
+    await asyncio.sleep(0.01)
+
+    task_count = len(bus._tasks)
+    assert task_count > 0
+
+    await bus.close()
+
+    assert not bus._tasks

{microagent-1.8.1 → microagent-1.8.2}/examples/settings.py

@@ -1,5 +1,5 @@
-import sys
 import logging
+import sys
 
 logging.basicConfig(format=(
     '%(levelname)-8s [pid#%(process)d] %(asctime)s %(name)s '