aiogram_tool 1.0.0__tar.gz

aiogram_tool-1.0.0/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Dyadchenko Vladislav Sergeevich
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

aiogram_tool-1.0.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.3
+Name: aiogram_tool
+Version: 1.0.0
+Summary: Tools which doing work with aiogram simple
+License: LICENSE.md
+Author: Vlad_shayzi1
+Author-email: tecnomega@mail.ru
+Requires-Python: >=3.10
+Classifier: License :: Other/Proprietary License
+Classifier: Programming Language :: Python :: 3
+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)
+Description-Content-Type: text/markdown
+
+## aiogram_tool
+It's libriary with tools for aiogram.
+
+
+# What kind of tools are these?
+- [Dependency Injection](https://github.com/shayzi3/aiogram_tool/blob/master/examples/depend/default.py)
+- [Rate limiter for handlers](https://github.com/shayzi3/aiogram_tool/blob/master/examples/limit/default.py)
+
+
+## Installation
+
+### Pip
+```cmd
+pip install aiogram_tool
+```
+
+### Poetry
+```cmd
+poetry add aiogram_tool
+```
+
+
+## Documentation
+
+- [RU](https://github.com/shayzi3/aiogram_tool/tree/master/docs/ru)
+- [EN](https://github.com/shayzi3/aiogram_tool/tree/master/docs/en)
+
+
+## Features `Depend`
+
+- Depend without response for Router, handler
+- Exit from depend before call handler
+- use cache
+

aiogram_tool-1.0.0/README.md

@@ -0,0 +1,33 @@
+## aiogram_tool
+It's libriary with tools for aiogram.
+
+
+# What kind of tools are these?
+- [Dependency Injection](https://github.com/shayzi3/aiogram_tool/blob/master/examples/depend/default.py)
+- [Rate limiter for handlers](https://github.com/shayzi3/aiogram_tool/blob/master/examples/limit/default.py)
+
+
+## Installation
+
+### Pip
+```cmd
+pip install aiogram_tool
+```
+
+### Poetry
+```cmd
+poetry add aiogram_tool
+```
+
+
+## Documentation
+
+- [RU](https://github.com/shayzi3/aiogram_tool/tree/master/docs/ru)
+- [EN](https://github.com/shayzi3/aiogram_tool/tree/master/docs/en)
+
+
+## Features `Depend`
+
+- Depend without response for Router, handler
+- Exit from depend before call handler
+- use cache

aiogram_tool-1.0.0/aiogram_tool/depend/__init__.py

@@ -0,0 +1,10 @@
+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.0/aiogram_tool/depend/components/filter.py

@@ -0,0 +1,28 @@
+from typing import Any
+
+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]})
+          depend_kwargs = await inject_parametrs(
+               callback=handler_object.callback,
+               dependency_override=dependency_override,
+               middleware_data=kwargs
+          )
+          return depend_kwargs

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

@@ -0,0 +1,36 @@
+from typing import Any, Callable, Awaitable
+
+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})
+          inject = await inject_parametrs(
+               callback=handler_object.callback,
+               dependency_override=dependency_override,
+               middleware_data=data
+          )
+          data.update(inject)
+          return await handler(event, data)

aiogram_tool-1.0.0/aiogram_tool/depend/depend.py

@@ -0,0 +1,103 @@
+import inspect
+
+from contextlib import (
+     asynccontextmanager, 
+     contextmanager
+)
+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 == "_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 type_ in types:
+                         if isinstance(type_, Depend):
+                              self.arguments[key] = type_
+                              
+               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]) -> Any:
+          kwargs = {}
+          for key, value in self.arguments.items():
+               if isinstance(value, Depend):
+                    kwargs[key] = await value.call(middleware_data)
+               else:
+                    kwargs[key] = middleware_data.get(key)
+
+          if self.isasync is False:
+               if self.isgenerator is True:
+                    with self.obj(**kwargs) as value:
+                         return value
+               return self.obj(**kwargs)
+               
+          else:
+               if self.isgenerator is True:
+                    async with self.obj(**kwargs) as asvalue:
+                         return asvalue
+               return await self.obj(**kwargs)

aiogram_tool-1.0.0/aiogram_tool/depend/setup.py

@@ -0,0 +1,34 @@
+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.0/aiogram_tool/depend/utils/inject.py

@@ -0,0 +1,33 @@
+import inspect
+
+from typing import Any, Callable, _AnnotatedAlias
+
+from ..depend import Depend
+
+
+
+async def inject_parametrs(
+     callback: Callable,
+     middleware_data: dict[str, Any],
+     dependency_override: dict[str, Depend] = {},
+) -> dict[str, Any]:
+     data = {}
+     signature = inspect.signature(callback)
+     for key, annotation in signature.parameters.items():
+          default_value = annotation.default
+               
+          if isinstance(annotation.annotation, _AnnotatedAlias):
+               types = getattr(annotation.annotation, "__metadata__")
+               for type_ in types:
+                    if isinstance(type_, Depend):
+                         if type_.obj_name in dependency_override.keys():
+                              data[key] = await dependency_override[type_.obj_name].call(middleware_data)
+                         else:
+                              data[key] = await type_.call(middleware_data)
+               
+          elif isinstance(default_value, Depend):
+               if default_value.obj_name in dependency_override.keys():
+                    data[key] = await dependency_override[default_value.obj_name].call(middleware_data)
+               else:
+                    data[key] = await default_value.call(middleware_data)
+     return data

aiogram_tool-1.0.0/aiogram_tool/limit/__init__.py

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

aiogram_tool-1.0.0/aiogram_tool/limit/limit.py

@@ -0,0 +1,87 @@
+import inspect
+
+from typing import Callable, Awaitable
+from datetime import datetime, timedelta
+
+from aiogram import Dispatcher
+from aiogram.filters import Filter
+from aiogram.types.base import TelegramObject
+from aiogram.dispatcher.event.handler import HandlerObject
+
+from .storage.abstract_storage import AbstractStorage
+from .storage import MemoryStorage
+
+
+
+
+class Limit(Filter):
+     
+     def __init__(
+          self,
+          seconds: float = 0,
+          minutes: float = 0,
+          hours: float = 0,
+          days: float = 0,
+          all_users: bool = False,
+          storage: AbstractStorage | None = None,
+          answer_callback: Callable[[TelegramObject, timedelta, datetime], Awaitable] | None = None
+     ) -> None:
+          if not isinstance(all_users, bool):
+               raise TypeError("all_users must be bool type")
+          
+          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")
+          
+          # checks types
+          self.storage = storage
+          self.answer_callback = answer_callback
+          self.all_users = all_users
+          
+          self.time = timedelta(
+               seconds=seconds,
+               minutes=minutes,
+               hours=hours,
+               days=days
+          )
+          
+          
+     async def __call__(
+          self, 
+          message: TelegramObject, 
+          dispatcher: Dispatcher, 
+          handler: HandlerObject
+     ) -> bool:
+          storage = dispatcher.workflow_data.get("storage", MemoryStorage())
+          answer_callback = dispatcher.workflow_data.get("answer_callback")
+          
+          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:
+               query = "users" + "@" + handler.callback.__name__
+          
+          user_time = await storage.get(query)
+          if user_time is None:
+               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)
+               else:
+                    await message.answer(f"Retry after {round(time_last.total_seconds(), 0)} seconds")
+               return False
+          
+          await storage.update(query, datetime.utcnow() + self.time)
+          return True
+          

