kernelbot 0.0.2__py3-none-any.whl

kernelbot/__init__.py

@@ -0,0 +1,13 @@
+"""kernelbot — KernelGram Bot API library, telebot-compatible."""
+
+import logging
+
+from .version import __version__
+from .bot import TeleBot
+from . import apihelper
+from . import types
+from . import util
+
+logger = logging.getLogger("kernelbot")
+
+__all__ = ["TeleBot", "apihelper", "types", "util", "__version__"]

kernelbot/apihelper.py

@@ -0,0 +1,131 @@
+"""Low-level HTTP layer for the KernelGram Bot API.
+
+Mirrors the public surface of `telebot.apihelper`.
+"""
+
+import json
+import socket
+import requests
+import logging
+
+from .version import __version__
+
+logger = logging.getLogger("kernelbot")
+
+# --- KernelGram endpoints (hardcoded) ---
+API_HOST = "https://api.kernelgram.club"
+API_URL = API_HOST + "/bot{0}/{1}"
+FILE_URL = API_HOST + "/file/bot{0}/{1}"
+
+# --- Behaviour flags ---
+CONNECT_TIMEOUT = 3.5
+READ_TIMEOUT = 999
+SESSION_TIME_TO_LIVE = None
+RETRY_ON_ERROR = False
+MAX_RETRIES = 3
+
+FORCE_IPV4 = True
+CUSTOM_REQUEST_SENDER = None
+proxy = None
+
+# Поля, которые при multipart-запросе KernelGram ожидает как JSON-строку.
+_JSON_FIELDS = ("reply_markup",)
+
+
+def _build_session():
+    session = requests.Session()
+    if FORCE_IPV4:
+        from requests.adapters import HTTPAdapter
+        from urllib3.util import connection
+
+        def _ipv4_only(address, *args, **kwargs):
+            host, port = address
+            infos = socket.getaddrinfo(host, port, socket.AF_INET, socket.SOCK_STREAM)
+            family, socktype, proto, _canon, sockaddr = infos[0]
+            sock = socket.socket(family, socktype, proto)
+            try:
+                sock.connect(sockaddr)
+            except Exception:
+                sock.close()
+                raise
+            return sock
+
+        connection.create_connection = _ipv4_only
+
+    adapter = HTTPAdapter(max_retries=MAX_RETRIES)
+    session.mount("https://", adapter)
+    session.mount("http://", adapter)
+    return session
+
+
+_session = None
+
+
+def _get_session():
+    global _session
+    if _session is None:
+        _session = _build_session()
+    return _session
+
+
+def _serialize_for_multipart(params):
+    """Привести dict-параметры к JSON-строкам для multipart-запроса."""
+    out = dict(params)
+    for key in _JSON_FIELDS:
+        if key in out and not isinstance(out[key], str):
+            out[key] = json.dumps(out[key], ensure_ascii=False)
+    return out
+
+
+def _make_request(token, method_name, method="get", params=None, files=None, **kwargs):
+    url = API_URL.format(token, method_name)
+    params = params or {}
+    timeout = kwargs.pop("timeout", READ_TIMEOUT + CONNECT_TIMEOUT)
+
+    if CUSTOM_REQUEST_SENDER is not None:
+        return CUSTOM_REQUEST_SENDER(method=method, url=url, params=params, files=files, timeout=timeout)
+
+    session = _get_session()
+    proxies = proxy
+
+    try:
+        if method == "get":
+            resp = session.get(url, params=params, timeout=timeout, proxies=proxies, **kwargs)
+        elif method == "post":
+            if files:
+                data = _serialize_for_multipart(params)
+                resp = session.post(url, data=data, files=files, timeout=timeout, proxies=proxies, **kwargs)
+            else:
+                resp = session.post(url, json=params, timeout=timeout, proxies=proxies, **kwargs)
+        else:
+            raise ValueError("Unsupported HTTP method: %r" % method)
+    except requests.exceptions.RequestException as e:
+        logger.error("Request to %s failed: %s", url, e)
+        raise
+
+    try:
+        result = resp.json()
+    except ValueError:
+        resp.raise_for_status()
+        raise
+
+    if not result.get("ok"):
+        description = result.get("description", "Unknown error")
+        logger.error("KernelGram API error in %s: %s", method_name, description)
+        raise ApiTelegramException(method_name, result, result)
+
+    return result
+
+
+class ApiTelegramException(Exception):
+    """Raised when the KernelGram Bot API returns ok=false."""
+
+    def __init__(self, function_name, result, payload):
+        super().__init__(
+            "KernelGram API error in %s: %s" % (function_name, result.get("description"))
+        )
+        self.function_name = function_name
+        self.result = result
+        self.error_code = result.get("error_code")
+        self.description = result.get("description")
+        self.payload = payload

