supermegaexplosion 0.1.0__tar.gz

supermegaexplosion-0.1.0/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: supermegaexplosion
+Version: 0.1.0
+Summary: DSA utility library — input helpers, algorithms, data structures, and AI assistant
+Author-email: "Hadoopnb.ai" <hadoopnb@example.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: ai
+Requires-Dist: transformers>=4.30.0; extra == "ai"
+Requires-Dist: torch>=2.0.0; extra == "ai"
+
+# libbs
+
+DSA utility library — interactive input helpers, string/math/array algorithms, data structures, and an optional AI coding assistant.
+
+```python
+from libbs import *
+
+show_commands()          # list everything available
+input_matrix()           # interactively type a matrix
+is_palindrome("racecar") # True
+sieve(100)               # primes up to 100
+max_subarray_sum([-2,1,-3,4,-1,2,1,-5,4])  # 6
+ListNode.from_list([1,2,3,4,5])
+respond_help("How to reverse a linked list?")  # requires: pip install libbs[ai]
+```
+
+## Install
+
+```bash
+pip install libbs           # core
+pip install libbs[ai]       # with AI assistant (transformers + torch)
+```
+
+## License
+
+MIT

supermegaexplosion-0.1.0/README.md

@@ -0,0 +1,26 @@
+# libbs
+
+DSA utility library — interactive input helpers, string/math/array algorithms, data structures, and an optional AI coding assistant.
+
+```python
+from libbs import *
+
+show_commands()          # list everything available
+input_matrix()           # interactively type a matrix
+is_palindrome("racecar") # True
+sieve(100)               # primes up to 100
+max_subarray_sum([-2,1,-3,4,-1,2,1,-5,4])  # 6
+ListNode.from_list([1,2,3,4,5])
+respond_help("How to reverse a linked list?")  # requires: pip install libbs[ai]
+```
+
+## Install
+
+```bash
+pip install libbs           # core
+pip install libbs[ai]       # with AI assistant (transformers + torch)
+```
+
+## License
+
+MIT

supermegaexplosion-0.1.0/libbs/__init__.py

@@ -0,0 +1,9 @@
+from libbs.input_utils import *
+from libbs.strings import *
+from libbs.math_utils import *
+from libbs.arrays import *
+from libbs.ds import *
+from libbs.ai_helper import respond_help
+from libbs.catalog import show_commands, show_command
+
+__version__ = "0.1.0"

supermegaexplosion-0.1.0/libbs/ai_helper.py

@@ -0,0 +1,30 @@
+def respond_help(query, model_name="TinyLlama/TinyLlama-1.1B-Chat-v1.0"):
+    try:
+        from transformers import pipeline
+    except ImportError:
+        print(
+            "The AI helper requires extra dependencies.\n"
+            "Install them with: pip install libbs[ai]\n"
+            "Or: pip install transformers torch"
+        )
+        return
+
+    print(f"Loading AI model ({model_name})... This may take a while on first run.")
+    pipe = pipeline(
+        "text-generation",
+        model=model_name,
+        trust_remote_code=True,
+    )
+    prompt = (
+        "You are a helpful DSA and Python coding assistant. "
+        "Answer the following question concisely with code examples.\n\n"
+        f"Question: {query}\n\nAnswer:"
+    )
+    result = pipe(
+        prompt,
+        max_new_tokens=512,
+        temperature=0.3,
+        do_sample=True,
+        pad_token_id=pipe.tokenizer.eos_token_id,
+    )
+    print(result[0]["generated_text"].split("Answer:")[-1].strip())

supermegaexplosion-0.1.0/libbs/arrays.py

