openbot-api 1.0.0__tar.gz

openbot_api-1.0.0/LICENSE

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

openbot_api-1.0.0/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: openbot_api
+Version: 1.0.0
+Summary: Python client for the Openbot ID authorization API
+Author: Kafnik
+License-Expression: MIT
+Keywords: telegram,authorization,fastapi,telebot
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Openbot API 1.0.0
+
+Python library to check Telegram user roles and levels against your Openbot ID server.
+
+## Install
+
+```bash
+pip install openbot_api
+```
+
+Until the new package is published to PyPI, install the local wheel included in the release archive.
+
+## Usage
+
+```python
+import os
+import telebot
+import openbot_api
+
+bot = telebot.TeleBot(os.environ["TELEGRAM_BOT_TOKEN"])
+openbot = openbot_api.OpenbotAPI(api_key=os.environ["OPENBOT_API_KEY"], bot=bot)
+
+@bot.message_handler(commands=["start"])
+@openbot.check_level("tester", level=2)
+@openbot.check_level("developer", level=2)
+def start(message):
+    bot.reply_to(message, "✅ Доступ разрешён!")
+
+bot.infinity_polling()
+```
+
+Two stacked `check_level` decorators grant access if **either** status and its required level match.
+
+Other methods: `get_user(id)`, `get_status(id)`, `get_level(id)`, `has_level(id, role, level)`, `check_access(id)`, and `require_access()`.
+
+The API key is a secret. Do not commit it to Git, place it in bot source, or share it publicly. The client is intentionally **read-only**: new keys may only be issued by an authorized administrator on the server, not through an unauthenticated public endpoint.
+
+## API keys on Linux server
+
+See `server-key-tools/README.md` in the release archive. Back up your existing key database before replacing any existing files. `api_keys.py` and `manage_keys.py` are server-side tools and must **not** be published as part of the Python package.

openbot_api-1.0.0/README.md

@@ -0,0 +1,40 @@
+# Openbot API 1.0.0
+
+Python library to check Telegram user roles and levels against your Openbot ID server.
+
+## Install
+
+```bash
+pip install openbot_api
+```
+
+Until the new package is published to PyPI, install the local wheel included in the release archive.
+
+## Usage
+
+```python
+import os
+import telebot
+import openbot_api
+
+bot = telebot.TeleBot(os.environ["TELEGRAM_BOT_TOKEN"])
+openbot = openbot_api.OpenbotAPI(api_key=os.environ["OPENBOT_API_KEY"], bot=bot)
+
+@bot.message_handler(commands=["start"])
+@openbot.check_level("tester", level=2)
+@openbot.check_level("developer", level=2)
+def start(message):
+    bot.reply_to(message, "✅ Доступ разрешён!")
+
+bot.infinity_polling()
+```
+
+Two stacked `check_level` decorators grant access if **either** status and its required level match.
+
+Other methods: `get_user(id)`, `get_status(id)`, `get_level(id)`, `has_level(id, role, level)`, `check_access(id)`, and `require_access()`.
+
+The API key is a secret. Do not commit it to Git, place it in bot source, or share it publicly. The client is intentionally **read-only**: new keys may only be issued by an authorized administrator on the server, not through an unauthenticated public endpoint.
+
+## API keys on Linux server
+
+See `server-key-tools/README.md` in the release archive. Back up your existing key database before replacing any existing files. `api_keys.py` and `manage_keys.py` are server-side tools and must **not** be published as part of the Python package.

openbot_api-1.0.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "openbot_api"
+version = "1.0.0"
+description = "Python client for the Openbot ID authorization API"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = []
+authors = [{name = "Kafnik"}]
+license = "MIT"
+license-files = ["LICENSE"]
+keywords = ["telegram", "authorization", "fastapi", "telebot"]
+
+[tool.setuptools.packages.find]
+where = ["src"]

openbot_api-1.0.0/setup.cfg

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

openbot_api-1.0.0/src/openbot_api/__init__.py

@@ -0,0 +1,5 @@
+"""Public Python client for Openbot ID."""
+
+from .client import OpenbotAPI, APIError, AccessDenied
+
+__all__ = ["OpenbotAPI", "APIError", "AccessDenied"]

openbot_api-1.0.0/src/openbot_api/client.py

