PandaAPI 1.0.1__tar.gz → 1.0.3__tar.gz

{pandaapi-1.0.1 → pandaapi-1.0.3}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: PandaAPI
-Version: 1.0.1
+Version: 1.0.3
 Summary: Python utility hub by @ll_PANDA_BBY_ll
 Author: PANDA
 Author-email: 
-License: MIT
+License-Expression: MIT
 Keywords: python,PandaAPI,telegram,bot
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent

pandaapi-1.0.3/PandaAPI/modules/ai.py

@@ -0,0 +1,59 @@
+import requests
+import json
+
+
+GEMINI_KEY = "AQ.Ab8RN6JORDWFSVSJUzMxcmvKqCA4qW5GBJMwDicXWun9vGsPpQ"
+
+
+def gemini(prompt: str) -> dict:
+    url = (
+        "https://generativelanguage.googleapis.com/v1beta/models/"
+        f"gemini-2.0-flash:generateContent?key={GEMINI_KEY}"
+    )
+    payload = {"contents": [{"parts": [{"text": prompt}]}]}
+    try:
+        r = requests.post(
+            url,
+            headers={"Content-Type": "application/json"},
+            data=json.dumps(payload),
+            timeout=15,
+        )
+        if r.status_code == 200:
+            text = r.json()["candidates"][0]["content"]["parts"][0]["text"]
+            return {"result": text, "success": True}
+        # fallback to pollinations if key fails
+        r2 = requests.get(
+            f"https://text.pollinations.ai/{requests.utils.quote(prompt)}?model=openai",
+            timeout=20,
+        )
+        if r2.status_code == 200:
+            return {"result": r2.text.strip(), "success": True}
+        return {"success": False, "error": r.text}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def chatgpt(prompt: str) -> dict:
+    try:
+        r = requests.get(
+            f"https://text.pollinations.ai/{requests.utils.quote(prompt)}?model=openai",
+            timeout=20,
+        )
+        if r.status_code == 200:
+            return {"result": r.text.strip(), "success": True}
+        return {"success": False, "error": f"Status {r.status_code}"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def blackbox(prompt: str) -> dict:
+    try:
+        r = requests.get(
+            f"https://text.pollinations.ai/{requests.utils.quote(prompt)}?model=mistral",
+            timeout=20,
+        )
+        if r.status_code == 200:
+            return {"result": r.text.strip(), "success": True}
+        return {"success": False, "error": f"Status {r.status_code}"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}

pandaapi-1.0.3/PandaAPI/modules/tools.py

@@ -0,0 +1,262 @@
+import random
+import string
+import requests
+from bs4 import BeautifulSoup
+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:
+    try:
+        # using ritetag API (no auth needed for basic)
+        url = f"https://ritetag.com/best-hashtags-for/{requests.utils.quote(keyword)}"
+        headers = {"User-Agent": "Mozilla/5.0"}
+        r = requests.get(url, headers=headers, timeout=10)
+        soup = BeautifulSoup(r.text, "html.parser")
+        tags = []
+        for el in soup.select(".hashtag-text, .tag, span.ht"):
+            t = el.text.strip()
+            if t.startswith("#"):
+                tags.append(t)
+        if not tags:
+            # fallback: generate basic hashtags
+            words = keyword.lower().split()
+            tags = [
+                f"#{keyword.replace(' ', '')}",
+                f"#{keyword.replace(' ', '_')}",
+            ] + [f"#{w}" for w in words]
+        return {"input": keyword, "results": tags[:20], "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def chatbot(text: str) -> dict:
+    try:
+        r = requests.get(
+            f"https://text.pollinations.ai/{requests.utils.quote(text)}",
+            timeout=20,
+        )
+        if r.status_code == 200:
+            return {"result": r.text.strip(), "success": True}
+        return {"success": False, "error": f"Status {r.status_code}"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def meme() -> dict:
+    try:
+        r = requests.get("https://meme-api.com/gimme", timeout=10).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:
+    try:
+        url = f"https://source.unsplash.com/featured/?{requests.utils.quote(query)}"
+        r = requests.get(url, timeout=10, allow_redirects=True)
+        # unsplash source redirects to actual image
+        final_url = r.url
+        # also fetch a few via scraping picsum/unsplash search
+        search_url = f"https://unsplash.com/s/photos/{requests.utils.quote(query)}"
+        headers = {"User-Agent": "Mozilla/5.0"}
+        rs = requests.get(search_url, headers=headers, timeout=10)
+        soup = BeautifulSoup(rs.text, "html.parser")
+        imgs = []
+        for img in soup.find_all("img"):
+            src = img.get("src", "")
+            if "images.unsplash.com" in src:
+                imgs.append(src)
+            if len(imgs) >= 10:
+                break
+        if not imgs:
+            imgs = [final_url]
+        return {"results": imgs, "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def imdb(query: str) -> dict:
+    try:
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36",
+            "Accept-Language": "en-US,en;q=0.9",
+        }
+        # use OMDB-style scrape via IMDB search JSON endpoint
+        search_url = f"https://v2.sg.media-imdb.com/suggestion/x/{requests.utils.quote(query)}.json"
+        r = requests.get(search_url, headers=headers, timeout=10)
+        data = r.json()
+        results = data.get("d", [])
+        if not results:
+            return {"success": False, "error": "No results"}
+        top = results[0]
+        imdb_id = top.get("id", "")
+        title = top.get("l", "")
+        year = top.get("y", "")
+        image = top.get("i", {}).get("imageUrl", "") if isinstance(top.get("i"), dict) else ""
+        rank = top.get("rank", "")
+        # fetch detail page for more info
+        detail_url = f"https://www.imdb.com/title/{imdb_id}/"
+        rd = requests.get(detail_url, headers=headers, timeout=10)
+        soup = BeautifulSoup(rd.text, "html.parser")
+        import json as _json
+        description = ""
+        genre = []
+        actors = []
+        rating = ""
+        script = soup.find("script", type="application/ld+json")
+        if script:
+            ld = _json.loads(script.string)
+            description = ld.get("description", "")
+            genre = ld.get("genre", [])
+            actors = [a["name"] for a in ld.get("actor", [])]
+            rating = ld.get("aggregateRating", {}).get("ratingValue", "")
+        return {
+            "name": title,
+            "year": year,
+            "imdb_id": imdb_id,
+            "image": image,
+            "url": detail_url,
+            "description": description,
+            "genre": genre,
+            "actors": actors,
+            "rating": rating,
+            "success": True,
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def leetcode(username: str) -> dict:
+    url = "https://leetcode.com/graphql/"
+    q2 = {
+        "operationName": "userPublicProfile",
+        "query": """
+        query userPublicProfile($username: String!) {
+          matchedUser(username: $username) {
+            username
+            githubUrl
+            twitterUrl
+            linkedinUrl
+            submitStats {
+              acSubmissionNum {
+                difficulty
+                count
+              }
+            }
+            profile {
+              ranking
+              userAvatar
+              realName
+              countryName
+              company
+              jobTitle
+              skillTags
+            }
+          }
+        }""",
+        "variables": {"username": username},
+    }
+    try:
+        headers = {"Content-Type": "application/json", "Referer": "https://leetcode.com"}
+        r2 = requests.post(url, json=q2, headers=headers, timeout=10).json()
+        user = r2.get("data", {}).get("matchedUser")
+        if not user:
+            return {"success": False, "error": "User not found"}
+        return {**user, "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def bhagwatgita(chapter: int, shalok: int = 1) -> dict:
+    try:
+        # use bhagavad-gita.org API
+        url = f"https://bhagavad-gita3.p.rapidapi.com/v2/chapters/{chapter}/verses/{shalok}/"
+        # fallback to free API
+        url = f"https://vedicscriptures.github.io/slok/{chapter}/{shalok}/"
+        r = requests.get(url, timeout=10)
+        data = r.json()
+        return {
+            "chapter": chapter,
+            "shloka": shalok,
+            "slok": data.get("slok", ""),
+            "transliteration": data.get("transliteration", ""),
+            "hindi": data.get("tej", {}).get("ht", ""),
+            "english": data.get("siva", {}).get("et", ""),
+            "success": True,
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}

{pandaapi-1.0.1 → pandaapi-1.0.3}/PandaAPI.egg-info/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: PandaAPI
-Version: 1.0.1
+Version: 1.0.3
 Summary: Python utility hub by @ll_PANDA_BBY_ll
 Author: PANDA
 Author-email: 
-License: MIT
+License-Expression: MIT
 Keywords: python,PandaAPI,telegram,bot
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent

{pandaapi-1.0.1 → pandaapi-1.0.3}/pyproject.toml

@@ -4,13 +4,13 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "PandaAPI"
-version = "1.0.1"
+version = "1.0.3"
 authors = [
   { name = "PANDA" }
 ]
 description = "Python utility hub by @ll_PANDA_BBY_ll"
 readme = "README.md"
-license = { text = "MIT" }
+license = "MIT"
 requires-python = ">=3.8"
 keywords = ["python", "PandaAPI", "telegram", "bot"]
 classifiers = [

pandaapi-1.0.1/PandaAPI/modules/ai.py

@@ -1,59 +0,0 @@
-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.1/PandaAPI/modules/tools.py

@@ -1,259 +0,0 @@
-import random
-import string
-import re
-import requests
-from bs4 import BeautifulSoup
-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:
-        try:
-            from requests_html import HTMLSession
-            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"]
-        except ImportError:
-            # fallback: plain requests + bs4
-            headers = {"User-Agent": "Mozilla/5.0"}
-            r = requests.get(
-                f"https://www.imdb.com/find?q={query}&s=tt", headers=headers
-            )
-            soup = BeautifulSoup(r.text, "html.parser")
-            result = soup.select_one(".ipc-metadata-list-summary-item a")
-            if not result:
-                return {"success": False, "error": "No results"}
-            first_url = result["href"]
-
-        headers = {"User-Agent": "Mozilla/5.0"}
-        page = requests.get(f"https://www.imdb.com{first_url}", headers=headers)
-        soup = BeautifulSoup(page.text, "html.parser")
-        import json as _json
-        script = soup.find("script", type="application/ld+json")
-        if not script:
-            return {"success": False, "error": "Could not parse IMDB page"}
-        ld = _json.loads(script.string)
-        return {
-            "name": soup.title.text.strip() if soup.title else "",
-            "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 \u00bb", "")
-             .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)}