aiogram_tool 1.0.1__tar.gz → 1.1.0__tar.gz

{aiogram_tool-1.0.1 → aiogram_tool-1.1.0}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.3
 Name: aiogram_tool
-Version: 1.0.1
+Version: 1.1.0
 Summary: Tools which doing work with aiogram simple
 License: MIT
-Keywords: aiogram,rate,throttling,limit,dependency-injection,depends,cooldown,delay
+Keywords: aiogram,rate,throttling,limit,dependency-injection,depends,cooldown,delay,DI
 Author: Vlad_shayzi1
 Author-email: tecnomega@mail.ru
 Requires-Python: >=3.10
@@ -13,8 +13,8 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
-Requires-Dist: aiogram (>=3.21.0,<4.0.0)
-Requires-Dist: redis (>=6.2.0,<7.0.0)
+Requires-Dist: aiogram (>=3.22.0,<4.0.0)
+Requires-Dist: redis (>=6.4.0,<7.0.0)
 Description-Content-Type: text/markdown
 
 ## aiogram_tool
@@ -47,7 +47,6 @@ poetry add aiogram_tool
 
 ## Features `Depend`
 
-- Depend without response for Router, handler
-- Exit from depend before call handler
-- use cache
-
+- Depend for Router
+- cache
+- scopes

{aiogram_tool-1.0.1 → aiogram_tool-1.1.0}/README.md

@@ -28,6 +28,6 @@ poetry add aiogram_tool
 
 ## Features `Depend`
 
-- Depend without response for Router, handler
-- Exit from depend before call handler
-- use cache
+- Depend for Router
+- cache
+- scopes

{aiogram_tool-1.0.1 → aiogram_tool-1.1.0}/aiogram_tool/depend/__init__.py

@@ -1,10 +1,11 @@
 from .depend import Depend
-from .components.filter import DependFilter
 from .setup import setup_depend_tool
+from .components import DependExit, DependHandler
 
 
 __all__ = [
      "Depend",
-     "DependFilter",
      "setup_depend_tool",
+     "DependExit",
+     "DependFilter"
 ]

aiogram_tool-1.1.0/aiogram_tool/depend/components/__init__.py

@@ -0,0 +1,9 @@
+from .exit import DependExit
+from .handler import DependHandler
+from .filter import DependFilter
+from .outer_middleware import StackMiddleware
+
+__all__ = [
+     "DependExit",
+     "DependHandler",
+]

aiogram_tool-1.1.0/aiogram_tool/depend/components/exit.py

@@ -0,0 +1,19 @@
+from aiogram.types.base import TelegramObject
+
+
+
+class DependExit:
+     def __init__(
+          self, 
+          event: TelegramObject | None = None,
+          **event_kwargs
+     ) -> None:
+          if not hasattr(event, "answer") and event is not None:
+               raise ValueError("event haven't method answer")
+          
+          self._event = event
+          self._event_kwargs = event_kwargs
+          
+     async def event_answer(self) -> None:
+          if self._event is not None:
+               await self._event.answer(**self._event_kwargs)

aiogram_tool-1.1.0/aiogram_tool/depend/components/filter.py

@@ -0,0 +1,35 @@
+from contextlib import AsyncExitStack
+
+from aiogram.filters import Filter
+from aiogram.types.base import TelegramObject
+from aiogram import Dispatcher
+from aiogram.dispatcher.event.handler import HandlerObject
+
+from .exit import DependExit
+from ..depend import Depend
+from ..utils.inject import inject_parametrs
+
+
+
+class DependFilter(Filter):
+     
+     async def __call__(self, event: TelegramObject, **data):
+          data.update({"event": event})
+          
+          dispatcher: Dispatcher = data.get("dispatcher")
+          handler_object: HandlerObject = data.get("handler")
+          
+          dependency_override: dict[str, Depend] = dispatcher.get("dependency_override", {})
+          stack: AsyncExitStack = data.get("async_stack")
+          
+          inject = await inject_parametrs(
+               callback=handler_object.callback,
+               dependency_override=dependency_override,
+               middleware_data=data,
+               stack=stack
+          )
+          for value in inject.values():
+               if isinstance(value, DependExit):
+                    await value.event_answer()
+                    return False
+          return inject

aiogram_tool-1.1.0/aiogram_tool/depend/components/handler.py

