redzed 26.1.28__py3-none-any.whl → 26.2.4__py3-none-any.whl

redzed/__init__.py

@@ -15,7 +15,7 @@ Docs: https://redzed.readthedocs.io/en/latest/
 Home: https://github.com/xitop/redzed/
 """
 
-__version_info__ = (26, 1, 28)
+__version_info__ = (26, 2, 4)
 __version__ = '.'.join(str(n) for n in __version_info__)
 
 from . import circuit, block, debug, formula_trigger, initializers, undef

redzed/block.py

@@ -225,6 +225,9 @@ class Block(BlockOrFormula):
         # pylint: disable-next=no-member
         return self.rz_export_state()         # type: ignore[attr-defined]
 
+    def rz_is_shut_down(self) -> bool:
+        return self.circuit.is_shut_down()
+
     def event(self, etype: str, /, evalue: t.Any = UNDEF, **edata: t.Any) -> t.Any:
         """
         An entry point for events.
@@ -232,13 +235,13 @@ class Block(BlockOrFormula):
         Call the specialized _event_ETYPE() method if it exists.
         Otherwise call the _default_event_handler() as the last resort.
         """
-        if self.circuit.after_shutdown() and not etype.startswith('_get_'):
+        check_identifier(etype, "Event type")
+        if not etype.startswith('_get_') and self.rz_is_shut_down():
             raise CircuitShutDown("The circuit was shut down")
 
         if evalue is not UNDEF:
             edata['evalue'] = evalue
 
-        check_identifier(etype, "Event type")
         if get_debug_level() >= 1:
             if not edata:
                 self.log_debug("Got event '%s'", etype)

redzed/blocklib/outputs.py

@@ -14,7 +14,7 @@ from collections.abc import Callable, Awaitable
 import typing as t
 
 import redzed
-from redzed.utils import BufferShutDown, cancel_shield, func_call_string, MsgSync, time_period
+from redzed.utils import BufferShutDown, cancel_shield, func_call_string, time_period
 from .validator import _Validate
 
 
@@ -30,9 +30,14 @@ class OutputFunc(redzed.Block):
             triggered_by: str|redzed.Block|redzed.Formula|redzed.UndefType = redzed.UNDEF,
             **kwargs) -> None:
         super().__init__(*args, **kwargs)
-        self._stop_value = stop_value
         self._func = func
-        self._parameters: list[tuple[str, bool]] = []    # item: (name, is_required)
+        self._shutdown = False
+        if stop_value is not redzed.UNDEF:
+            @redzed.stop_function
+            def stop_function_():
+                self._event_put({'evalue': stop_value})
+            stop_function_.__qualname__ += self.name
+            stop_function_.__name__ += self.name
         if triggered_by is not redzed.UNDEF:
             @redzed.triggered
             def trigger(value=triggered_by) -> None:
@@ -53,9 +58,11 @@ class OutputFunc(redzed.Block):
         self.log_debug2("output function returned: %r", result)
         return result
 
+    def rz_is_shut_down(self) -> bool:
+        return self._shutdown
+
     def rz_stop(self) -> None:
-        if self._stop_value is not redzed.UNDEF:
-            self._event_put({'evalue': self._stop_value})
+        self._shutdown = True
 
 
 class _Buffer(_Validate, redzed.Block):
@@ -65,9 +72,14 @@ class _Buffer(_Validate, redzed.Block):
             triggered_by: str|redzed.Block|redzed.Formula|redzed.UndefType = redzed.UNDEF,
             **kwargs) -> None:
         super().__init__(*args, **kwargs)
-        # the stop_value is stored already validated
-        self._stop_value = \
-            redzed.UNDEF if stop_value is redzed.UNDEF else self._validate(stop_value)
+        self._shutdown = False
+        if stop_value is not redzed.UNDEF:
+            stop_value = self._validate(stop_value)
+            @redzed.stop_function
+            def stop_function_():
+                self.rz_put_value(stop_value)
+            stop_function_.__qualname__ += self.name
+            stop_function_.__name__ += self.name
         if triggered_by is not redzed.UNDEF:
             @redzed.triggered
             def trigger(value=triggered_by) -> None:
@@ -80,6 +92,15 @@ class _Buffer(_Validate, redzed.Block):
         evalue = self._validate(evalue)
         self.rz_put_value(evalue)
 
+    def _event__get_size(self, _edata: redzed.EventData) -> int:
+        return self.rz_get_size()
+
+    def rz_is_shut_down(self) -> bool:
+        return self._shutdown
+
+    def rz_stop(self) -> None:
+        self._shutdown = True
+
     def rz_put_value(self, value: t.Any) -> None:
         raise NotImplementedError
 
@@ -89,6 +110,12 @@ class _Buffer(_Validate, redzed.Block):
     async def rz_buffer_get(self) -> t.Any:
         raise NotImplementedError
 
+    def rz_close(self) -> None:
+        if (size := self.rz_get_size()) == 1:
+            self.log_error("One value was not retrieved from buffer")
+        elif size > 1:
+            self.log_error("%d values were not retrieved from buffer", size)
+
 
 class QueueBuffer(_Buffer):
     """
