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

redzed/debug.py

@@ -1,26 +1,37 @@
 """
-Debug level.
+Debug levels.
+- - - - - -
+Part of the redzed package.
+Docs: https://redzed.readthedocs.io/en/latest/
+Home: https://github.com/xitop/redzed/
 """
 from __future__ import annotations
 
-__all__ = ['get_debug_level', 'set_debug_level']
-
 import logging
 import os
 
 from . import circuit
 
+__all__ = ['get_debug_level', 'set_debug_level']
+
 _logger = logging.getLogger(__package__)
-_debug_handler: logging.StreamHandler|None = None
 
 
-class _CircuitTimeFormatter(logging.Formatter):
-    """Formatter for debug level 3."""
-    def format(self, record: logging.LogRecord) -> str:
-        msg = super().format(record)
-        if get_debug_level() >= 3:
-            msg = f"{circuit.get_circuit().runtime():.03f} {msg}"
-        return msg
+def get_level_from_env() -> int|None:
+    if (env_level := os.environ.get('REDZED_DEBUG', '')) == '':
+        return None
+    try:
+        level = int(env_level)
+    except Exception:
+        pass
+    else:
+        if 0 <= level <= 3:
+            return level
+    _logger.warning(
+        "Envvar 'REDZED_DEBUG' should be: 0 (disabled), 1 (normal), "
+        + "2 (verbose) or 3 (verbose with circuit timestamps)")
+    _logger.error("Ignoring REDZED_DEBUG='%s'. Please use a correct value.", env_level)
+    return None
 
 
 class _DebugLevel:
@@ -31,56 +42,62 @@ class _DebugLevel:
     """
 
     def __init__(self) -> None:
-        self._level = -1    # make sure the set_level's core will run
-        self.set_level(self._get_level_from_env())
-
-    def _get_level_from_env(self) -> int:
-        try:
-            level = os.environ['REDZED_DEBUG']
-        except KeyError:
-            return 0
-        level = level.strip()
-        if not level:
-            return 0
-        if level in {'0', '1', '2', '3'}:
-            return int(level)
-        _logger.warning(
-            "Envvar 'REDZED_DEBUG' should be: 0 (disabled), 1 (normal), "
-            + "2 (verbose) or 3 (verbose with circuit timestamps)")
-        _logger.warning("Ignoring REDZED_DEBUG='%s'. Please use a correct value.", level)
-        return 0
-
-    def get_level(self) -> int:
+        if (level := get_level_from_env()) is None:
+            level = 0
+        self._level = level
+        _logger.debug("[Logging] Debug level: %d", level)
+
+    @property
+    def level(self) -> int:
         return self._level
 
-    def set_level(self, level: int) -> None:
+    @level.setter
+    def level(self, level: int) -> None:
         """Set debug level."""
-        global _debug_handler       # pylint: disable=global-statement
-
-        if not isinstance(level, int):
-            raise TypeError(f"Expected an integer, got {level!r}")
         if level == self._level:
             return
+        if not isinstance(level, int):
+            raise TypeError(f"Expected an integer, got {level!r}")
         if not 0 <= level <= 3:
             raise ValueError(f"Debug level must be an integer 0 to 3, but got {level}")
-        # self._level is -1 on initial call
-        if self._level >= 0:
-            _logger.debug("Debug level: %d -> %d", self._level, level)
-        elif level > 0:
-            _logger.debug("Debug level: %d", level)
+        _logger.debug("[Logging] Debug level: %d -> %d", self._level, level)
         self._level = level
-        if level == 0:
-            if _debug_handler is not None:
-                _logger.removeHandler(_debug_handler)
-                _debug_handler = None
-            _logger.setLevel(logging.WARNING)
-        elif not _logger.hasHandlers() and _debug_handler is None:
-            _logger.addHandler(_debug_handler := logging.StreamHandler())
-            _debug_handler.setFormatter(_CircuitTimeFormatter("%(levelname)s - %(message)s"))
-            _logger.setLevel(logging.DEBUG)
 
 
-_global_debug_level = _DebugLevel()
+_debug_level = _DebugLevel()
+
+
+def get_debug_level():
+    """Get the debug level."""
+    return _debug_level.level
 
-get_debug_level = _global_debug_level.get_level
-set_debug_level = _global_debug_level.set_level
+
+def set_debug_level(level):
+    """
+    Set the debug level.
+
+    Also make sure debug messages will be logged or printed.
+    For this purpose, if there is no handler, add an own stream handler.
+    """
+    _debug_level.level = level
+    if circuit.get_circuit().get_state() in [
+            circuit.CircuitState.UNDER_CONSTRUCTION, circuit.CircuitState.CLOSED]:
+        return
+    if level > 0:
+        if not _logger.hasHandlers():
+            _logger.addHandler(logging.StreamHandler())
+            _logger.propagate = False
+        _logger.setLevel(logging.DEBUG)
+    else:
+        _logger.setLevel(logging.NOTSET if _logger.propagate else logging.INFO)
+
+
+class _CircuitTimeFilter(logging.Filter):
+    """Filter adding timestamsps in debug level 3."""
+    def filter(self, record: logging.LogRecord) -> bool:
+        if _debug_level.level >= 3 and isinstance(record.msg, str):
+            record.msg = f"{circuit.get_circuit().runtime():.03f} {record.msg}"
+        return True
+
+
+_logger.addFilter(_CircuitTimeFilter())

redzed/formula_trigger.py

@@ -194,12 +194,8 @@ class Formula(base_block.BlockOrFormula):
         self._evaluate_active = False
         return triggers
 
-def formula(name: str, *args, **kwargs) -> Callable[[_FUNC], _FUNC]:
+def formula(func: _FUNC) -> _FUNC:
     """@formula() creates a Formula block with the decorated function."""
-    if 'func' in kwargs:
-        # Argument func=... will be supplied by us
-        raise TypeError("@formula() got an unexpected keyword argument 'func='")
-    def decorator(func: _FUNC) -> _FUNC:
-        Formula(name, *args, func=func, **kwargs)
-        return func
-    return decorator
+    comment = '' if func.__doc__ is None else inspect.cleandoc(func.__doc__).partition('\n')[0]
+    Formula(func.__name__, func=func, comment=comment)
+    return func

redzed/initializers.py

@@ -2,8 +2,8 @@
 Block initializers.
 - - - - - -
 Part of the redzed package.
-# Docs: https://redzed.readthedocs.io/en/latest/
-# Project home: https://github.com/xitop/redzed/
+Docs: https://redzed.readthedocs.io/en/latest/
+Project home: https://github.com/xitop/redzed/
 """
 from __future__ import annotations
 
