aiogram_tool 1.0.1__tar.gz → 1.2.0__tar.gz

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

@@ -1,9 +1,9 @@
 Metadata-Version: 2.3
 Name: aiogram_tool
-Version: 1.0.1
+Version: 1.2.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,4 @@ poetry add aiogram_tool
 
 ## Features `Depend`
 
-- Depend without response for Router, handler
-- Exit from depend before call handler
-- use cache
-
+- Depend for Router

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

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

aiogram_tool-1.2.0/aiogram_tool/depend/__init__.py

@@ -0,0 +1,16 @@
+from .depend import Depend
+from .setup import setup_depend_tool
+from .components import DependExit, DependHandler
+from .utils.depend_scope import dependency_scope
+from .types.enums import Scope
+
+
+__all__ = [
+     "Depend",
+     "setup_depend_tool",
+     "DependExit",
+     "DependFilter",
+     "DependHandler",
+     "dependency_scope",
+     "Scope"
+]

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

@@ -0,0 +1,9 @@
+from .exit import DependExit
+from .handler import DependHandler
+from .inner_middleware import DependInnerMiddleware
+
+
+__all__ = [
+     "DependExit",
+     "DependHandler",
+]

aiogram_tool-1.2.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.2.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.0.1/aiogram_tool/depend/components/middleware.py → aiogram_tool-1.2.0/aiogram_tool/depend/components/inner_middleware.py

@@ -1,39 +1,42 @@
-from typing import Any, Callable, Awaitable
+from typing import Awaitable, Callable, Any
 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 aiogram.types.base import TelegramObject
+from aiogram.dispatcher.middlewares.base import BaseMiddleware
 
+from .exit import DependExit
 from ..depend import Depend
-from ..utils.inject import inject_parametrs
+from ..utils.inject_callback import inject_parametrs
 
 
 
-
-
-class DependMiddleware(BaseMiddleware):
-          
-          
+class DependInnerMiddleware(BaseMiddleware):
+     
      async def __call__(
           self, 
-          handler: Callable[[TelegramObject, dict[str, Any]], Awaitable], 
+          handler: Callable[[TelegramObject, dict[str, Any]], Awaitable[Any]], 
           event: TelegramObject, 
           data: dict[str, Any]
-     ):
-          handler_object: HandlerObject = data.get("handler")
-          dispatcher: Dispatcher = data.get("dispatcher")
+     ) -> Any:
+          data.update({"event": event})
           
-          dependency_override: dict[str, Depend] = dispatcher.workflow_data.get("dependency_override", {})
+          dispatcher: Dispatcher = data.get("dispatcher")
+          handler_object: HandlerObject = data.get("handler")
           
-          data.update({"event": event})
-          async with AsyncExitStack() as stack:
+          dependency_override: dict[str, Depend] = dispatcher.get("dependency_override", {})
+
+          async with AsyncExitStack() as 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):
+                         return await value.event_answer()
+
                data.update(inject)
                return await handler(event, data)

aiogram_tool-1.2.0/aiogram_tool/depend/depend.py

@@ -0,0 +1,63 @@
+import inspect
+
+from typing import Callable, Any
+from contextlib import AsyncExitStack
+
+from .utils.explore_obj import ExploreObj
+from .types.schema import ScopeObject
+from .types.enums import Scope
+
+
+
+class Depend(ExploreObj):
+     app_container = {}
+     
+     def __init__(self, obj: Callable) -> None:
+          self.scope = Scope.REQUEST
+
+          explore_obj = obj
+          if not inspect.iscoroutinefunction(obj):
+               try:
+                    scope_object = obj() 
+                    if isinstance(scope_object, ScopeObject):
+                         explore_obj = scope_object.obj
+                         self.scope = scope_object.scope
+               except:
+                    pass
+                    
+          super().__init__(obj=explore_obj)
+          
+     async def call(
+          self, 
+          middleware_data: dict[str, Any],
+          stack: AsyncExitStack
+     ) -> Any:
+          if self.scope == Scope.APP:
+               if self.obj_name in self.app_container:
+                    return self.app_container[self.obj_name]
+          
+          inject_obj_parameters = {}
+          for key, value in self.obj_parameters.items():
+               if isinstance(value, Depend):
+                    inject_obj_parameters[key] = await value.call(middleware_data, stack)
+                    
+               elif value is inspect._empty:
+                    inject_obj_parameters[key] = middleware_data.get(key, None)
+                    
+          obj_returning = None
+          call_obj_with_params = self.obj(**inject_obj_parameters)
+          if self.isasync is False:
+               if self.isgenerator is True:
+                    obj_returning = stack.enter_context(call_obj_with_params)
+               else:
+                    obj_returning = call_obj_with_params
+          else:
+               if self.isgenerator is True:
+                    obj_returning = await stack.enter_async_context(call_obj_with_params)
+               else:
+                    obj_returning = await call_obj_with_params
+                    
+          if self.scope == Scope.APP:
+               if self.obj_name not in self.app_container:
+                    self.app_container[self.obj_name] = obj_returning
+          return obj_returning