@@ -0,0 +1,169 @@
+"""HTTPS-only client for Openbot ID API."""
+
+import functools
+import json
+import os
+from urllib.error import HTTPError, URLError
+from urllib.parse import urlencode
+from urllib.request import Request, urlopen
+
+
+DEFAULT_API_URL = "https://server.tail116c85.ts.net"
+
+
+class APIError(Exception):
+    """The API could not complete the verification."""
+
+
+class AccessDenied(Exception):
+    """The checked user does not have permission."""
+
+
+class OpenbotAPI:
+    def __init__(self, api_key=None, *, api_url=DEFAULT_API_URL, timeout=5, bot=None):
+        self.api_key = api_key or os.getenv("OPENBOT_API_KEY")
+        if not self.api_key:
+            raise ValueError("An API key is required")
+        self.api_url = api_url.rstrip("/")
+        if not self.api_url.startswith("https://"):
+            raise ValueError("API URL must use HTTPS")
+        if timeout <= 0:
+            raise ValueError("timeout must be positive")
+        self.timeout = timeout
+        self.bot = bot
+
+    def _get(self, path, params=None):
+        url = self.api_url + path
+        if params:
+            url += "?" + urlencode(params)
+        request = Request(url, headers={"X-API-Key": self.api_key, "Accept": "application/json"})
+        try:
+            with urlopen(request, timeout=self.timeout) as response:
+                result = json.load(response)
+        except HTTPError as exc:
+            raise APIError(f"API returned HTTP {exc.code}") from exc
+        except (URLError, TimeoutError, OSError, ValueError) as exc:
+            raise APIError("Openbot ID API is unavailable or returned invalid JSON") from exc
+        if not isinstance(result, dict):
+            raise APIError("Unexpected API response")
+        return result
+
+    @staticmethod
+    def _valid_user_id(user_id):
+        if type(user_id) is not int or user_id <= 0:
+            raise ValueError("user_id must be a positive integer")
+        return user_id
+
+    def get_user(self, user_id):
+        return self._get(f"/api/user/{self._valid_user_id(user_id)}")
+
+    def get_status(self, user_id):
+        return self.get_user(user_id)["status"]
+
+    def get_level(self, user_id):
+        return self.get_user(user_id)["level"]
+
+    def check_access(self, user_id):
+        result = self._get(f"/api/check_access/{self._valid_user_id(user_id)}")
+        if type(result.get("allowed")) is not bool:
+            raise APIError("API response lacks an allowed flag")
+        return result["allowed"]
+
+    def has_level(self, user_id, status, level=1):
+        if not isinstance(status, str) or not status.strip():
+            raise ValueError("status must be a non-empty string")
+        if type(level) is not int or level < 1:
+            raise ValueError("level must be a positive integer")
+        result = self._get(
+            f"/api/check_level/{self._valid_user_id(user_id)}",
+            {"status": status, "level": level},
+        )
+        if type(result.get("allowed")) is not bool:
+            raise APIError("API response lacks an allowed flag")
+        return result["allowed"]
+
+    def check_level(self, status, level=1, *, on_denied=None, on_error=None):
+        """Stacked check_level decorators use OR across roles (same client).
+
+        For example, tester 2+ OR developer 2+ will grant access.
+        Failed/unavailable API checks never execute the protected handler.
+        """
+        if not isinstance(status, str) or not status.strip():
+            raise ValueError("status must be a non-empty string")
+        if type(level) is not int or level < 1:
+            raise ValueError("level must be a positive integer")
+
+        def decorate(handler):
+            # The inner decorator already created the only guard. Attach another
+            # acceptable status instead of wrapping it in a second AND-check.
+            if getattr(handler, "_openbot_level_client", None) is self:
+                handler._openbot_level_requirements.append((status.strip(), level))
+                if on_denied is not None:
+                    handler._openbot_on_denied = on_denied
+                if on_error is not None:
+                    handler._openbot_on_error = on_error
+                return handler
+
+            @functools.wraps(handler)
+            def wrapped(message, *args, **kwargs):
+                try:
+                    user_id = message.from_user.id
+                    allowed = any(
+                        self.has_level(user_id, required_status, required_level)
+                        for required_status, required_level in wrapped._openbot_level_requirements
+                    )
+                except APIError as exc:
+                    callback = wrapped._openbot_on_error
+                    if callback:
+                        return callback(message, exc)
+                    if self.bot:
+                        return self.bot.reply_to(message, "⚠️ Openbot ID недоступен. Попробуйте позже.")
+                    raise
+                if not allowed:
+                    callback = wrapped._openbot_on_denied
+                    if callback:
+                        return callback(message)
+                    if self.bot:
+                        return self.bot.reply_to(message, "⛔ Недостаточно прав для этой команды.")
+                    raise AccessDenied("User is not permitted")
+                return handler(message, *args, **kwargs)
+
+            wrapped._openbot_level_client = self
+            wrapped._openbot_level_requirements = [(status.strip(), level)]
+            wrapped._openbot_on_denied = on_denied
+            wrapped._openbot_on_error = on_error
+            return wrapped
+
+        return decorate
+
+
+    def require_access(self, *, on_denied=None, on_error=None):
+        """Decorator requiring the server's general access policy."""
+        return self._decorate_permission(self.check_access, on_denied=on_denied, on_error=on_error)
+
+    def _decorate_permission(self, verify, *, on_denied, on_error):
+        def decorate(handler):
+            @functools.wraps(handler)
+            def wrapped(message, *args, **kwargs):
+                try:
+                    user_id = message.from_user.id
+                    allowed = verify(user_id)
+                except APIError as exc:
+                    if on_error:
+                        return on_error(message, exc)
+                    if self.bot:
+                        return self.bot.reply_to(message, "⚠️ Openbot ID недоступен. Попробуйте позже.")
+                    raise
+                if not allowed:
+                    if on_denied:
+                        return on_denied(message)
+                    if self.bot:
+                        return self.bot.reply_to(message, "⛔ Недостаточно прав для этой команды.")
+                    raise AccessDenied("User is not permitted")
+                return handler(message, *args, **kwargs)
+            return wrapped
+        return decorate
+
+
+# Optional backwards-compatible class name for migrated projects.
+OpenbotID = OpenbotAPI