@@ -18,7 +18,7 @@ import typing as t
 
 from . import block
 from .undef import UNDEF, UndefType
-from .utils import check_async_func, time_period
+from .utils import time_period
 
 
 _LONG_TIMEOUT = 60      # threshold for a "long timeout" debug message
@@ -225,19 +225,18 @@ class InitTask(AsyncInitializer):
 
     def __init__(
             self,
-            coro_func: Callable[..., Awaitable[t.Any]],
+            aw_func: Callable[..., Awaitable[t.Any]],
             *args: t.Any,
             timeout: float|str = 10.0
             ) -> None:
         """Similar to InitFunction, but asynchonous."""
-        check_async_func(coro_func)
         super().__init__(timeout)
-        self._corofunc = coro_func
+        self._aw_func = aw_func
         self._args = args
 
     async def _async_get_init(self) -> t.Any:
         async with asyncio.timeout(self._timeout):
-            return await self._corofunc(*self._args)
+            return await self._aw_func(*self._args)
 
 
 class InitWait(AsyncInitializer):

redzed/signal_shutdown.py

@@ -2,8 +2,8 @@
 Stop the runner with a signal.
 - - - - - -
 Part of the redzed package.
-# Docs: https://redzed.readthedocs.io/en/latest/
-# Project home: https://github.com/xitop/redzed/
+Docs: https://redzed.readthedocs.io/en/latest/
+Project home: https://github.com/xitop/redzed/
 """
 from __future__ import annotations
 
@@ -55,7 +55,7 @@ class TerminatingSignal:
         """A signal handler."""
         # - we need the _threadsafe variant of call_soon
         # - get_running loop() and get_circuit() will succeed,
-        #   because this handler is active only during edzed.run()
+        #   because this handler is active only during redzed.run()
         msg = f"Signal {self._signame!r} caught"
         call_soon = asyncio.get_running_loop().call_soon_threadsafe
         call_soon(_logger.warning, "%s", msg)

redzed/undef.py

@@ -2,8 +2,8 @@
 The UNDEF singleton constant.
 - - - - - -
 Part of the redzed package.
-# Docs: https://redzed.readthedocs.io/en/latest/
-# Home: https://github.com/xitop/redzed/
+Docs: https://redzed.readthedocs.io/en/latest/
+Home: https://github.com/xitop/redzed/
 """
 from __future__ import annotations
 

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/utils/data_utils.py

@@ -4,12 +4,11 @@ Small utilities.
 from __future__ import annotations
 
 __all__ = [
-    'check_async_coro', 'check_async_func', 'check_identifier', 'func_call_string',
+    'check_identifier', 'func_name', 'func_call_string',
     'is_multiple', 'tasks_are_eager', 'to_tuple']
 
 import asyncio
 from collections.abc import Callable, Mapping, Sequence
