aiogram_tool 1.1.0__tar.gz → 1.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: aiogram_tool
-Version: 1.1.0
+Version: 1.2.0
 Summary: Tools which doing work with aiogram simple
 License: MIT
 Keywords: aiogram,rate,throttling,limit,dependency-injection,depends,cooldown,delay,DI
@@ -48,5 +48,3 @@ poetry add aiogram_tool
 ## Features `Depend`
 
 - Depend for Router
-- cache
-- scopes

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

@@ -28,6 +28,4 @@ poetry add aiogram_tool
 
 ## Features `Depend`
 
-- Depend for Router
-- cache
-- scopes
+- Depend for Router

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

@@ -1,11 +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"
+     "DependFilter",
+     "DependHandler",
+     "dependency_scope",
+     "Scope"
 ]

{aiogram_tool-1.1.0 → aiogram_tool-1.2.0}/aiogram_tool/depend/components/__init__.py

@@ -1,7 +1,7 @@
 from .exit import DependExit
 from .handler import DependHandler
-from .filter import DependFilter
-from .outer_middleware import StackMiddleware
+from .inner_middleware import DependInnerMiddleware
+
 
 __all__ = [
      "DependExit",

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

@@ -0,0 +1,42 @@
+from typing import Awaitable, Callable, Any
+from contextlib import AsyncExitStack
+
+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_callback import inject_parametrs
+
+
+
+class DependInnerMiddleware(BaseMiddleware):
+     
+     async def __call__(
+          self, 
+          handler: Callable[[TelegramObject, dict[str, Any]], Awaitable[Any]], 
+          event: TelegramObject, 
+          data: dict[str, Any]
+     ) -> Any:
+          data.update({"event": event})
+          
+          dispatcher: Dispatcher = data.get("dispatcher")
+          handler_object: HandlerObject = data.get("handler")
+          
+          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.1.0 → aiogram_tool-1.2.0}/aiogram_tool/depend/setup.py

@@ -1,10 +1,8 @@
 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
+from .components import DependInnerMiddleware
 
 
 
@@ -25,25 +23,19 @@ def setup_depend_tool(
           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}")
+          for update in allowed_updates:
+               if update not in dispatcher.observers:
+                    raise TypeError(f"Invalid observer {update}")
                else:
-                    observer: TelegramEventObserver = getattr(dispatcher, allow)
-                    
-                    if observer.handlers:
-                         observer.outer_middleware(StackMiddleware())
-                         for handler in observer.handlers:
-                              handler.filters.append(FilterObject(DependFilter()))
+                    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())
+               
                
-               if observer.handlers:
-                    observer.outer_middleware(StackMiddleware())
-                    for handler in observer.handlers:
-                         handler.filters.append(FilterObject(DependFilter()))
                     
                
                

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.1.0 → aiogram_tool-1.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "aiogram_tool"
-version = "1.1.0"
+version = "1.2.0"
 description = "Tools which doing work with aiogram simple"
 authors = [
     {name = "Vlad_shayzi1",email = "tecnomega@mail.ru"}

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

@@ -1,35 +0,0 @@
-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/outer_middleware.py

@@ -1,19 +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
-
-
-
-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/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)