PandaAPI 1.0.0__tar.gz

pandaapi-1.0.0/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: PandaAPI
+Version: 1.0.0
+Summary: Python utility hub by @ll_PANDA_BBY_ll
+Author: PANDA
+Author-email: 
+License: MIT
+Keywords: python,PandaAPI,telegram,bot
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: beautifulsoup4
+Provides-Extra: media
+Requires-Dist: yt-dlp; extra == "media"
+Dynamic: requires-python
+
+# PandaAPI
+
+**PandaAPI** — Python utility hub by [@ll_PANDA_BBY_ll](https://t.me/ll_PANDA_BBY_ll)
+
+## Install
+
+```bash
+pip install PandaAPI
+```
+
+With media support (yt-dlp):
+
+```bash
+pip install PandaAPI[media]
+```
+
+## Usage
+
+```python
+from PandaAPI import api
+
+# Password generator
+print(api.password(16))
+
+# GitHub user info
+print(api.github("nikhil390u8o"))
+
+# AI
+print(api.gemini("Hello!"))
+print(api.chatgpt("Explain black holes"))
+
+# YouTube
+results = api.yt_search("lofi chill beats")
+print(results)
+
+# Telegram bot info
+print(api.tg_bot_info("YOUR_BOT_TOKEN"))
+```
+
+## Modules
+
+| Module | Functions |
+|--------|-----------|
+| `tools` | `password`, `morse_encode`, `morse_decode`, `github`, `pypi`, `hashtag`, `chatbot`, `meme`, `unsplash`, `imdb`, `leetcode`, `bhagwatgita` |
+| `ai` | `gemini`, `chatgpt`, `blackbox` |
+| `telegram` | `tg_bot_info`, `tg_user` |
+| `media` | `yt_search`, `yt_thumb` |
+
+## License
+
+MIT

pandaapi-1.0.0/PandaAPI/__init__.py

@@ -0,0 +1,80 @@
+import random
+import string
+import requests
+from .modules import telegram, media, tools, ai
+
+__version__ = "1.0.0"
+__all__ = ["PandaAPI"]
+
+
+class PandaAPI:
+    """
+    PandaAPI — Python utility hub by @ll_PANDA_BBY_ll
+    """
+
+    def __init__(self) -> None:
+        pass
+
+    # ── Tools ────────────────────────────────────
+    def password(self, length: int = 12) -> str:
+        return tools.password(length)
+
+    def morse_encode(self, text: str) -> dict:
+        return tools.morse_encode(text)
+
+    def morse_decode(self, code: str) -> dict:
+        return tools.morse_decode(code)
+
+    def github(self, username: str) -> dict:
+        return tools.github(username)
+
+    def pypi(self, package: str) -> dict:
+        return tools.pypi(package)
+
+    def hashtag(self, keyword: str) -> dict:
+        return tools.hashtag(keyword)
+
+    def chatbot(self, text: str) -> dict:
+        return tools.chatbot(text)
+
+    def meme(self) -> dict:
+        return tools.meme()
+
+    def unsplash(self, query: str) -> dict:
+        return tools.unsplash(query)
+
+    def imdb(self, query: str) -> dict:
+        return tools.imdb(query)
+
+    def leetcode(self, username: str) -> dict:
+        return tools.leetcode(username)
+
+    def bhagwatgita(self, chapter: int, shalok: int = 1) -> dict:
+        return tools.bhagwatgita(chapter, shalok)
+
+    # ── AI ───────────────────────────────────────
+    def gemini(self, prompt: str) -> dict:
+        return ai.gemini(prompt)
+
+    def chatgpt(self, prompt: str) -> dict:
+        return ai.chatgpt(prompt)
+
+    def blackbox(self, prompt: str) -> dict:
+        return ai.blackbox(prompt)
+
+    # ── Telegram ─────────────────────────────────
+    def tg_bot_info(self, bot_token: str) -> dict:
+        return telegram.get_bot_info(bot_token)
+
+    def tg_user(self, user_id: int, bot_token: str) -> dict:
+        return telegram.get_user(user_id, bot_token)
+
+    # ── Media ────────────────────────────────────
+    def yt_search(self, query: str) -> list:
+        return media.yt_search(query)
+
+    def yt_thumb(self, video_id: str) -> str:
+        return media.yt_thumb(video_id)
+
+
+api = PandaAPI()

pandaapi-1.0.0/PandaAPI/func.py

@@ -0,0 +1,18 @@
+MORSE_CODE_DICT = {
+    "A": ".-",    "B": "-...",  "C": "-.-.",  "D": "-..",
+    "E": ".",     "F": "..-.",  "G": "--.",   "H": "....",
+    "I": "..",    "J": ".---",  "K": "-.-",   "L": ".-..",
+    "M": "--",    "N": "-.",    "O": "---",   "P": ".--.",
+    "Q": "--.-",  "R": ".-.",   "S": "...",   "T": "-",
+    "U": "..-",   "V": "...-",  "W": ".--",   "X": "-..-",
+    "Y": "-.--",  "Z": "--..",
+    "1": ".----", "2": "..---", "3": "...--", "4": "....-",
+    "5": ".....", "6": "-....", "7": "--...", "8": "---..",
+    "9": "----.", "0": "-----",
+    ",": "--..--","." : ".-.-.-","?" : "..--..",
+    "'" : ".----.","/": "-..-.", "(": "-.--.",  ")": "-.--.-",
+    "&": ".-...",  ":": "---...", ";": "-.-.-.",
+    "=": "-...-",  "+": ".-.-.",  "-": "-....-",
+    "_": "..__.-",  '"': ".-..-.", "$": "...-..-",
+    "!": "-.-.--",  "@": ".--.-.",
+}

pandaapi-1.0.0/PandaAPI/modules/__init__.py

@@ -0,0 +1 @@
+from . import telegram, media, tools, ai

pandaapi-1.0.0/PandaAPI/modules/ai.py

@@ -0,0 +1,59 @@
+import requests
+import json
+
+
+def gemini(prompt: str) -> dict:
+    url = (
+        "https://generativelanguage.googleapis.com/v1beta/models/"
+        "gemini-pro:generateContent"
+        "?key=AIzaSyBQaoUF-KWjPV_4ABtSN0DQ0RPkNeCh4tM"
+    )
+    payload = {"contents": [{"parts": [{"text": prompt}]}]}
+    try:
+        r = requests.post(url, headers={"Content-Type": "application/json"},
+                          data=json.dumps(payload))
+        if r.status_code == 200:
+            text = r.json()["candidates"][0]["content"]["parts"][0]["text"]
+            return {"result": text, "success": True}
+        return {"success": False, "error": r.text}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def chatgpt(prompt: str) -> dict:
+    """Uses free exh.ai endpoint (same as BadAPI)."""
+    try:
+        url = "https://api.exh.ai/chatbot/v1/get_response"
+        headers = {
+            "Authorization": (
+                "Bearer eyJhbGciOiJIUzUxMiJ9"
+                ".eyJ1c2VybmFtZSI6ImJvdGlmeS13ZWItdjMifQ"
+                ".O-w89I5aX2OE_i4k6jdHZJEDWECSUfOb1lr9UdVH4oT"
+                "PMkFGUNm9BNzoQjcXOu8NEiIXq64-481hnenHdUrXfg"
+            ),
+            "Content-Type": "application/json",
+        }
+        payload = {
+            "messages": [{"role": "user", "content": prompt}],
+            "model": "gpt-3.5-turbo",
+        }
+        r = requests.post(url, headers=headers, data=json.dumps(payload))
+        return {"result": r.json().get("response", ""), "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def blackbox(prompt: str) -> dict:
+    try:
+        url = "https://www.blackbox.ai/api/chat"
+        headers = {"Content-Type": "application/json"}
+        payload = {
+            "messages": [{"role": "user", "content": prompt}],
+            "agentMode": {},
+            "trendingAgentMode": {},
+            "isMicMode": False,
+        }
+        r = requests.post(url, headers=headers, json=payload)
+        return {"result": r.text, "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}

pandaapi-1.0.0/PandaAPI/modules/media.py

@@ -0,0 +1,35 @@
+import requests
+
+
+def yt_search(query: str) -> list:
+    """
+    Uses yt-dlp's ytsearch via a simple scrape-free approach.
+    Returns list of dicts with title, url, duration, channel.
+    """
+    try:
+        import yt_dlp
+
+        ydl_opts = {
+            "quiet": True,
+            "skip_download": True,
+            "extract_flat": True,
+        }
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info = ydl.extract_info(f"ytsearch5:{query}", download=False)
+            entries = info.get("entries", [])
+            return [
+                {
+                    "title": e.get("title"),
+                    "url": f"https://youtube.com/watch?v={e.get('id')}",
+                    "duration": e.get("duration"),
+                    "channel": e.get("channel"),
+                    "id": e.get("id"),
+                }
+                for e in entries
+            ]
+    except ImportError:
+        return [{"error": "yt_dlp not installed", "success": False}]
+
+
+def yt_thumb(video_id: str) -> str:
+    return f"https://img.youtube.com/vi/{video_id}/maxresdefault.jpg"

pandaapi-1.0.0/PandaAPI/modules/telegram.py

@@ -0,0 +1,23 @@
+import requests
+
+BASE = "https://api.telegram.org/bot{token}/{method}"
+
+
+def _call(token: str, method: str, **params) -> dict:
+    url = BASE.format(token=token, method=method)
+    r = requests.get(url, params=params)
+    return r.json()
+
+
+def get_bot_info(token: str) -> dict:
+    r = _call(token, "getMe")
+    if r.get("ok"):
+        return {"result": r["result"], "success": True}
+    return {"error": r.get("description"), "success": False}
+
+
+def get_user(user_id: int, token: str) -> dict:
+    r = _call(token, "getChat", chat_id=user_id)
+    if r.get("ok"):
+        return {"result": r["result"], "success": True}
+    return {"error": r.get("description"), "success": False}

pandaapi-1.0.0/PandaAPI/modules/tools.py

@@ -0,0 +1,248 @@
+import random
+import string
+import re
+import requests
+from bs4 import BeautifulSoup
+from requests_html import HTMLSession
+from ..func import MORSE_CODE_DICT
+
+
+def password(length: int = 12) -> str:
+    chars = string.ascii_letters + string.punctuation + string.digits
+    return "".join(random.sample(chars, length))
+
+
+def morse_encode(text: str) -> dict:
+    cipher = ""
+    for ch in text.upper():
+        if ch == " ":
+            cipher += " "
+        elif ch in MORSE_CODE_DICT:
+            cipher += MORSE_CODE_DICT[ch] + " "
+    return {"input": text, "result": cipher.strip(), "success": True}
+
+
+def morse_decode(code: str) -> dict:
+    code += " "
+    decipher = ""
+    citext = ""
+    i = 0
+    for ch in code:
+        if ch != " ":
+            i = 0
+            citext += ch
+        else:
+            i += 1
+            if i == 2:
+                decipher += " "
+            else:
+                key = next(
+                    (k for k, v in MORSE_CODE_DICT.items() if v == citext), "?"
+                )
+                decipher += key
+                citext = ""
+    return {"input": code.strip(), "result": decipher, "success": True}
+
+
+def github(username: str) -> dict:
+    r = requests.get(f"https://api.github.com/users/{username}").json()
+    return {
+        "name": r.get("name"),
+        "username": r.get("login"),
+        "id": r.get("id"),
+        "bio": r.get("bio"),
+        "location": r.get("location"),
+        "repos": r.get("public_repos"),
+        "followers": r.get("followers"),
+        "following": r.get("following"),
+        "avatar": r.get("avatar_url"),
+        "url": r.get("html_url"),
+        "success": True,
+    }
+
+
+def pypi(package: str) -> dict:
+    r = requests.get(f"https://pypi.org/pypi/{package}/json").json()
+    info = r.get("info", {})
+    return {
+        "name": info.get("name"),
+        "version": info.get("version"),
+        "summary": info.get("summary"),
+        "author": info.get("author"),
+        "license": info.get("license"),
+        "home_page": info.get("home_page"),
+        "success": True,
+    }
+
+
+def hashtag(keyword: str) -> dict:
+    url = "https://all-hashtag.com/library/contents/ajax_generator.php"
+    data = {"keyword": keyword, "filter": "top"}
+    response = requests.post(url, data=data).text
+    soup = BeautifulSoup(response, "html.parser")
+    div = soup.find("div", {"class": "copy-hashtags"})
+    if not div:
+        return {"success": False, "error": "No hashtags found"}
+    tags = div.string.split()
+    return {"input": keyword, "results": tags, "success": True}
+
+
+def chatbot(text: str) -> dict:
+    try:
+        url = (
+            "https://fallenxbot.vercel.app/api"
+            f"?apikey=593560829-fallen-usbk33kbsu"
+            f"&group-controller/mukesh/message={text}"
+        )
+        r = requests.get(url).json()
+        return {"result": r.get("reply", ""), "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def meme() -> dict:
+    try:
+        r = requests.get("https://meme-api.com/gimme").json()
+        return {
+            "title": r.get("title"),
+            "url": r.get("url"),
+            "subreddit": r.get("subreddit"),
+            "author": r.get("author"),
+            "success": True,
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def unsplash(query: str) -> dict:
+    url = (
+        f"https://www.istockphoto.com/search/2/image"
+        f"?alloweduse=availableforalluses&phrase={query}&sort=best"
+    )
+    headers = {
+        "User-Agent": (
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+            "AppleWebKit/537.36 (KHTML, like Gecko) "
+            "Chrome/121.0.0.0 Safari/537.36"
+        ),
+        "Accept-Language": "en-US,en;q=0.9",
+        "Referer": "https://unsplash.com/",
+    }
+    r = requests.get(url, headers=headers)
+    if r.status_code != 200:
+        return {"success": False, "error": f"Status {r.status_code}"}
+    soup = BeautifulSoup(r.content, "html.parser")
+    imgs = [
+        img["src"]
+        for img in soup.find_all("img")
+        if img.get("src", "").startswith("https://media.istockphoto.com")
+    ]
+    return {"results": imgs, "success": True}
+
+
+def imdb(query: str) -> dict:
+    try:
+        session = HTMLSession()
+        r = session.get(f"https://www.imdb.com/find?q={query}")
+        results = r.html.xpath(
+            "//section[@data-testid='find-results-section-title']/div/ul/li"
+        )
+        if not results:
+            return {"success": False, "error": "No results"}
+        first_url = results[0].find("a")[0].attrs["href"]
+        headers = {
+            "User-Agent": (
+                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
+                "AppleWebKit/537.36"
+            )
+        }
+        page = requests.get(f"https://www.imdb.com/{first_url}", headers=headers)
+        soup = BeautifulSoup(page.text, "html.parser")
+        import json as _json
+        ld = _json.loads(soup.find("script", type="application/ld+json").string)
+        return {
+            "name": soup.title.text.strip(),
+            "url": ld.get("url"),
+            "image": ld.get("image"),
+            "description": ld.get("description"),
+            "genre": ld.get("genre"),
+            "actors": [a["name"] for a in ld.get("actor", [])],
+            "review": ld.get("review", {}).get("reviewBody"),
+            "rating": ld.get("review", {}).get("reviewRating", {}).get("ratingValue"),
+            "trailer": ld.get("trailer"),
+            "success": True,
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def leetcode(username: str) -> dict:
+    url = "https://leetcode.com/graphql/"
+    q1 = {
+        "operationName": "userProfileCalendar",
+        "query": """
+        query userProfileCalendar($username: String!, $year: Int) {
+          matchedUser(username: $username) {
+            userCalendar(year: $year) {
+              streak
+              totalActiveDays
+              activeYears
+            }
+          }
+        }""",
+        "variables": {"username": username, "year": 2024},
+    }
+    q2 = {
+        "operationName": "userPublicProfile",
+        "query": """
+        query userPublicProfile($username: String!) {
+          matchedUser(username: $username) {
+            username
+            githubUrl
+            twitterUrl
+            linkedinUrl
+            profile {
+              ranking
+              userAvatar
+              realName
+              countryName
+              company
+              jobTitle
+              skillTags
+            }
+          }
+        }""",
+        "variables": {"username": username},
+    }
+    try:
+        r1 = requests.post(url, json=q1).json()
+        r2 = requests.post(url, json=q2).json()
+        d1 = r1["data"]["matchedUser"]
+        d2 = r2["data"]["matchedUser"]
+        return {**d1, **d2, "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def bhagwatgita(chapter: int, shalok: int = 1) -> dict:
+    try:
+        url = f"https://www.holy-bhagavad-gita.org/chapter/{chapter}/hi"
+        r = requests.get(url)
+        soup = BeautifulSoup(r.text, "html.parser")
+        intro_div = soup.find("div", class_="chapterIntro")
+        verses = soup.find_all("section", class_="listItem")
+        texts = [
+            v.text.strip()
+             .replace("View commentary »", "")
+             .replace("Bhagavad Gita ", "")
+             .strip()
+            for v in verses
+        ]
+        return {
+            "chapter": chapter,
+            "chapter_intro": intro_div.text if intro_div else "",
+            "shalok": texts[shalok] if shalok < len(texts) else "",
+            "success": True,
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}

pandaapi-1.0.0/PandaAPI.egg-info/PKG-INFO

@@ -0,0 +1,69 @@
+Metadata-Version: 2.4
+Name: PandaAPI
+Version: 1.0.0
+Summary: Python utility hub by @ll_PANDA_BBY_ll
+Author: PANDA
+Author-email: 
+License: MIT
+Keywords: python,PandaAPI,telegram,bot
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests
+Requires-Dist: beautifulsoup4
+Provides-Extra: media
+Requires-Dist: yt-dlp; extra == "media"
+Dynamic: requires-python
+
+# PandaAPI
+
+**PandaAPI** — Python utility hub by [@ll_PANDA_BBY_ll](https://t.me/ll_PANDA_BBY_ll)
+
+## Install
+
+```bash
+pip install PandaAPI
+```
+
+With media support (yt-dlp):
+
+```bash
+pip install PandaAPI[media]
+```
+
+## Usage
+
+```python
+from PandaAPI import api
+
+# Password generator
+print(api.password(16))
+
+# GitHub user info
+print(api.github("nikhil390u8o"))
+
+# AI
+print(api.gemini("Hello!"))
+print(api.chatgpt("Explain black holes"))
+
+# YouTube
+results = api.yt_search("lofi chill beats")
+print(results)
+
+# Telegram bot info
+print(api.tg_bot_info("YOUR_BOT_TOKEN"))
+```
+
+## Modules
+
+| Module | Functions |
+|--------|-----------|
+| `tools` | `password`, `morse_encode`, `morse_decode`, `github`, `pypi`, `hashtag`, `chatbot`, `meme`, `unsplash`, `imdb`, `leetcode`, `bhagwatgita` |
+| `ai` | `gemini`, `chatgpt`, `blackbox` |
+| `telegram` | `tg_bot_info`, `tg_user` |
+| `media` | `yt_search`, `yt_thumb` |
+
+## License
+
+MIT

pandaapi-1.0.0/PandaAPI.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+setup.py
+PandaAPI/__init__.py
+PandaAPI/func.py
+PandaAPI.egg-info/PKG-INFO
+PandaAPI.egg-info/SOURCES.txt
+PandaAPI.egg-info/dependency_links.txt
+PandaAPI.egg-info/requires.txt
+PandaAPI.egg-info/top_level.txt
+PandaAPI/modules/__init__.py
+PandaAPI/modules/ai.py
+PandaAPI/modules/media.py
+PandaAPI/modules/telegram.py
+PandaAPI/modules/tools.py

pandaapi-1.0.0/PandaAPI.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pandaapi-1.0.0/PandaAPI.egg-info/requires.txt

@@ -0,0 +1,5 @@
+requests
+beautifulsoup4
+
+[media]
+yt-dlp

pandaapi-1.0.0/PandaAPI.egg-info/top_level.txt

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

pandaapi-1.0.0/README.md

@@ -0,0 +1,51 @@
+# PandaAPI
+
+**PandaAPI** — Python utility hub by [@ll_PANDA_BBY_ll](https://t.me/ll_PANDA_BBY_ll)
+
+## Install
+
+```bash
+pip install PandaAPI
+```
+
+With media support (yt-dlp):
+
+```bash
+pip install PandaAPI[media]
+```
+
+## Usage
+
+```python
+from PandaAPI import api
+
+# Password generator
+print(api.password(16))
+
+# GitHub user info
+print(api.github("nikhil390u8o"))
+
+# AI
+print(api.gemini("Hello!"))
+print(api.chatgpt("Explain black holes"))
+
+# YouTube
+results = api.yt_search("lofi chill beats")
+print(results)
+
+# Telegram bot info
+print(api.tg_bot_info("YOUR_BOT_TOKEN"))
+```
+
+## Modules
+
+| Module | Functions |
+|--------|-----------|
+| `tools` | `password`, `morse_encode`, `morse_decode`, `github`, `pypi`, `hashtag`, `chatbot`, `meme`, `unsplash`, `imdb`, `leetcode`, `bhagwatgita` |
+| `ai` | `gemini`, `chatgpt`, `blackbox` |
+| `telegram` | `tg_bot_info`, `tg_user` |
+| `media` | `yt_search`, `yt_thumb` |
+
+## License
+
+MIT

pandaapi-1.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "PandaAPI"
+version = "1.0.0"
+authors = [
+  { name = "PANDA" }
+]
+description = "Python utility hub by @ll_PANDA_BBY_ll"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.8"
+keywords = ["python", "PandaAPI", "telegram", "bot"]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Operating System :: OS Independent",
+]
+dependencies = [
+  "requests",
+  "beautifulsoup4",
+]
+
+[project.optional-dependencies]
+media = ["yt-dlp"]
+
+[tool.setuptools.packages.find]
+where = ["."]

pandaapi-1.0.0/setup.cfg

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

pandaapi-1.0.0/setup.py

@@ -0,0 +1,43 @@
+from setuptools import setup, find_packages
+import re
+
+
+def get_version():
+    with open("PandaAPI/__init__.py", encoding="utf-8") as f:
+        match = re.search(r'^__version__ = [\'"]([\'"]*)[\'"]', f.read(), re.M)
+    if not match:
+        raise RuntimeError("Version not found")
+    return match.group(1)
+
+
+try:
+    with open("README.md", encoding="utf-8") as f:
+        long_desc = f.read()
+except FileNotFoundError:
+    long_desc = "PandaAPI — Python utility hub"
+
+
+setup(
+    name="PandaAPI",
+    version="1.0.0",
+    author="PANDA",
+    author_email="",
+    description="Python utility hub by @ll_PANDA_BBY_ll",
+    long_description=long_desc,
+    long_description_content_type="text/markdown",
+    packages=find_packages(),
+    license="MIT",
+    install_requires=[
+        "requests",
+        "beautifulsoup4",
+    ],
+    extras_require={
+        "media": ["yt-dlp"],
+    },
+    python_requires=">=3.8",
+    keywords=["python", "PandaAPI", "telegram", "bot"],
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "Operating System :: OS Independent",
+    ],
+)