pyroflow 0.1.6__tar.gz → 0.2.1__tar.gz

{pyroflow-0.1.6 → pyroflow-0.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyroflow
-Version: 0.1.6
+Version: 0.2.1
 Summary: Conversation-oriented Pyrogram extension with per-update listeners and multi-session coordination
 Project-URL: Homepage, https://github.com/eeeob/pyroflow
 Project-URL: Bug Tracker, https://github.com/eeeob/pyroflow/issues
@@ -13,7 +13,6 @@ Classifier: Framework :: AsyncIO
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -22,16 +21,21 @@ Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Communications :: Chat
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
-Requires-Python: >=3.9
+Requires-Python: >=3.10
 Requires-Dist: cachetools
 Requires-Dist: kurigram>=2.2.0
 Requires-Dist: sortedcontainers==2.4.0
-Requires-Dist: typing-extensions>=4.6.0; python_version < '3.10'
+Requires-Dist: typing-extensions>=4.6.0; python_version < '3.13'
 Provides-Extra: dev
 Requires-Dist: hatch<=1.16.5; extra == 'dev'
 Requires-Dist: twine<=6.2.0; extra == 'dev'
 Provides-Extra: redis
 Requires-Dist: redis>=4.2.0; extra == 'redis'
+Provides-Extra: test
+Requires-Dist: pytest-asyncio>=0.23; extra == 'test'
+Requires-Dist: pytest>=7.0; extra == 'test'
+Requires-Dist: redis>=4.2.0; extra == 'test'
+Requires-Dist: tomli; (python_version < '3.11') and extra == 'test'
 Description-Content-Type: text/markdown
 
 # pyroflow
@@ -72,7 +76,7 @@ pyroflow solves all three problems:
 
 ## Installation
 
-**Minimum requirements:** Python 3.9+
+**Minimum requirements:** Python 3.10+
 
 ```
 pip install pyroflow          # core
@@ -233,10 +237,10 @@ client.run()
 A `UpdateHistory` records which handlers ran successfully for each update. This enables features like `back` buttons that replay or inspect previous processing steps.
 
 ```python
-from pyroflow import Client, MessageHistory
+from pyroflow import Client, CallbackQueryHistory
 
 client = Client("my_session")
-client.register_history(MessageHistory())
+client.register_history(CallbackQueryHistory())
 
 client.run()
 ```
@@ -248,7 +252,7 @@ They can also be removed at runtime:
 ```python
 await client.unregister_listener(Message)
 await client.unregister_coordinated(Message)
-await client.unregister_history(Message)
+await client.unregister_history(CallbackQueryHistory)
 ```
 
 ---

{pyroflow-0.1.6 → pyroflow-0.2.1}/README.md

@@ -36,7 +36,7 @@ pyroflow solves all three problems:
 
 ## Installation
 
-**Minimum requirements:** Python 3.9+
+**Minimum requirements:** Python 3.10+
 
 ```
 pip install pyroflow          # core
@@ -197,10 +197,10 @@ client.run()
 A `UpdateHistory` records which handlers ran successfully for each update. This enables features like `back` buttons that replay or inspect previous processing steps.
 
 ```python
-from pyroflow import Client, MessageHistory
+from pyroflow import Client, CallbackQueryHistory
 
 client = Client("my_session")
-client.register_history(MessageHistory())
+client.register_history(CallbackQueryHistory())
 
 client.run()
 ```
@@ -212,7 +212,7 @@ They can also be removed at runtime:
 ```python
 await client.unregister_listener(Message)
 await client.unregister_coordinated(Message)
-await client.unregister_history(Message)
+await client.unregister_history(CallbackQueryHistory)
 ```
 
 ---

{pyroflow-0.1.6 → pyroflow-0.2.1}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "hatchling.build"
 name = "pyroflow"
 dynamic = ["version"]
 description = "Conversation-oriented Pyrogram extension with per-update listeners and multi-session coordination"
-requires-python = ">=3.9"
+requires-python = ">=3.10"
 authors = [{ name = "Abdullah", email = "aldheeb01@gmail.com" }]
 readme = "README.md"
 license = { text = "MIT" }
@@ -27,7 +27,6 @@ classifiers = [
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.9",
     "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
@@ -43,7 +42,7 @@ dependencies = [
     "cachetools", 
     "sortedcontainers==2.4.0", 
     "kurigram>=2.2.0", 
-    "typing_extensions>=4.6.0; python_version < '3.10'",
+    "typing_extensions>=4.6.0; python_version < '3.13'",
 ]
 
 
@@ -62,6 +61,13 @@ redis = [
     "redis>=4.2.0",
 ]
 
+test = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.23",
+    "redis>=4.2.0",
+    "tomli; python_version < '3.11'",
+]
+
 
 [tool.hatch.build.targets.sdist]
 exclude = [
@@ -78,3 +84,11 @@ allow-direct-references = true
 [tool.hatch.build.targets.wheel]
 ignore-vcs = true
 packages = ["pyroflow"]
+
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+testpaths = ["tests"]
+filterwarnings = [
+    "ignore::DeprecationWarning",
+]

{pyroflow-0.1.6 → pyroflow-0.2.1}/pyroflow/__init__.py

@@ -1,3 +1,5 @@
+from .__meta__ import __version__
+
 from .listener_coordinator import *
 from .update_coordinated import *
 from .update_coordinator import *
@@ -12,3 +14,4 @@ from .types import Message, CallbackQuery
 
 
 
+

pyroflow-0.2.1/pyroflow/__meta__.py

@@ -0,0 +1 @@
+__version__ = "0.2.1"

pyroflow-0.2.1/pyroflow/enums.py

@@ -0,0 +1,23 @@
+import sys
+
+if sys.version_info >= (3, 11):
+    from enum import StrEnum
+else:
+    from enum import Enum
+    
+    class StrEnum(str, Enum):
+        def _generate_next_value_(name, *args):
+            return name.lower()
+        def __str__(self):
+            return str(self.value)
+
+from enum import IntEnum, auto
+
+
+class UpdateLockState(IntEnum):
+    PROCESSING = 0
+    HANDLED    = 1
+
+class DuplicatePolicy(StrEnum):
+    REJECT = auto()
+    REPLACE = auto()

{pyroflow-0.1.6 → pyroflow-0.2.1}/pyroflow/listener_coordinator/listener_coordinator.py

@@ -1,18 +1,11 @@
 from abc import ABC, abstractmethod
-from typing import Optional, Union, Tuple, TYPE_CHECKING
+from typing import Optional, Union, Tuple, TypeAlias, TYPE_CHECKING
 
 
 from ..utils.typings import AsyncLockProto
 from ..typings import ListenerCoordinatorIdT
 from ..models import ListenerKey
 
-import sys
-
-if sys.version_info >= (3, 10):
-    from typing import TypeAlias
-else:
-    from typing_extensions import TypeAlias
-
 if TYPE_CHECKING:
     from ..update_listener import UpdateListener
 

{pyroflow-0.1.6 → pyroflow-0.2.1}/pyroflow/models.py

@@ -8,7 +8,6 @@ import asyncio
 import time
 
 
-
 @dataclass(frozen=True, slots=True, eq=False)
 class ListenerKey:
     chat_id: int
@@ -18,11 +17,11 @@ class ListenerKey:
     @property
     def to_tuple(self) -> Tuple[int, Optional[int], Optional[int]]:
         return (
-            self.chat_id, 
-            self.user_id, 
+            self.chat_id,
+            self.user_id,
             self.message_id
         )
-    
+
 
     def sub_keys(self, min_dep: int = 1) -> Generator["ListenerKey", None, None]:
         keys = self.to_tuple
@@ -32,26 +31,26 @@ class ListenerKey:
             yield ListenerKey(
                 *keys[:i]
             )
-    
+
     def __hash__(self):
         return hash(self.to_tuple)
-    
+
     def __eq__(self, value):
         return isinstance(value, ListenerKey) and self.to_tuple == value.to_tuple
 
 @dataclass(slots=True)
 class ListenerModel:
     key: ListenerKey
-    meta: Optional[JsonValueT] = None 
+    meta: Optional[JsonValueT] = None
     future: asyncio.Future = field(default_factory=asyncio.Future)
 
 
     def resolve(self, update) -> None:
         self.future.set_result(update)
-    
+
     def set_exc(self, exc: Exception) -> None:
         self.future.set_exception(exc)
-    
+
     def done(self) -> bool:
         return self.future.done()
 

{pyroflow-0.1.6 → pyroflow-0.2.1}/pyroflow/typings.py

@@ -1,11 +1,4 @@
-from typing import Union, Tuple
-
-import sys
-
-if sys.version_info >= (3, 10):
-    from typing import TypeAlias
-else:
-    from typing_extensions import TypeAlias
+from typing import Union, Tuple, TypeAlias
 
 UpdateCoordinatorKeyT: TypeAlias = Tuple[Union[int, str], ...]
 UpdateHistoryKeyT = UpdateCoordinatorKeyT

{pyroflow-0.1.6 → pyroflow-0.2.1}/pyroflow/update_coordinated/callback_query_coordinated.py

@@ -28,4 +28,4 @@ class CallbackQueryCoordinated(UpdateCoordinated[CallbackQuery]):
         return (update.id, )
     
     async def _is_coordinatable(self, update):
-        True
+        return True

pyroflow-0.2.1/pyroflow/update_history/message_history.py

@@ -0,0 +1,42 @@
+from typing import TYPE_CHECKING
+
+from ..types import Message
+from .update_history import UpdateHistory
+
+
+class MessageHistory(UpdateHistory[Message]):
+    __update_type__ = Message
+
+    if not TYPE_CHECKING:
+        def __init__(
+            self,
+            store_factory = None,
+            is_recordable_func = None,
+            extract_key_func = None,
+            extract_data_func = None,
+            **kw
+            ):
+
+            if is_recordable_func is None:
+                is_recordable_func = self._is_recordable
+
+            if extract_key_func is None:
+                extract_key_func = self._extract_key
+
+            if extract_data_func is None:
+                extract_data_func = self._extract_data
+
+            super().__init__(store_factory, is_recordable_func, extract_key_func, extract_data_func, **kw)
+
+    async def _is_recordable(self, update):
+        return update.chat is not None
+
+    async def _extract_key(self, update):
+        return (
+            update.chat.id,
+            getattr(update.from_user, "id", None),
+            update.id,
+        )
+
+    async def _extract_data(self, update):
+        return update.text

{pyroflow-0.1.6 → pyroflow-0.2.1}/pyroflow/utils/async_tools.py

@@ -3,18 +3,41 @@ from concurrent.futures import ThreadPoolExecutor
 
 from .typings import NestedContainer, MaybeAwaitable, _True, _False, _P, _T
 from .validate_tools import is_exception, iscoroutinefunction_wrapped
-from .iter_tools import flat_cont
+from .iter_tools import iter_flat_cont
 
 import asyncio
 import functools
 import logging
 import contextvars
 import inspect
+import traceback
 
 
 log = logging.getLogger(__file__)
 
 
+def _log_exc(
+    header: Optional[str],
+    caller_stack: List[traceback.FrameSummary],
+    exc: BaseException,
+    index: Optional[int] = None,
+) -> None:
+    exc_trace = traceback.format_exception(type(exc), exc, exc.__traceback__)
+    caller_trace = traceback.format_list(caller_stack)
+
+    if header is None:
+        header = ""
+
+    if index is not None:
+        header = f"{header} [awaitable index={index}]" if header else f"[awaitable index={index}]"
+
+    log.error(
+        "%s\n%s",
+        header,
+        "".join(caller_trace) + "".join(exc_trace)
+    )
+
+
 @overload
 async def to_thread(
     func: Callable[_P, _T],
@@ -37,25 +60,26 @@ async def to_thread(
     func,
     *args,
     executor = None,
-    log_exc = True, 
-    return_exc = False, 
+    log_exc = True,
+    return_exc = False,
     **kwargs,
     ):
-    
+    caller_stack = traceback.extract_stack()[:-1]
+
     loop = asyncio.get_running_loop()
     ctx = contextvars.copy_context()
     func = functools.partial(ctx.run, func, *args, **kwargs)
-    
-    
+
+
     try:
         return await loop.run_in_executor(executor, func)
     except Exception as e:
         if log_exc:
-            log.exception("error in to_thread")
-        
+            _log_exc("error in to_thread", caller_stack, e)
+
         if return_exc:
             return e
-        
+
         raise
 
 
@@ -77,12 +101,14 @@ async def gather_helper(
     log_exc = True,
     ):
 
-    results = await asyncio.gather(*flat_cont(coros), return_exceptions=return_exc)
+    caller_stack = traceback.extract_stack()[:-1]
 
-    if log_exc:
-        for r in results:
+    results = await asyncio.gather(*iter_flat_cont(coros), return_exceptions=return_exc)
+
+    if log_exc and return_exc:
+        for i, r in enumerate(results):
             if is_exception(r):
-                log.error("error in gather_helper", exc_info=r)
+                _log_exc("error in gather_helper", caller_stack, r, index=i)
 
     return results
 
@@ -130,15 +156,25 @@ async def safe_await(
     log_exc = True,
     ):
 
+    caller_stack = traceback.extract_stack()[:-1]
+
     results = []
+    is_multi = False
 
-    for coro in flat_cont(coros):
+    for i, coro in enumerate(iter_flat_cont(coros)):
+        if not is_multi and i > 0:
+            is_multi = True
         try:
             result = await coro
         except Exception as e:
             if log_exc:
-                log.exception("Error in safe_await")
-                
+                _log_exc(
+                    "error in safe_await",
+                    caller_stack,
+                    e,
+                    index=i if is_multi else None,
+                )
+
             result = e
 
         if is_exception(result):
@@ -172,21 +208,21 @@ async def maybe_awaitable(
 async def maybe_awaitable(
     awaitable_or_callable,
     *args,
-    executor = None, 
-    return_exc = False, 
+    executor = None,
+    return_exc = False,
     log_exc = True,
     **kwargs,
 ):
-    
+
     if inspect.isawaitable(awaitable_or_callable):
         if args or kwargs:
             raise TypeError(
                 "Cannot pass args/kwargs to an already-created awaitable"
             )
         return await safe_await(
-            awaitable_or_callable, 
-            return_exc=return_exc, 
-            log_exc=log_exc, 
+            awaitable_or_callable,
+            return_exc=return_exc,
+            log_exc=log_exc,
         )
     elif iscoroutinefunction_wrapped(awaitable_or_callable):
         return await safe_await(
@@ -209,12 +245,9 @@ async def maybe_awaitable(
         )
 
 
-
-
-
 __all__ = [
-    "to_thread", 
-    "gather_helper", 
-    "safe_await", 
+    "to_thread",
+    "gather_helper",
+    "safe_await",
     "maybe_awaitable"
-]
+]

{pyroflow-0.1.6 → pyroflow-0.2.1}/pyroflow/utils/classes.py

@@ -1,18 +1,12 @@
 from abc import ABC
-from typing import Generic, Type
+from typing import Generic, Type, ClassVar
 
 from pyrogram.types import Update as PyroUpdate
 from .typings import UpdateType
 
 import asyncio
-import sys
 
 
-if sys.version_info >= (3, 10):
-    from typing import ClassVar
-else:
-    from typing_extensions import ClassVar
-
 class AsyncioLock(asyncio.Lock):
     async def release(self):
         return super().release()

pyroflow-0.2.1/pyroflow/utils/iter_tools.py

@@ -0,0 +1,37 @@
+from typing import List, Generator, Any, overload
+
+
+from .typings import NestedContainer, _T
+from .validate_tools import is_container
+
+
+
+
+@overload
+def iter_flat_cont(*containers: None) -> Generator[Any, None, None]: ...
+@overload
+def iter_flat_cont(*containers: NestedContainer[None]) -> Generator[Any, None, None]: ...
+@overload
+def iter_flat_cont(*containers: NestedContainer[_T]) -> Generator[_T, None, None]: ...
+def iter_flat_cont(*containers):
+    for item in containers:
+        if is_container(item):
+            yield from iter_flat_cont(*item)
+        elif item is not None:
+            yield item
+
+@overload
+def flat_cont(*containers: None) -> List: ...
+@overload
+def flat_cont(*containers: NestedContainer[None]) -> List: ...
+@overload
+def flat_cont(*containers: NestedContainer[_T]) -> List[_T]: ...
+def flat_cont(*containers):
+    return list(iter_flat_cont(*containers))
+
+
+__all__ = (
+    "iter_flat_cont", 
+    "flat_cont", 
+    
+)

{pyroflow-0.1.6 → pyroflow-0.2.1}/pyroflow/utils/typings.py

@@ -1,19 +1,15 @@
 from typing import (
-    Collection as TCollection, Generator, Union, Reversible, 
-    Sequence, AbstractSet, Mapping, List, Any, Dict, 
-    Callable, Coroutine, Awaitable, TypeVar, 
-    Literal, TYPE_CHECKING, 
+    Collection as TCollection, Generator, Union, Reversible,
+    Sequence, AbstractSet, Mapping, List, Any, Dict,
+    Coroutine, Awaitable, TypeVar,
+    Literal, TYPE_CHECKING,
+    ParamSpec, TypeAlias, Protocol, Callable,
 )
 
 from enum import Enum
 
 import sys
 
-if sys.version_info >= (3, 10):
-    from typing import ParamSpec, TypeAlias, Protocol
-else:
-    from typing_extensions import ParamSpec, TypeAlias, Protocol
-
 if sys.version_info >= (3, 11):
     from enum import EnumType
 else:
@@ -74,15 +70,15 @@ UpdateType = TypeVar("UpdateType", bound=PyroUpdate)
 
 
 __all__ = (
-    "Container", 
-    "NestedContainer", 
-    "NotContainer", 
-    "MaybeAwaitable", 
-    "Number", 
-    "MaybeCoroutineCallable", 
-    "AsyncLockProto", 
-    "JsonValueT", 
-    "UpdateType", 
-    "_P", "_T", "_CT", 
-    "_True", "_False", 
+    "Container",
+    "NestedContainer",
+    "NotContainer",
+    "MaybeAwaitable",
+    "Number",
+    "MaybeCoroutineCallable",
+    "AsyncLockProto",
+    "JsonValueT",
+    "UpdateType",
+    "_P", "_T", "_CT",
+    "_True", "_False",
 )

{pyroflow-0.1.6 → pyroflow-0.2.1}/pyroflow/utils/validate_tools.py

@@ -1,4 +1,4 @@
-from typing import Any, Union
+from typing import Any, Union, get_args
 
 import sys
 import inspect
@@ -6,20 +6,21 @@ import inspect
 
 if sys.version_info >= (3, 13):
     from typing import TypeIs
-elif sys.version_info >= (3, 10):
-    from typing_extensions import TypeIs
 else:
-    from typing_extensions import TypeGuard as TypeIs
+    from typing_extensions import TypeIs
 
 from .typings import Container, NotContainer, _T
 
+_CONTAINER_TYPES = get_args(Container)
+_NOT_CONTAINER_TYPES = get_args(NotContainer)
+
 def is_exception(obj: Any) -> TypeIs[BaseException]:
     return isinstance(obj, BaseException)
 
 def is_container(obj: Any) -> TypeIs[Union['Container[_T]', Any]]:
-    return isinstance(obj, Container) and not isinstance(obj, NotContainer)
+    return isinstance(obj, _CONTAINER_TYPES) and not isinstance(obj, _NOT_CONTAINER_TYPES)
 
-def iscoroutinefunction_wrapped(f):
+def iscoroutinefunction_wrapped(f) -> bool:
     is_coro = False
 
     def _stop(func):