supermegaexplosion 0.2.0__tar.gz → 0.3.1__tar.gz

{supermegaexplosion-0.2.0 → supermegaexplosion-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supermegaexplosion
-Version: 0.2.0
+Version: 0.3.1
 Summary: DSA utility library — input helpers, algorithms, data structures, and AI assistant
 Author-email: "Hadoopnb.ai" <hadoopnb@example.com>
 License-Expression: MIT

{supermegaexplosion-0.2.0 → supermegaexplosion-0.3.1}/libbs/__init__.py

@@ -6,4 +6,4 @@ from libbs.ds import *
 from libbs.ai_helper import respond_help
 from libbs.catalog import show_commands, show_command
 
-__version__ = "0.1.0"
+__version__ = "0.3.1"

supermegaexplosion-0.3.1/libbs/ai_helper.py

@@ -0,0 +1,288 @@
+import os
+import json
+import base64
+import re
+import time
+import threading
+
+_CONFIG_DIR = os.path.expanduser("~/.config/supermegaexplosion")
+_CONFIG_FILE = os.path.join(_CONFIG_DIR, "config.json")
+
+_EMBEDDED_KEY = base64.b64decode(
+    "QVEuQWI4Uk42SVhxTFVmcEpqVlhaTjY3S3lkRFUtNFoxWHZKWXFWMnBPMGMzZHZoSTRISXc="
+).decode()
+
+_MODELS = ["gemini-2.0-flash-lite", "gemini-2.0-flash"]
+
+_lock = threading.Lock()
+_request_times = []
+
+_FALLBACKS = {
+    "reverse linked list": """def reverse_linked_list(head):
+    prev = None
+    cur = head
+    while cur:
+        nxt = cur.next
+        cur.next = prev
+        prev = cur
+        cur = nxt
+    return prev""",
+    "two sum": """def two_sum(nums, target):
+    seen = {}
+    for i, v in enumerate(nums):
+        comp = target - v
+        if comp in seen:
+            return [seen[comp], i]
+        seen[v] = i
+    return []""",
+    "palindrome": """def is_palindrome(s):
+    s = ''.join(c.lower() for c in s if c.isalnum())
+    return s == s[::-1]""",
+    "zig zag": """def zigzag(n):
+    for i in range(n):
+        print(' ' * (n - i - 1) + '* ' * (i + 1))
+    for i in range(n - 1):
+        print(' ' * (i + 1) + '* ' * (n - i - 1))""",
+    "anagram": """def is_anagram(s1, s2):
+    from collections import Counter
+    return Counter(s1) == Counter(s2)""",
+    "fibonacci": """def fibonacci(n):
+    if n <= 0: return []
+    seq = [0, 1]
+    for _ in range(2, n):
+        seq.append(seq[-1] + seq[-2])
+    return seq[:n]""",
+    "binary search": """def binary_search(arr, target):
+    lo, hi = 0, len(arr) - 1
+    while lo <= hi:
+        mid = (lo + hi) // 2
+        if arr[mid] == target: return mid
+        if arr[mid] < target: lo = mid + 1
+        else: hi = mid - 1
+    return -1""",
+    "bubble sort": """def bubble_sort(arr):
+    n = len(arr)
+    for i in range(n):
+        for j in range(n - 1 - i):
+            if arr[j] > arr[j + 1]:
+                arr[j], arr[j + 1] = arr[j + 1], arr[j]""",
+    "merge sort": """def merge_sort(arr):
+    if len(arr) <= 1: return arr
+    mid = len(arr) // 2
+    left = merge_sort(arr[:mid])
+    right = merge_sort(arr[mid:])
+    return merge(left, right)
+
+def merge(a, b):
+    res = []
+    i = j = 0
+    while i < len(a) and j < len(b):
+        if a[i] <= b[j]:
+            res.append(a[i]); i += 1
+        else:
+            res.append(b[j]); j += 1
+    return res + a[i:] + b[j:]""",
+    "quick sort": """def quick_sort(arr):
+    if len(arr) <= 1: return arr
+    pivot = arr[0]
+    left = [x for x in arr[1:] if x <= pivot]
+    right = [x for x in arr[1:] if x > pivot]
+    return quick_sort(left) + [pivot] + quick_sort(right)""",
+    "linked list cycle": """def has_cycle(head):
+    slow = fast = head
+    while fast and fast.next:
+        slow = slow.next
+        fast = fast.next.next
+        if slow is fast: return True
+    return False""",
+    "level order": """from collections import deque
+def level_order(root):
+    if not root: return []
+    res, q = [], deque([root])
+    while q:
+        level = []
+        for _ in range(len(q)):
+            node = q.popleft()
+            level.append(node.val)
+            if node.left: q.append(node.left)
+            if node.right: q.append(node.right)
+        res.append(level)
+    return res""",
+    "max subarray": """def max_subarray(nums):
+    cur = max_sum = nums[0]
+    for v in nums[1:]:
+        cur = max(v, cur + v)
+        max_sum = max(max_sum, cur)
+    return max_sum""",
+    "lru cache": """class LRUCache:
+    def __init__(self, cap):
+        self.cap = cap
+        self.cache = {}
+        self.order = []
+
+    def get(self, key):
+        if key not in self.cache: return -1
+        self.order.remove(key)
+        self.order.append(key)
+        return self.cache[key]
+
+    def put(self, key, val):
+        if key in self.cache:
+            self.order.remove(key)
+        elif len(self.cache) >= self.cap:
+            oldest = self.order.pop(0)
+            del self.cache[oldest]
+        self.cache[key] = val
+        self.order.append(key)""",
+}
+
+
+def _load_config():
+    try:
+        with open(_CONFIG_FILE) as f:
+            return json.load(f)
+    except (FileNotFoundError, json.JSONDecodeError):
+        return {}
+
+
+def _save_config(data):
+    os.makedirs(_CONFIG_DIR, exist_ok=True)
+    with open(_CONFIG_FILE, "w") as f:
+        json.dump(data, f)
+
+
+def _get_key(api_key):
+    return api_key or os.environ.get("GEMINI_API_KEY") or _load_config().get("api_key")
+
+
+def _rate_limit_wait():
+    with _lock:
+        now = time.time()
+        cutoff = now - 60
+        recent = [t for t in _request_times if t > cutoff]
+        _request_times[:] = recent
+        if len(recent) >= 4:
+            wait = recent[0] + 60 - now
+            return max(wait, 1)
+        _request_times.append(now)
+    return 0
+
+
+def _extract_retry_delay(error_text):
+    match = re.search(r"retry in (\d+(?:\.\d+)?)\s*s", error_text, re.IGNORECASE)
+    if match:
+        return float(match.group(1))
+    match = re.search(r"retryDelay.*?(\d+)s", error_text, re.IGNORECASE)
+    if match:
+        return float(match.group(1))
+    return None
+
+
+def _countdown(seconds, label="Retrying"):
+    bar_width = 20
+    interval = max(0.5, seconds / bar_width)
+    steps = max(1, int(seconds / interval))
+    for i in range(steps, 0, -1):
+        filled = int((steps - i + 1) * bar_width / steps)
+        bar = "#" * filled + "." * (bar_width - filled)
+        remaining = seconds * i / steps
+        print(f"\r  [{bar}] {label} in {remaining:.0f}s  ", end="", flush=True)
+        time.sleep(interval)
+    print("\r" + " " * 55 + "\r", end="", flush=True)
+
+
+def _find_fallback(query):
+    q = query.lower().strip()
+    for keyword, answer in _FALLBACKS.items():
+        if keyword in q:
+            return answer
+    return None
+
+
+def respond_help(query=None, api_key=None):
+    interactive = query is None
+    if interactive:
+        query = input("Ask a DSA/Python question: ").strip()
+        if not query:
+            return
+
+    fallback = _find_fallback(query)
+
+    try:
+        from google import genai
+    except ImportError:
+        print(
+            "Missing dependency. Install with:\n"
+            "  pip install supermegaexplosion[ai]"
+        )
+        if fallback:
+            print("\n  Here's a built-in answer:\n")
+            print(fallback)
+        return
+
+    key = _get_key(api_key)
+
+    if not key:
+        print(
+            "No API key found. Using a shared demo key (rate-limited).\n"
+            "Set your own free key at https://aistudio.google.com/ for better quota.\n"
+        )
+        key = _EMBEDDED_KEY
+        _save_config({"api_key": ""})
+
+    if key == _EMBEDDED_KEY and not _load_config().get("api_key"):
+        if interactive:
+            try:
+                ans = input("Enter your Gemini API key (or press Enter to use the demo key): ").strip()
+                if ans:
+                    key = ans
+                    _save_config({"api_key": ans})
+            except (EOFError, OSError):
+                pass
+
+    wait = _rate_limit_wait()
+    if wait > 0:
+        _countdown(wait, "Cooling down")
+
+    client = genai.Client(api_key=key)
+    last_error = None
+
+    for attempt in range(4):
+        for model_name in _MODELS:
+            try:
+                resp = client.models.generate_content(
+                    model=model_name,
+                    contents=(
+                        "You are a DSA and Python coding assistant. "
+                        "Answer concisely with code examples.\n\n"
+                        f"Question: {query}"
+                    ),
+                    config={"max_output_tokens": 512, "temperature": 0.3},
+                )
+                print(resp.text)
+                return
+            except Exception as e:
+                last_error = e
+                msg = str(e)
+
+                if "limit: 0" in msg or "PERMISSION_DENIED" in msg:
+                    continue
+
+                if "429" in msg or "RESOURCE_EXHAUSTED" in msg:
+                    delay = _extract_retry_delay(msg)
+                    if delay:
+                        _countdown(min(delay, 30), "Quota hit")
+                    elif attempt < 3:
+                        _countdown(5 * (attempt + 1), f"Retry {attempt + 1}/3")
+                    else:
+                        break
+                    break
+
+    if fallback:
+        print("\n  [!] AI unavailable. Here's a built-in answer:\n")
+        print(fallback)
+    else:
+        print(
+            "\n  [X] AI quota exhausted. Set your own key or try again later:\n"
+            "     set GEMINI_API_KEY=your_key"
+        )

{supermegaexplosion-0.2.0 → supermegaexplosion-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "supermegaexplosion"
-version = "0.2.0"
+version = "0.3.1"
 description = "DSA utility library — input helpers, algorithms, data structures, and AI assistant"
 readme = "README.md"
 authors = [{ name = "Hadoopnb.ai", email = "hadoopnb@example.com" }]

{supermegaexplosion-0.2.0 → supermegaexplosion-0.3.1}/supermegaexplosion.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supermegaexplosion
-Version: 0.2.0
+Version: 0.3.1
 Summary: DSA utility library — input helpers, algorithms, data structures, and AI assistant
 Author-email: "Hadoopnb.ai" <hadoopnb@example.com>
 License-Expression: MIT

supermegaexplosion-0.2.0/libbs/ai_helper.py

@@ -1,46 +0,0 @@
-import os
-
-
-def respond_help(query=None, api_key=None, model="gemini-2.0-flash-lite"):
-    if query is None:
-        query = input("Ask a DSA/Python question: ").strip()
-        if not query:
-            return
-
-    if api_key is None:
-        api_key = os.environ.get("GEMINI_API_KEY")
-    if not api_key:
-        print(
-            "Gemini API key not found.\n"
-            "Set the GEMINI_API_KEY environment variable:\n"
-            "  set GEMINI_API_KEY=your_key_here\n"
-            "Or pass api_key='your_key' to respond_help()."
-        )
-        return
-
-    try:
-        from google import genai
-    except ImportError:
-        print(
-            "Missing dependency. Install with:\n"
-            "  pip install supermegaexplosion[ai]"
-        )
-        return
-
-    try:
-        client = genai.Client(api_key=api_key)
-        resp = client.models.generate_content(
-            model=model,
-            contents=(
-                "You are a DSA and Python coding assistant. "
-                "Answer concisely with code examples.\n\n"
-                f"Question: {query}"
-            ),
-            config={
-                "max_output_tokens": 512,
-                "temperature": 0.3,
-            },
-        )
-        print(resp.text)
-    except Exception as e:
-        print(f"Error: {e}")