PandaAPI 1.0.4__tar.gz → 1.0.6__tar.gz

pandaapi-1.0.6/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: PandaAPI
+Version: 1.0.6
+Summary: Python utility hub by @ll_PANDA_BBY_ll
+Author: PANDA
+Author-email: 
+License-Expression: MIT
+Keywords: python,PandaAPI,telegram,bot,osint,hacker
+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"
+Provides-Extra: exif
+Requires-Dist: Pillow; extra == "exif"
+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
+```
+
+## Usage
+
+```python
+from PandaAPI import api
+
+# OSINT
+print(api.ip_lookup("8.8.8.8"))
+print(api.username_search("pandaqt"))
+print(api.dns_lookup("google.com"))
+
+# Network
+print(api.port_scan("scanme.nmap.org"))
+print(api.ssl_check("google.com"))
+
+# Crypto
+print(api.b64_encode("hello"))
+print(api.sha256("password"))
+print(api.jwt_decode("your.jwt.token"))
+
+# Temp Mail (with OTP support)
+mail = api.temp_mail_create()
+print(mail["email"])
+inbox = api.temp_mail_inbox(mail["sid_token"])
+if inbox["emails"]:
+    msg = api.temp_mail_read(mail["sid_token"], inbox["emails"][0]["id"])
+    print(msg["otp_codes"])     # extracted OTP codes
+    print(msg["verify_links"]) # extracted verification links
+
+# Fake Identity
+print(api.fake_identity("IN"))  # Indian fake identity
+
+# Lyrics
+print(api.lyrics("Kesariya", "Arijit Singh"))
+
+# AI
+print(api.gemini("Hello!"))
+print(api.chatgpt("Explain black holes"))
+```
+
+## 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` |
+| `osint` | `ip_lookup`, `phone_lookup`, `email_verify`, `username_search`, `breach_check`, `whois`, `dns_lookup`, `ssl_info`, `exif_read` |
+| `crypto` | `b64_encode`, `b64_decode`, `md5`, `sha256`, `sha512`, `rot13`, `caesar`, `xor_encrypt`, `xor_decrypt`, `jwt_decode` |
+| `network` | `ping`, `port_scan`, `headers`, `ssl_check`, `torcheck`, `reverse_ip`, `subdomain_scan` |
+| `dark` | `fake_identity`, `temp_mail_create`, `temp_mail_inbox`, `temp_mail_read`, `dark_joke`, `lyrics` |
+
+## License
+
+MIT

pandaapi-1.0.6/PandaAPI/__init__.py

