re-aiogram 0.1.0__py3-none-any.whl

re_aiogram/__init__.py

@@ -0,0 +1,29 @@
+# features
+from .core.bot import Bot
+
+# aiogram
+# from .client import *
+# from .dispatcher import *
+# from .enums import *
+# from .exceptions import *
+# from .filters import *
+# from .fsm import *
+# from .handlers import *
+# from .loggers import *
+# from .message import *
+# from .methods import *
+# from .types import *
+# from .utils import *
+# from .webhook import *
+
+from .types import Message, CallbackQuery
+
+from aiogram import Router
+router = Router()
+
+__all__=[
+    "Bot",
+    "Message",
+    "CallbackQuery",
+    "router"
+]

re_aiogram/client/__init__.py

@@ -0,0 +1 @@
+from aiogram.client import *

re_aiogram/core/__init__.py

@@ -0,0 +1,2 @@
+from bot import Bot
+from mediagroup import MediaGroup

re_aiogram/core/bot.py

@@ -0,0 +1,97 @@
+from aiogram import Bot as _Bot, Dispatcher as _Dispatcher
+import asyncio
+import logging
+import signal
+import sys
+import importlib
+
+
+class Bot:
+    def __init__(self, token: str = None):
+        if not token:
+            raise ValueError("Token is required")
+
+        self._bot = _Bot(token=token)
+        self._dp = _Dispatcher()
+
+        # middlewares
+        from .mediagroup import AlbumMiddleware
+
+        self._dp.message.middleware(AlbumMiddleware())
+
+    @property
+    def message(self):
+        return self._dp.message
+
+    def load(self, *paths: str):
+        """
+        Load routers from the specified paths.
+
+        :param paths:
+        """
+        routers = []
+
+        for path in paths:
+            module = importlib.import_module(path)
+
+            if hasattr(module, "router"):
+                routers.append(module.router)
+            else:
+                raise ValueError(
+                    f"There is no 'router' variable in the {path} module"
+                )
+
+        for router in routers:
+            if router.parent_router is None:
+                self._dp.include_router(router)
+
+    def run(self, logging_enabled: bool = True):
+        """
+        Start the Bot with graceful shutdown.
+        """
+        if logging_enabled:
+            logging.basicConfig(level=logging.INFO)
+
+        try:
+            asyncio.run(self._start())
+        except KeyboardInterrupt:
+            logging.info("Bot stopped by user")
+        except Exception as e:
+            logging.error("Polling error: %s", e)
+            sys.exit(1)
+
+    async def _start(self):
+        """Start polling and ensure cleanup on exit."""
+        loop = asyncio.get_running_loop()
+
+        # Register signal handlers for graceful shutdown where supported
+        for sig in (signal.SIGINT, signal.SIGTERM):
+            try:
+                loop.add_signal_handler(sig, self._request_shutdown)
+            except (NotImplementedError, ValueError):
+                # Windows doesn't support add_signal_handler for all signals
+                break
+
+        try:
+            await self._dp.start_polling(self._bot)
+        finally:
+            await self._shutdown()
+
+    def _request_shutdown(self):
+        """Signal handler: initiate graceful stop."""
+        logging.info("Shutdown signal received, stopping polling...")
+        asyncio.create_task(self._dp.stop_polling())
+
+    async def _shutdown(self):
+        """Close sessions and clean up resources."""
+        logging.info("Closing bot session...")
+        await self._bot.session.close()
+
+        loop = asyncio.get_running_loop()
+        for sig in (signal.SIGINT, signal.SIGTERM):
+            try:
+                loop.remove_signal_handler(sig)
+            except (NotImplementedError, ValueError):
+                pass
+
+        logging.info("Shutdown complete")

re_aiogram/core/mediagroup.py

