telegram-async 0.1.0__tar.gz

telegram_async-0.1.0/LICENSE

@@ -0,0 +1,27 @@
+
+---
+
+# 📄 `LICENSE` (MIT)
+
+```text
+MIT License
+
+Copyright (c) 2026 Denys
+
+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.

telegram_async-0.1.0/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: telegram-async
+Version: 0.1.0
+Summary: Asynchronous Telegram bot framework with throttling, callbacks, and middleware
+Author-email: Denys <ostrovskyidenys30@gmail.com>
+License: MIT
+Keywords: telegram,async,bot,framework
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.13.3
+Requires-Dist: rich>=14.2.0
+Dynamic: license-file
+
+# telegram-async
+
+**Asynchronous Telegram bot framework** z middleware, throttlingiem, callbackami i pseudo-przyciskami.
+
+Framework ułatwia tworzenie botów Telegram w Pythonie z wykorzystaniem `asyncio` i `aiohttp`. Wspiera:
+
+- Komendy `/start`, `/help`, `/confirm`  
+- Throttling wiadomości użytkownika  
+- Middleware logger (Rich)  
+- Callbacki i pseudo-przyciski (`/ok`)  
+- Background task działający w pętli co X sekund  
+
+## Instalacja
+
+```bash
+pip install telegram-async

telegram_async-0.1.0/README.md