@@ -105,7 +132,6 @@ class QueueBuffer(_Buffer):
         self._queue: asyncio.Queue[t.Any] = queue_type(maxsize)
         # Queue.shutdown is available in Python 3.13, but we want to support 3.11+
         self._waiters = 0
-        self._shutdown = False
 
     def rz_put_value(self, value: t.Any) -> None:
         self._queue.put_nowait(value)
@@ -114,18 +140,10 @@ class QueueBuffer(_Buffer):
         """Get the number of items in the buffer."""
         return self._queue.qsize()
 
-    def _event__get_size(self, _edata: redzed.EventData) -> int:
-        return self.rz_get_size()
-
     def rz_stop(self) -> None:
-        waiters = self._waiters
-        if self._stop_value is not redzed.UNDEF:
-            self.rz_put_value(self._stop_value)
-            waiters -= 1
-        # unblock waiters
-        for _ in range(waiters):
+        super().rz_stop()
+        for _ in range(self._waiters):
             self.rz_put_value(redzed.UNDEF)
-        self._shutdown = True
 
     async def rz_buffer_get(self) -> t.Any:
         """
@@ -147,10 +165,6 @@ class QueueBuffer(_Buffer):
             raise BufferShutDown("The buffer was shut down")
         return value
 
-    def rz_close(self) -> None:
-        if (size := self._queue.qsize()) > 0:
-            self.log_warning("%d unprocessed item(s) left in the buffer", size)
-
 
 class MemoryBuffer(_Buffer):
     """
@@ -159,45 +173,47 @@ class MemoryBuffer(_Buffer):
 
     def __init__(self, *args, **kwargs) -> None:
         super().__init__(*args, **kwargs)
-        self._cell: MsgSync[t.Any] = MsgSync()
-        self._stop_pending = False
+        # allowed states:
+        #            _shutdown    value   has_value
+        # - has value: False,    not UNDEF, set
+        # - is empty:  False,    UNDEF,     cleared
+        # - draining:  True,     not UNDEF, set
+        # - shut down: True,     UNDEF,     set
+        self._value = redzed.UNDEF
+        self._has_value = asyncio.Event()
 
     def rz_get_size(self) -> int:
         """Get the number of items (0 or 1) in the buffer."""
-        has_data = self._cell.has_data() or self._cell.is_shutdown() and self._stop_pending
+        has_data = self._value is not redzed.UNDEF
         return 1 if has_data else 0
 
-    def _event__get_size(self, _edata: redzed.EventData) -> int:
-        return self.rz_get_size()
-
     def rz_put_value(self, value: t.Any) -> None:
-        self._cell.send(value)
+        if value is redzed.UNDEF:
+            raise ValueError(f"{self}: Cannot put UNDEF into the buffer")
+        self._value = value
+        self._has_value.set()
 
     def rz_stop(self) -> None:
         """Shut down"""
-        self._cell.shutdown()
-        self._stop_pending = self._stop_value is not redzed.UNDEF
+        super().rz_stop()
+        if not self._has_value.is_set():
+            assert self._value is redzed.UNDEF
+            self._has_value.set()   # unblock reader(s)
 
     async def rz_buffer_get(self) -> t.Any:
-        """
-        Remove and return an item from the memory cell.
-
-        When the buffer is empty:
-          - before shutdown wait
-          - after shutdown return the *stop_value* once (if defined),
-            then raise BufferShutDown
-        """
-        try:
-            return await self._cell.recv()
-        except BufferShutDown:
-            if not self._stop_pending:
-                raise
-            self._stop_pending = False
-            return self._stop_value
-
-    def rz_close(self) -> None:
-        if self._stop_pending:
-            self.log_error("The stop_value was not retrieved")
+        """Remove and return an item from the memory cell."""
+        while True:
+            await self._has_value.wait()
+            if self._value is redzed.UNDEF:
+                if self._shutdown:
+                    raise BufferShutDown("The buffer was shut down")
+                if not self._has_value.is_set():
+                    raise RuntimeError("BUG!: busy loop prevented")
+                continue
+            value, self._value = self._value, redzed.UNDEF
+            if not self._shutdown:
+                self._has_value.clear()
+            return value
 
 
 class OutputWorker(redzed.Block):
@@ -268,6 +284,7 @@ class OutputWorker(redzed.Block):
                 self.log_warning("%d worker(s) did not stop", running)
             raise
 
+
 class OutputController(redzed.Block):
     """
     Run an awaitable for the latest value from a buffer.

redzed/blocklib/repeat.py

@@ -13,7 +13,7 @@ import asyncio
 import typing as t
 
 import redzed
-from redzed.utils import MsgSync, time_period
+from redzed.utils import time_period
 
 
 class Repeat(redzed.Block):
@@ -27,20 +27,27 @@ class Repeat(redzed.Block):
             **kwargs
             ) -> None:
         self._dest = dest
-        self._interval = time_period(interval)
+        self._default_interval = time_period(interval)
         if count is not None and count < 0:
             # count = 0 (no repeating) is accepted
             raise ValueError("argument 'count' must not be negative")
-        self._count = count
-        self._sync: MsgSync[tuple[str, redzed.EventData]] = MsgSync()
-        self._warning_logged = False
+        self._default_count = count
+        self._got_event = False
+        self._new_event = asyncio.Event()
+        # current event
+        self._etype: str
+        self._edata: redzed.EventData
+        self._interval: float
+        self._count: int|None
         super().__init__(*args, **kwargs)
 
     def rz_pre_init(self) -> None:
         """Resolve destination block name."""
-        if not isinstance(dest := self.circuit.resolve_name(self._dest), redzed.Block):
-            raise TypeError(
-                f"{self}: {dest} is not a Block, but a Formula; cannot send events to it.")
+        dest = self.circuit.resolve_name(self._dest)
+        if isinstance(dest, redzed.Formula):
+            raise TypeError(f"{self}: {dest} is a Formula; cannot send events to it.")
+        if isinstance(dest, type(self)):
+            raise TypeError(f"{self}: {dest} is another Repeat block; this is not allowed")
         self._dest = dest
         self.circuit.create_service(self._repeater(), name=f"Event repeating task at {self}")
 
@@ -52,21 +59,30 @@ class Repeat(redzed.Block):
         repeat = 0      # prevent pylint warning
         while True:
             try:
-                etype, edata = await self._sync.recv(
-                    timeout=self._interval if repeating else None)
-                repeat = 0
+                async with asyncio.timeout(self._interval if repeating else None):
+                    await self._new_event.wait()
             except asyncio.TimeoutError:
+                pass
+            # getting a timeout does not necessarily mean the event was not set
+            if self._new_event.is_set():
+                self._new_event.clear()
+                repeat = 0
+            else:
                 repeat += 1
 
             if repeat > 0:  # skip the original event
                 self._set_output(repeat)
                 assert isinstance(self._dest, redzed.Block)    # @mypy: name resolved
-                self._dest.event(etype, **(edata | {'repeat': repeat}))
+                self._dest.event(self._etype, **(self._edata | {'repeat': repeat}))
             repeating = self._count is None or repeat < self._count
 
     def _default_event_handler(self, etype: str, edata: redzed.EventData) -> None:
         # send the original event synchronously
         self._set_output(0)
         assert isinstance(self._dest, redzed.Block)    # mypy: name is resolved
+        self._etype = etype
+        self._edata = edata
+        self._interval = edata.pop('repeat_interval', self._default_interval)
+        self._count = edata.pop('repeat_count', self._default_count)
         self._dest.event(etype, **(edata | {'repeat': 0}))
-        self._sync.send((etype, edata))
+        self._new_event.set()

redzed/circuit.py

@@ -7,10 +7,11 @@ Project home: https://github.com/xitop/redzed/
 """
 from __future__ import annotations
 