kernelbot/bot.py

@@ -0,0 +1,237 @@
+"""TeleBot class for KernelGram. Mirrors telebot.TeleBot."""
+
+import re
+import time
+import logging
+
+from . import apihelper
+from . import types
+
+logger = logging.getLogger("kernelbot")
+
+
+class TeleBot:
+    """Synchronous KernelGram bot, API-compatible with pyTelegramBotAPI."""
+
+    def __init__(self, token, parse_mode=None, threaded=True, num_threads=2):
+        if not token or not isinstance(token, str):
+            raise ValueError("Token must be a non-empty string")
+        self.token = token
+        self.parse_mode = parse_mode
+        self.threaded = threaded
+        self.num_threads = num_threads
+        self._message_handlers = []
+        self._callback_handlers = []
+        self._update_listener = None
+
+    # ---------------- API methods ----------------
+
+    def get_me(self):
+        return types.User(**apihelper._make_request(self.token, "getMe"))
+
+    def get_updates(self, offset=None, limit=None, timeout=20, allowed_updates=None):
+        params = {"timeout": timeout}
+        if offset is not None:
+            params["offset"] = offset
+        if limit is not None:
+            params["limit"] = limit
+        if allowed_updates is not None:
+            params["allowed_updates"] = allowed_updates
+        return apihelper._make_request(self.token, "getUpdates", method="get", params=params)
+
+    def send_message(self, chat_id, text, parse_mode=None, reply_markup=None,
+                     disable_web_page_preview=None, **kwargs):
+        params = {"chat_id": chat_id, "text": text}
+        pm = parse_mode if parse_mode is not None else self.parse_mode
+        if pm:
+            params["parse_mode"] = pm
+        if reply_markup is not None:
+            params["reply_markup"] = reply_markup
+        if disable_web_page_preview is not None:
+            params["disable_web_page_preview"] = disable_web_page_preview
+        params.update(kwargs)
+        result = apihelper._make_request(self.token, "sendMessage", method="post", params=params)
+        return types.Message(**result)
+
+    def send_photo(self, chat_id, photo, caption=None, parse_mode=None,
+                   reply_markup=None, **kwargs):
+        params = {"chat_id": chat_id}
+        pm = parse_mode if parse_mode is not None else self.parse_mode
+        if caption is not None:
+            params["caption"] = caption
+        if pm:
+            params["parse_mode"] = pm
+        if reply_markup is not None:
+            params["reply_markup"] = reply_markup
+        params.update(kwargs)
+
+        files = None
+        if hasattr(photo, "read"):
+            files = {"photo": photo}
+            result = apihelper._make_request(self.token, "sendPhoto", method="post",
+                                             params=params, files=files)
+        else:
+            params["photo"] = photo
+            result = apihelper._make_request(self.token, "sendPhoto", method="post",
+                                             params=params)
+        return types.Message(**result)
+
+    def delete_message(self, chat_id, message_id):
+        params = {"chat_id": chat_id, "message_id": message_id}
+        return apihelper._make_request(self.token, "deleteMessage", method="post", params=params)
+
+    def edit_message_text(self, text, chat_id=None, message_id=None, inline_message_id=None,
+                          parse_mode=None, reply_markup=None, **kwargs):
+        params = {"text": text}
+        if chat_id is not None:
+            params["chat_id"] = chat_id
+        if message_id is not None:
+            params["message_id"] = message_id
+        if inline_message_id is not None:
+            params["inline_message_id"] = inline_message_id
+        pm = parse_mode if parse_mode is not None else self.parse_mode
+        if pm:
+            params["parse_mode"] = pm
+        if reply_markup is not None:
+            params["reply_markup"] = reply_markup
+        params.update(kwargs)
+        result = apihelper._make_request(self.token, "editMessageText", method="post", params=params)
+        if isinstance(result, dict) and "message_id" in result:
+            return types.Message(**result)
+        return result
+
+    def edit_message_caption(self, caption, chat_id=None, message_id=None,
+                             parse_mode=None, reply_markup=None, **kwargs):
+        params = {"caption": caption}
+        if chat_id is not None:
+            params["chat_id"] = chat_id
+        if message_id is not None:
+            params["message_id"] = message_id
+        pm = parse_mode if parse_mode is not None else self.parse_mode
+        if pm:
+            params["parse_mode"] = pm
+        if reply_markup is not None:
+            params["reply_markup"] = reply_markup
+        params.update(kwargs)
+        result = apihelper._make_request(self.token, "editMessageCaption", method="post", params=params)
+        if isinstance(result, dict) and "message_id" in result:
+            return types.Message(**result)
+        return result
+
+    def answer_callback_query(self, callback_query_id, text=None, show_alert=False,
+                              url=None, cache_time=None, **kwargs):
+        params = {"callback_query_id": callback_query_id}
+        if text is not None:
+            params["text"] = text
+        if show_alert:
+            params["show_alert"] = True
+        if url is not None:
+            params["url"] = url
+        if cache_time is not None:
+            params["cache_time"] = cache_time
+        params.update(kwargs)
+        return apihelper._make_request(self.token, "answerCallbackQuery", method="post", params=params)
+
+    def reply_to(self, message, text, **kwargs):
+        return self.send_message(message.chat.id, text, **kwargs)
+
+    def get_file(self, file_id):
+        result = apihelper._make_request(self.token, "getFile", method="get", params={"file_id": file_id})
+        return types.File(**result)
+
+    # ---------------- Handlers ----------------
+
+    def message_handler(self, commands=None, regexp=None, func=None,
+                        content_types=None, chat_types=None):
+        def decorator(handler):
+            self._message_handlers.append({
+                "function": handler,
+                "commands": commands,
+                "regexp": re.compile(regexp) if regexp else None,
+                "func": func,
+                "content_types": content_types or ["text"],
+                "chat_types": chat_types,
+            })
+            return handler
+        return decorator
+
+    def callback_query_handler(self, func=None):
+        def decorator(handler):
+            self._callback_handlers.append({"function": handler, "func": func})
+            return handler
+        return decorator
+
+    def set_update_listener(self, listener):
+        self._update_listener = listener
+
+    def _test_message_handler(self, handler, message):
+        if handler["content_types"] and message.content_type not in handler["content_types"]:
+            return False
+        if handler["chat_types"] and getattr(message.chat, "type", None) not in handler["chat_types"]:
+            return False
+        if handler["commands"]:
+            text = getattr(message, "text", "") or ""
+            if not any(text.startswith("/" + c) for c in handler["commands"]):
+                return False
+        if handler["regexp"] and not handler["regexp"].search(getattr(message, "text", "") or ""):
+            return False
+        if handler["func"] and not handler["func"](message):
+            return False
+        return True
+
+    def process_new_updates(self, updates):
+        for update in updates:
+            if self._update_listener:
+                self._update_listener([update])
+
+            msg = update.get("message")
+            if msg:
+                message = types.Message(**msg)
+                for handler in self._message_handlers:
+                    if self._test_message_handler(handler, message):
+                        handler["function"](message)
+                        break
+                continue
+
+            cb = update.get("callback_query")
+            if cb:
+                callback = types.CallbackQuery(**cb)
+                for handler in self._callback_handlers:
+                    if handler["func"] is None or handler["func"](callback):
+                        handler["function"](callback)
+                        break
+
+    # ---------------- Polling ----------------
+
+    def polling(self, interval=0, timeout=20, allowed_updates=None, offset=None):
+        offset = offset or self._last_update_id()
+        logger.info("kernelbot: polling started")
+        while True:
+            try:
+                result = self.get_updates(offset=offset, timeout=timeout,
+                                          allowed_updates=allowed_updates)
+                updates = result.get("result", [])
+                if updates:
+                    offset = updates[-1]["update_id"] + 1
+                    self.process_new_updates(updates)
+                if interval:
+                    time.sleep(interval)
+            except KeyboardInterrupt:
+                logger.info("kernelbot: polling stopped")
+                return
+            except Exception as e:
+                logger.error("kernelbot: polling error: %s", e)
+                time.sleep(3)
+
+    def infinity_polling(self, timeout=20, **kwargs):
+        self.polling(timeout=timeout, **kwargs)
+
+    def _last_update_id(self):
+        try:
+            result = self.get_updates(offset=-1, timeout=0)
+            updates = result.get("result", [])
+            if updates:
+                return updates[-1]["update_id"] + 1
+        except Exception:
+            pass
+        return None