@@ -0,0 +1,16 @@
+# telegram-async
+
+**Asynchronous Telegram bot framework** z middleware, throttlingiem, callbackami i pseudo-przyciskami.
+
+Framework ułatwia tworzenie botów Telegram w Pythonie z wykorzystaniem `asyncio` i `aiohttp`. Wspiera:
+
+- Komendy `/start`, `/help`, `/confirm`  
+- Throttling wiadomości użytkownika  
+- Middleware logger (Rich)  
+- Callbacki i pseudo-przyciski (`/ok`)  
+- Background task działający w pętli co X sekund  
+
+## Instalacja
+
+```bash
+pip install telegram-async

telegram_async-0.1.0/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "telegram-async"
+version = "0.1.0"
+description = "Asynchronous Telegram bot framework with throttling, callbacks, and middleware"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [
+  {name = "Denys", email = "ostrovskyidenys30@gmail.com"}
+]
+dependencies = [
+  "aiohttp>=3.13.3",
+  "rich>=14.2.0"
+]
+keywords = ["telegram", "async", "bot", "framework"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent"
+]
+
+[tool.setuptools.packages.find]
+where = ["."]

telegram_async-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

telegram_async-0.1.0/setup.py

@@ -0,0 +1,11 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="telegram_async",
+    version="0.1.0",
+    packages=find_packages(),
+    install_requires=[
+        "aiohttp",
+        "rich"
+    ],
+)

telegram_async-0.1.0/telegram_async/__init__.py

@@ -0,0 +1,2 @@
+from .bot import Bot
+from .roles import Role

telegram_async-0.1.0/telegram_async/bot.py

@@ -0,0 +1,60 @@
+from .client import TelegramClient
+from .dispatcher import Dispatcher
+from .server import WebhookServer
+from .roles import Role
+from .logger import logger
+from .decorators import command as command_deco, on_message, middleware, role_required
+
+class Bot:
+    def __init__(self, token, role_provider=None, session_store=None):
+        self.client = TelegramClient(token)
+        self.role_provider = role_provider or (lambda _: Role.GUEST)
+        self.dispatcher = Dispatcher(self.client, self.role_provider, session_store=session_store)
+
+    def command(self, name: str):
+        def wrapper(func):
+            func = command_deco(name)(func)
+            self.dispatcher.register(func)
+            logger.info(f"Registered command {name}")
+            return func
+        return wrapper
+
+    def on_message(self, **filters):
+        def wrapper(func):
+            func = on_message(**filters)(func)
+            self.dispatcher.register(func)
+            return func
+        return wrapper
+
+    def middleware(self):
+        def wrapper(func):
+            func = middleware()(func)
+            self.dispatcher.register(func)
+            return func
+        return wrapper
+
+    def require(self, role: Role):
+        def wrapper(func):
+            func = role_required(role)(func)
+            return func
+        return wrapper
+
+    def run_webhook(self, host="0.0.0.0", port=8080):
+        server = WebhookServer(self.dispatcher)
+        server.run(host, port)
+
+    async def run_polling(self):
+        import asyncio
+        from aiohttp import ClientSession
+        offset = None
+        while True:
+            async with ClientSession() as session:
+                params = {"timeout": 30}
+                if offset:
+                    params["offset"] = offset
+                async with session.get(f"{self.client.base}/getUpdates", params=params) as r:
+                    updates = await r.json()
+                    for update in updates.get("result", []):
+                        await self.dispatcher.dispatch(update)
+                        offset = update["update_id"] + 1
+            await asyncio.sleep(1)

telegram_async-0.1.0/telegram_async/callback.py

@@ -0,0 +1,25 @@
+from collections import defaultdict
+
+class CallbackRegistry:
+    def __init__(self):
+        # pattern -> handler
+        self.handlers = {}
+
+    def register(self, pattern: str, handler):
+        self.handlers[pattern] = handler
+
+    async def dispatch(self, ctx, callback_data: str):
+        for pattern, handler in self.handlers.items():
+            if pattern == callback_data:
+                await handler(ctx)
+                return
+
+# Singleton do użytku w frameworku
+callback_registry = CallbackRegistry()
+
+# dekorator do bot.py
+def on_callback(pattern: str):
+    def wrapper(func):
+        callback_registry.register(pattern, func)
+        return func
+    return wrapper

telegram_async-0.1.0/telegram_async/client.py

@@ -0,0 +1,19 @@
+import aiohttp
+
+class TelegramClient:
+    def __init__(self, token: str):
+        self.base = f"https://api.telegram.org/bot{token}"
+
+    async def send_message(self, chat_id: int, text: str):
+        async with aiohttp.ClientSession() as s:
+            await s.post(
+                f"{self.base}/sendMessage",
+                json={"chat_id": chat_id, "text": text}
+            )
+
+    async def answer_callback(self, callback_id: str, text: str = None):
+        async with aiohttp.ClientSession() as s:
+            await s.post(
+                f"{self.base}/answerCallbackQuery",
+                json={"callback_query_id": callback_id, "text": text or ""}
+            )

telegram_async-0.1.0/telegram_async/context.py

@@ -0,0 +1,16 @@
+from typing import Any
+
+class Context:
+    def __init__(self, client, update: dict, role: Any, session=None):
+        self.client = client
+        self.update = update
+        self.message = update.get("message") or {}
+        self.chat_id = self.message.get("chat", {}).get("id")
+        self.user_id = self.message.get("from", {}).get("id")
+        self.text = self.message.get("text", "")
+        self.role = role
+        self.session = session or {}
+
+    async def reply(self, text: str):
+        if self.chat_id:
+            await self.client.send_message(self.chat_id, text)

telegram_async-0.1.0/telegram_async/decorators.py

@@ -0,0 +1,31 @@
+from functools import wraps
+from .roles import Role
+
+def role_required(role: Role):
+    def decorator(func):
+        func.__required_role__ = role
+        return func
+    return decorator
+
+def command(name: str):
+    def decorator(func):
+        func.__command__ = name
+        return func
+    return decorator
+
+def on_message(text_contains=None, from_user=None, chat_id=None):
+    def decorator(func):
+        func.__on_message__ = True
+        func.__filter__ = {
+            "text_contains": text_contains,
+            "from_user": from_user,
+            "chat_id": chat_id
+        }
+        return func
+    return decorator
+
+def middleware():
+    def decorator(func):
+        func.__middleware__ = True
+        return func
+    return decorator

telegram_async-0.1.0/telegram_async/dispatcher.py

@@ -0,0 +1,61 @@
+from .context import Context
+from .roles import Role
+
+class Dispatcher:
+    def __init__(self, client, role_provider, session_store=None):
+        self.client = client
+        self.role_provider = role_provider
+        self.session_store = session_store or {}
+        self.command_handlers = {}
+        self.message_handlers = []
+        self.middlewares = []
+
+    def register(self, func):
+        if hasattr(func, "__command__"):
+            role = getattr(func, "__required_role__", Role.GUEST)
+            self.command_handlers[func.__command__] = (func, role)
+
+        if hasattr(func, "__on_message__"):
+            self.message_handlers.append(func)
+
+        if hasattr(func, "__middleware__"):
+            self.middlewares.append(func)
+
+    async def _run_middlewares(self, ctx, handler):
+        async def call(index):
+            if index < len(self.middlewares):
+                await self.middlewares[index](ctx, lambda: call(index + 1))
+            else:
+                await handler(ctx)
+        await call(0)
+
+    async def dispatch(self, update: dict):
+        msg = update.get("message")
+        if not msg:
+            return
+
+        user_id = msg.get("from", {}).get("id")
+        role = self.role_provider(user_id)
+        session = self.session_store.get(user_id, {})
+
+        ctx = Context(self.client, update, role, session)
+
+        text = msg.get("text", "")
+
+        if text.startswith("/"):
+            command = text.split()[0]
+            if command in self.command_handlers:
+                handler, min_role = self.command_handlers[command]
+                if role >= min_role:
+                    await self._run_middlewares(ctx, handler)
+                return
+
+        for handler in self.message_handlers:
+            filt = getattr(handler, "__filter__", {})
+            if filt.get("text_contains") and filt["text_contains"] not in text:
+                continue
+            if filt.get("from_user") and filt["from_user"] != user_id:
+                continue
+            if filt.get("chat_id") and filt["chat_id"] != ctx.chat_id:
+                continue
+            await self._run_middlewares(ctx, handler)

telegram_async-0.1.0/telegram_async/docs.py

@@ -0,0 +1,14 @@
+from telegram_async.decorators import command
+
+def generate_help(dispatcher) -> str:
+    """
+    Generuje tekst help z listą komend i minimalną info
+    """
+    lines = ["📖 Lista komend:"]
+    for cmd, (handler, role) in dispatcher.command_handlers.items():
+        lines.append(f"{cmd} - minimalna rola: {role.name}")
+    return "\n".join(lines)
+
+async def send_help(ctx, dispatcher):
+    help_text = generate_help(dispatcher)
+    await ctx.reply(help_text)

telegram_async-0.1.0/telegram_async/logger.py

@@ -0,0 +1,10 @@
+import logging
+from rich.logging import RichHandler
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(message)s",
+    handlers=[RichHandler()]
+)
+
+logger = logging.getLogger("telegram_async")

telegram_async-0.1.0/telegram_async/middleware.py

@@ -0,0 +1,13 @@
+from telegram_async import Bot
+from telegram_async.throttling import Throttle
+
+bot = Bot(token="TOKEN")
+throttle = Throttle()
+
+@bot.middleware()
+async def rate_limit(ctx, next):
+    allowed = await throttle.check(ctx.user_id, rate=5, per=10)
+    if not allowed:
+        await ctx.reply("⛔ Too many attempts. Please wait a moment.")
+        return
+    await next()

telegram_async-0.1.0/telegram_async/roles.py

@@ -0,0 +1,6 @@
+from enum import IntEnum
+
+class Role(IntEnum):
+    GUEST = 0
+    USER = 1
+    ADMIN = 2

telegram_async-0.1.0/telegram_async/server.py

@@ -0,0 +1,15 @@
+from aiohttp import web
+
+class WebhookServer:
+    def __init__(self, dispatcher):
+        self.dispatcher = dispatcher
+        self.app = web.Application()
+        self.app.router.add_post("/webhook", self.handle)
+
+    async def handle(self, request):
+        update = await request.json()
+        await self.dispatcher.dispatch(update)
+        return web.Response(text="ok")
+
+    def run(self, host="0.0.0.0", port=8080):
+        web.run_app(self.app, host=host, port=port)

telegram_async-0.1.0/telegram_async/storage.py

@@ -0,0 +1,9 @@
+class SessionStorage:
+    def __init__(self):
+        self.store = {}
+
+    def get(self, user_id):
+        return self.store.get(user_id, {})
+
+    def set(self, user_id, data):
+        self.store[user_id] = data

telegram_async-0.1.0/telegram_async/tasks.py

@@ -0,0 +1,19 @@
+import asyncio
+
+class TaskManager:
+    def __init__(self):
+        self.tasks = []
+
+    def add_task(self, coro, interval: int = None):
+        """Dodaje zadanie async, opcjonalnie z interwałem (sekundy)"""
+        async def looped():
+            while True:
+                await coro()
+                if not interval:
+                    break
+                await asyncio.sleep(interval)
+        t = asyncio.create_task(looped())
+        self.tasks.append(t)
+        return t
+
+task_manager = TaskManager()

telegram_async-0.1.0/telegram_async/throttling.py

@@ -0,0 +1,21 @@
+import time
+from collections import defaultdict
+from asyncio import Lock
+
+class Throttle:
+    def __init__(self):
+        # user_id -> [timestamp1, timestamp2, ...]
+        self.calls = defaultdict(list)
+        self.lock = Lock()
+
+    async def check(self, user_id: int, rate: int = 5, per: int = 10) -> bool:
+        """Zwraca True jeśli użytkownik może wykonać akcję"""
+        now = time.time()
+        async with self.lock:
+            timestamps = self.calls[user_id]
+            # usuwamy stare
+            self.calls[user_id] = [t for t in timestamps if now - t < per]
+            if len(self.calls[user_id]) >= rate:
+                return False
+            self.calls[user_id].append(now)
+            return True

telegram_async-0.1.0/telegram_async.egg-info/PKG-INFO

@@ -0,0 +1,32 @@
+Metadata-Version: 2.4
+Name: telegram-async
+Version: 0.1.0
+Summary: Asynchronous Telegram bot framework with throttling, callbacks, and middleware
+Author-email: Denys <ostrovskyidenys30@gmail.com>
+License: MIT
+Keywords: telegram,async,bot,framework
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: aiohttp>=3.13.3
+Requires-Dist: rich>=14.2.0
+Dynamic: license-file
+
+# telegram-async
+
+**Asynchronous Telegram bot framework** z middleware, throttlingiem, callbackami i pseudo-przyciskami.
+
+Framework ułatwia tworzenie botów Telegram w Pythonie z wykorzystaniem `asyncio` i `aiohttp`. Wspiera:
+
+- Komendy `/start`, `/help`, `/confirm`  
+- Throttling wiadomości użytkownika  
+- Middleware logger (Rich)  
+- Callbacki i pseudo-przyciski (`/ok`)  
+- Background task działający w pętli co X sekund  
+
+## Instalacja
+
+```bash
+pip install telegram-async

telegram_async-0.1.0/telegram_async.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE
+README.md
+pyproject.toml
+setup.py
+telegram_async/__init__.py
+telegram_async/bot.py
+telegram_async/callback.py
+telegram_async/client.py
+telegram_async/context.py
+telegram_async/decorators.py
+telegram_async/dispatcher.py
+telegram_async/docs.py
+telegram_async/logger.py
+telegram_async/middleware.py
+telegram_async/roles.py
+telegram_async/server.py
+telegram_async/storage.py
+telegram_async/tasks.py
+telegram_async/throttling.py
+telegram_async.egg-info/PKG-INFO
+telegram_async.egg-info/SOURCES.txt
+telegram_async.egg-info/dependency_links.txt
+telegram_async.egg-info/requires.txt
+telegram_async.egg-info/top_level.txt

telegram_async-0.1.0/telegram_async.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

telegram_async-0.1.0/telegram_async.egg-info/requires.txt

@@ -0,0 +1,2 @@
+aiohttp>=3.13.3
+rich>=14.2.0

telegram_async-0.1.0/telegram_async.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+dist
+telegram_async