@@ -0,0 +1,112 @@
+def rotate(arr, k):
+    if not arr:
+        return arr
+    k %= len(arr)
+    arr[:] = arr[-k:] + arr[:-k]
+    return arr
+
+
+def chunk(arr, size):
+    return [arr[i:i + size] for i in range(0, len(arr), size)]
+
+
+def flatten(lst):
+    return [item for sub in lst for item in sub]
+
+
+def two_sum(nums, target):
+    seen = {}
+    for i, v in enumerate(nums):
+        complement = target - v
+        if complement in seen:
+            return [seen[complement], i]
+        seen[v] = i
+    return []
+
+
+def max_subarray_sum(nums):
+    if not nums:
+        return 0
+    max_ending = max_sofar = nums[0]
+    for v in nums[1:]:
+        max_ending = max(v, max_ending + v)
+        max_sofar = max(max_sofar, max_ending)
+    return max_sofar
+
+
+def merge_intervals(intervals):
+    if not intervals:
+        return []
+    intervals.sort(key=lambda x: x[0])
+    merged = [list(intervals[0])]
+    for start, end in intervals[1:]:
+        if start <= merged[-1][1]:
+            merged[-1][1] = max(merged[-1][1], end)
+        else:
+            merged.append([start, end])
+    return merged
+
+
+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
+
+
+def next_permutation(arr):
+    i = len(arr) - 2
+    while i >= 0 and arr[i] >= arr[i + 1]:
+        i -= 1
+    if i >= 0:
+        j = len(arr) - 1
+        while arr[j] <= arr[i]:
+            j -= 1
+        arr[i], arr[j] = arr[j], arr[i]
+    arr[i + 1:] = reversed(arr[i + 1:])
+    return arr
+
+
+def merge_sorted(arr1, arr2):
+    result = []
+    i = j = 0
+    while i < len(arr1) and j < len(arr2):
+        if arr1[i] <= arr2[j]:
+            result.append(arr1[i])
+            i += 1
+        else:
+            result.append(arr2[j])
+            j += 1
+    result.extend(arr1[i:])
+    result.extend(arr2[j:])
+    return result
+
+
+def majority_element(nums):
+    count = 0
+    candidate = None
+    for v in nums:
+        if count == 0:
+            candidate = v
+        count += 1 if v == candidate else -1
+    return candidate
+
+
+__all__ = [
+    "rotate",
+    "chunk",
+    "flatten",
+    "two_sum",
+    "max_subarray_sum",
+    "merge_intervals",
+    "binary_search",
+    "next_permutation",
+    "merge_sorted",
+    "majority_element",
+]

supermegaexplosion-0.1.0/libbs/catalog.py