-__all__ = ['CircuitState', 'get_circuit', 'reset_circuit', 'run', 'unique_name']
+__all__ = [
+    'CircuitState', 'stop_function', 'get_circuit', 'reset_circuit', 'run', 'unique_name']
 
 import asyncio
-from collections.abc import Coroutine, Iterable, MutableMapping, Sequence
+from collections.abc import Callable, Coroutine, Iterable, MutableMapping, Sequence
 import contextlib
 import enum
 import itertools
@@ -63,6 +64,13 @@ def unique_name(prefix: str = 'auto') -> str:
     return get_circuit().rz_unique_name(prefix)
 
 
+_StopFunction: t.TypeAlias = Callable[[], t.Any]
+
+def stop_function(func: _StopFunction) -> _StopFunction:
+    get_circuit().rz_add_stop_function(func)
+    return func
+
+
 class CircuitState(enum.IntEnum):
     """
     Circuit state.
@@ -83,16 +91,16 @@ class _TerminateTaskGroup(Exception):
 
 
 @contextlib.contextmanager
-def error_debug(item: Block|Formula|Trigger, suppress_error: bool = False) -> t.Iterator[None]:
+def error_debug(exc_source: t.Any, suppress_error: bool = False) -> t.Iterator[None]:
     """Add a note to raised exception -or- log and suppress exception."""
     try:
         yield None
     except Exception as err:
         if not suppress_error:
-            err.add_note(f"This {type(err).__name__} occurred in {item}")
+            err.add_note(f"This {type(err).__name__} occurred in {exc_source}")
             raise
         # errors should be suppressed only during the shutdown & cleanup
-        _logger.error("[Circuit] %s: Suppressing %s: %s", item, type(err).__name__, err)
+        _logger.error("[Circuit] %s: Suppressing %s: %s", exc_source, type(err).__name__, err)
 
 
 class Circuit:
@@ -108,6 +116,7 @@ class Circuit:
         self._blocks: dict[str, Block|Formula] = {}
             # all Blocks and Formulas belonging to this circuit stored by name
         self._triggers: list[Trigger] = []      # all triggers belonging to this circuit
+        self._stops: list[_StopFunction] = []
         self._errors: list[Exception] = []      # exceptions occurred in the runner
         self.rz_persistent_dict: MutableMapping[str, t.Any]|None = None
             # persistent state data back-end
@@ -169,6 +178,9 @@ class Circuit:
 
     # --- circuit components storage ---
 
+    def rz_add_stop_function(self, func: _StopFunction) -> None:
+        self._stops.append(func)
+
     def rz_add_item(self, item: Block|Formula|Trigger) -> None:
         """Add a circuit item."""
         self._check_not_started()
@@ -279,7 +291,7 @@ class Circuit:
 
     def _check_not_started(self) -> None:
         """Raise an error if the circuit runner has started already."""
-        if self._state == CircuitState.CLOSED:
+        if self._state is CircuitState.CLOSED:
             # A circuit may be closed before start (see shutdown),
             # let's use this message instead of the one below.
             raise RuntimeError("The circuit was closed")
@@ -287,7 +299,7 @@ class Circuit:
         if self._state > CircuitState.INIT_CIRCUIT:
             raise RuntimeError("Not allowed after the start")
 
-    def after_shutdown(self) -> bool:
+    def is_shut_down(self) -> bool:
         """Test if we are past the shutdown() call."""
         return self._state >= CircuitState.SHUTDOWN
 
@@ -444,11 +456,12 @@ class Circuit:
     async def _runner_init(self) -> None:
         """Run the circuit during the initialization phase."""
         self._set_state(CircuitState.INIT_CIRCUIT)
+        # ensure a logging handler (won't work in UNDER_CONSTRUCTION level)
+        set_debug_level(get_debug_level())
         await asyncio.sleep(0)  # allow reached_state() synchronization
-        if self.after_shutdown():
+        if self.is_shut_down():
             # It looks like a supporting task has failed immediately after the start
             return
-        set_debug_level(get_debug_level())  # will check the existence of a logging handler
 
         pe_blocks = [blk for blk in self.get_items(Block) if blk.has_method('rz_pre_init')]
         pe_formulas = list(self.get_items(Formula))
@@ -497,14 +510,24 @@ class Circuit:
                     self.save_persistent_state(blk, now)
 
         stop_triggers = list(self.get_items(Trigger))
+        if stop_triggers:
+            self._log_debug2_blocks("Stopping triggers", stop_triggers)
+            for tstop in stop_triggers:
+                with error_debug(tstop, suppress_error=True):
+                    tstop.rz_stop()
+
+        if self._stops:
+            self.log_debug2("Running %d stop function(s)", len(self._stops))
+            for fstop in self._stops:
+                with error_debug(f"Stop function {fstop.__name__}()", suppress_error=True):
+                    fstop()
+
         stop_blocks = [blk for blk in self.get_items(Block) if blk.has_method('rz_stop')]
         if stop_blocks:
-            self._log_debug2_blocks("Stopping (sync)", stop_triggers, stop_blocks)
-            for stop in itertools.chain(stop_triggers, stop_blocks):
-                assert isinstance(stop, (Block, Trigger))       # @mypy
-                with error_debug(stop, suppress_error=True):
-                    # union-attr: checked with .has_method()
-                    stop.rz_stop()  # type: ignore[union-attr]
+            self._log_debug2_blocks("Stopping (sync)", stop_blocks)
+            for bstop in stop_blocks:
+                with error_debug(bstop, suppress_error=True):
+                    bstop.rz_stop()
 
         if self._auto_cancel_tasks:
             self.log_debug2("Cancelling %d service task(s)")
@@ -544,10 +567,6 @@ class Circuit:
 
         When the runner terminates, it cannot be invoked again.
         """
