aiogram-tool 1.2.2__tar.gz → 1.2.3__tar.gz

{aiogram_tool-1.2.2 → aiogram_tool-1.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: aiogram-tool
-Version: 1.2.2
+Version: 1.2.3
 Summary: Tools which doing work with aiogram simple
 Project-URL: Repository, https://github.com/shayzi3/aiogram_tool
 Project-URL: Contributing, https://github.com/shayzi3/aiogram_tool/blob/master/CONTRIBUTING.md

aiogram_tool-1.2.3/docs/en/setup.md

@@ -0,0 +1,128 @@
+# aiogram_tool_setup
+
+`aiogram_tool_setup` is the main entry point of the library. It registers all tools on the aiogram dispatcher and must be called **before** starting polling / webhooks.
+
+- **Module:** `aiogram_tool.tools.setup`
+- **Requirements:** Python 3.11+, aiogram 3.x
+
+## Signature
+
+```python
+def aiogram_tool_setup(
+    dispatcher: Dispatcher,
+    tools: Iterable[BaseTool],
+) -> None:
+    """Main function for registering all tools"""
+```
+
+### Parameters
+
+| Parameter | Type | Description |
+|---|---|---|
+| `dispatcher` | `aiogram.Dispatcher` | The aiogram 3.x dispatcher instance the tools will be registered on |
+| `tools` | `Iterable[BaseTool]` | An iterable (usually a list) of tools implementing the `BaseTool` interface |
+
+The function returns nothing (`None`).
+
+## BaseTool
+
+All library tools inherit from the abstract base class:
+
+```python
+class BaseTool(ABC):
+    @abstractmethod
+    def setup(self, dispatcher: Dispatcher) -> None:
+        raise NotImplementedError
+```
+
+To write your own tool, implement the `setup` method, which subscribes filters/middlewares on the dispatcher:
+
+```python
+from aiogram import Dispatcher
+from aiogram_tool.tools.setup import BaseTool
+
+
+class MyTool(BaseTool):
+    def setup(self, dispatcher: Dispatcher) -> None:
+        # e.g. dispatcher.message.outer_middleware(...)
+        ...
+```
+
+## Validation
+
+- `dispatcher` is not an instance of `Dispatcher` → `TypeError("Invalid type for dispatcher")`
+- An item from `tools` is not an instance of `BaseTool` → `TypeError(f"Invalid type for tool {tool}")`
+
+Tools are invoked in the order they appear in the iterable.
+
+## Available tools
+
+| Tool | Import | Purpose |
+|---|---|---|
+| `DependTool` | `aiogram_tool.tools.depend` | FastAPI-style dependency injection |
+| `RateLimitTool` | `aiogram_tool.tools.limit` | Rate limiting for handlers |
+| `LongCallbackData` / `CallbackDataAnswer` | `aiogram_tool.tools.callback_data` | Bypassing the 64-byte `callback_data` limit (used as a base class, see the callback_data documentation) |
+
+Details: [depend.md](depend.md), [limit.md](limit.md), [callback_data.md](callback_data.md).
+
+## Examples
+
+### Basic usage
+
+```python
+from aiogram import Bot, Dispatcher
+from aiogram_tool.tools.setup import aiogram_tool_setup
+from aiogram_tool.tools.depend import DependTool
+from aiogram_tool.tools.limit import RateLimitTool
+
+bot = Bot("YOUR_TOKEN_HERE")
+dp = Dispatcher()
+
+aiogram_tool_setup(dp, [DependTool(), RateLimitTool()])
+
+await dp.start_polling(bot)
+```
+
+### With custom infrastructure
+
+Many tools accept constructor parameters (e.g. a storage or a scope registry) that are passed before `setup` is called:
+
+```python
+from redis.asyncio import Redis as AsyncRedis
+
+from aiogram_tool.tools.setup import aiogram_tool_setup
+from aiogram_tool.tools.depend import DependTool, ScopeRegistry
+from aiogram_tool.tools.limit import RateLimitTool
+from aiogram_tool.storage import AsyncRedisLockStorage
+
+scope_registry = ScopeRegistry()
+redis = AsyncRedis()
+
+aiogram_tool_setup(
+    dp,
+    [
+        DependTool(scope_registry=scope_registry),
+        RateLimitTool(storage=AsyncRedisLockStorage(redis=redis)),
+    ],
+)
+```
+
+> See the documentation of the corresponding tool for tool constructor signatures.
+
+### Registering multiple instances
+
+The order in the list determines the registration order on the dispatcher:
+
+```python
+aiogram_tool_setup(dp, [RateLimitTool(...), DependTool(...)])
+```
+
+## Errors
+
+```python
+aiogram_tool_setup(bot, [DependTool()])
+# TypeError: Invalid type for dispatcher
+
+aiogram_tool_setup(dp, [SomeRandomObject()])
+# TypeError: Invalid type for tool <SomeRandomObject ...>
+```

aiogram_tool-1.2.3/docs/en/storages.md

@@ -0,0 +1,215 @@
+# Storages
+
+The `aiogram_tool.storage` module provides backends for storing tool state (rate limiting, long callback data, etc.) and locks.
+
+- **Package:** `aiogram_tool/storage/`
+- **Public imports:** `aiogram_tool.storage` re-exports all classes (`FileStorage`, `FileLockStorage`, `MemoryStorage`, `MemoryLockStorage`, `AsyncRedisStorage`, `AsyncRedisLockStorage`)
+
+## Overview
+
+| Storage | Inheritance | Persistence | Locks |
+|---|---|---|---|
+| `MemoryStorage` | `BaseStorage` | In memory (lost on restart) | ❌ |
+| `MemoryLockStorage` | `MemoryStorage`, `BaseLockStorage` | In memory | ✅ |
+| `AsyncRedisStorage` | `BaseStorage` | Redis (survives restart, shared across instances) | ❌ |
+| `AsyncRedisLockStorage` | `AsyncRedisStorage`, `BaseLockStorage` | Redis | ✅ |
+| `FileStorage` | `MemoryStorage` | Local file | ❌ |
+| `FileLockStorage` | `FileStorage`, `BaseLockStorage` | Local file + memory | ✅ |
+
+## Interfaces
+
+### `BaseStorage` (`aiogram_tool.storage.base`)
+
+```python
+class BaseStorage(ABC):
+    async def set_value(self, key: str, value: str) -> None: ...
+    async def get_value(self, key: str) -> str | _MISSING: ...
+```
+
+- `get_value` returns a `str` or the `_MISSING` sentinel (`aiogram_tool.types._MISSING`) if the key is absent. Do not use `None` as an absence check.
+
+### `BaseLockStorage`
+
+```python
+class BaseLockStorage(BaseStorage):
+    async def lock(self, key: str) -> AbstractAsyncContextManager[None]: ...
+```
+
+The `lock(key)` method returns an async context manager that locks by key:
+
+```python
+async with storage.lock("my_key"):
+    ...  # critical section
+```
+
+---
+
+## MemoryStorage
+
+The simplest storage based on `dict` (or rather, any `MutableMapping`). Suitable for development, tests, and bots without persistence requirements.
+
+```python
+MemoryStorage(storage: MutableMapping | None = None)
+```
+
+- `storage` — an optional external mapping (useful for tests and pre-filling).
+
+> As a `MutableMapping` you can pass not only a `dict`, but also caches from [`cachetools`](https://github.com/uri-grants/cachetools) — for example, `Cache` or `TTLCache` (with automatic eviction by size or TTL).
+
+```python
+from aiogram_tool.storage import MemoryStorage
+
+storage = MemoryStorage()
+await storage.set_value("key", "value")
+value = await storage.get_value("key")  # "value"
+```
+
+## MemoryLockStorage
+
+Same as `MemoryStorage`, plus locks based on `asyncio.Lock`. `lock(key)` lazily creates and returns an `asyncio.Lock` for the key, protected by a global internal lock.
+
+```python
+MemoryLockStorage(
+    storage: MutableMapping | None = None,
+    locks_storage: MutableMapping | None = None,
+)
+```
+
+- `locks_storage` — an external mapping for the locks themselves (optional).
+
+⚠️ Locks only work within the current process — not suitable for multiple bot instances.
+
+```python
+from aiogram_tool.storage import MemoryLockStorage
+
+storage = MemoryLockStorage()
+async with storage.lock("user:123"):
+    ...
+```
+
+## AsyncRedisStorage
+
+A Redis-backed storage (`redis.asyncio.Redis`). Recommended for production: state survives restarts and is shared between instances.
+
+```python
+AsyncRedisStorage(redis: AsyncRedis, expire: int | None = None)
+```
+
+- `redis` — a `redis.asyncio.Redis` client
+- `expire` — TTL in seconds for each entry; `None` — no expiration
+
+```python
+from redis.asyncio import Redis as AsyncRedis
+from aiogram_tool.storage import AsyncRedisStorage
+
+storage = AsyncRedisStorage(redis=AsyncRedis(), expire=3600)
+await storage.set_value("key", "value")
+value = await storage.get_value("key")  # "value" (bytes are decoded automatically)
+```
+
+The value passed to `set_value` does not have to be a `str` — it is passed to Redis as is.
+
+## AsyncRedisLockStorage
+
+A Redis storage with distributed locks (`redis.asyncio.lock.Lock`).
+
+```python
+AsyncRedisLockStorage(redis: AsyncRedis, expire: int | None = None)
+```
+
+`lock(key)` returns a Redis lock with the key `aigram_tool_lock:{key}`, `timeout=10` and `blocking_timeout=10` (seconds). Suitable for multiple bot instances.
+
+```python
+from redis.asyncio import Redis as AsyncRedis
+from aiogram_tool.storage import AsyncRedisLockStorage
+
+storage = AsyncRedisLockStorage(redis=AsyncRedis(), expire=3600)
+async with storage.lock("my_key"):
+    ...
+```
+
+## FileStorage
+
+A storage in a text file (format: `key&value` lines). Inherits from `MemoryStorage`.
+
+```python
+FileStorage(file: str, storage: MutableMapping | None = None)
+```
+
+- `file` — path to an existing file; if the file is missing, `FileNotFoundError` is raised
+- `storage` — an optional internal `MutableMapping` cache; if provided, the "file + memory" mode is enabled: reads check the cache first and cache results read from the file
+
+Features:
+
+- The `&` symbol is forbidden in keys (`ValueError`)
+- Entries are appended to the end of the file (`a`); reads go from the end of the file — the last write for a key wins
+- Values may contain `&` (parsing uses `maxsplit=1`)
+
+```python
+from aiogram_tool.storage import FileStorage
+
+storage = FileStorage(file="state.txt", storage={})
+await storage.set_value("key", "value")
+value = await storage.get_value("key")
+```
+
+> The file must exist before the storage is created — create it in advance if necessary (e.g. `Path("state.txt").touch()`).
+
+## FileLockStorage
+
+`FileStorage` + locks based on `asyncio.Lock` (same as `MemoryLockStorage`).
+
+```python
+FileLockStorage(
+    file: str,
+    storage: MutableMapping | None = None,
+    locks_storage: MutableMapping | None = None,
+)
+```
+
+Data is persisted in the file, but locks are process-local.
+
+## Passing storages to tools
+
+Storages are usually passed to a tool's constructor when calling `aiogram_tool_setup`:
+
+```python
+from redis.asyncio import Redis as AsyncRedis
+
+from aiogram_tool.tools.setup import aiogram_tool_setup
+from aiogram_tool.tools.limit import RateLimitTool
+from aiogram_tool.storage import AsyncRedisLockStorage
+
+aiogram_tool_setup(
+    dp,
+    [
+        RateLimitTool(storage=AsyncRedisLockStorage(redis=AsyncRedis(), expire=3600)),
+    ],
+)
+```
+
+A callback data example:
+
+```python
+from redis.asyncio import Redis as AsyncRedis
+from aiogram_tool.tools.callback_data import LongCallbackData
+from aiogram_tool.storage import AsyncRedisLockStorage
+
+
+class PersistentData(LongCallbackData, prefix="redis"):
+    _storage = AsyncRedisLockStorage(redis=AsyncRedis(), expire=3600)
+    user_id: int
+    big_context: str
+```
+
+## Choosing a storage
+
+- **Development / tests** → `MemoryStorage` / `MemoryLockStorage`
+- **Production, single instance, no Redis** → `FileStorage` / `FileLockStorage`
+- **Production, multiple instances, or reliability needed** → `AsyncRedisStorage` / `AsyncRedisLockStorage`
+
+## Limitations
+
+- Locks of `MemoryLockStorage` and `FileLockStorage` do not work across processes — use `AsyncRedisLockStorage` for multiple workers
+- `FileStorage` performs a full scan of the file on every read (without a cache) — use Redis for large volumes of data
+- `FileStorage` requires an existing file and forbids `&` in keys

aiogram_tool-1.2.3/docs/ru/setup.md

@@ -0,0 +1,106 @@
+# aiogram_tool_setup
+
+`aiogram_tool_setup` — главная точка входа библиотеки. Она регистрирует все инструменты в диспетчере aiogram и должна вызываться **до** старта пуллинга / вебхуков.
+
+## Сигнатура
+
+```python
+def aiogram_tool_setup(
+    dispatcher: Dispatcher,
+    tools: Iterable[BaseTool],
+) -> None:
+    """Main function for registering all tools"""
+```
+
+### Параметры
+
+| Параметр | Тип | Описание |
+|---|---|---|
+| `dispatcher` | `aiogram.Dispatcher` | Экземпляр диспетчера aiogram 3.x, в котором будут зарегистрированы инструменты |
+| `tools` | `Iterable[BaseTool]` | Итерируемый набор инструментов (обычно список), реализующих интерфейс `BaseTool` |
+
+Функция ничего не возвращает (`None`).
+
+## BaseTool
+
+Все инструменты библиотеки наследуются от абстрактного базового класса:
+
+```python
+class BaseTool(ABC):
+    @abstractmethod
+    def setup(self, dispatcher: Dispatcher) -> None:
+        raise NotImplementedError
+```
+
+Чтобы написать собственный инструмент, реализуйте метод `setup`, который сохраняет фильтры/мидлвари в диспетчере:
+
+```python
+from aiogram import Dispatcher
+from aiogram_tool.tools.setup import BaseTool
+
+
+class MyTool(BaseTool):
+    def setup(self, dispatcher: Dispatcher) -> None:
+        # например, dispatcher.message.outer_middleware(...)
+        ...
+```
+
+Инструменты вызываются в порядке следования в итерируемом объекте.
+
+## Доступные инструменты
+
+| Инструмент | Импорт | Назначение |
+|---|---|---|
+| `DependTool` | `aiogram_tool.tools.depend` | Dependency injection в стиле FastAPI |
+| `RateLimitTool` | `aiogram_tool.tools.limit` | Ограничение частоты вызовов хендлеров |
+| `LongCallbackData` / `CallbackDataAnswer` | `aiogram_tool.tools.callback_data` | Обход лимита 64 байт для `callback_data` (используется как базовый класс, см. документацию callback_data) |
+
+## Примеры
+
+### Базовое использование
+
+```python
+from aiogram import Bot, Dispatcher
+from aiogram_tool.tools.setup import aiogram_tool_setup
+from aiogram_tool.tools.depend import DependTool
+from aiogram_tool.tools.limit import RateLimitTool
+
+bot = Bot("YOUR_TOKEN_HERE")
+dp = Dispatcher()
+
+aiogram_tool_setup(dp, [DependTool(), RateLimitTool()])
+
+await dp.start_polling(bot)
+```
+
+### С кастомной инфраструктурой
+
+```python
+from redis.asyncio import Redis as AsyncRedis
+
+from aiogram_tool.tools.setup import aiogram_tool_setup
+from aiogram_tool.tools.depend import DependTool, ScopeRegistry
+from aiogram_tool.tools.limit import RateLimitTool
+from aiogram_tool.storage import AsyncRedisLockStorage
+
+scope_registry = ScopeRegistry()
+redis = AsyncRedis()
+
+aiogram_tool_setup(
+    dp,
+    [
+        DependTool(scope_registry=scope_registry),
+        RateLimitTool(storage=AsyncRedisLockStorage(redis=redis)),
+    ],
+)
+```
+
+## Ошибки
+
+```python
+aiogram_tool_setup(bot, [DependTool()])
+# TypeError: Invalid type for dispatcher
+
+aiogram_tool_setup(dp, [SomeRandomObject()])
+# TypeError: Invalid type for tool <SomeRandomObject ...>
+```

aiogram_tool-1.2.3/docs/ru/storages.md

@@ -0,0 +1,209 @@
+# Хранилища (storage)
+
+## Обзор
+
+| Хранилище | Наследование | Персистентность | Блокировки |
+|---|---|---|---|
+| `MemoryStorage` | `BaseStorage` | В памяти (теряется при перезапуске) | ❌ |
+| `MemoryLockStorage` | `MemoryStorage`, `BaseLockStorage` | В памяти | ✅ |
+| `AsyncRedisStorage` | `BaseStorage` | Redis (переживает перезапуск, общий для инстансов) | ❌ |
+| `AsyncRedisLockStorage` | `AsyncRedisStorage`, `BaseLockStorage` | Redis | ✅ |
+| `FileStorage` | `MemoryStorage` | Локальный файл | ❌ |
+| `FileLockStorage` | `FileStorage`, `BaseLockStorage` | Локальный файл + память | ✅ |
+
+## Интерфейсы
+
+### `BaseStorage` (`aiogram_tool.storage.base`)
+
+```python
+class BaseStorage(ABC):
+    async def set_value(self, key: str, value: str) -> None: ...
+    async def get_value(self, key: str) -> str | _MISSING: ...
+```
+
+- `get_value` возвращает `str` или sentinel `_MISSING` (`aiogram_tool.types._MISSING`), если ключа нет. Не используйте `None` как проверку отсутствия.
+
+### `BaseLockStorage`
+
+```python
+class BaseLockStorage(BaseStorage):
+    async def lock(self, key: str) -> AbstractAsyncContextManager[None]: ...
+```
+
+Метод `lock(key)` возвращает асинхронный контекстный менеджер блокировки по ключу:
+
+```python
+async with storage.lock("my_key"):
+    ...  # критическая секция
+```
+
+---
+
+## MemoryStorage
+
+Простейшее хранилище на базе `dict` (точнее — любого `MutableMapping`). Подходит для разработки, тестов и ботов без требований к персистентности.
+
+```python
+MemoryStorage(storage: MutableMapping | None = None)
+```
+
+- `storage` — опциональный внешний словарь (полезно для тестов и предзаполнения).
+
+> В качестве `MutableMapping` можно передавать не только `dict`, но и кэши из [`cachetools`](https://github.com/uri-grants/cachetools) — например, `Cache` или `TTLCache` (с автоматическим вытеснением по размеру или TTL).
+
+```python
+from aiogram_tool.storage import MemoryStorage
+
+storage = MemoryStorage()
+await storage.set_value("key", "value")
+value = await storage.get_value("key")  # "value"
+```
+
+## MemoryLockStorage
+
+То же, что `MemoryStorage`, плюс блокировки на `asyncio.Lock`. `lock(key)` лениво создаёт и возвращает `asyncio.Lock` для ключа под защитой глобального внутреннего лока.
+
+```python
+MemoryLockStorage(
+    storage: MutableMapping | None = None,
+    locks_storage: MutableMapping | None = None,
+)
+```
+
+- `locks_storage` — внешний словарь для самих локов (опционально).
+
+⚠️ Блокировки действуют только внутри текущего процесса — не подходят для нескольких инстансов бота.
+
+```python
+from aiogram_tool.storage import MemoryLockStorage
+
+storage = MemoryLockStorage()
+async with storage.lock("user:123"):
+    ...
+```
+## AsyncRedisStorage
+
+Хранилище на Redis (`redis.asyncio.Redis`). Рекомендуется для продакшена: состояние переживает перезапуск и разделяется между инстансами.
+
+```python
+AsyncRedisStorage(redis: AsyncRedis, expire: int | None = None)
+```
+
+- `redis` — клиент `redis.asyncio.Redis`
+- `expire` — TTL в секундах для каждой записи; `None` — без истечения
+
+```python
+from redis.asyncio import Redis as AsyncRedis
+from aiogram_tool.storage import AsyncRedisStorage
+
+storage = AsyncRedisStorage(redis=AsyncRedis(), expire=3600)
+await storage.set_value("key", "value")
+value = await storage.get_value("key")  # "value" (bytes автоматически декодируются)
+```
+
+Значение, передаваемое в `set_value`, не обязано быть `str` — оно передаётся в Redis как есть.
+
+## AsyncRedisLockStorage
+
+Redis-хранилище с распределёнными блокировками (`redis.asyncio.lock.Lock`).
+
+```python
+AsyncRedisLockStorage(redis: AsyncRedis, expire: int | None = None)
+```
+
+`lock(key)` возвращает Redis-лок с ключом `aigram_tool_lock:{key}`, `timeout=10` и `blocking_timeout=10` (секунды). Подходит для нескольких инстансов бота.
+
+```python
+from redis.asyncio import Redis as AsyncRedis
+from aiogram_tool.storage import AsyncRedisLockStorage
+
+storage = AsyncRedisLockStorage(redis=AsyncRedis(), expire=3600)
+async with storage.lock("my_key"):
+    ...
+```
+
+## FileStorage
+
+Хранилище в текстовом файле (формат: строки `key&value`). Наследуется от `MemoryStorage`.
+
+```python
+FileStorage(file: str, storage: MutableMapping | None = None)
+```
+
+- `file` — путь к существующему файлу; если файла нет, выбрасывается `FileNotFoundError`
+- `storage` — опциональный внутренний `MutableMapping`-кэш; если передан, включается режим «file + memory»: чтение сначала проверяет кэш и кэширует результаты чтения из файла
+
+Особенности:
+
+- Символ `&` запрещён в ключах (`ValueError`)
+- Записи добавляются в конец файла (`a`); чтение идёт с конца файла — выигрывает последняя запись по ключу
+- Значения могут содержать `&` (парсинг использует `maxsplit=1`)
+
+```python
+from aiogram_tool.storage import FileStorage
+
+storage = FileStorage(file="state.txt", storage={})
+await storage.set_value("key", "value")
+value = await storage.get_value("key")
+```
+
+> Файл должен существовать до создания хранилища — при необходимости создайте его заранее (например, `Path("state.txt").touch()`).
+
+## FileLockStorage
+
+`FileStorage` + блокировки на `asyncio.Lock` (как у `MemoryLockStorage`).
+
+```python
+FileLockStorage(
+    file: str,
+    storage: MutableMapping | None = None,
+    locks_storage: MutableMapping | None = None,
+)
+```
+
+Данные персистентны в файле, но блокировки локальны для процесса.
+
+## Как передавать хранилища в инструменты
+
+Хранилища обычно передаются конструктору инструмента при вызове `aiogram_tool_setup`:
+
+```python
+from redis.asyncio import Redis as AsyncRedis
+
+from aiogram_tool.tools.setup import aiogram_tool_setup
+from aiogram_tool.tools.limit import RateLimitTool
+from aiogram_tool.storage import AsyncRedisLockStorage
+
+aiogram_tool_setup(
+    dp,
+    [
+        RateLimitTool(storage=AsyncRedisLockStorage(redis=AsyncRedis(), expire=3600)),
+    ],
+)
+```
+
+Пример с callback data:
+
+```python
+from redis.asyncio import Redis as AsyncRedis
+from aiogram_tool.tools.callback_data import LongCallbackData
+from aiogram_tool.storage import AsyncRedisLockStorage
+
+
+class PersistentData(LongCallbackData, prefix="redis"):
+    _storage = AsyncRedisLockStorage(redis=AsyncRedis(), expire=3600)
+    user_id: int
+    big_context: str
+```
+
+## Выбор хранилища
+
+- **Разработка / тесты** → `MemoryStorage` / `MemoryLockStorage`
+- **Продакшен, один инстанс, без Redis** → `FileStorage` / `FileLockStorage`
+- **Продакшен, несколько инстансов или нужна надёжность** → `AsyncRedisStorage` / `AsyncRedisLockStorage`
+
+## Ограничения
+
+- Локи `MemoryLockStorage` и `FileLockStorage` не работают между процессами — для нескольких воркеров используйте `AsyncRedisLockStorage`
+- `FileStorage` выполняет полный проход по файлу при каждом чтении (без кэша) — для больших объёмов данных используйте Redis
+- `FileStorage` требует существования файла и запрещает `&` в ключах

{aiogram_tool-1.2.2 → aiogram_tool-1.2.3}/examples/callback_data/basic.py

@@ -12,7 +12,7 @@ from aiogram.types import (
 # Import LongCallbackData
 from aiogram_tool.tools.callback_data import LongCallbackData
 
-bot = Bot("YOUR_TOKEN_HERE")
+bot = Bot("123456:TEST-PLACEHOLDER-TOKEN")
 dp = Dispatcher()
 
 

{aiogram_tool-1.2.2 → aiogram_tool-1.2.3}/examples/callback_data/custom_expired_answer.py

@@ -15,7 +15,7 @@ from aiogram_tool.storage.impl.memory import MemoryLockStorage
 # Import base answer class
 from aiogram_tool.tools.callback_data import CallbackDataAnswer, LongCallbackData
 
-bot = Bot("YOUR_TOKEN_HERE")
+bot = Bot("123456:TEST-PLACEHOLDER-TOKEN")
 dp = Dispatcher()
 
 

{aiogram_tool-1.2.2 → aiogram_tool-1.2.3}/examples/callback_data/redis_storage.py

@@ -14,7 +14,7 @@ from redis.asyncio import Redis as AsyncRedis
 from aiogram_tool.storage import AsyncRedisLockStorage
 from aiogram_tool.tools.callback_data import LongCallbackData
 
-bot = Bot("YOUR_TOKEN_HERE")
+bot = Bot("123456:TEST-PLACEHOLDER-TOKEN")
 dp = Dispatcher()
 
 # Init Redis storage (expire in 3600 seconds)

{aiogram_tool-1.2.2 → aiogram_tool-1.2.3}/examples/depend/classes.py

@@ -7,7 +7,7 @@ from aiogram.types import Message
 from aiogram_tool.tools.depend import Depends, DependTool, Scope, ScopeRegistry
 from aiogram_tool.tools.setup import aiogram_tool_setup
 
-bot = Bot("YOUR_TOKEN_HERE")
+bot = Bot("123456:TEST-PLACEHOLDER-TOKEN")
 dp = Dispatcher()
 
 scope_registry = ScopeRegistry()

{aiogram_tool-1.2.2 → aiogram_tool-1.2.3}/examples/depend/filter_and_exit.py

@@ -7,7 +7,7 @@ from aiogram.types import Message
 from aiogram_tool.tools.depend import DependExit, DependFilter, Depends, DependTool
 from aiogram_tool.tools.setup import aiogram_tool_setup
 
-bot = Bot("YOUR_TOKEN_HERE")
+bot = Bot("123456:TEST-PLACEHOLDER-TOKEN")
 dp = Dispatcher()
 
 

{aiogram_tool-1.2.2 → aiogram_tool-1.2.3}/examples/depend/override.py

@@ -7,7 +7,7 @@ from aiogram.types import Message
 from aiogram_tool.tools.depend import Depends, DependTool
 from aiogram_tool.tools.setup import aiogram_tool_setup
 
-bot = Bot("YOUR_TOKEN_HERE")
+bot = Bot("123456:TEST-PLACEHOLDER-TOKEN")
 dp = Dispatcher()
 
 

{aiogram_tool-1.2.2 → aiogram_tool-1.2.3}/examples/depend/scopes.py

@@ -13,7 +13,7 @@ from aiogram_tool.tools.depend import (
 )
 from aiogram_tool.tools.setup import aiogram_tool_setup
 
-bot = Bot("YOUR_TOKEN_HERE")
+bot = Bot("123456:TEST-PLACEHOLDER-TOKEN")
 dp = Dispatcher()
 
 # Custom scope registry

{aiogram_tool-1.2.2 → aiogram_tool-1.2.3}/examples/depend/subdepends.py

@@ -12,7 +12,7 @@ from aiogram_tool.tools.depend import (
 )
 from aiogram_tool.tools.setup import aiogram_tool_setup
 
-bot = Bot("YOUR_TOKEN_HERE")
+bot = Bot("123456:TEST-PLACEHOLDER-TOKEN")
 dp = Dispatcher()
 
 

{aiogram_tool-1.2.2 → aiogram_tool-1.2.3}/examples/limit/advanced.py

@@ -11,7 +11,7 @@ from aiogram_tool.tools.limit import RateLimitAnswer, RateLimitFilter, RateLimit
 from aiogram_tool.tools.limit.rate_limit import SlidingWindowRateLimit
 from aiogram_tool.tools.setup import aiogram_tool_setup
 
-bot = Bot("YOUR_TOKEN_HERE")
+bot = Bot("123456:TEST-PLACEHOLDER-TOKEN")
 dp = Dispatcher()
 
 

{aiogram_tool-1.2.2 → aiogram_tool-1.2.3}/examples/limit/basic.py

@@ -9,7 +9,7 @@ from aiogram_tool.tools.limit import RateLimitFilter, RateLimitTool
 from aiogram_tool.tools.limit.rate_limit import FixedWindowRateLimit
 from aiogram_tool.tools.setup import aiogram_tool_setup
 
-bot = Bot("YOUR_TOKEN_HERE")
+bot = Bot("123456:TEST-PLACEHOLDER-TOKEN")
 dp = Dispatcher()
 
 

{aiogram_tool-1.2.2 → aiogram_tool-1.2.3}/examples/limit/limit_algorithms.py

@@ -13,7 +13,7 @@ from aiogram_tool.tools.limit.rate_limit import (
 )
 from aiogram_tool.tools.setup import aiogram_tool_setup
 
-bot = Bot("YOUR_TOKEN_HERE")
+bot = Bot("123456:TEST-PLACEHOLDER-TOKEN")
 dp = Dispatcher()
 
 

{aiogram_tool-1.2.2 → aiogram_tool-1.2.3}/pyproject.toml

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