openbot_api-1.0.0/src/openbot_api.egg-info/PKG-INFO

@@ -0,0 +1,52 @@
+Metadata-Version: 2.4
+Name: openbot_api
+Version: 1.0.0
+Summary: Python client for the Openbot ID authorization API
+Author: Kafnik
+License-Expression: MIT
+Keywords: telegram,authorization,fastapi,telebot
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# Openbot API 1.0.0
+
+Python library to check Telegram user roles and levels against your Openbot ID server.
+
+## Install
+
+```bash
+pip install openbot_api
+```
+
+Until the new package is published to PyPI, install the local wheel included in the release archive.
+
+## Usage
+
+```python
+import os
+import telebot
+import openbot_api
+
+bot = telebot.TeleBot(os.environ["TELEGRAM_BOT_TOKEN"])
+openbot = openbot_api.OpenbotAPI(api_key=os.environ["OPENBOT_API_KEY"], bot=bot)
+
+@bot.message_handler(commands=["start"])
+@openbot.check_level("tester", level=2)
+@openbot.check_level("developer", level=2)
+def start(message):
+    bot.reply_to(message, "✅ Доступ разрешён!")
+
+bot.infinity_polling()
+```
+
+Two stacked `check_level` decorators grant access if **either** status and its required level match.
+
+Other methods: `get_user(id)`, `get_status(id)`, `get_level(id)`, `has_level(id, role, level)`, `check_access(id)`, and `require_access()`.
+
+The API key is a secret. Do not commit it to Git, place it in bot source, or share it publicly. The client is intentionally **read-only**: new keys may only be issued by an authorized administrator on the server, not through an unauthenticated public endpoint.
+
+## API keys on Linux server
+
+See `server-key-tools/README.md` in the release archive. Back up your existing key database before replacing any existing files. `api_keys.py` and `manage_keys.py` are server-side tools and must **not** be published as part of the Python package.

openbot_api-1.0.0/src/openbot_api.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+src/openbot_api/__init__.py
+src/openbot_api/client.py
+src/openbot_api.egg-info/PKG-INFO
+src/openbot_api.egg-info/SOURCES.txt
+src/openbot_api.egg-info/dependency_links.txt
+src/openbot_api.egg-info/top_level.txt

openbot_api-1.0.0/src/openbot_api.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

openbot_api-1.0.0/src/openbot_api.egg-info/top_level.txt

@@ -0,0 +1 @@
+openbot_api