-import inspect
 import itertools
 import logging
 import typing as t
@@ -24,7 +23,7 @@ def check_identifier(name: t.Any, msg_prefix: str) -> None:
     if not name:
         raise ValueError(f"{msg_prefix} cannot be an empty string")
     if not name.isidentifier():
-        raise ValueError(f"{msg_prefix} must be a valid identifier, got '{name!r}'")
+        raise ValueError(f"{msg_prefix} must be a valid identifier, got '{name}'")
 
 
 def is_multiple(arg: t.Any) -> bool:
@@ -50,19 +49,29 @@ def to_tuple(args: _T_item|Sequence[_T_item]) -> tuple[_T_item, ...]:
     return t.cast(tuple[_T_item], (args,))
 
 
-# must not touch *kwargs* # pylint: disable-next=dangerous-default-value
+def func_name(func: Callable[..., t.Any]) -> str:
+    """Return the name of a callable."""
+    if not callable(func):
+        raise TypeError(f"{func!r} is not callable")
+    if (name := getattr(func, '__name__', None)) is not None:
+        return name
+    # callable objects with __call__ do not have a __name__
+    if not isinstance(func, type) and (hasattr(ftype := type(func), '__call__')):
+        return f'{ftype.__name__}.__call__'
+    # fail-safe default, though there is no such type of callable
+    return ftype.__name__
+
+
 def func_call_string(
         func: Callable[..., t.Any]|None,
         args: Sequence[t.Any],
-        kwargs: Mapping[str, t.Any] = {}
+        kwargs: Mapping[str, t.Any]|None = None
         ) -> str:
     """Convert args and kwargs to a printable string."""
-    arglist = '(' + ', '.join(itertools.chain(
-        (repr(a) for a in args),
-        (f"{k}={v!r}" for k, v in kwargs.items()))) + ')'
-    if func is None:
-        return arglist
-    return func.__name__ + arglist
+    agen = (repr(a) for a in args)
+    gen = itertools.chain(agen, (f"{k}={v!r}" for k, v in kwargs.items())) if kwargs else agen
+    arglist = f"({', '.join(gen)})"
+    return arglist if func is None else func_name(func) + arglist
 
 
 def tasks_are_eager() -> bool:
@@ -81,36 +90,3 @@ def tasks_are_eager() -> bool:
         flag = True
     asyncio.create_task(test_task())
     return flag
-
-
-def check_async_coro(arg: t.Any) -> None:
-    """
-    Check if arg is a coroutine object.
-
-    Raise a TypeError with a descriptive message if it isn't.
-    """
-    if inspect.iscoroutine(arg):
-        return
-    if inspect.iscoroutinefunction(arg):
-        received = f"an async function '{arg.__name__}'. Did you mean '{arg.__name__}()'?"
-    else:
-        received = repr(arg)
-    raise TypeError(f"Expected a coroutine, but got {received}")
-
-
-def check_async_func(arg: t.Any) -> None:
-    """
-    Check if *arg* is an async function.
-
-    Raise a TypeError with a descriptive message if it isn't.
-    """
-    if inspect.iscoroutinefunction(arg):
-        return
-    if inspect.iscoroutine(arg):
-        received = (f"a coroutine '{arg.__name__}()'. "
-            + f"Did you mean '{arg.__name__}' without parentheses?")
-    elif callable(arg):
-        received = f"a non-async function/callable '{arg.__name__}'"
-    else:
-        received = repr(arg)
-    raise TypeError(f"Expected an async function, but got {received}")

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: redzed
-Version: 25.12.30
+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.2.4.dist-info/RECORD

@@ -0,0 +1,30 @@
+redzed/__init__.py,sha256=IVRc3KnMDB9N_M0fiii8X84I6_AEjhmOqtrzAJbvuzY,1097
+redzed/base_block.py,sha256=A1ZxEIH8jsNXj3z3HvzgAVshUsMoFtqIoR41-U2vMaw,5187
+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
+redzed/initializers.py,sha256=1vqnxvQTRYJunAOmYMuZAOL9sr1GPP9Wz2FK92o4wVc,7740
+redzed/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+redzed/signal_shutdown.py,sha256=BAolHuMw-P86R8cSIebjsvUDZOSt-PanKFA0iQS1GIc,2078
+redzed/undef.py,sha256=0Q70QdtbmCHbAmFwJJ7L8CILi1-hxYOKU5nlR5EyH9I,892
+redzed/blocklib/__init__.py,sha256=au7jbjO_RUFzK5U4STk-7pc1DTVA0OVh2W_aKsx1Y3s,557
+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=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=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.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,,

