4 files changed, 130 insertions, 0 deletions

diff --git a/libs/__init__.py b/libs/__init__.py
new file mode 100644
index 0000000..d8ed122
--- /dev/null
+++ b/libs/__init__.py
@@ -0,0 +1,7 @@
+from . import fsm, msg, storage
+
+__all__ = [
+    "storage",
+    "fsm",
+    "msg",
+]
diff --git a/libs/fsm.py b/libs/fsm.py
new file mode 100644
index 0000000..00ccacb
--- /dev/null
+++ b/libs/fsm.py
@@ -0,0 +1,23 @@
+from contextlib import asynccontextmanager
+
+from aiogram.fsm.context import FSMContext
+from pydantic.main import BaseModel
+from typing_extensions import AsyncGenerator
+
+
+async def set_data(state: FSMContext, model: BaseModel) -> None:
+    await state.set_data(model.model_dump())
+
+
+async def get_data[T: BaseModel](state: FSMContext, model_type: type[T]) -> T:
+    return model_type.model_validate(await state.get_data())
+
+
+@asynccontextmanager
+async def edit_data[T: BaseModel](
+    state: FSMContext,
+    model_type: type[T],
+) -> AsyncGenerator[T]:
+    model = await get_data(state, model_type)
+    yield model
+    await set_data(state, model)
diff --git a/libs/msg.py b/libs/msg.py
new file mode 100644
index 0000000..9bcc52a
--- /dev/null
+++ b/libs/msg.py
@@ -0,0 +1,25 @@
+import asyncio
+from typing import AsyncGenerator, Iterable
+
+from aiogram import Bot
+from aiogram.exceptions import TelegramAPIError, TelegramRetryAfter
+
+from models import RichText
+
+
+async def publish(
+    bot: Bot,
+    users: Iterable[int],
+    rich_text: RichText,
+) -> AsyncGenerator[int]:
+    for n, user_id in enumerate(users, start=1):
+        for _ in range(5):
+            try:
+                await rich_text.send(bot, user_id)
+                break
+            except TelegramRetryAfter as e:
+                await asyncio.sleep(e.retry_after + 1)
+            except TelegramAPIError:
+                await asyncio.sleep(5)
+
+        yield n
diff --git a/libs/storage.py b/libs/storage.py
new file mode 100644
index 0000000..6220cfc
--- /dev/null
+++ b/libs/storage.py
@@ -0,0 +1,75 @@
+from pathlib import Path
+from typing import Any, Mapping
+
+from aiofiles import open as open
+from aiogram.fsm.state import State
+from aiogram.fsm.storage.base import (
+    BaseStorage,
+    DefaultKeyBuilder,
+    KeyBuilder,
+    StateType,
+    StorageKey,
+)
+from pydantic import TypeAdapter
+from pydantic.main import BaseModel
+
+
+class Record(BaseModel):
+    data: dict[str, Any] = {}
+    state: str | None = None
+
+
+class JsonStorage(BaseStorage):
+    file_path: Path
+    records: dict[str, Record]
+    records_adapter: TypeAdapter
+    key_builder: KeyBuilder
+
+    def __init__(self, file_path: Path, key_builder: KeyBuilder | None = None) -> None:
+        self.file_path = file_path
+        self.records = {}
+        self.records_adapter = TypeAdapter(dict[str, Record])
+        self.key_builder = DefaultKeyBuilder() if key_builder is None else key_builder
+
+    async def read(self) -> None:
+        async with open(self.file_path, "rb") as file:
+            json = await file.read()
+            self.records = self.records_adapter.validate_json(json)
+
+    async def flush(self) -> None:
+        async with open(self.file_path, "wb") as file:
+            json = self.records_adapter.dump_json(self.records)
+            await file.write(json)
+
+    async def get_record(self, key: StorageKey) -> Record:
+        await self.read()
+        record_key = self.key_builder.build(key)
+        if record_key not in self.records:
+            self.records[record_key] = Record()
+        return self.records[record_key]
+
+    async def set_state(self, key: StorageKey, state: StateType = None) -> None:
+        record = await self.get_record(key)
+        record.state = state.state if isinstance(state, State) else state
+        await self.flush()
+
+    async def get_state(self, key: StorageKey) -> str | None:
+        record = await self.get_record(key)
+        return record.state
+
+    async def set_data(self, key: StorageKey, data: Mapping[str, Any]) -> None:
+        if not isinstance(data, dict):
+            raise TypeError(
+                f"Data must be a dict or dict-like object, got {type(data).__name__}",
+                data,
+            )
+        record = await self.get_record(key)
+        record.data = data.copy()
+        await self.flush()
+
+    async def get_data(self, key: StorageKey) -> dict[str, Any]:
+        record = await self.get_record(key)
+        return record.data
+
+    async def close(self) -> None:
+        await self.flush()