aiogram_tool-1.2.0/aiogram_tool/depend/setup.py

@@ -0,0 +1,42 @@
+from aiogram import Dispatcher
+from aiogram.dispatcher.event.telegram import TelegramEventObserver
+
+from .depend import Depend
+from .components import DependInnerMiddleware
+
+
+
+
+
+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 update in allowed_updates:
+               if update not in dispatcher.observers:
+                    raise TypeError(f"Invalid observer {update}")
+               else:
+                    observer: TelegramEventObserver = dispatcher.observers.get(update)
+                    observer.middleware(DependInnerMiddleware())
+     
+     else:
+          for allow in dispatcher.resolve_used_update_types():
+               observer: TelegramEventObserver = getattr(dispatcher, allow)
+               observer.middleware(DependInnerMiddleware())
+               
+               
+                    
+               
+               
+     

aiogram_tool-1.2.0/aiogram_tool/depend/types/enums.py

@@ -0,0 +1,11 @@
+from enum import Enum, auto
+
+
+class Scope(Enum):
+     """
+     APP: Caching the result for the entire duration of the application
+     \nREQUEST: New result for every request
+     """
+     APP = auto()
+     REQUEST = auto()
+     

aiogram_tool-1.2.0/aiogram_tool/depend/types/schema.py

@@ -0,0 +1,10 @@
+from typing import Callable
+from dataclasses import dataclass
+
+from .enums import Scope
+
+
+@dataclass
+class ScopeObject:
+     obj: Callable
+     scope: Scope

aiogram_tool-1.2.0/aiogram_tool/depend/utils/depend_scope.py

@@ -0,0 +1,22 @@
+from typing import Callable, ParamSpec, TypeVar
+from functools import wraps
+
+from ..types.schema import ScopeObject
+from ..types.enums import Scope
+
+
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+
+def dependency_scope(scope: Scope) -> Callable[[Callable[P, R]], Callable[P, R]]:
+     def decorator(obj: Callable[P, R]) -> Callable[P, R]:
+          @wraps(obj)
+          def wrapper() -> ScopeObject:
+               return ScopeObject(
+                    obj=obj,
+                    scope=scope
+               )
+          return wrapper
+     return decorator

aiogram_tool-1.2.0/aiogram_tool/depend/utils/explore_obj.py

@@ -0,0 +1,58 @@
+import inspect
+
+from typing import Callable, _AnnotatedAlias
+from contextlib import asynccontextmanager, contextmanager
+
+from aiogram_tool import depend
+
+     
+
+
+class ExploreObj:
+     def __init__(self, obj: Callable):
+          self.obj = obj
+          self.isgenerator = False
+          self.isasync = False
+          self.obj_parameters: dict[str, depend.Depend] = {}
+          self.obj_name = getattr(obj, "__name__", "")
+          
+          if isinstance(self.obj, type):
+               raise TypeError("dont valid type. Initialize class")
+          
+          if not callable(self.obj):
+               raise TypeError("obj must be a callable")
+          
+          if not inspect.isfunction(self.obj):
+               self.obj_name = self.obj.__class__.__name__
+               self.obj = getattr(self.obj, "__call__")
+               
+          self.__rule_for_call_obj()
+          self.__find_obj_parameters()
+               
+     
+     def __rule_for_call_obj(self) -> None:
+          if inspect.iscoroutinefunction(self.obj):
+               self.isasync = True
+               
+          else:
+               if inspect.isasyncgenfunction(self.obj):
+                    self.isgenerator = True
+                    self.isasync = True
+                    self.obj = asynccontextmanager(self.obj)
+                    
+               elif inspect.isgeneratorfunction(self.obj):
+                    self.isgenerator = True
+                    self.obj = contextmanager(self.obj)
+                    
+                    
+     def __find_obj_parameters(self) -> None:
+          signature = inspect.signature(self.obj)
+          for param, param_spec in signature.parameters.items():
+               if isinstance(param_spec.annotation, _AnnotatedAlias):
+                    types = getattr(param_spec.annotation, "__metadata__")
+                    for dependency in types:
+                         if isinstance(dependency, depend.Depend):
+                              self.obj_parameters[param] = dependency
+               else:
+                    self.obj_parameters[param] = param_spec.default
+                    