@@ -0,0 +1,35 @@
+from contextlib import AsyncExitStack
+from aiogram.filters import Filter
+from aiogram.types.base import TelegramObject
+
+from ..depend import Depend
+from .exit import DependExit
+
+
+
+class DependHandler(Filter):
+     def __init__(self, *dependencies: Depend):
+          for dep in dependencies:
+               if not isinstance(dep, Depend):
+                    raise TypeError("Invalid type in dependency")
+          
+          self._dependencies = dependencies
+             
+          
+     async def __call__(self, event: TelegramObject, **kwargs) -> bool:
+          kwargs.update({"event": event})
+          
+          async with AsyncExitStack() as stack:
+               for depend in self._dependencies:
+                    result = await depend.call(
+                         middleware_data=kwargs,
+                         stack=stack
+                    )
+                    if isinstance(result, DependExit):
+                         await result.event_answer()
+                         return False
+          return True
+               
+               
+               
+     

aiogram_tool-1.1.0/aiogram_tool/depend/components/outer_middleware.py

@@ -0,0 +1,19 @@
+from typing import Any, Callable, Awaitable
+from contextlib import AsyncExitStack
+
+from aiogram.dispatcher.middlewares.base import BaseMiddleware
+from aiogram.types.base import TelegramObject
+
+
+
+class StackMiddleware(BaseMiddleware):
+     
+     async def __call__(
+          self, 
+          handler: Callable[[TelegramObject, dict[str, Any]], Awaitable],
+          event: TelegramObject, 
+          data: dict[str, Any]
+     ):
+          async with AsyncExitStack() as stack:
+               data.update({"async_stack": stack})
+               return await handler(event, data)

aiogram_tool-1.1.0/aiogram_tool/depend/setup.py

@@ -0,0 +1,50 @@
+from aiogram import Dispatcher
+from aiogram.dispatcher.event.telegram import TelegramEventObserver
+from aiogram.dispatcher.event.handler import FilterObject
+
+
+from .depend import Depend
+from .components import DependFilter, StackMiddleware
+
+
+
+
+
+def setup_depend_tool(
+     dispatcher: Dispatcher,
+     dependency_override: dict[str, Depend] = {},
+     allowed_updates: list[str] = [],
+) -> None:
+     if not isinstance(dispatcher, Dispatcher):
+          raise TypeError("Invalid type for dispatcher")
+     
+     if dependency_override:
+          for dep in dependency_override.values():
+               if not isinstance(dep, Depend):
+                    raise TypeError("Invalid type in dependency_override")
+          dispatcher["dependency_override"] = dependency_override     
+               
+     if allowed_updates:
+          for allow in allowed_updates:
+               if allow not in dispatcher.observers:
+                    raise TypeError(f"Invalid observer {allow}")
+               else:
+                    observer: TelegramEventObserver = getattr(dispatcher, allow)
+                    
+                    if observer.handlers:
+                         observer.outer_middleware(StackMiddleware())
+                         for handler in observer.handlers:
+                              handler.filters.append(FilterObject(DependFilter()))
+     
+     else:
+          for allow in dispatcher.resolve_used_update_types():
+               observer: TelegramEventObserver = getattr(dispatcher, allow)
+               
+               if observer.handlers:
+                    observer.outer_middleware(StackMiddleware())
+                    for handler in observer.handlers:
+                         handler.filters.append(FilterObject(DependFilter()))
+                    
+               
+               
+     

{aiogram_tool-1.0.1 → aiogram_tool-1.1.0}/aiogram_tool/depend/utils/inject.py

@@ -13,7 +13,7 @@ from ..depend import Depend
 
 async def depend_call(
      depend: Depend, 
-     dependency_override: dict[str, Any],
+     dependency_override: dict[str, Depend],
      middleware_data: dict[str, Any],
      stack: AsyncExitStack
 ) -> Any:
@@ -30,7 +30,7 @@ async def inject_parametrs(
      middleware_data: dict[str, Any],
      dependency_override: dict[str, Depend] = {},
 ) -> dict[str, Any]:
-     data = {}
+     injected_params = {}
      signature = inspect.signature(callback)
      for key, annotation in signature.parameters.items():
           default_value = annotation.default