@@ -0,0 +1,84 @@
+COMMANDS = {
+    "Input": {
+        "input_matrix": "Read a matrix interactively. Optionally specify rows/cols/dtype/sep.",
+        "input_list": "Read a 1D list. Optionally specify n/dtype/sep.",
+        "input_linked_list": "Read values from stdin, return a ListNode head.",
+        "input_tree": "Read level-order values (null for gaps), return TreeNode root.",
+        "input_grid": "Read lines until blank line, return list of strings.",
+    },
+    "Strings": {
+        "is_anagram": "Check if two strings are anagrams (same chars, same count).",
+        "is_palindrome": "Check if a string reads the same forwards and backwards.",
+        "is_balanced": "Check if brackets/parens/braces in string are balanced.",
+        "reverse_words": "Reverse the order of space-separated words in a string.",
+        "longest_common_prefix": "Find the longest common prefix among a list of strings.",
+        "longest_substring": "Length of longest substring without repeating characters.",
+        "count_vowels": "Count vowels (a/e/i/o/u) in a string.",
+        "is_subsequence": "Check if s is a subsequence of t (order-preserving).",
+        "rabin_karp": "Rabin-Karp string matching. Returns list of start indices.",
+        "kmp_search": "KMP string matching. Returns list of start indices.",
+    },
+    "Math": {
+        "is_prime": "Check if n is a prime number.",
+        "sieve": "Return list of all primes up to n using Sieve of Eratosthenes.",
+        "prime_factors": "Return list of prime factors of n.",
+        "gcd": "Greatest common divisor of a and b.",
+        "lcm": "Least common multiple of a and b.",
+        "is_perfect_square": "Check if n is a perfect square.",
+        "is_power_of_two": "Check if n is a power of two.",
+        "nCr": "Binomial coefficient: n choose r.",
+        "nPr": "Permutation: n permute r (n! / (n-r)!).",
+        "fibonacci": "Return a list of the first n Fibonacci numbers.",
+        "is_armstrong": "Check if n is an Armstrong (narcissistic) number.",
+    },
+    "Arrays": {
+        "rotate": "Rotate list arr by k positions to the right (in-place).",
+        "chunk": "Split arr into subarrays of a given size.",
+        "flatten": "Flatten a nested list one level deep.",
+        "two_sum": "Return indices of two numbers that add up to target.",
+        "max_subarray_sum": "Maximum subarray sum using Kadane's algorithm.",
+        "merge_intervals": "Merge overlapping intervals [[s1,e1], [s2,e2], ...].",
+        "binary_search": "Return index of target in sorted arr, or -1 if not found.",
+        "next_permutation": "Rearrange arr into the next lexicographic permutation.",
+        "merge_sorted": "Merge two sorted lists into a single sorted list.",
+        "majority_element": "Find the majority element (> n/2 occurrences) using Boyer-Moore.",
+    },
+    "Data Structures": {
+        "ListNode": "Linked list node. Use ListNode.from_list(values) to construct.",
+        "TreeNode": "Binary tree node. Use TreeNode.from_level_order(values) to construct.",
+        "print_linked_list": "Print a linked list as space-separated values.",
+        "print_tree": "Print a binary tree sideways in ASCII.",
+        "linked_list_to_list": "Convert a linked list head to a Python list.",
+        "reverse_linked_list": "Reverse a linked list in-place, return new head.",
+        "detect_cycle": "Detect cycle in a linked list using Floyd's algorithm.",
+        "middle_node": "Return the middle node of a linked list.",
+        "has_path_sum": "Check if root-to-leaf path sums to target.",
+    },
+    "AI Assistant": {
+        "respond_help": "Ask a coding/DSA question and get an answer from a free local AI model.",
+    },
+}
+
+
+def show_commands():
+    print("\n" + "=" * 60)
+    print("  libbs — Available Commands")
+    print("=" * 60)
+    for category, funcs in COMMANDS.items():
+        print(f"\n  [{category}]")
+        print("  " + "-" * 56)
+        for name, desc in funcs.items():
+            print(f"    {name:<30} {desc}")
+    print("\n" + "=" * 60)
+    print("  Use show_command('name') for detailed help on any function.")
+    print("=" * 60 + "\n")
+
+
+def show_command(name):
+    for category, funcs in COMMANDS.items():
+        if name in funcs:
+            print(f"\n  [{category}] {name}")
+            print("  " + "-" * 50)
+            print(f"    {funcs[name]}\n")
+            return
+    print(f"  Unknown command: '{name}'. Use show_commands() to list all.\n")

supermegaexplosion-0.1.0/libbs/ds.py

@@ -0,0 +1,136 @@
+class ListNode:
+    def __init__(self, val=0, next=None):
+        self.val = val
+        self.next = next
+
+    def __repr__(self):
+        vals = []
+        cur = self
+        while cur:
+            vals.append(str(cur.val))
+            cur = cur.next
+        return " -> ".join(vals) if vals else "None"
+
+    @staticmethod
+    def from_list(vals):
+        if not vals:
+            return None
+        head = ListNode(vals[0])
+        cur = head
+        for v in vals[1:]:
+            cur.next = ListNode(v)
+            cur = cur.next
+        return head
+
+
+class TreeNode:
+    def __init__(self, val=0, left=None, right=None):
+        self.val = val
+        self.left = left
+        self.right = right
+
+    def __repr__(self):
+        return f"TreeNode({self.val})"
+
+    @staticmethod
+    def from_level_order(vals):
+        if not vals or vals[0] is None:
+            return None
+        root = TreeNode(vals[0])
+        queue = [root]
+        i = 1
+        while queue and i < len(vals):
+            node = queue.pop(0)
+            if i < len(vals) and vals[i] is not None:
+                node.left = TreeNode(vals[i])
+                queue.append(node.left)
+            i += 1
+            if i < len(vals) and vals[i] is not None:
+                node.right = TreeNode(vals[i])
+                queue.append(node.right)
+            i += 1
+        return root
+
+
+def print_linked_list(head):
+    vals = []
+    cur = head
+    while cur:
+        vals.append(str(cur.val))
+        cur = cur.next
+    print(" -> ".join(vals) if vals else "None")
+
+
+def linked_list_to_list(head):
+    result = []
+    cur = head
+    while cur:
+        result.append(cur.val)
+        cur = cur.next
+    return result
+
+
+def reverse_linked_list(head):
+    prev = None
+    cur = head
+    while cur:
+        nxt = cur.next
+        cur.next = prev
+        prev = cur
+        cur = nxt
+    return prev
+
+
+def detect_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
+
+
+def middle_node(head):
+    slow = fast = head
+    while fast and fast.next:
+        slow = slow.next
+        fast = fast.next.next
+    return slow
+
+
+def print_tree(root):
+    def inner(node, prefix, is_left):
+        if not node:
+            return
+        inner(node.right, prefix + ("|   " if is_left else "    "), False)
+        print(prefix + ("+-- " if is_left else "+-- ") + str(node.val))
+        inner(node.left, prefix + ("    " if is_left else "|   "), True)
+
+    if root:
+        print(root.val)
+        inner(root.right, "", False)
+        inner(root.left, "", True)
+
+
+def has_path_sum(root, target):
+    if not root:
+        return False
+    if not root.left and not root.right:
+        return root.val == target
+    return has_path_sum(root.left, target - root.val) or has_path_sum(
+        root.right, target - root.val
+    )
+
+
+__all__ = [
+    "ListNode",
+    "TreeNode",
+    "print_linked_list",
+    "linked_list_to_list",
+    "reverse_linked_list",
+    "detect_cycle",
+    "middle_node",
+    "print_tree",
+    "has_path_sum",
+]