@@ -0,0 +1,183 @@
+from aiogram import BaseMiddleware as _BaseMiddleware
+from aiogram.types import (
+    Message,
+    InputMediaPhoto,
+    InputMediaVideo,
+    InputMediaDocument,
+    InputMediaAudio,
+    InputMedia,
+)
+from typing import Callable, Any, Awaitable, Union, List
+import asyncio
+import time
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class MediaGroup(list):
+    """
+    Custom list-like class for media groups.
+    Inherits from list for full aiogram compatibility (answer_media_group, etc.)
+    while providing convenient properties for introspection.
+    """
+
+    def __init__(
+        self,
+        messages: List[Message],
+        media: List[Union[InputMediaPhoto, InputMediaVideo, InputMediaDocument, InputMediaAudio, InputMedia]],
+    ):
+        super().__init__(media)
+        self._messages = messages
+
+    @property
+    def messages(self) -> List[Message]:
+        """Original aiogram Message objects."""
+        return self._messages.copy()
+
+    @property
+    def photos(self) -> List[Message]:
+        """Messages containing photos."""
+        return [m for m in self._messages if m.photo]
+
+    @property
+    def videos(self) -> List[Message]:
+        """Messages containing videos."""
+        return [m for m in self._messages if m.video]
+
+    @property
+    def documents(self) -> List[Message]:
+        """Messages containing documents."""
+        return [m for m in self._messages if m.document]
+
+    @property
+    def audio(self) -> List[Message]:
+        """Messages containing audio files."""
+        return [m for m in self._messages if m.audio]
+
+    @property
+    def caption(self) -> Union[str, None]:
+        """First caption found in the group (Telegram sends caption only on the first item)."""
+        for msg in self._messages:
+            if msg.caption:
+                return msg.caption
+        return None
+
+    @property
+    def captions(self) -> List[str]:
+        """All captions from the group."""
+        return [msg.caption for msg in self._messages if msg.caption]
+
+    @property
+    def is_mixed(self) -> bool:
+        """True if album contains different media types."""
+        types = {m.content_type for m in self._messages}
+        return len(types) > 1
+
+    @property
+    def count(self) -> int:
+        """Number of items in the group."""
+        return len(self._messages)
+
+    def __repr__(self) -> str:
+        types = [m.content_type for m in self._messages]
+        return f"<MediaGroup count={self.count} types={types}>"
+
+
+class AlbumMiddleware(_BaseMiddleware):
+    """
+    Middleware for media groups with memory leak protection.
+    Injects a MediaGroup instance into the handler data.
+    """
+
+    def __init__(
+        self,
+        latency: Union[int, float] = 0.01,
+        max_age: Union[int, float] = 60.0,
+    ):
+        self.latency = latency
+        self.max_age = max_age
+        self.album_data: dict[str, list[Message]] = {}
+        self._last_access: dict[str, float] = {}
+        self._lock = asyncio.Lock()
+
+    async def __call__(
+        self,
+        handler: Callable[[Message, dict[str, Any]], Awaitable[Any]],
+        message: Message,
+        data: dict[str, Any],
+    ) -> Any:
+        if not message.media_group_id:
+            return await handler(message, data)
+
+        await self._cleanup_old_albums()
+
+        async with self._lock:
+            if message.media_group_id in self.album_data:
+                self.album_data[message.media_group_id].append(message)
+                self._last_access[message.media_group_id] = time.time()
+                return None
+
+            self.album_data[message.media_group_id] = [message]
+            self._last_access[message.media_group_id] = time.time()
+
+        await asyncio.sleep(self.latency)
+
+        async with self._lock:
+            album = sorted(
+                self.album_data.get(message.media_group_id, []),
+                key=lambda m: m.message_id,
+            )
+
+            media_items: list = []
+            for msg in album:
+                if msg.photo:
+                    file_id = msg.photo[-1].file_id
+                    caption = msg.caption if msg.caption else None
+                    media_items.append(InputMediaPhoto(media=file_id, caption=caption))
+                elif msg.video:
+                    file_id = msg.video.file_id
+                    caption = msg.caption if msg.caption else None
+                    media_items.append(InputMediaVideo(media=file_id, caption=caption))
+                elif msg.document:
+                    file_id = msg.document.file_id
+                    caption = msg.caption if msg.caption else None
+                    media_items.append(InputMediaDocument(media=file_id, caption=caption))
+                elif msg.audio:
+                    file_id = msg.audio.file_id
+                    caption = msg.caption if msg.caption else None
+                    media_items.append(InputMediaAudio(media=file_id, caption=caption))
+                else:
+                    try:
+                        obj_dict = msg.model_dump()
+                        file_id = obj_dict[msg.content_type]["file_id"]
+                        media_items.append(InputMedia(media=file_id))
+                    except (KeyError, TypeError):
+                        logger.warning(
+                            "Unsupported media type in album: %s", msg.content_type
+                        )
+
+            data["_is_last"] = True
+            data["album"] = album
+            data["media_group"] = MediaGroup(album, media_items)
+
+        try:
+            return await handler(message, data)
+        finally:
+            async with self._lock:
+                self.album_data.pop(message.media_group_id, None)
+                self._last_access.pop(message.media_group_id, None)
+
+    async def _cleanup_old_albums(self):
+        now = time.time()
+        stale_ids = [
+            mg_id
+            for mg_id, last_time in list(self._last_access.items())
+            if now - last_time > self.max_age
+        ]
+        if stale_ids:
+            async with self._lock:
+                for mg_id in stale_ids:
+                    self.album_data.pop(mg_id, None)
+                    self._last_access.pop(mg_id, None)
+            logger.debug("Cleaned up %d stale album entries", len(stale_ids))