-        if self._state == CircuitState.CLOSED:
-            raise RuntimeError("Cannot restart a closed circuit.")
-        if self._state != CircuitState.UNDER_CONSTRUCTION:
-            raise RuntimeError("The circuit is already running.")
         if not self._blocks:
             raise RuntimeError("The circuit is empty")
         if tasks_are_eager():
@@ -561,7 +580,7 @@ class Circuit:
                 self.abort(err)
             else:
                 # There might be errors reported with abort().
-                # In such case the state has been set to SHUTDOWN.
+                # In such case the state has been set to SHUTDOWN or even CLOSED.
                 # _set_state(RUNNING) will be silently ignored.
                 self._set_state(CircuitState.RUNNING)
             # wait until cancelled from the task group; possible causes:
@@ -573,17 +592,18 @@ class Circuit:
             # will be re-raised at the end if there won't be other exceptions
             pass
         # cancellation causes 2 and 3 do not modify the state
-        if not self.after_shutdown():
+        if not self.is_shut_down():
             self._set_state(CircuitState.SHUTDOWN)
             await asyncio.sleep(0)
-        try:
-            await self._runner_shutdown()
-        except Exception as err:
-            # If an exception is propagated from _runner_shutdown, it is probably a bug.
-            # Calling abort is not necessary when shutting down, but the call will log
-            # and register the exception to be included in the final ExceptionGroup.
-            self.abort(err)
-        self._set_state(CircuitState.CLOSED)
+        if self._state < CircuitState.CLOSED:
+            try:
+                await self._runner_shutdown()
+            except Exception as err:
+                # If an exception is propagated from _runner_shutdown, it is probably a bug.
+                # Calling abort is not necessary when shutting down, but the call will log
+                # and register the exception to be included in the final ExceptionGroup.
+                self.abort(err)
+            self._set_state(CircuitState.CLOSED)
 
         if self._errors:
             raise ExceptionGroup("_runner_core() errors", self._errors)
@@ -605,7 +625,7 @@ class Circuit:
             # the same error may be reported from several places
             return
         self._errors.append(err)