supermegaexplosion-0.1.0/libbs/input_utils.py

@@ -0,0 +1,66 @@
+def input_matrix(rows=None, cols=None, dtype=int, sep=None):
+    mat = []
+    if rows is not None:
+        for i in range(rows):
+            line = input(f"Row {i+1}: ").strip()
+            vals = line.split(sep) if sep else line.split()
+            if cols is not None and len(vals) != cols:
+                raise ValueError(f"Expected {cols} elements, got {len(vals)}")
+            mat.append([dtype(v) for v in vals])
+    else:
+        print("Enter matrix rows (empty line to stop):")
+        while True:
+            line = input().strip()
+            if not line:
+                break
+            vals = line.split(sep) if sep else line.split()
+            mat.append([dtype(v) for v in vals])
+    return mat
+
+
+def input_list(n=None, dtype=int, sep=None):
+    line = input("Enter values: ").strip()
+    vals = line.split(sep) if sep else line.split()
+    if n is not None and len(vals) != n:
+        raise ValueError(f"Expected {n} elements, got {len(vals)}")
+    return [dtype(v) for v in vals]
+
+
+def input_grid():
+    print("Enter grid lines (empty line to stop):")
+    grid = []
+    while True:
+        line = input()
+        if not line.strip():
+            break
+        grid.append(line)
+    return grid
+
+
+def input_linked_list(dtype=int, sep=None):
+    from libbs.ds import ListNode
+    line = input("Enter linked list values: ").strip()
+    vals = line.split(sep) if sep else line.split()
+    return ListNode.from_list([dtype(v) for v in vals])
+
+
+def input_tree(dtype=int):
+    from libbs.ds import TreeNode
+    line = input("Enter tree level-order (null for gaps): ").strip()
+    vals = line.split()
+    parsed = []
+    for v in vals:
+        if v.lower() in ("null", "none", "n"):
+            parsed.append(None)
+        else:
+            parsed.append(dtype(v))
+    return TreeNode.from_level_order(parsed)
+
+
+__all__ = [
+    "input_matrix",
+    "input_list",
+    "input_grid",
+    "input_linked_list",
+    "input_tree",
+]

supermegaexplosion-0.1.0/libbs/math_utils.py