re_aiogram/dispatcher/__init__.py

@@ -0,0 +1 @@
+from aiogram.dispatcher import *

re_aiogram/enums/__init__.py

@@ -0,0 +1 @@
+from aiogram.enums import *

re_aiogram/exceptions/__init__.py

@@ -0,0 +1 @@
+from aiogram.exceptions import *

re_aiogram/filters/__init__.py

@@ -0,0 +1,4 @@
+from aiogram.filters import *
+
+from aiogram.utils.magic_filter import MagicFilter
+F = MagicFilter()

re_aiogram/fsm/__init__.py

@@ -0,0 +1 @@
+from aiogram.fsm import *

re_aiogram/handlers/__init__.py

@@ -0,0 +1 @@
+from aiogram.handlers import *

re_aiogram/loggers/__init__.py

@@ -0,0 +1 @@
+from aiogram.loggers import *

re_aiogram/methods/__init__.py

@@ -0,0 +1 @@
+from aiogram.methods import *

re_aiogram/types/__init__.py

@@ -0,0 +1,2 @@
+from aiogram.types import *
+from ..core.mediagroup import MediaGroup

re_aiogram/utils/__init__.py

@@ -0,0 +1 @@
+from aiogram.utils import *

re_aiogram/webhook/__init__.py

@@ -0,0 +1 @@
+from aiogram.webhook import *

re_aiogram-0.1.0.dist-info/METADATA