-        if self.after_shutdown():
+        if self.is_shut_down():
             self.log_error("Unhandled error during shutdown: %r", err)
         else:
             self.log_warning("Aborting due to an exception: %r", err)
@@ -617,9 +637,9 @@ class Circuit:
 
         Prevent the runner from starting if it wasn't started yet.
         """
-        if self.after_shutdown():
+        if self.is_shut_down():
             return
-        if self._state == CircuitState.UNDER_CONSTRUCTION:
+        if self._state <= CircuitState.INIT_CIRCUIT:
             self._set_state(CircuitState.CLOSED)
             return
         self._set_state(CircuitState.SHUTDOWN)
@@ -656,7 +676,7 @@ class Circuit:
         try:
             await coro  # return value of a service is ignored
         except asyncio.CancelledError:
-            if self.after_shutdown():
+            if self.is_shut_down():
                 self.log_debug1("%s was cancelled", longname)
                 raise
             err = RuntimeError(f"{longname} was cancelled before shutdown")
@@ -666,7 +686,7 @@ class Circuit:
             err.add_note(f"Error occurred in {longname}")
             self.abort(err)
             raise
-        if self.after_shutdown():
+        if self.is_shut_down():
             self.log_debug1("%s terminated", longname)
             return
         exc = RuntimeError(f"{longname} terminated before shutdown")
@@ -680,7 +700,7 @@ class Circuit:
             **task_kwargs
             ) -> asyncio.Task[None]:
         """Create a service task for the circuit."""
-        if self.after_shutdown():
+        if self.is_shut_down():
             raise RuntimeError("Cannot create a service after shutdown")
         # Python 3.12 and 3.13 only: Eager tasks start to run before their name is set.
         # As a workaround we tell the watchdog wrapper the name.
@@ -734,8 +754,13 @@ async def run(*coroutines: Coroutine[t.Any, t.Any, t.Any], catch_sigterm: bool =
 
     If errors occur, raise an exception group with all exceptions.
     """
+    circuit = get_circuit()
+    state = circuit.get_state()
+    if state is CircuitState.CLOSED:
+        raise RuntimeError("Cannot restart a closed circuit.")
+    if state is not CircuitState.UNDER_CONSTRUCTION:
+        raise RuntimeError("The circuit is already running.")
     with TerminatingSignal(signal.SIGTERM) if catch_sigterm else contextlib.nullcontext():
-        circuit = get_circuit()
         try:
             async with asyncio.TaskGroup() as tg:
                 tg.create_task(circuit.rz_runner(), name="Circuit runner")

redzed/utils/async_utils.py

@@ -8,7 +8,7 @@ import asyncio
 from collections.abc import Awaitable
 import typing as t
 
-__all__ = ['BufferShutDown',  'cancel_shield', 'MsgSync']
+__all__ = ['BufferShutDown',  'cancel_shield']
 
 try:
     BufferShutDown = asyncio.QueueShutDown      # Python 3.13+
@@ -18,105 +18,6 @@ except AttributeError:
 
 
 _T = t.TypeVar("_T")