@@ -0,0 +1,180 @@
+import random
+import string
+import requests
+from .modules import telegram, media, tools, ai, osint, crypto, network, dark
+
+__version__ = "1.0.5"
+__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)
+
+    # ── OSINT ────────────────────────────────────────────
+    def ip_lookup(self, ip: str) -> dict:
+        return osint.ip_lookup(ip)
+
+    def phone_lookup(self, phone: str) -> dict:
+        return osint.phone_lookup(phone)
+
+    def email_verify(self, email: str) -> dict:
+        return osint.email_verify(email)
+
+    def username_search(self, username: str) -> dict:
+        return osint.username_search(username)
+
+    def breach_check(self, email: str) -> dict:
+        return osint.breach_check(email)
+
+    def whois(self, domain: str) -> dict:
+        return osint.whois(domain)
+
+    def dns_lookup(self, domain: str) -> dict:
+        return osint.dns_lookup(domain)
+
+    def ssl_info(self, domain: str) -> dict:
+        return osint.ssl_info(domain)
+
+    def exif_read(self, image_url: str) -> dict:
+        return osint.exif_read(image_url)
+
+    # ── Crypto / Encode ───────────────────────────────
+    def b64_encode(self, text: str) -> dict:
+        return crypto.b64_encode(text)
+
+    def b64_decode(self, text: str) -> dict:
+        return crypto.b64_decode(text)
+
+    def md5(self, text: str) -> dict:
+        return crypto.md5(text)
+
+    def sha256(self, text: str) -> dict:
+        return crypto.sha256(text)
+
+    def sha512(self, text: str) -> dict:
+        return crypto.sha512(text)
+
+    def rot13(self, text: str) -> dict:
+        return crypto.rot13(text)
+
+    def caesar(self, text: str, shift: int = 13) -> dict:
+        return crypto.caesar(text, shift)
+
+    def xor_encrypt(self, text: str, key: str) -> dict:
+        return crypto.xor_encrypt(text, key)
+
+    def xor_decrypt(self, encoded: str, key: str) -> dict:
+        return crypto.xor_decrypt(encoded, key)
+
+    def jwt_decode(self, token: str) -> dict:
+        return crypto.jwt_decode(token)
+
+    # ── Network ──────────────────────────────────────────
+    def ping(self, host: str) -> dict:
+        return network.ping(host)
+
+    def port_scan(self, host: str, ports: list = None) -> dict:
+        return network.port_scan(host, ports)
+
+    def headers(self, url: str) -> dict:
+        return network.headers(url)
+
+    def ssl_check(self, domain: str) -> dict:
+        return network.ssl_check(domain)
+
+    def torcheck(self, ip: str = None) -> dict:
+        return network.torcheck(ip)
+
+    def reverse_ip(self, ip: str) -> dict:
+        return network.reverse_ip(ip)
+
+    def subdomain_scan(self, domain: str) -> dict:
+        return network.subdomain_scan(domain)
+
+    # ── Dark / Fun ───────────────────────────────────────
+    def fake_identity(self, country: str = "US") -> dict:
+        return dark.fake_identity(country)
+
+    def temp_mail_create(self) -> dict:
+        return dark.temp_mail_create()
+
+    def temp_mail_inbox(self, sid_token: str, seq: int = 0) -> dict:
+        return dark.temp_mail_inbox(sid_token, seq)
+
+    def temp_mail_read(self, sid_token: str, mail_id: str) -> dict:
+        return dark.temp_mail_read(sid_token, mail_id)
+
+    def dark_joke(self) -> dict:
+        return dark.dark_joke()
+
+    def lyrics(self, song: str, artist: str = "") -> dict:
+        return dark.lyrics(song, artist)
+
+
+api = PandaAPI()

pandaapi-1.0.6/PandaAPI/modules/__init__.py

@@ -0,0 +1 @@
+from . import telegram, media, tools, ai, osint, crypto, network, dark

pandaapi-1.0.6/PandaAPI/modules/crypto.py