kernelbot/types.py

@@ -0,0 +1,85 @@
+"""KernelGram Bot API types, mirroring telebot.types."""
+
+
+class TeleBotBase:
+    """Base class: turns dicts into attribute-accessible objects."""
+
+    def __init__(self, **kwargs):
+        for key, value in kwargs.items():
+            if isinstance(value, dict):
+                value = self._wrap(value)
+            elif isinstance(value, list):
+                value = [self._wrap(v) for v in value]
+            setattr(self, key, value)
+
+    @staticmethod
+    def _wrap(value):
+        if isinstance(value, dict):
+            return TeleBotBase(**value)
+        return value
+
+    def __repr__(self):
+        return "<%s %s>" % (self.__class__.__name__, self.__dict__)
+
+
+class User(TeleBotBase):
+    @property
+    def full_name(self):
+        name = getattr(self, "first_name", "") or ""
+        last = getattr(self, "last_name", "") or ""
+        return (name + " " + last).strip()
+
+
+class Chat(TeleBotBase):
+    pass
+
+
+class Message(TeleBotBase):
+    def __init__(self, **kwargs):
+        if "from" in kwargs:
+            kwargs["from_user"] = kwargs.pop("from")
+        super().__init__(**kwargs)
+
+    @property
+    def content_type(self):
+        for key in (
+            "text", "audio", "document", "animation", "photo", "sticker",
+            "video", "video_note", "voice", "location", "contact", "venue",
+            "dice", "new_chat_members", "left_chat_member", "new_chat_title",
+            "new_chat_photo", "delete_chat_photo", "group_chat_created",
+            "supergroup_chat_created", "channel_chat_created",
+            "migrate_to_chat_id", "migrate_from_chat_id", "pinned_message",
+            "invoice", "successful_payment", "connected_website", "poll",
+            "passport_data", "proximity_alert_triggered", "video_chat_scheduled",
+            "video_chat_started", "video_chat_ended",
+            "video_chat_participants_invited", "web_app_data",
+            "message_auto_delete_timer_changed", "forum_topic_created",
+            "forum_topic_closed", "forum_topic_reopened", "forum_topic_edited",
+            "general_forum_topic_hidden", "general_forum_topic_unhidden",
+            "write_access_allowed", "user_shared", "chat_shared", "story",
+        ):
+            if hasattr(self, key):
+                return key
+        return "text"
+
+
+class Update(TeleBotBase):
+    pass
+
+
+class CallbackQuery(TeleBotBase):
+    def __init__(self, **kwargs):
+        if "from" in kwargs:
+            kwargs["from_user"] = kwargs.pop("from")
+        super().__init__(**kwargs)
+
+
+class InlineQuery(TeleBotBase):
+    def __init__(self, **kwargs):
+        if "from" in kwargs:
+            kwargs["from_user"] = kwargs.pop("from")
+        super().__init__(**kwargs)
+
+
+class File(TeleBotBase):
+    pass