-_MISSING = object()
-
-class MsgSync(t.Generic[_T]):
-    """
-    Task synchronization based on sending messages of type _T.
-
-    The count of unread message is always either zero or one,
-    because messages are not queued. A new message replaces
-    the previous unread one, if any.
-
-    An existing unread message is available immediately.
-    Otherwise the recipient must wait and will be awakened when
-    a new message arrives. Reading a message consumes it,
-    so each message can reach only one receiver.
-    """
-
-    def __init__(self) -> None:
-        self._msg: t.Any = _MISSING
-        self._shutdown = False
-        self._has_data = asyncio.Event()    # valid before shutdown
-        self._draining = False              # valid after shutdown
-
-    def shutdown(self) -> None:
-        """
-        Disallow sending immediately. Disallow receiving after the MsgSync gets empty.
-
-        Calls to .send() will raise BufferShutDown.
-
-        If a message was sent before shutdown and is waiting, it can be
-        normally received before the receiver shuts down too. After
-        the shutdown all blocked callers will be unblocked with BufferShutDown.
-        Calls to .recv() will raise BufferShutDown as well.
-        """
-        self._shutdown = True
-        self._draining = self._has_data.is_set()
-        if not self._draining:
-            # wakeup all waiters
-            self._has_data.set()
-
-    def is_shutdown(self) -> bool:
-        """Check if the buffer was shut down."""
-        return self._shutdown
-
-    def send(self, msg: _T) -> None:
-        """
-        Send a message to one receiver.
-
-        If the previously sent message hasn't been received yet,
-        the new message overwrites it.
-        """
-        if self._shutdown:
-            raise BufferShutDown("The buffer was shut down")
-        self._msg = msg
-        self._has_data.set()
-
-    def clear(self) -> None:
-        """Remove the waiting message."""
-        if self._shutdown:
-            self._draining = False
-        else:
-            self._has_data.clear()
-        self._msg = _MISSING
-
-    def has_data(self) -> bool:
-        """Return True only if there is a waiting message."""
-        return self._draining if self._shutdown else self._has_data.is_set()
-
-    async def _recv(self) -> _T:
-        """Receive (consume) a message."""
-        while not self._has_data.is_set():
-            await self._has_data.wait()
-        if not self._shutdown:
-            self._has_data.clear()
-        elif self._draining:
-            self._draining = False
-        else:
-            raise BufferShutDown("The buffer was shut down")
-        msg, self._msg = self._msg, _MISSING
-        return t.cast(_T, msg)
-
-    async def recv(self, timeout: float | None = None, default: t.Any = _MISSING) -> t.Any:
-        """
-        Receive a message with optional timeout.
-
-        If a message is not available, wait until it arrives.
-
-        If a timeout [seconds] is given, return the default value
-        if no message is received before the timeout period elapses.
-        Without a default, raise the TimeoutError.
-        """
-        if timeout is None:
-            return await self._recv()
-        try:
-            async with asyncio.timeout(timeout):
-                return await self._recv()
-        except TimeoutError:
-            if default is not _MISSING:
-                return default
-            raise
 
 
 async def cancel_shield(aw: Awaitable[_T]) -> _T:

{redzed-26.1.28.dist-info → redzed-26.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redzed
-Version: 26.1.28
+Version: 26.2.4
 Summary: An asyncio-based library for building small automated systems
 Author-email: Vlado Potisk <redzed@poti.sk>
 License-Expression: MIT
@@ -8,7 +8,7 @@ Project-URL: homepage, https://github.com/xitop/redzed
 Project-URL: repository, https://github.com/xitop/redzed
 Project-URL: documentation, https://redzed.readthedocs.io/en/latest/
 Keywords: automation,finite-state machine
-Classifier: Development Status :: 3 - Alpha
+Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Programming Language :: Python :: 3

{redzed-26.1.28.dist-info → redzed-26.2.4.dist-info}/RECORD

@@ -1,7 +1,7 @@
-redzed/__init__.py,sha256=NxdFNxuOXDhqZRUpCZLhmSFH2W8-khvjkVq_4umGJ9E,1098
+redzed/__init__.py,sha256=IVRc3KnMDB9N_M0fiii8X84I6_AEjhmOqtrzAJbvuzY,1097
 redzed/base_block.py,sha256=A1ZxEIH8jsNXj3z3HvzgAVshUsMoFtqIoR41-U2vMaw,5187
-redzed/block.py,sha256=oviZ1Tonp-eQrgLX4CYnv9KrPSgBPeCHDyUM_yhghJU,11692
-redzed/circuit.py,sha256=QO5XtX-zZhSFz_1ixKgnwrPzZ3vaBm98qWI8Y8-7r3I,31151
+redzed/block.py,sha256=_Qp8DQ1Ojb_PuGcYy2xS4gkhUeQymIx69iJaKHUM9jQ,11768
+redzed/circuit.py,sha256=6C1mmg83Z_mjCHUpLlU9mdK4297cjrBycIuUUnjSB5E,31894
 redzed/cron_service.py,sha256=0RSIte6zkbF4mSojrPoVFMHkVep1OZ2Mv2BtG3YiPTs,11372
 redzed/debug.py,sha256=hsHbBxPOOUVL_utfiRnkRh49FszDvHsCZ9xAqxawUIU,2868
 redzed/formula_trigger.py,sha256=lkBMeLVrcvqA71WGGapj9hitm52-dATMgT5QFhC1lOY,7360
@@ -13,18 +13,18 @@ redzed/blocklib/__init__.py,sha256=au7jbjO_RUFzK5U4STk-7pc1DTVA0OVh2W_aKsx1Y3s,5
 redzed/blocklib/counter.py,sha256=pUT5Np31gk1rP2LqaTjJdzdyyS8NhpD9104Re_MtLpY,1251
 redzed/blocklib/fsm.py,sha256=3UVQyKwZstL96jf3HYfuvN6R49uOMXVo20MFz9EpGkc,24746
 redzed/blocklib/inputs.py,sha256=YtKtbDUtXyQyUTNadniwyxCA_-UPCgrrY17EipfXcaI,6223
-redzed/blocklib/outputs.py,sha256=TnYjQV9DUfBX86WzXQP1xlSh-Oui-xvuN3uQEWvXIvc,13313
-redzed/blocklib/repeat.py,sha256=hkIO7qgm4wS32dcKkkfL_DjnoKWf-l3k2DfRiRUk6iE,2500
+redzed/blocklib/outputs.py,sha256=77FwFzh3q1Ri7tsAi39fmojD0vMmwBTSAYEjf1ZABpg,13964
+redzed/blocklib/repeat.py,sha256=R4f0WjTTnqpiYOHDCHucmGdp6ChyVozLaZDaE-Nx7Tc,3146
 redzed/blocklib/timedate.py,sha256=bmYZx6ToYsuD3UQzc1zxD2ddvovzF0A63-y4Pnkrm6Q,5225
 redzed/blocklib/timeinterval.py,sha256=alK68glDdWPD9SWxZ97pEzhQIReC41RMdXrRIRZsyuE,6878
 redzed/blocklib/timer.py,sha256=fCQTbmBOqo7pc6k32yj7JoyUM9XbdgHOXzu2tRiOiJE,1483
 redzed/blocklib/validator.py,sha256=6r0qtPIJ2neCP32WhI7tGxEUus_ji6kx_jrzHd2_M9I,1312
 redzed/utils/__init__.py,sha256=Yo8cj1f1HQj862UOdCsXOkMg4kfq1c5S3HJDhuiE5os,326
-redzed/utils/async_utils.py,sha256=Vknijh9rABL8GcJbYv6a7I4qO2VLerMsGTr5wiGWbjo,4486
+redzed/utils/async_utils.py,sha256=ABwloG7YKqRwfIwWsXNaGlNPc7MdEdq29-aRGRDsBgk,1075
 redzed/utils/data_utils.py,sha256=hesExhPcM2-IZPbDXAuGCUMpCI4YiNodp_ZJUj0_h9I,2952
 redzed/utils/time_utils.py,sha256=eCqk4T4ipn4hgzL8-4Usn1W6kkTyRCuQ9-BMSvnELww,8524
-redzed-26.1.28.dist-info/licenses/LICENSE.txt,sha256=brj9B7uNdzUvTJON_5Eibf7zeLRhcMuBYMInalu0KlI,1091
-redzed-26.1.28.dist-info/METADATA,sha256=t_DTA4MdjNI4KoOY8ayUvtU_FNABfmLfUdqQVQddmaI,2057
-redzed-26.1.28.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-redzed-26.1.28.dist-info/top_level.txt,sha256=7Rt0BRMqaJ0AGAmrd2JDqmqSY4cmQeW--7u6KDV1gZg,7
-redzed-26.1.28.dist-info/RECORD,,
+redzed-26.2.4.dist-info/licenses/LICENSE.txt,sha256=brj9B7uNdzUvTJON_5Eibf7zeLRhcMuBYMInalu0KlI,1091
+redzed-26.2.4.dist-info/METADATA,sha256=nQARn1_dngD-r1UBeYDVthqAwmqy6taWhJhDlP14kNo,2055
+redzed-26.2.4.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+redzed-26.2.4.dist-info/top_level.txt,sha256=7Rt0BRMqaJ0AGAmrd2JDqmqSY4cmQeW--7u6KDV1gZg,7
+redzed-26.2.4.dist-info/RECORD,,