aiogram_tool-1.0.0/aiogram_tool/limit/setup.py

@@ -0,0 +1,27 @@
+import inspect
+
+from typing import Callable, Awaitable
+from aiogram.types import Message
+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[[Message, 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)

aiogram_tool-1.0.0/aiogram_tool/limit/storage/__init__.py

@@ -0,0 +1,7 @@
+from .memory_storage import MemoryStorage
+from .redis_storage import RedisStorage
+
+
+__all__ = [
+     "RedisStorage",
+]

aiogram_tool-1.0.0/aiogram_tool/limit/storage/abstract_storage.py

@@ -0,0 +1,16 @@
+from abc import ABC, abstractmethod
+from datetime import datetime
+
+
+
+class AbstractStorage(ABC):
+     
+     
+     @abstractmethod
+     async def get(self, name: str) -> datetime | None:
+          raise NotImplementedError
+     
+     
+     @abstractmethod
+     async def update(self, name: str, value: datetime) -> None:
+          raise NotImplementedError

aiogram_tool-1.0.0/aiogram_tool/limit/storage/memory_storage.py

@@ -0,0 +1,23 @@
+from datetime import datetime
+
+from .abstract_storage import AbstractStorage
+
+
+
+class DataStorage:
+     data: dict[str, datetime] = {}
+     
+     
+
+
+class MemoryStorage(AbstractStorage):
+     def __init__(self):
+          self.storage = DataStorage
+     
+     
+     async def get(self, name: str) -> datetime | None:
+          return self.storage.data.get(name)
+     
+     
+     async def update(self, name: str, value: datetime) -> None:
+          self.storage.data.update({name: value})

aiogram_tool-1.0.0/aiogram_tool/limit/storage/redis_storage.py

@@ -0,0 +1,37 @@
+import json
+
+from datetime import datetime
+from redis.asyncio import Redis as AsyncRedis
+
+
+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")
+          
+          self.redis = redis
+          
+          
+     async def get(self, name: str) -> datetime | None:
+          async with self.redis as session:
+               data = await session.hget(name="limit_tool", key=name)
+               if data is None:
+                    return None
+               
+               if isinstance(data, bytes):
+                    data = data.decode()
+          return datetime.fromisoformat(data)
+     
+          
+     async def update(self, name: str, value: datetime) -> None:
+          async with self.redis as session:
+               await session.hset(
+                    name="limit_tool",
+                    key=name,
+                    value=value.isoformat()
+               )

aiogram_tool-1.0.0/pyproject.toml

@@ -0,0 +1,19 @@
+[project]
+name = "aiogram_tool"
+version = "1.0.0"
+description = "Tools which doing work with aiogram simple"
+authors = [
+    {name = "Vlad_shayzi1",email = "tecnomega@mail.ru"}
+]
+license = "LICENSE.md"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "aiogram (>=3.21.0,<4.0.0)",
+    "redis (>=6.2.0,<7.0.0)"
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"