aiogram_tool-1.0.1/aiogram_tool/depend/utils/inject.py → aiogram_tool-1.2.0/aiogram_tool/depend/utils/inject_callback.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.2.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.2.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.2.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.2.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.2.0/aiogram_tool/limit/utils/__init__.py

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

aiogram_tool-1.2.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.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aiogram_tool"
-version = "1.0.1"
+version = "1.2.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/__init__.py

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

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/depend.py

@@ -1,104 +0,0 @@
-import inspect
-
-from contextlib import (
-     asynccontextmanager, 
-     contextmanager,
-     AsyncExitStack
-)
-from typing import (
-     Callable, 
-     Any, 
-     _AnnotatedAlias
-)
-
-
-
-class Depend:
-     def __init__(self, obj: Callable) -> None:
-          self.obj = obj
-          self.isgenerator = False
-          self.isasync = False
-          self.obj_name = getattr(obj, "__name__", "")
-          self.arguments = {}
-          
-          if isinstance(self.obj, type):
-               raise TypeError("dont valid type. Initialize class")
-          
-          if not callable(self.obj):
-               raise TypeError("obj must be a callable")
-          
-          if not inspect.isfunction(self.obj):
-               self.obj_name = self.obj.__class__.__name__
-               self.obj = getattr(self.obj, "__call__")
-                    
-          self.__explore_obj()
-          self.__explore_signature()
-          
-                    
-     def __explore_obj(self) -> None:
-          if inspect.iscoroutinefunction(self.obj):
-               self.isasync = True
-               
-          else:
-               if inspect.isasyncgenfunction(self.obj):
-                    self.isgenerator = True
-                    self.isasync = True
-                    self.obj = asynccontextmanager(self.obj)
-                    
-               elif inspect.isgeneratorfunction(self.obj):
-                    self.isgenerator = True
-                    self.obj = contextmanager(self.obj)
-                    
-               else:
-                    types = []
-                    for closure in inspect.getclosurevars(self.obj):
-                         if isinstance(closure, dict):
-                              types.extend(list(closure.values()))
-
-                    for type_ in types:
-                         name = getattr(type_, "__name__", None)
-                         if name in "_AsyncGeneratorContextManager":
-                              self.isasync = True
-                              self.isgenerator = True
-                              
-                         elif name == "_GeneratorContextManager":
-                              self.isgenerator = True
-                    
-                    
-     def __explore_signature(self) -> None:
-          signature = inspect.signature(self.obj)
-          for key, annotation in signature.parameters.items():
-               default_value = annotation.default
-               
-               if isinstance(annotation.annotation, _AnnotatedAlias):
-                    types = getattr(annotation.annotation, "__metadata__")
-                    for dep in types:
-                         if isinstance(dep, Depend):
-                              self.arguments[key] = dep
-                              
-               elif isinstance(default_value, Depend):
-                    self.arguments[key] = default_value
-                    
-               else:
-                    self.arguments[key] = annotation.annotation
-                 
-     async def call(
-          self, 
-          middleware_data: dict[str, Any],
-          stack: AsyncExitStack
-     ) -> Any:
-          kwargs = {}
-          for key, value in self.arguments.items():
-               if isinstance(value, Depend):
-                    kwargs[key] = await value.call(middleware_data, stack)
-               else:
-                    kwargs[key] = middleware_data.get(key)
-                    
-          if self.isasync is False:
-               if self.isgenerator is True:
-                    return stack.enter_context(self.obj(**kwargs))
-               return self.obj(**kwargs)
-          else:
-               if self.isgenerator is True:
-                    return await stack.enter_async_context(self.obj(**kwargs))
-               return await self.obj(**kwargs)

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)