{redzed-25.12.30.dist-info → redzed-26.2.4.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{redzed-25.12.30.dist-info → redzed-26.2.4.dist-info}/licenses/LICENSE.txt

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Vlado Potisk <redzed@poti.sk>
+Copyright (c) 2025-2026 Vlado Potisk <redzed@poti.sk>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

redzed-25.12.30.dist-info/RECORD

@@ -1,28 +0,0 @@
-redzed/__init__.py,sha256=eyvuX8qwxEFuiP6jOu4x1qv-AmHJAGKOziV1dKCNWWA,1098
-redzed/base_block.py,sha256=NzJhY0POAJUyfp9EcQG2RvXM472vAV5iWG5LdsScpso,5191
-redzed/block.py,sha256=0iwK8Pb5LJ0xzoOt5dkx-FeWplzUzAWHOWfah368u7s,12012
-redzed/circuit.py,sha256=VkcAZZg5HfEdboUZ_vMnElI9E4MprwaoBveN8-hUvZw,31095
-redzed/cron_service.py,sha256=f-YR0w2U0dpipX271cyUYXvsvJunpE3mywuV7SkFE_k,10581
-redzed/debug.py,sha256=QeWHpfTZADPB6nY0zrj1Aqo91Wd9HB9bAJVgq_d3hCo,2767
-redzed/formula_trigger.py,sha256=0_TVbR1wCQ0Wv7NlJtcfD-iDUbmTBlbVCSdbKDw_tX0,7516
-redzed/initializers.py,sha256=oF5Wkdu2REFdfuCEdo8kS-9N2uW2dhdzYWoibILB3ks,7804
-redzed/signal_shutdown.py,sha256=KjL6Kq9K0m_2nerjo7hryNFPhgdNTmSyTOfDi-SMsjA,2081
-redzed/undef.py,sha256=iPxcUIKBDh5wqjdr8qvs9EQkx5s52ryNDY22at-PF0c,896
-redzed/blocklib/__init__.py,sha256=au7jbjO_RUFzK5U4STk-7pc1DTVA0OVh2W_aKsx1Y3s,557
-redzed/blocklib/counter.py,sha256=XvJPOarg6RZ9H-GrWFQrt3JJnGk9YGc1B7NOpF6ju4A,1125
-redzed/blocklib/fsm.py,sha256=6Qv4pOsF-FOEBm9NQUSD6F2yLfb0chvbpvbrgg3sIk8,23492
-redzed/blocklib/inputs.py,sha256=hhfU2Id7oJfmhZB-_PoowXBfYDuw9OQyceg_AprJVVs,7218
-redzed/blocklib/outputs.py,sha256=hoBPr_978PyhR6OzD0rxou34PFukIRD1pIpK6JNgqQE,12894
-redzed/blocklib/repeat.py,sha256=hkIO7qgm4wS32dcKkkfL_DjnoKWf-l3k2DfRiRUk6iE,2500
-redzed/blocklib/timedate.py,sha256=78wqiH1mUz5zoz3ZgDOmsPaYYmQLypgt9IfmLUcH9Cw,5196
-redzed/blocklib/timeinterval.py,sha256=hxPhao1Gm9q_NOp6WdjmsStkrfwkadH5uJh-Hli9D-4,6752
-redzed/blocklib/timer.py,sha256=X3CoqwGJ46oLw0R5u0HK1a11VpcZdTWvPbWOkFjZrDI,1520
-redzed/utils/__init__.py,sha256=Yo8cj1f1HQj862UOdCsXOkMg4kfq1c5S3HJDhuiE5os,326
-redzed/utils/async_utils.py,sha256=Vknijh9rABL8GcJbYv6a7I4qO2VLerMsGTr5wiGWbjo,4486
-redzed/utils/data_utils.py,sha256=xiaVnEJF7Q9oGFqqTOyiVyzI-sG0lYHxImfyFcXjwFI,3542
-redzed/utils/time_utils.py,sha256=eCqk4T4ipn4hgzL8-4Usn1W6kkTyRCuQ9-BMSvnELww,8524
-redzed-25.12.30.dist-info/licenses/LICENSE.txt,sha256=HwuPxdAOIKlSWHESVtk6Zov7d0BZaPu74eruoZc5UN8,1086
-redzed-25.12.30.dist-info/METADATA,sha256=LiyTs38Xa48jh2ozWNw1uUICaNKrTg7xWSUd1vEHTK0,2058
-redzed-25.12.30.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-redzed-25.12.30.dist-info/top_level.txt,sha256=7Rt0BRMqaJ0AGAmrd2JDqmqSY4cmQeW--7u6KDV1gZg,7
-redzed-25.12.30.dist-info/RECORD,,