kernelbot/util.py

@@ -0,0 +1,27 @@
+"""Utility helpers for kernelbot."""
+
+
+def split_string(text, chars_per_string):
+    """Split text into chunks of at most `chars_per_string` characters."""
+    return [text[i:i + chars_per_string] for i in range(0, len(text), chars_per_string)]
+
+
+def smart_split(text, chars_per_string=3000):
+    """Split text preferring '\\n', '. ' and ' ' boundaries."""
+    if len(text) <= chars_per_string:
+        return [text]
+
+    parts = []
+    remaining = text
+    while len(remaining) > chars_per_string:
+        chunk = remaining[:chars_per_string]
+        for sep in ("\n", ". ", " "):
+            idx = chunk.rfind(sep)
+            if idx != -1:
+                chunk = remaining[:idx + len(sep)]
+                break
+        parts.append(chunk)
+        remaining = remaining[len(chunk):]
+    if remaining:
+        parts.append(remaining)
+    return parts

kernelbot/version.py

@@ -0,0 +1 @@
+__version__ = "0.0.2"

kernelbot-0.0.2.dist-info/METADATA

@@ -0,0 +1,293 @@
+Metadata-Version: 2.4
+Name: kernelbot
+Version: 0.0.2
+Summary: A simple, but extensible Python implementation for the KernelGram Bot API. Telebot-compatible.
+Author-email: ReaalRick <rickReaal@proton.me>
+License: MIT
+Project-URL: Homepage, https://github.com/ReaalRick/kernelbot
+Project-URL: Repository, https://github.com/ReaalRick/kernelbot
+Project-URL: Issues, https://github.com/ReaalRick/kernelbot/issues
+Keywords: kernelgram,bot,api,telebot
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Dynamic: license-file
+
+# kernelbot
+
+Простая, но расширяемая реализация **KernelGram Bot API** на Python.
+
+[![PyPI version](https://img.shields.io/badge/pypi-coming%20soon-lightgrey)](https://pypi.org/project/kernelbot/)
+[![Python](https://img.shields.io/badge/python-3.8%2B-blue)](https://www.python.org/)
+[![License](https://img.shields.io/badge/license-MIT-green)](LICENSE)
+[![KernelGram](https://img.shields.io/badge/platform-KernelGram-2ea44f)](https://kernelgram.club)
+
+`kernelbot` — это замена [`pyTelegramBotAPI`](https://github.com/eternnoir/pyTelegramBotAPI) (telebot), адаптированная для [KernelGram](https://kernelgram.club) — мессенджера по типу телеграма но со своим сервером. Если у вас есть код под `telebot`, достаточно поменять импорт — и он заработает.
+
+---
+
+## Содержание
+
+- [Официальная документация](#официальная-документация)
+- [Установка](#установка)
+- [Первый бот](#первый-бот)
+  - [Что нужно](#что-нужно)
+  - [Простой эхо-бот](#простой-эхо-бот)
+- [Общая документация API](#общая-документация-api)
+  - [Типы](#типы)
+  - [Методы](#методы)
+  - [Обработчики сообщений](#обработчики-сообщений)
+  - [Обработчики callback-запросов](#обработчики-callback-запросов)
+  - [Отправка фото](#отправка-фото)
+  - [Отправка больших сообщений](#отправка-больших-сообщений)
+- [Продвинутое использование](#продвинутое-использование)
+  - [Только IPv4](#только-ipv4)
+  - [Скачивание файлов](#скачивание-файлов)
+  - [Прокси](#прокси)
+- [Ограничения KernelGram](#ограничения-kernelgram)
+- [Переход с telebot](#переход-с-telebot)
+- [Лицензия](#лицензия)
+
+---
+
+## Официальная документация
+
+- FAQ по ботам KernelGram: https://kernelgram.club/bots
+
+---
+
+## Установка
+
+Библиотека протестирована на Python 3.8+.
+
+Установка через pip:
+
+```
+
+pip install kernelbot
+
+```
+
+Или из исходников:
+
+```
+
+pip install git+https://github.com/ReaalRick/kernelbot.git
+
+```
+
+---
+
+## Первый бот
+
+### Что нужно
+
+Токен, полученный у `@BotFather` внутри приложения KernelGram. Назовём его `TOKEN`.
+
+### Простой эхо-бот
+
+Класс `TeleBot` инкапсулирует все вызовы API в одном классе. Он предоставляет функции вида `send_xyz` (`send_message`, `send_photo` и другие) и несколько способов слушать входящие сообщения.
+
+Создайте файл `echo_bot.py`:
+
+```python
+import kernelbot
+
+bot = kernelbot.TeleBot("TOKEN", parse_mode=None)
+
+@bot.message_handler(commands=['start', 'help'])
+def send_welcome(message):
+    bot.reply_to(message, "Howdy, how are you doing?")
+
+@bot.message_handler(func=lambda m: True)
+def echo_all(message):
+    bot.reply_to(message, message.text)
+
+bot.infinity_polling()
+```
+
+Запуск:
+
+```
+python echo_bot.py
+```
+
+Проверьте: отправьте /start и любое текстовое сообщение.
+
+---
+
+### Общая документация API
+
+Все типы описаны в kernelbot.types. Они соответствуют определениям KernelGram Bot API
+
+У объекта Message есть атрибут content_type, одно из значений:
+
+```
+text, audio, document, animation, photo, sticker, video,
+video_note, voice, location, contact, venue, dice,
+new_chat_members, left_chat_member, new_chat_title, new_chat_photo,
+delete_chat_photo, group_chat_created, supergroup_chat_created,
+channel_chat_created, migrate_to_chat_id, migrate_from_chat_id,
+pinned_message, invoice, successful_payment, connected_website,
+poll, passport_data, proximity_alert_triggered, video_chat_scheduled,
+video_chat_started, video_chat_ended, video_chat_participants_invited,
+web_app_data, message_auto_delete_timer_changed, forum_topic_created,
+forum_topic_closed, forum_topic_reopened, forum_topic_edited,
+general_forum_topic_hidden, general_forum_topic_unhidden,
+write_access_allowed, user_shared, chat_shared, story.
+```
+
+У типа Message также есть from_user — KernelGram Bot API возвращает отправителя в поле from, но from — зарезервированное слово в Python, поэтому оно переименовано.
+
+Методы
+
+Все методы API находятся в классе TeleBot. Имена следуют обычным соглашениям Python:
+
+KernelGram API метод kernelbot
+getMe get_me()
+sendMessage send_message()
+sendPhoto send_photo()
+editMessageText edit_message_text()
+editMessageCaption edit_message_caption()
+deleteMessage delete_message()
+answerCallbackQuery answer_callback_query()
+getUpdates get_updates()
+getFile get_file()
+
+Обработчики сообщений
+
+Обработчик сообщений — это функция, декорированная message_handler экземпляра TeleBot:
+
+```python
+@bot.message_handler(commands=['start'])
+def handle_start(message):
+    pass
+```
+
+Поддерживаемые фильтры:
+
+Имя Аргументы Условие
+content_types список строк (по умолчанию ['text']) True, если message.content_type в списке
+regexp строка регулярного выражения True, если re.search совпадает с message.text
+commands список строк True, если message.text начинается с одной из команд
+chat_types список типов чатов True, если message.chat.type в списке
+func lambda или ссылка на функцию True, если вызываемый объект возвращает True
+
+Все обработчики проверяются в порядке объявления.
+
+Обработчики callback-запросов
+
+Инлайн-кнопки передаются через reply_markup с полем inline_keyboard:
+
+```python
+@bot.message_handler(commands=["start"])
+def start(message):
+    markup = {
+        "inline_keyboard": [
+            [{"text": "Say hi", "callback_data": "hi"}],
+        ],
+    }
+    bot.send_message(message.chat.id, "Choose:", reply_markup=markup)
+
+
+@bot.callback_query_handler(func=lambda call: call.data == "hi")
+def on_hi(call):
+    bot.answer_callback_query(call.id, text="Hello!")
+    bot.send_message(call.message.chat.id, "Hi there!")
+```
+
+Отправка фото
+
+```python
+with open("photo.jpg", "rb") as f:
+    bot.send_photo(chat_id, f, caption="<b>Look</b>", reply_markup=markup)
+```
+
+Отправка больших сообщений
+
+```python
+from kernelbot import util
+
+large_text = open("large_text.txt", "rb").read()
+for text in util.smart_split(large_text, chars_per_string=3000):
+    bot.send_message(chat_id, text)
+```
+
+---
+
+Продвинутое использование
+
+Только IPv4
+
+API KernelGram обслуживается через Cloudflare, который отдаёт и IPv4-, и IPv6-адреса. В некоторых мобильных сетях IPv6 до Cloudflare не доходит, что вызывает ClientConnectorDNSError или No route to host.
+
+kernelbot по умолчанию форсит IPv4. Чтобы отключить:
+
+```python
+from kernelbot import apihelper
+apihelper.FORCE_IPV4 = False
+```
+
+Скачивание файлов
+
+```python
+import requests
+from kernelbot import apihelper
+
+file_info = bot.get_file(file_id)
+url = apihelper.FILE_URL.format(bot.token, file_info.file_path)
+content = requests.get(url).content
+```
+
+Прокси
+
+```python
+from kernelbot import apihelper
+apihelper.proxy = {"https": "socks5://user:pass@host:port"}
+```
+
+Требует pip install requests[socks] для SOCKS-прокси.
+
+---
+
+Ограничения KernelGram
+
+Некоторые методы и возможности Telegram Bot API в KernelGram не реализованы или работают иначе:
+
+· setMyProfilePhoto — отсутствует (METHOD_NOT_FOUND). Аватар бота устанавливается через @BotFather.
+· Reply-клавиатуры (reply_markup.keyboard) принимаются API, но не отображаются в клиенте. Используйте инлайн-клавиатуры (reply_markup.inline_keyboard).
+· Все методы set* для профиля бота (имя, описание, команды) доступны только через @BotFather.
+
+---
+
+Переход с telebot
+
+kernelbot повторяет публичный API pyTelegramBotAPI. Для перехода достаточно двух строк:
+
+```python
+# Было
+import telebot
+bot = telebot.TeleBot(TOKEN)
+
+# Стало
+import kernelbot
+bot = kernelbot.TeleBot(TOKEN)
+```
+
+Всё остальное — обработчики, фильтры, reply_to, send_message, infinity_polling — работает так же.
+
+---
+
+Лицензия
+
+MIT. См. LICENSE.

kernelbot-0.0.2.dist-info/RECORD

@@ -0,0 +1,11 @@
+kernelbot/__init__.py,sha256=14_q0BvQUHiZBTzeDmzJRZgWudtJCmp2o4ZCO-8yPKw,315
+kernelbot/apihelper.py,sha256=4ycGi6NR5sfWWzGgyVX7C3o6GKVvr1JtD_O7wRbtlJg,4007
+kernelbot/bot.py,sha256=4z3mQrHgv4jLX5sOjU6lSbEmoOx_7reolCoWL6KFKnA,9622
+kernelbot/types.py,sha256=wBHCWWcL-tcOj6SkkL0RdMITdVYVzsztFDZsMVm8ITg,2722
+kernelbot/util.py,sha256=XDEvIVTgm3yRgYN7wXdiMoOSLxeQ2rq7N2OlANaU3Ws,854
+kernelbot/version.py,sha256=QvlVh4JTl3JL7jQAja76yKtT-IvF4631ASjWY1wS6AQ,22
+kernelbot-0.0.2.dist-info/licenses/LICENSE,sha256=xGZxQ1A4VzAX7SoOPIteaWD3qhQPSexXlCIEpL1VtE4,1066
+kernelbot-0.0.2.dist-info/METADATA,sha256=BACWDPn7CF-4YCglm8GTzLl9nuqncZL4wEElnSQ_YH8,10622
+kernelbot-0.0.2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+kernelbot-0.0.2.dist-info/top_level.txt,sha256=9xoFJVdmfKyFREyqgNFOBERj4BgFFfP16riRn_2265E,10
+kernelbot-0.0.2.dist-info/RECORD,,

kernelbot-0.0.2.dist-info/WHEEL

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

kernelbot-0.0.2.dist-info/licenses/LICENSE

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

kernelbot-0.0.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+kernelbot