@@ -0,0 +1,109 @@
+import base64
+import hashlib
+import json
+
+
+def b64_encode(text: str) -> dict:
+    try:
+        result = base64.b64encode(text.encode()).decode()
+        return {"input": text, "result": result, "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def b64_decode(text: str) -> dict:
+    try:
+        result = base64.b64decode(text.encode()).decode()
+        return {"input": text, "result": result, "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def md5(text: str) -> dict:
+    try:
+        result = hashlib.md5(text.encode()).hexdigest()
+        return {"input": text, "result": result, "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def sha256(text: str) -> dict:
+    try:
+        result = hashlib.sha256(text.encode()).hexdigest()
+        return {"input": text, "result": result, "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def sha512(text: str) -> dict:
+    try:
+        result = hashlib.sha512(text.encode()).hexdigest()
+        return {"input": text, "result": result, "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def rot13(text: str) -> dict:
+    try:
+        result = text.translate(
+            str.maketrans(
+                'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
+                'NOPQRSTUVWXYZABCDEFGHIJKLMnopqrstuvwxyzabcdefghijklm'
+            )
+        )
+        return {"input": text, "result": result, "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def caesar(text: str, shift: int = 13) -> dict:
+    try:
+        result = ""
+        for ch in text:
+            if ch.isalpha():
+                base = ord('A') if ch.isupper() else ord('a')
+                result += chr((ord(ch) - base + shift) % 26 + base)
+            else:
+                result += ch
+        return {"input": text, "shift": shift, "result": result, "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def xor_encrypt(text: str, key: str) -> dict:
+    try:
+        result = ''.join(chr(ord(c) ^ ord(key[i % len(key)])) for i, c in enumerate(text))
+        encoded = base64.b64encode(result.encode('latin-1')).decode()
+        return {"input": text, "key": key, "result": encoded, "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def xor_decrypt(encoded: str, key: str) -> dict:
+    try:
+        decoded = base64.b64decode(encoded.encode()).decode('latin-1')
+        result = ''.join(chr(ord(c) ^ ord(key[i % len(key)])) for i, c in enumerate(decoded))
+        return {"input": encoded, "key": key, "result": result, "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def jwt_decode(token: str) -> dict:
+    try:
+        parts = token.split('.')
+        if len(parts) != 3:
+            return {"success": False, "error": "Invalid JWT format"}
+        def decode_part(p):
+            p += '=' * (-len(p) % 4)
+            return json.loads(base64.urlsafe_b64decode(p).decode())
+        header = decode_part(parts[0])
+        payload = decode_part(parts[1])
+        return {
+            "header": header,
+            "payload": payload,
+            "signature": parts[2],
+            "note": "Signature not verified",
+            "success": True,
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}

pandaapi-1.0.6/PandaAPI/modules/dark.py

@@ -0,0 +1,184 @@
+import requests
+import re
+
+
+def fake_identity(country: str = "US") -> dict:
+    try:
+        r = requests.get(
+            f"https://randomuser.me/api/?nat={country.lower()}&inc=name,location,email,phone,dob,login",
+            timeout=10,
+        ).json()
+        user = r["results"][0]
+        return {
+            "name": f"{user['name']['first']} {user['name']['last']}",
+            "email": user["email"],
+            "phone": user["phone"],
+            "username": user["login"]["username"],
+            "password": user["login"]["password"],
+            "dob": user["dob"]["date"][:10],
+            "age": user["dob"]["age"],
+            "address": f"{user['location']['street']['number']} {user['location']['street']['name']}, {user['location']['city']}, {user['location']['state']}, {user['location']['country']}",
+            "postcode": str(user["location"]["postcode"]),
+            "success": True,
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def temp_mail_create() -> dict:
+    try:
+        r = requests.get(
+            "https://api.guerrillamail.com/ajax.php?f=get_email_address&lang=en",
+            timeout=10,
+        ).json()
+        email = r.get("email_addr")
+        sid_token = r.get("sid_token")
+        return {
+            "email": email,
+            "sid_token": sid_token,
+            "note": "Use sid_token in temp_mail_inbox() to check emails",
+            "success": True,
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def temp_mail_inbox(sid_token: str, seq: int = 0) -> dict:
+    try:
+        r = requests.get(
+            f"https://api.guerrillamail.com/ajax.php?f=check_email&seq={seq}&sid_token={sid_token}",
+            timeout=10,
+        ).json()
+        emails = r.get("list", [])
+        parsed = []
+        for mail in emails:
+            parsed.append({
+                "id": mail.get("mail_id"),
+                "from": mail.get("mail_from"),
+                "subject": mail.get("mail_subject"),
+                "date": mail.get("mail_date"),
+                "read": mail.get("mail_read") == "1",
+            })
+        return {"emails": parsed, "count": len(parsed), "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def temp_mail_read(sid_token: str, mail_id: str) -> dict:
+    try:
+        r = requests.get(
+            f"https://api.guerrillamail.com/ajax.php?f=fetch_email&email_id={mail_id}&sid_token={sid_token}",
+            timeout=10,
+        ).json()
+        body = r.get("mail_body", "")
+        otp_patterns = re.findall(r'\b\d{4,8}\b', body)
+        links = re.findall(r'https?://[^\s<>"]+', body)
+        verify_links = [l for l in links if any(k in l.lower() for k in ['verify', 'confirm', 'activate', 'token', 'otp', 'code', 'click'])]
+        return {
+            "from": r.get("mail_from"),
+            "subject": r.get("mail_subject"),
+            "date": r.get("mail_date"),
+            "body": body,
+            "otp_codes": otp_patterns,
+            "verify_links": verify_links,
+            "success": True,
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def dark_joke() -> dict:
+    try:
+        r = requests.get(
+            "https://v2.jokeapi.dev/joke/Dark?type=twopart",
+            timeout=10,
+        ).json()
+        if r.get("type") == "twopart":
+            return {
+                "setup": r.get("setup"),
+                "punchline": r.get("delivery"),
+                "category": r.get("category"),
+                "success": True,
+            }
+        return {"joke": r.get("joke"), "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def lyrics(song: str, artist: str = "") -> dict:
+    try:
+        query = f"{artist} {song}".strip()
+        headers = {
+            "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+        }
+
+        # Method 1: lyrics.ovh (English songs)
+        if artist:
+            r = requests.get(
+                f"https://api.lyrics.ovh/v1/{requests.utils.quote(artist)}/{requests.utils.quote(song)}",
+                timeout=10,
+            )
+            if r.status_code == 200:
+                lyr = r.json().get("lyrics", "")
+                if lyr:
+                    return {"song": song, "artist": artist, "lyrics": lyr, "source": "lyrics.ovh", "success": True}
+
+        # Method 2: Genius search scrape
+        search_r = requests.get(
+            f"https://api.genius.com/search?q={requests.utils.quote(query)}",
+            headers={**headers, "Authorization": "Bearer alXE5K2_D2ZJVMWKW7pWAbsOaOFWlEAzHmDNJY3CyGRTMh5z3HKFqSBJaWrHK2T9"},
+            timeout=10,
+        )
+        if search_r.status_code == 200:
+            hits = search_r.json().get("response", {}).get("hits", [])
+            if hits:
+                top = hits[0]["result"]
+                song_title = top.get("title", song)
+                artist_name = top.get("primary_artist", {}).get("name", artist)
+                song_url = top.get("url", "")
+                # scrape lyrics from genius page
+                page = requests.get(song_url, headers=headers, timeout=10)
+                from bs4 import BeautifulSoup
+                soup = BeautifulSoup(page.text, "html.parser")
+                # remove scripts
+                for s in soup.find_all("script"):
+                    s.decompose()
+                containers = soup.find_all("div", attrs={"data-lyrics-container": "true"})
+                if containers:
+                    lyr_parts = []
+                    for c in containers:
+                        for br in c.find_all("br"):
+                            br.replace_with("\n")
+                        lyr_parts.append(c.get_text())
+                    lyr = "\n".join(lyr_parts).strip()
+                    return {
+                        "song": song_title,
+                        "artist": artist_name,
+                        "lyrics": lyr,
+                        "genius_url": song_url,
+                        "source": "genius",
+                        "success": True,
+                    }
+
+        # Method 3: lyrics.ovh suggest fallback
+        rs = requests.get(
+            f"https://api.lyrics.ovh/suggest/{requests.utils.quote(query)}",
+            timeout=10,
+        ).json()
+        results = rs.get("data", [])
+        if results:
+            top = results[0]
+            artist_name = top.get("artist", {}).get("name", "")
+            title = top.get("title", "")
+            r2 = requests.get(
+                f"https://api.lyrics.ovh/v1/{requests.utils.quote(artist_name)}/{requests.utils.quote(title)}",
+                timeout=10,
+            )
+            if r2.status_code == 200:
+                lyr = r2.json().get("lyrics", "")
+                if lyr:
+                    return {"song": title, "artist": artist_name, "lyrics": lyr, "source": "lyrics.ovh", "success": True}
+
+        return {"success": False, "error": "Lyrics not found — try English song name or add artist name"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}

pandaapi-1.0.6/PandaAPI/modules/media.py

@@ -0,0 +1 @@
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

pandaapi-1.0.6/PandaAPI/modules/network.py

@@ -0,0 +1,120 @@
+import requests
+import socket
+import ssl
+import json
+
+
+def ping(host: str) -> dict:
+    try:
+        ip = socket.gethostbyname(host)
+        return {"host": host, "ip": ip, "alive": True, "success": True}
+    except socket.gaierror:
+        return {"host": host, "alive": False, "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def port_scan(host: str, ports: list = None) -> dict:
+    if ports is None:
+        ports = [21, 22, 23, 25, 53, 80, 110, 143, 443, 445, 3306, 3389, 5432, 6379, 8080, 8443, 27017]
+    results = {}
+    try:
+        ip = socket.gethostbyname(host)
+        for port in ports:
+            try:
+                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                s.settimeout(1)
+                result = s.connect_ex((ip, port))
+                results[port] = result == 0
+                s.close()
+            except Exception:
+                results[port] = False
+        open_ports = [p for p, v in results.items() if v]
+        return {"host": host, "ip": ip, "open_ports": open_ports, "all": results, "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def headers(url: str) -> dict:
+    try:
+        if not url.startswith("http"):
+            url = "https://" + url
+        r = requests.get(url, timeout=10, allow_redirects=True)
+        return {
+            "url": url,
+            "status": r.status_code,
+            "headers": dict(r.headers),
+            "success": True,
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def ssl_check(domain: str) -> dict:
+    try:
+        ctx = ssl.create_default_context()
+        with ctx.wrap_socket(socket.socket(), server_hostname=domain) as s:
+            s.settimeout(10)
+            s.connect((domain, 443))
+            cert = s.getpeercert()
+        import datetime
+        expiry = datetime.datetime.strptime(cert['notAfter'], '%b %d %H:%M:%S %Y %Z')
+        issued = datetime.datetime.strptime(cert['notBefore'], '%b %d %H:%M:%S %Y %Z')
+        issuer = dict(x[0] for x in cert.get('issuer', []))
+        subject = dict(x[0] for x in cert.get('subject', []))
+        days_left = (expiry - datetime.datetime.utcnow()).days
+        return {
+            "domain": domain,
+            "issuer": issuer.get('organizationName', ''),
+            "subject": subject.get('commonName', ''),
+            "valid_from": str(issued.date()),
+            "valid_until": str(expiry.date()),
+            "days_remaining": days_left,
+            "expired": days_left < 0,
+            "success": True,
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def torcheck(ip: str = None) -> dict:
+    try:
+        if not ip:
+            ip = requests.get("https://api.ipify.org", timeout=5).text.strip()
+        r = requests.get(f"https://check.torproject.org/api/ip?ip={ip}", timeout=10).json()
+        return {
+            "ip": ip,
+            "is_tor": r.get("IsTor", False),
+            "success": True,
+        }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def reverse_ip(ip: str) -> dict:
+    try:
+        r = requests.get(
+            f"https://api.hackertarget.com/reverseiplookup/?q={ip}",
+            timeout=10,
+        )
+        domains = [d.strip() for d in r.text.strip().split('\n') if d.strip() and 'error' not in d.lower()]
+        return {"ip": ip, "domains": domains, "count": len(domains), "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def subdomain_scan(domain: str) -> dict:
+    try:
+        r = requests.get(
+            f"https://api.hackertarget.com/hostsearch/?q={domain}",
+            timeout=15,
+        )
+        lines = [l.strip() for l in r.text.strip().split('\n') if l.strip() and 'error' not in l.lower()]
+        subdomains = []
+        for line in lines:
+            parts = line.split(',')
+            if len(parts) == 2:
+                subdomains.append({"subdomain": parts[0], "ip": parts[1]})
+        return {"domain": domain, "subdomains": subdomains, "count": len(subdomains), "success": True}
+    except Exception as e:
+        return {"success": False, "error": str(e)}