@@ -0,0 +1,186 @@
+Metadata-Version: 2.4
+Name: re-aiogram
+Version: 0.1.0
+Summary: Lightweight wrapper over aiogram 3.x
+Author: carrotgoodbye
+License: MIT
+Keywords: telegram,aiogram,bot,telebot,api,framework,wrapper,asyncio
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiogram<4.0.0,>=3.0.0
+Dynamic: license-file
+
+# re_aiogram
+
+**re_aiogram** is a lightweight wrapper over [aiogram 3.x](https://aiogram.dev/) that keeps the familiar aiogram API while simplifying bot development and adding extra features.
+
+The goal of the project is to stay fully compatible with aiogram, but provide a cleaner and more convenient developer experience.
+
+---
+
+# Install
+
+```bash
+pip install re_aiogram
+````
+
+```python
+import re_aiogram
+```
+
+---
+
+# Features
+
+* familiar aiogram-style API
+* simplified bot startup without explicit dispatcher
+* router auto-loading
+* built-in MediaGroup support
+* aiogram-compatible imports
+
+---
+
+# Quick Start
+
+```python
+from re_aiogram import Bot, Message
+from re_aiogram.filters import Command
+
+API_TOKEN = "YOUR_API_TOKEN"
+
+bot = Bot(token=API_TOKEN)
+
+
+@bot.message(Command("start"))
+async def cmd_start(message: Message):
+    await message.answer(
+        "Hi! I am a Telegram bot powered by re_aiogram!"
+    )
+
+
+bot.run(logging_enabled=True)
+```
+
+---
+
+# MediaGroup Handler
+
+Built-in support for Telegram media groups.
+
+```python
+from re_aiogram import Bot, Message
+from re_aiogram.filters import F
+from re_aiogram.types import MediaGroup
+
+bot = Bot(token="TOKEN")
+
+
+@bot.message(F.media_group_id)
+async def handle_album(message: Message, media_group: MediaGroup):
+    await message.answer_media_group(media_group)
+```
+
+`media_group` contains the collected media group messages.
+
+## Properties
+
+| Property                | Description                                                                                                                            |
+| ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------- |
+| `media_group.count`     | Returns the number of media items in the group.                                                                                        |
+| `media_group.caption`   | Returns the first caption found in the group (Telegram sends caption only on the first item). Returns `None` if no caption is present. |
+| `media_group.captions`  | Returns a list of all captions from the group.                                                                                         |
+| `media_group.messages`  | Returns a copy of the original `Message` objects from the group.                                                                       |
+| `media_group.photos`    | Returns a list of `Message` objects that contain photos.                                                                               |
+| `media_group.videos`    | Returns a list of `Message` objects that contain videos.                                                                               |
+| `media_group.documents` | Returns a list of `Message` objects that contain documents.                                                                            |
+| `media_group.audio`     | Returns a list of `Message` objects that contain audio files.                                                                          |
+| `media_group.is_mixed`  | Returns `True` if the album contains different media types (e.g., photos and videos together).                                         |
+
+---
+
+# Routers
+
+Router connection is simplified with `bot.load()`
+
+## Project structure
+
+```text
+project/
+│
+├── main.py
+└── handlers/
+    └── start.py
+```
+
+### main.py
+
+```python
+from re_aiogram import Bot
+
+API_TOKEN = "YOUR_API_TOKEN"
+
+bot = Bot(token=API_TOKEN)
+
+bot.load("handlers.start")
+
+bot.run(logging_enabled=True)
+```
+
+### handlers/start.py
+
+```python
+from re_aiogram import router, Message
+from re_aiogram.filters import Command
+
+
+@router.message(Command("start"))
+async def start(message: Message):
+    await message.answer("Router connected!")
+```
+
+---
+
+# Future improvements
+
+These features are planned for upcoming versions and are not yet part of the core API.
+
+## Flow System (FSM alternative)
+
+A lightweight state/flow system replacing traditional FSM:
+
+* step-based flow control
+* `ctx.next()` and `ctx.back()`
+* shared `ctx.data`
+* parallel flows via `scope()`
+* simple chain-based conversation handling
+
+Example concept:
+
+```python
+@router.message(Command("register"))
+async def register(message: Message, ctx: FlowContext):
+    await message.answer("What is your name?")
+    ctx.next(get_name)
+```
+
+---
+
+# Philosophy
+
+re_aiogram tries to make Telegram bot development:
+
+* simpler
+* cleaner
+* less boilerplate-heavy
+* more beginner-friendly
+
+while still preserving compatibility with the `aiogram` ecosystem.
+
+---
+
+# License
+
+`MIT License`

re_aiogram-0.1.0.dist-info/RECORD

@@ -0,0 +1,21 @@
+re_aiogram/__init__.py,sha256=vKCRDj0ZMtixJbQPLJsfPfenhpSkEMA9VHYfdR0XsXU,558
+re_aiogram/client/__init__.py,sha256=Z1NYBuXC6jTn1XL9FLFVRB5ZnH3G0CLk0k-1eHUPW2M,28
+re_aiogram/core/__init__.py,sha256=A3Xl9YpeIm5fsxP3CzOoqvZXK9pSJDofF2BXWHjTc3I,56
+re_aiogram/core/bot.py,sha256=Iv01Fw1tVRwivJepEPykFzoAc_8SUNdJELFd5GS7050,2920
+re_aiogram/core/mediagroup.py,sha256=Hyx2pX4tC3dFXfmShPR_vccdj19noefmMkZvlRHBMqA,6447
+re_aiogram/dispatcher/__init__.py,sha256=Q_zgqC_C04pu53QJCVbLaGI0hMgAgU1dRitAVQ_qYJs,32
+re_aiogram/enums/__init__.py,sha256=xfZH0fSJZCsezFzz518yJHYmiXHzCIMfBX5Lc14w-Bk,27
+re_aiogram/exceptions/__init__.py,sha256=rzWgxPe18zVTRrAkV8_oXHxInUKF2QHCbQjULvgzaiM,32
+re_aiogram/filters/__init__.py,sha256=uiYN75D2bG3P4YcirVZA7RhucOkNaT8Vgh0PfMXpves,102
+re_aiogram/fsm/__init__.py,sha256=KdWz1tgVAiz_L3epQsVI83i3cw31qBi2uUhk9HiCmnQ,27
+re_aiogram/handlers/__init__.py,sha256=Hq954qso_xVxlansetEQZVeBtlFsnK4_hSi9-LVj9TI,30
+re_aiogram/loggers/__init__.py,sha256=nmt8fCYDzLz5Oj0Pj4WviWgu0YdK23Mc8NmzM69aM24,29
+re_aiogram/methods/__init__.py,sha256=e8vJWIdkYg5vzgokh6h8CU5es5B4SkkKgw7LAMV0QRo,29
+re_aiogram/types/__init__.py,sha256=1zRW-DVikVDclJsWuve9g_0-uoupYV493oKLnUVQads,69
+re_aiogram/utils/__init__.py,sha256=2PiWpdXKqe6Biy-M96FHxOj5GLXWZpU8mnIQomsszlg,27
+re_aiogram/webhook/__init__.py,sha256=1uX57FdMFDuICRrVsCOwCMiv9gxAu82R9m0OfPKQkfI,29
+re_aiogram-0.1.0.dist-info/licenses/LICENSE,sha256=pA6Bs2tlRvpm1ph7Wi_3BTfLJdPwzwp1io7jViEwf3o,1091
+re_aiogram-0.1.0.dist-info/METADATA,sha256=7inct04jIOqKFdrUj_uf8lciIKcu0ihARTxwuhVtEu0,5230
+re_aiogram-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+re_aiogram-0.1.0.dist-info/top_level.txt,sha256=YLIyi2WD6p8aJOCRNe2XVAKAmo-jRzERo-mY3JDB_II,11
+re_aiogram-0.1.0.dist-info/RECORD,,

re_aiogram-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

re_aiogram-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 carrotgoodbye
+
+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.

re_aiogram-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+re_aiogram