@@ -0,0 +1,109 @@
+def is_prime(n):
+    if n < 2:
+        return False
+    i = 2
+    while i * i <= n:
+        if n % i == 0:
+            return False
+        i += 1
+    return True
+
+
+def sieve(n):
+    if n < 2:
+        return []
+    prime = [True] * (n + 1)
+    prime[0] = prime[1] = False
+    for i in range(2, int(n ** 0.5) + 1):
+        if prime[i]:
+            step = i
+            start = i * i
+            prime[start:n + 1:step] = [False] * (((n - start) // step) + 1)
+    return [i for i, v in enumerate(prime) if v]
+
+
+def prime_factors(n):
+    factors = []
+    d = 2
+    while d * d <= n:
+        while n % d == 0:
+            factors.append(d)
+            n //= d
+        d += 1 if d == 2 else 2
+    if n > 1:
+        factors.append(n)
+    return factors
+
+
+def gcd(a, b):
+    while b:
+        a, b = b, a % b
+    return a
+
+
+def lcm(a, b):
+    return a * b // gcd(a, b)
+
+
+def is_perfect_square(n):
+    if n < 0:
+        return False
+    r = int(n ** 0.5)
+    return r * r == n
+
+
+def is_power_of_two(n):
+    return n > 0 and (n & (n - 1)) == 0
+
+
+def nCr(n, r):
+    if r < 0 or r > n:
+        return 0
+    r = min(r, n - r)
+    res = 1
+    for i in range(1, r + 1):
+        res = res * (n - r + i) // i
+    return res
+
+
+def nPr(n, r):
+    if r < 0 or r > n:
+        return 0
+    res = 1
+    for i in range(r):
+        res *= (n - i)
+    return res
+
+
+def fibonacci(n):
+    if n <= 0:
+        return []
+    if n == 1:
+        return [0]
+    seq = [0, 1]
+    for _ in range(2, n):
+        seq.append(seq[-1] + seq[-2])
+    return seq[:n]
+
+
+def is_armstrong(n):
+    if n < 0:
+        return False
+    s = str(n)
+    power = len(s)
+    return sum(int(d) ** power for d in s) == n
+
+
+__all__ = [
+    "is_prime",
+    "sieve",
+    "prime_factors",
+    "gcd",
+    "lcm",
+    "is_perfect_square",
+    "is_power_of_two",
+    "nCr",
+    "nPr",
+    "fibonacci",
+    "is_armstrong",
+]

supermegaexplosion-0.1.0/libbs/strings.py

@@ -0,0 +1,119 @@
+from collections import Counter
+
+
+def is_anagram(s1, s2):
+    return Counter(s1) == Counter(s2)
+
+
+def is_palindrome(s):
+    cleaned = "".join(c.lower() for c in s if c.isalnum())
+    return cleaned == cleaned[::-1]
+
+
+def is_balanced(s):
+    pairs = {")": "(", "]": "[", "}": "{"}
+    stack = []
+    for ch in s:
+        if ch in pairs.values():
+            stack.append(ch)
+        elif ch in pairs:
+            if not stack or stack[-1] != pairs[ch]:
+                return False
+            stack.pop()
+    return len(stack) == 0
+
+
+def reverse_words(s):
+    return " ".join(s.split()[::-1])
+
+
+def longest_common_prefix(strs):
+    if not strs:
+        return ""
+    prefix = strs[0]
+    for s in strs[1:]:
+        while not s.startswith(prefix):
+            prefix = prefix[:-1]
+            if not prefix:
+                return ""
+    return prefix
+
+
+def longest_substring(s):
+    seen = {}
+    start = 0
+    max_len = 0
+    for i, ch in enumerate(s):
+        if ch in seen and seen[ch] >= start:
+            start = seen[ch] + 1
+        seen[ch] = i
+        max_len = max(max_len, i - start + 1)
+    return max_len
+
+
+def count_vowels(s):
+    return sum(1 for ch in s.lower() if ch in "aeiou")
+
+
+def is_subsequence(s, t):
+    it = iter(t)
+    return all(ch in it for ch in s)
+
+
+def rabin_karp(text, pattern):
+    d, q = 256, 101
+    n, m = len(text), len(pattern)
+    if m > n or m == 0:
+        return []
+    h = pow(d, m - 1, q)
+    p_hash = t_hash = 0
+    for i in range(m):
+        p_hash = (d * p_hash + ord(pattern[i])) % q
+        t_hash = (d * t_hash + ord(text[i])) % q
+    result = []
+    for i in range(n - m + 1):
+        if p_hash == t_hash:
+            if text[i:i + m] == pattern:
+                result.append(i)
+        if i < n - m:
+            t_hash = (d * (t_hash - ord(text[i]) * h) + ord(text[i + m])) % q
+    return result
+
+
+def kmp_search(text, pattern):
+    n, m = len(text), len(pattern)
+    if m == 0:
+        return []
+    lps = [0] * m
+    j = 0
+    for i in range(1, m):
+        while j > 0 and pattern[i] != pattern[j]:
+            j = lps[j - 1]
+        if pattern[i] == pattern[j]:
+            j += 1
+            lps[i] = j
+    result = []
+    j = 0
+    for i in range(n):
+        while j > 0 and text[i] != pattern[j]:
+            j = lps[j - 1]
+        if text[i] == pattern[j]:
+            j += 1
+        if j == m:
+            result.append(i - m + 1)
+            j = lps[j - 1]
+    return result
+
+
+__all__ = [
+    "is_anagram",
+    "is_palindrome",
+    "is_balanced",
+    "reverse_words",
+    "longest_common_prefix",
+    "longest_substring",
+    "count_vowels",
+    "is_subsequence",
+    "rabin_karp",
+    "kmp_search",
+]

supermegaexplosion-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=64", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "supermegaexplosion"
+version = "0.1.0"
+description = "DSA utility library — input helpers, algorithms, data structures, and AI assistant"
+readme = "README.md"
+authors = [{ name = "Hadoopnb.ai", email = "hadoopnb@example.com" }]
+license = "MIT"
+classifiers = [
+    "Programming Language :: Python :: 3",
+]
+requires-python = ">=3.8"
+
+[project.optional-dependencies]
+ai = ["transformers>=4.30.0", "torch>=2.0.0"]

supermegaexplosion-0.1.0/setup.cfg

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

supermegaexplosion-0.1.0/supermegaexplosion.egg-info/PKG-INFO

@@ -0,0 +1,39 @@
+Metadata-Version: 2.4
+Name: supermegaexplosion
+Version: 0.1.0
+Summary: DSA utility library — input helpers, algorithms, data structures, and AI assistant
+Author-email: "Hadoopnb.ai" <hadoopnb@example.com>
+License-Expression: MIT
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Provides-Extra: ai
+Requires-Dist: transformers>=4.30.0; extra == "ai"
+Requires-Dist: torch>=2.0.0; extra == "ai"
+
+# libbs
+
+DSA utility library — interactive input helpers, string/math/array algorithms, data structures, and an optional AI coding assistant.
+
+```python
+from libbs import *
+
+show_commands()          # list everything available
+input_matrix()           # interactively type a matrix
+is_palindrome("racecar") # True
+sieve(100)               # primes up to 100
+max_subarray_sum([-2,1,-3,4,-1,2,1,-5,4])  # 6
+ListNode.from_list([1,2,3,4,5])
+respond_help("How to reverse a linked list?")  # requires: pip install libbs[ai]
+```
+
+## Install
+
+```bash
+pip install libbs           # core
+pip install libbs[ai]       # with AI assistant (transformers + torch)
+```
+
+## License
+
+MIT

supermegaexplosion-0.1.0/supermegaexplosion.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+libbs/__init__.py
+libbs/ai_helper.py
+libbs/arrays.py
+libbs/catalog.py
+libbs/ds.py
+libbs/input_utils.py
+libbs/math_utils.py
+libbs/strings.py
+supermegaexplosion.egg-info/PKG-INFO
+supermegaexplosion.egg-info/SOURCES.txt
+supermegaexplosion.egg-info/dependency_links.txt
+supermegaexplosion.egg-info/requires.txt
+supermegaexplosion.egg-info/top_level.txt

supermegaexplosion-0.1.0/supermegaexplosion.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

supermegaexplosion-0.1.0/supermegaexplosion.egg-info/requires.txt

@@ -0,0 +1,4 @@
+
+[ai]
+transformers>=4.30.0
+torch>=2.0.0

supermegaexplosion-0.1.0/supermegaexplosion.egg-info/top_level.txt

@@ -0,0 +1 @@
+libbs