@@ -39,7 +39,7 @@ async def inject_parametrs(
                types = getattr(annotation.annotation, "__metadata__")
                for dep in types:
                     if isinstance(dep, Depend):
-                         data[key] = await depend_call(
+                         injected_params[key] = await depend_call(
                               depend=dep,
                               dependency_override=dependency_override,
                               middleware_data=middleware_data,
@@ -47,10 +47,10 @@ async def inject_parametrs(
                          )
                          
           elif isinstance(default_value, Depend):
-               data[key] = await depend_call(
+               injected_params[key] = await depend_call(
                     depend=default_value,
                     dependency_override=dependency_override,
                     middleware_data=middleware_data,
                     stack=stack
                )
-     return data
+     return injected_params

aiogram_tool-1.1.0/aiogram_tool/limit/__init__.py

@@ -0,0 +1,12 @@
+from .limit import Limit
+from .setup import setup_limit_tool
+from .utils import AnswerCallback
+from .storage import RedisStorage, MemoryStorage
+
+__all__ = [
+     "Limit",
+     "setup_limit_tool",
+     "AnswerCallback",
+     "RedisStorage",
+     "MemoryStorage",
+]

{aiogram_tool-1.0.1 → aiogram_tool-1.1.0}/aiogram_tool/limit/limit.py

@@ -1,6 +1,5 @@
 import inspect
 
-from typing import Callable, Awaitable
 from datetime import datetime, timedelta
 
 from aiogram import Dispatcher
@@ -8,6 +7,7 @@ from aiogram.filters import Filter
 from aiogram.types.base import TelegramObject
 from aiogram.dispatcher.event.handler import HandlerObject
 
+from .utils.callback import AnswerCallback
 from .storage.abstract_storage import AbstractStorage
 from .storage import MemoryStorage
 
@@ -24,25 +24,24 @@ class Limit(Filter):
           days: float = 0,
           all_users: bool = False,
           storage: AbstractStorage | None = None,
-          answer_callback: Callable[[TelegramObject, timedelta, datetime], Awaitable] | None = None
+          answer_callback: AnswerCallback | None = None
      ) -> None:
           if not isinstance(all_users, bool):
-               raise TypeError("all_users must be bool type")
+               raise TypeError("Invalid type for all_users")
           
           if storage is not None:
                if not issubclass(type(storage), AbstractStorage):
                     raise TypeError(f"Invalid type for storage")
           
           if answer_callback is not None:
-               if not inspect.iscoroutinefunction(answer_callback):
-                    raise TypeError(f"answer_callback must be croutine function")
+               if not isinstance(answer_callback, AnswerCallback):
+                    raise TypeError(f"Invalid type for answer_callback")
           
-          # checks types
-          self.storage = storage
-          self.answer_callback = answer_callback
-          self.all_users = all_users
+          self._storage = storage
+          self._answer_callback = answer_callback
+          self._all_users = all_users
           
-          self.time = timedelta(
+          self._time = timedelta(
                seconds=seconds,
                minutes=minutes,
                hours=hours,
@@ -52,36 +51,36 @@ class Limit(Filter):
           
      async def __call__(
           self, 
-          message: TelegramObject, 
+          event: TelegramObject, 
           dispatcher: Dispatcher, 
           handler: HandlerObject
      ) -> bool:
-          storage = dispatcher.workflow_data.get("storage", MemoryStorage())
-          answer_callback = dispatcher.workflow_data.get("answer_callback")
+          storage: AbstractStorage = dispatcher.get("storage", MemoryStorage())
+          answer_callback: AnswerCallback | None = dispatcher.get("answer_callback", None)
           
-          if self.storage is not None:
-               storage = self.storage
+          if self._storage is not None:
+               storage = self._storage
                
-          if self.answer_callback is not None:
-               answer_callback = self.answer_callback
-               
-          query = str(message.from_user.id) + "@" + handler.callback.__name__
-          if self.all_users is True:
+          if self._answer_callback is not None:
+               answer_callback = self._answer_callback
+                    
+          query = str(event.from_user.id) + "@" + handler.callback.__name__
+          if self._all_users is True:
                query = "users" + "@" + handler.callback.__name__
           
           user_time = await storage.get(query)
           if user_time is None:
-               await storage.update(query, datetime.utcnow() + self.time)
+               await storage.update(query, datetime.utcnow() + self._time)
                return True
                
           if user_time >= datetime.utcnow():
                time_last = user_time - datetime.utcnow()
                if answer_callback is not None:
-                    await answer_callback(message, self.time, time_last)
+                    await answer_callback.call(event, self._time, time_last)
                else:
-                    await message.answer(f"Retry after {round(time_last.total_seconds(), 0)} seconds")
+                    await event.answer(f"Retry after {round(time_last.total_seconds(), 0)} seconds")
                return False
           
-          await storage.update(query, datetime.utcnow() + self.time)
+          await storage.update(query, datetime.utcnow() + self._time)
           return True
           

aiogram_tool-1.1.0/aiogram_tool/limit/setup.py

@@ -0,0 +1,25 @@
+from aiogram import Dispatcher
+
+from .utils.callback import AnswerCallback
+from .storage.abstract_storage import AbstractStorage
+from .storage import MemoryStorage
+
+
+
+def setup_limit_tool(
+     dispatcher: Dispatcher,
+     storage: AbstractStorage = MemoryStorage(),
+     answer_callback: AnswerCallback | None = None
+) -> None:
+     if not isinstance(dispatcher, Dispatcher):
+          raise TypeError("Invalid type for dispatcher")
+     
+     if not issubclass(type(storage), AbstractStorage):
+          raise TypeError("Invalid type for storage")
+     
+     if answer_callback is not None:
+          if not isinstance(answer_callback, AnswerCallback):
+               raise TypeError("Invalid type for answer_callback")
+     
+     dispatcher["storage"] = storage
+     dispatcher["answer_callback"] = answer_callback

{aiogram_tool-1.0.1 → aiogram_tool-1.1.0}/aiogram_tool/limit/storage/redis_storage.py

@@ -1,5 +1,3 @@
-import json
-
 from datetime import datetime
 from redis.asyncio import Redis as AsyncRedis
 
@@ -12,13 +10,13 @@ from .abstract_storage import AbstractStorage
 class RedisStorage(AbstractStorage):
      def __init__(self, redis: AsyncRedis):
           if not isinstance(redis, AsyncRedis):
-               raise TypeError("Invalid type for argument redis")
+               raise TypeError("Invalid type for redis")
           
-          self.redis = redis
+          self._redis = redis
           
           
      async def get(self, name: str) -> datetime | None:
-          async with self.redis as session:
+          async with self._redis as session:
                data = await session.hget(name="limit_tool", key=name)
                if data is None:
                     return None
@@ -29,7 +27,7 @@ class RedisStorage(AbstractStorage):
      
           
      async def update(self, name: str, value: datetime) -> None:
-          async with self.redis as session:
+          async with self._redis as session:
                await session.hset(
                     name="limit_tool",
                     key=name,

aiogram_tool-1.1.0/aiogram_tool/limit/utils/__init__.py

@@ -0,0 +1,6 @@
+from .callback import AnswerCallback
+
+
+__all__ = [
+     "AnswerCallback",
+]

aiogram_tool-1.1.0/aiogram_tool/limit/utils/callback.py

@@ -0,0 +1,40 @@
+import inspect
+
+from typing import Callable, Any
+
+from datetime import timedelta, datetime
+from aiogram.types.base import TelegramObject
+
+
+
+class AnswerCallback:
+     def __init__(self, obj: Callable[[TelegramObject, timedelta, datetime], Any]):
+          self._isasync = False
+          self._obj = obj
+          
+          if not callable(self._obj):
+               raise ValueError("obj in AnswerCallback must be callable")
+          
+          self.__explore_obj()
+          
+     
+     def __explore_obj(self) -> None:
+          if not inspect.isfunction(self._obj):
+               self._obj = getattr(self._obj, "__call__", None)
+               if self._obj is None:
+                    raise ValueError(f"don't find method __call__ at obj")
+               
+          if inspect.iscoroutinefunction(self._obj):
+               self._isasync = True
+          else:
+               self._isasync = False
+          
+          
+     async def call(
+          self, 
+          event: TelegramObject, 
+          rate_time: timedelta, 
+          time_last: datetime
+     ) -> Any:
+          calling = self._obj(event, rate_time, time_last)
+          return await calling if self._isasync else calling

{aiogram_tool-1.0.1 → aiogram_tool-1.1.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aiogram_tool"
-version = "1.0.1"
+version = "1.1.0"
 description = "Tools which doing work with aiogram simple"
 authors = [
     {name = "Vlad_shayzi1",email = "tecnomega@mail.ru"}
@@ -9,8 +9,8 @@ license = "MIT"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-    "redis (>=6.2.0,<7.0.0)",
-    "aiogram (>=3.21.0,<4.0.0)"
+    "aiogram (>=3.22.0,<4.0.0)",
+    "redis (>=6.4.0,<7.0.0)"
 ]
 keywords = [
     "aiogram",
@@ -20,7 +20,8 @@ keywords = [
     "dependency-injection",
     "depends",
     "cooldown",
-    "delay"
+    "delay",
+    "DI"
 ]
 
 

aiogram_tool-1.0.1/aiogram_tool/depend/components/filter.py

@@ -1,31 +0,0 @@
-from typing import Any
-from contextlib import AsyncExitStack
-
-from aiogram.filters import Filter
-from aiogram import Dispatcher
-from aiogram.dispatcher.event.handler import HandlerObject
-
-from ..depend import Depend
-from ..utils.inject import inject_parametrs
-
-
-
-
-class DependFilter(Filter):
-     
-     
-     async def __call__(self, *args: Any, **kwargs: dict[str, Any]) -> dict[str, Any]:
-          handler_object: HandlerObject = kwargs.get("handler")
-          dispatcher: Dispatcher = kwargs.get("dispatcher")
-          
-          dependency_override: dict[str, Depend] = dispatcher.workflow_data.get("dependency_override", {})
-          
-          kwargs.update({"event": args[0]})
-          async with AsyncExitStack() as stack:
-               depend_kwargs = await inject_parametrs(
-                    callback=handler_object.callback,
-                    dependency_override=dependency_override,
-                    middleware_data=kwargs,
-                    stack=stack
-               )
-               return depend_kwargs

aiogram_tool-1.0.1/aiogram_tool/depend/components/middleware.py

@@ -1,39 +0,0 @@
-from typing import Any, Callable, Awaitable
-from contextlib import AsyncExitStack
-
-from aiogram.dispatcher.middlewares.base import BaseMiddleware
-from aiogram.types.base import TelegramObject
-from aiogram import Dispatcher
-from aiogram.dispatcher.event.handler import HandlerObject
-
-from ..depend import Depend
-from ..utils.inject import inject_parametrs
-
-
-
-
-
-class DependMiddleware(BaseMiddleware):
-          
-          
-     async def __call__(
-          self, 
-          handler: Callable[[TelegramObject, dict[str, Any]], Awaitable], 
-          event: TelegramObject, 
-          data: dict[str, Any]
-     ):
-          handler_object: HandlerObject = data.get("handler")
-          dispatcher: Dispatcher = data.get("dispatcher")
-          
-          dependency_override: dict[str, Depend] = dispatcher.workflow_data.get("dependency_override", {})
-          
-          data.update({"event": event})
-          async with AsyncExitStack() as stack:
-               inject = await inject_parametrs(
-                    callback=handler_object.callback,
-                    dependency_override=dependency_override,
-                    middleware_data=data,
-                    stack=stack
-               )
-               data.update(inject)
-               return await handler(event, data)

aiogram_tool-1.0.1/aiogram_tool/depend/setup.py

@@ -1,34 +0,0 @@
-from aiogram import Dispatcher
-from aiogram.dispatcher.event.telegram import TelegramEventObserver
-
-from .depend import Depend
-from .components.middleware import DependMiddleware
-
-
-
-
-
-def setup_depend_tool(
-     dispatcher: Dispatcher,
-     dependency_override: dict[str, Depend] = {},
-     allowed_updates: list[str] = [],
-     middleware: bool = True,
-) -> None:
-     if not isinstance(dispatcher, Dispatcher):
-          raise TypeError("dispatcher must be Dispatcher type")
-     
-     if dependency_override:
-          for dep in dependency_override.values():
-               if not isinstance(dep, Depend):
-                    raise TypeError(f"Invalid type in dependency_override {dep}")
-               
-     if allowed_updates:
-          for allow in allowed_updates:
-               if allow not in dispatcher.observers:
-                    raise TypeError(f"observer {allow} not exists")
-     
-     if middleware is True:
-          for allow in dispatcher.resolve_used_update_types() or allowed_updates:
-               observer: TelegramEventObserver = getattr(dispatcher, allow)
-               observer.middleware(DependMiddleware())
-     dispatcher.__setitem__("dependency_override", dependency_override)

aiogram_tool-1.0.1/aiogram_tool/limit/__init__.py

@@ -1,7 +0,0 @@
-from .limit import Limit
-from .setup import setup_limit_tool
-
-__all__ = [
-     "Limit",
-     "setup_limit_tool"
-]

aiogram_tool-1.0.1/aiogram_tool/limit/setup.py

@@ -1,27 +0,0 @@
-import inspect
-
-from typing import Callable, Awaitable
-from aiogram.types.base import TelegramObject
-from aiogram import Dispatcher
-
-from datetime import datetime, timedelta
-
-from .storage.abstract_storage import AbstractStorage
-from .storage import MemoryStorage
-
-
-
-def setup_limit_tool(
-     dispatcher: Dispatcher,
-     storage: AbstractStorage = MemoryStorage(),
-     answer_callback: Callable[[TelegramObject, timedelta, datetime], Awaitable] | None = None
-) -> None:
-     if not issubclass(type(storage), AbstractStorage):
-          raise TypeError(f"Invalid type for storage")
-     
-     if answer_callback is not None:
-          if not inspect.iscoroutinefunction(answer_callback):
-               raise TypeError(f"answer_callback must be croutine function")
-          
-     dispatcher.__setitem__("storage", storage)
-     dispatcher.__setitem__("answer_callback", answer_callback)