eapyTool 0.2.0__tar.gz → 0.3.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eapyTool
-Version: 0.2.0
+Version: 0.3.1
 Summary: A Python utility library for math, algebra, data structures, and everyday tools
 Project-URL: Homepage, https://github.com/eapy/eapy
 Project-URL: Repository, https://github.com/eapy/eapy
@@ -63,6 +63,9 @@ A Python utility library that extends the standard library with math, algebra, d
 - `Stack` — LIFO stack (push/pop/peek)
 - `Queue` — FIFO queue (enqueue/dequeue)
 - `Trie` — prefix tree (insert/search/words_with_prefix)
+- `LinkedList` — singly linked list (append/prepend/remove/find)
+- `CircularBuffer` — fixed-size circular buffer
+- `PriorityQueue` — min-heap priority queue
 
 ### Base Conversion
 - `baseConvert(n, from_base, to_base)` — arbitrary base conversion (2-36)
@@ -107,6 +110,43 @@ A Python utility library that extends the standard library with math, algebra, d
 ### Random Utilities
 - `randomChoice`, `shuffle`, `randomString`, `randomInt`, `randomFloat` — enhanced random helpers
 
+### File I/O
+- `readJson`, `writeJson` — JSON file helpers
+- `readCsv`, `writeCsv` — CSV file helpers
+
+### Encoding
+- `base64Encode`, `base64Decode` — Base64 encoding
+- `urlEncode`, `urlDecode` — URL encoding
+
+### Math Extensions
+- `factorial` — factorial
+- `matrixInverse` — matrix inverse (Gauss-Jordan)
+- `interpolate` — linear interpolation
+
+### Regex Utilities
+- `extractEmails`, `extractURLs` — extract from text
+- `replaceMultiple` — multi-pattern replacement
+
+### Cache & Performance
+- `@lruCache(maxsize)` — LRU cache decorator
+- `@timeit` — execution time decorator
+
+### Progress Iterator
+- `tqdm(iterable)` — progress bar iterator
+
+### Type Checks
+- `isNumber`, `isString`, `isList`, `isDict`, `isCallable` — type check helpers
+
+### Network Utilities
+- `getJson(url)` — GET request returning JSON
+- `postJson(url, data)` — POST request with JSON body
+
+### Math Extensions (Vector)
+- `dotProduct`, `crossProduct`, `normalize` — vector operations
+
+### Local Storage
+- `Storage` — persistent key-value store with subpath support
+
 ## Installation
 
 ```bash

{eapytool-0.2.0 → eapytool-0.3.1}/README.md

@@ -40,6 +40,9 @@ A Python utility library that extends the standard library with math, algebra, d
 - `Stack` — LIFO stack (push/pop/peek)
 - `Queue` — FIFO queue (enqueue/dequeue)
 - `Trie` — prefix tree (insert/search/words_with_prefix)
+- `LinkedList` — singly linked list (append/prepend/remove/find)
+- `CircularBuffer` — fixed-size circular buffer
+- `PriorityQueue` — min-heap priority queue
 
 ### Base Conversion
 - `baseConvert(n, from_base, to_base)` — arbitrary base conversion (2-36)
@@ -84,6 +87,43 @@ A Python utility library that extends the standard library with math, algebra, d
 ### Random Utilities
 - `randomChoice`, `shuffle`, `randomString`, `randomInt`, `randomFloat` — enhanced random helpers
 
+### File I/O
+- `readJson`, `writeJson` — JSON file helpers
+- `readCsv`, `writeCsv` — CSV file helpers
+
+### Encoding
+- `base64Encode`, `base64Decode` — Base64 encoding
+- `urlEncode`, `urlDecode` — URL encoding
+
+### Math Extensions
+- `factorial` — factorial
+- `matrixInverse` — matrix inverse (Gauss-Jordan)
+- `interpolate` — linear interpolation
+
+### Regex Utilities
+- `extractEmails`, `extractURLs` — extract from text
+- `replaceMultiple` — multi-pattern replacement
+
+### Cache & Performance
+- `@lruCache(maxsize)` — LRU cache decorator
+- `@timeit` — execution time decorator
+
+### Progress Iterator
+- `tqdm(iterable)` — progress bar iterator
+
+### Type Checks
+- `isNumber`, `isString`, `isList`, `isDict`, `isCallable` — type check helpers
+
+### Network Utilities
+- `getJson(url)` — GET request returning JSON
+- `postJson(url, data)` — POST request with JSON body
+
+### Math Extensions (Vector)
+- `dotProduct`, `crossProduct`, `normalize` — vector operations
+
+### Local Storage
+- `Storage` — persistent key-value store with subpath support
+
 ## Installation
 
 ```bash

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "eapyTool"
-version = "0.2.0"
+version = "0.3.1"
 description = "A Python utility library for math, algebra, data structures, and everyday tools"
 readme = "README.md"
 license = "MPL-2.0"

{eapytool-0.2.0 → eapytool-0.3.1}/src/eapy/__init__.py

@@ -1,6 +1,6 @@
 """eapy - A Python utility library for math, algebra, data structures, and everyday tools."""
 
-__version__ = "0.2.0"
+__version__ = "0.3.1"
 
 from eapy.core import (
     # Timer
@@ -51,6 +51,7 @@ from eapy.core import (
     pipe, compose, curry,
     # Data structures
     Stack, Queue, Trie,
+    LinkedList, CircularBuffer, PriorityQueue,
     # Base conversion
     baseConvert, toBinary, toOctal, toHex,
     # Color
@@ -69,4 +70,24 @@ from eapy.core import (
     md5, sha256, hashFile,
     # Random
     randomChoice, shuffle, randomString, randomInt, randomFloat,
+    # File I/O
+    readJson, writeJson, readCsv, writeCsv,
+    # Encoding
+    base64Encode, base64Decode, urlEncode, urlDecode,
+    # Math extensions
+    factorial, matrixInverse, interpolate,
+    # Regex utilities
+    extractEmails, extractURLs, replaceMultiple,
+    # Cache / Performance
+    lruCache, timeit,
+    # Progress iterator
+    tqdm,
+    # Type checks
+    isNumber, isString, isList, isDict, isCallable,
+    # Network
+    getJson, postJson,
+    # Math extensions (vector)
+    dotProduct, crossProduct, normalize,
+    # Local storage
+    Storage,
 )

{eapytool-0.2.0 → eapytool-0.3.1}/src/eapy/core.py

@@ -1674,4 +1674,518 @@ def randomInt(min_val: int, max_val: int) -> int:
 
 def randomFloat(min_val: float = 0.0, max_val: float = 1.0) -> float:
     """Return a random float in [min_val, max_val)."""
-    return _random.uniform(min_val, max_val)
+    return _random.uniform(min_val, max_val)
+
+
+# ======================================================== Data structures (extended) ========================================================
+
+class LinkedListNode:
+    def __init__(self, value, next_node=None):
+        self.value = value
+        self.next = next_node
+
+
+class LinkedList:
+    """Singly linked list."""
+
+    def __init__(self):
+        self.head = None
+        self._size = 0
+
+    def append(self, value):
+        """Add value to the end."""
+        new_node = LinkedListNode(value)
+        if self.head is None:
+            self.head = new_node
+        else:
+            node = self.head
+            while node.next:
+                node = node.next
+            node.next = new_node
+        self._size += 1
+
+    def prepend(self, value):
+        """Add value to the beginning."""
+        self.head = LinkedListNode(value, self.head)
+        self._size += 1
+
+    def remove(self, value):
+        """Remove first occurrence of value."""
+        if self.head is None:
+            raise ValueError(f"{value} not found")
+        if self.head.value == value:
+            self.head = self.head.next
+            self._size -= 1
+            return
+        node = self.head
+        while node.next:
+            if node.next.value == value:
+                node.next = node.next.next
+                self._size -= 1
+                return
+            node = node.next
+        raise ValueError(f"{value} not found")
+
+    def find(self, value):
+        """Return True if value exists."""
+        node = self.head
+        while node:
+            if node.value == value:
+                return True
+            node = node.next
+        return False
+
+    def to_list(self) -> list:
+        """Convert to Python list."""
+        result = []
+        node = self.head
+        while node:
+            result.append(node.value)
+            node = node.next
+        return result
+
+    def __len__(self):
+        return self._size
+
+    def __repr__(self):
+        return f"LinkedList({self.to_list()})"
+
+
+class CircularBuffer:
+    """Fixed-size circular buffer."""
+
+    def __init__(self, capacity: int):
+        self.capacity = capacity
+        self._data = [None] * capacity
+        self._start = 0
+        self._end = 0
+        self._size = 0
+
+    def push(self, value):
+        """Add value, overwrites oldest if full."""
+        self._data[self._end] = value
+        self._end = (self._end + 1) % self.capacity
+        if self._size == self.capacity:
+            self._start = (self._start + 1) % self.capacity
+        else:
+            self._size += 1
+
+    def pop(self):
+        """Remove and return the oldest value."""
+        if self._size == 0:
+            raise IndexError("Buffer is empty")
+        value = self._data[self._start]
+        self._start = (self._start + 1) % self.capacity
+        self._size -= 1
+        return value
+
+    def peek(self):
+        """Return oldest value without removing."""
+        if self._size == 0:
+            raise IndexError("Buffer is empty")
+        return self._data[self._start]
+
+    def __len__(self):
+        return self._size
+
+    def __repr__(self):
+        items = []
+        idx = self._start
+        for _ in range(self._size):
+            items.append(self._data[idx])
+            idx = (idx + 1) % self.capacity
+        return f"CircularBuffer({items})"
+
+
+class PriorityQueue:
+    """Min-heap priority queue."""
+
+    def __init__(self):
+        self._heap = []
+
+    def push(self, item, priority: float = 0):
+        """Add item with given priority (lower = higher priority)."""
+        self._heap.append((priority, item))
+        self._heap.sort(key=lambda x: x[0])
+
+    def pop(self):
+        """Remove and return item with lowest priority value."""
+        if not self._heap:
+            raise IndexError("Queue is empty")
+        return self._heap.pop(0)[1]
+
+    def peek(self):
+        """Return item with lowest priority value."""
+        if not self._heap:
+            raise IndexError("Queue is empty")
+        return self._heap[0][1]
+
+    def is_empty(self) -> bool:
+        return len(self._heap) == 0
+
+    def __len__(self):
+        return len(self._heap)
+
+    def __repr__(self):
+        return f"PriorityQueue({[(p, i) for p, i in self._heap]})"
+
+
+# ======================================================== File I/O ========================================================
+
+import json
+import csv
+
+
+def readJson(path: str, encoding: str = "utf-8"):
+    """Read and parse a JSON file."""
+    with open(path, "r", encoding=encoding) as f:
+        return json.load(f)
+
+
+def writeJson(path: str, data, indent: int = 2, encoding: str = "utf-8"):
+    """Write data to a JSON file."""
+    with open(path, "w", encoding=encoding) as f:
+        json.dump(data, f, indent=indent, ensure_ascii=False)
+
+
+def readCsv(path: str, delimiter: str = ",", encoding: str = "utf-8") -> list[list[str]]:
+    """Read a CSV file and return list of rows."""
+    with open(path, "r", encoding=encoding, newline="") as f:
+        return list(csv.reader(f, delimiter=delimiter))
+
+
+def writeCsv(path: str, data: list[list], delimiter: str = ",", encoding: str = "utf-8"):
+    """Write list of rows to a CSV file."""
+    with open(path, "w", encoding=encoding, newline="") as f:
+        writer = csv.writer(f, delimiter=delimiter)
+        writer.writerows(data)
+
+
+# ======================================================== Encoding ========================================================
+
+import base64
+import urllib.parse
+
+
+def base64Encode(s: str) -> str:
+    """Encode string to Base64."""
+    return base64.b64encode(s.encode()).decode()
+
+
+def base64Decode(s: str) -> str:
+    """Decode Base64 string."""
+    return base64.b64decode(s.encode()).decode()
+
+
+def urlEncode(s: str) -> str:
+    """URL-encode a string."""
+    return urllib.parse.quote(s)
+
+
+def urlDecode(s: str) -> str:
+    """URL-decode a string."""
+    return urllib.parse.unquote(s)
+
+
+# ======================================================== Math extensions ========================================================
+
+def factorial(n: int) -> int:
+    """Return n! (n factorial)."""
+    if n < 0:
+        raise ValueError("Factorial not defined for negative numbers")
+    if n <= 1:
+        return 1
+    result = 1
+    for i in range(2, n + 1):
+        result *= i
+    return result
+
+
+def matrixInverse(m: Matrix) -> Matrix:
+    """Return the inverse of a square matrix using Gauss-Jordan elimination."""
+    n = len(m.data)
+    if any(len(row) != n for row in m.data):
+        raise ValueError("Matrix must be square")
+    # Augment with identity
+    aug = [m.data[i][:] + [1.0 if i == j else 0.0 for j in range(n)] for i in range(n)]
+    for col in range(n):
+        # Find pivot
+        max_row = col
+        for row in range(col + 1, n):
+            if abs(aug[row][col]) > abs(aug[max_row][col]):
+                max_row = row
+        aug[col], aug[max_row] = aug[max_row], aug[col]
+        if abs(aug[col][col]) < 1e-12:
+            raise ValueError("Matrix is singular")
+        pivot = aug[col][col]
+        for j in range(2 * n):
+            aug[col][j] /= pivot
+        for row in range(n):
+            if row != col:
+                factor = aug[row][col]
+                for j in range(2 * n):
+                    aug[row][j] -= factor * aug[col][j]
+    return Matrix([row[n:] for row in aug])
+
+
+def interpolate(x: float, points: list[tuple[float, float]], method: str = "linear") -> float:
+    """Interpolate at x given data points. Methods: 'linear'."""
+    xs = [p[0] for p in points]
+    ys = [p[1] for p in points]
+    if method == "linear":
+        if x <= xs[0]:
+            return ys[0]
+        if x >= xs[-1]:
+            return ys[-1]
+        for i in range(len(xs) - 1):
+            if xs[i] <= x <= xs[i + 1]:
+                t = (x - xs[i]) / (xs[i + 1] - xs[i])
+                return ys[i] + t * (ys[i + 1] - ys[i])
+    raise ValueError(f"Unknown method: {method}")
+
+
+# ======================================================== Regex utilities ========================================================
+
+
+def extractEmails(text: str) -> list[str]:
+    """Extract all email addresses from text."""
+    return re.findall(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', text)
+
+
+def extractURLs(text: str) -> list[str]:
+    """Extract all URLs from text."""
+    return re.findall(r'https?://[^\s<>"]+', text)
+
+
+def replaceMultiple(text: str, replacements: dict[str, str]) -> str:
+    """Replace multiple patterns in text. Keys are patterns, values are replacements."""
+    for pattern, replacement in replacements.items():
+        text = text.replace(pattern, replacement)
+    return text
+
+
+# ======================================================== Cache / Performance ========================================================
+
+import functools
+import time as _time
+
+
+def lruCache(maxsize: int = 128):
+    """LRU cache decorator with max size limit."""
+    def decorator(func):
+        cache = {}
+        order = []
+
+        @functools.wraps(func)
+        def wrapper(*args, **kwargs):
+            key = (args, tuple(sorted(kwargs.items())))
+            if key in cache:
+                order.remove(key)
+                order.append(key)
+                return cache[key]
+            result = func(*args, **kwargs)
+            cache[key] = result
+            order.append(key)
+            if len(cache) > maxsize:
+                oldest = order.pop(0)
+                del cache[oldest]
+            return result
+
+        wrapper.cache_clear = lambda: (cache.clear(), order.clear())
+        return wrapper
+    return decorator
+
+
+def timeit(func):
+    """Decorator that prints function execution time."""
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        start = _time.perf_counter()
+        result = func(*args, **kwargs)
+        elapsed = _time.perf_counter() - start
+        print(f"{func.__name__} executed in {elapsed:.4f}s")
+        return result
+    return wrapper
+
+
+# ======================================================== Progress iterator ========================================================
+
+class tqdm:
+    """Progress bar iterator (like tqdm)."""
+
+    def __init__(self, iterable, total: int = None, width: int = 40, prefix: str = ""):
+        self.iterable = iterable
+        self.total = total if total is not None else len(iterable)
+        self.width = width
+        self.prefix = prefix
+        self.n = 0
+
+    def __iter__(self):
+        for item in self.iterable:
+            yield item
+            self.n += 1
+            self._render()
+
+    def _render(self):
+        progress = self.n / self.total if self.total else 1
+        filled = int(self.width * progress)
+        bar = "█" * filled + "-" * (self.width - filled)
+        pct = progress * 100
+        sys.stdout.write(f"\r{self.prefix}[{bar}] {pct:.1f}% ({self.n}/{self.total})")
+        sys.stdout.flush()
+        if self.n >= self.total:
+            sys.stdout.write("\n")
+
+
+# ======================================================== Type checks ========================================================
+
+def isNumber(value) -> bool:
+    """Check if value is a number (int or float)."""
+    return isinstance(value, (int, float)) and not isinstance(value, bool)
+
+
+def isString(value) -> bool:
+    """Check if value is a string."""
+    return isinstance(value, str)
+
+
+def isList(value) -> bool:
+    """Check if value is a list."""
+    return isinstance(value, list)
+
+
+def isDict(value) -> bool:
+    """Check if value is a dict."""
+    return isinstance(value, dict)
+
+
+def isCallable(value) -> bool:
+    """Check if value is callable."""
+    return callable(value)
+
+
+# ======================================================== Network utilities ========================================================
+
+import urllib.request
+
+
+def getJson(url: str, headers: dict = None):
+    """Send GET request and return parsed JSON."""
+    req = urllib.request.Request(url)
+    if headers:
+        for k, v in headers.items():
+            req.add_header(k, v)
+    with urllib.request.urlopen(req) as resp:
+        return json.loads(resp.read().decode())
+
+
+def postJson(url: str, data=None, headers: dict = None):
+    """Send POST request with JSON body and return parsed JSON response."""
+    body = json.dumps(data).encode() if data else b"{}"
+    req = urllib.request.Request(url, data=body, method="POST")
+    req.add_header("Content-Type", "application/json")
+    if headers:
+        for k, v in headers.items():
+            req.add_header(k, v)
+    with urllib.request.urlopen(req) as resp:
+        return json.loads(resp.read().decode())
+
+
+# ======================================================== Math extensions (vector) ========================================================
+
+def dotProduct(a: list[float], b: list[float]) -> float:
+    """Compute dot product of two vectors."""
+    if len(a) != len(b):
+        raise ValueError("Vectors must have same length")
+    return sum(x * y for x, y in zip(a, b))
+
+
+def crossProduct(a: list[float], b: list[float]) -> list[float]:
+    """Compute cross product of two 3D vectors."""
+    if len(a) != 3 or len(b) != 3:
+        raise ValueError("Cross product requires 3D vectors")
+    return [
+        a[1] * b[2] - a[2] * b[1],
+        a[2] * b[0] - a[0] * b[2],
+        a[0] * b[1] - a[1] * b[0],
+    ]
+
+
+def normalize(v: list[float]) -> list[float]:
+    """Normalize a vector to unit length."""
+    mag = sum(x ** 2 for x in v) ** 0.5
+    if mag == 0:
+        raise ValueError("Cannot normalize zero vector")
+    return [x / mag for x in v]
+
+
+# ======================================================== Local storage ========================================================
+
+import os
+
+
+class Storage:
+    """Simple local key-value storage with file persistence.
+    
+    Supports subpaths (relative to base) and absolute paths.
+    """
+
+    def __init__(self, base_path: str = ".eapy_storage"):
+        self.base_path = os.path.abspath(base_path)
+        os.makedirs(self.base_path, exist_ok=True)
+
+    def _resolve_path(self, key: str) -> str:
+        """Resolve key to file path. Absolute paths used as-is."""
+        if os.path.isabs(key):
+            path = key
+        else:
+            path = os.path.join(self.base_path, key)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        return path
+
+    def set(self, key: str, value):
+        """Store a value."""
+        path = self._resolve_path(key)
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump(value, f, ensure_ascii=False)
+
+    def get(self, key: str, default=None):
+        """Retrieve a value."""
+        path = self._resolve_path(key)
+        if not os.path.exists(path):
+            return default
+        with open(path, "r", encoding="utf-8") as f:
+            return json.load(f)
+
+    def delete(self, key: str):
+        """Delete a stored value."""
+        path = self._resolve_path(key)
+        if os.path.exists(path):
+            os.remove(path)
+
+    def exists(self, key: str) -> bool:
+        """Check if key exists."""
+        return os.path.exists(self._resolve_path(key))
+
+    def keys(self, prefix: str = "") -> list[str]:
+        """List all keys under optional prefix."""
+        result = []
+        search_path = self._resolve_path(prefix) if prefix else self.base_path
+        if not os.path.isdir(search_path):
+            return result
+        for root, dirs, files in os.walk(search_path):
+            for f in files:
+                full = os.path.join(root, f)
+                rel = os.path.relpath(full, self.base_path)
+                result.append(rel)
+        return result
+
+    def clear(self):
+        """Remove all stored data."""
+        import shutil
+        if os.path.exists(self.base_path):
+            shutil.rmtree(self.base_path)
+            os.makedirs(self.base_path, exist_ok=True)
+
+    def __repr__(self):
+        return f"Storage(base_path='{self.base_path}')"

{eapytool-0.2.0 → eapytool-0.3.1}/tests/test_core.py

@@ -17,6 +17,7 @@ from eapy.core import (
     toCamelCase, toSnakeCase, toPascalCase, levenshtein,
     pipe, compose, curry,
     Stack, Queue, Trie,
+    LinkedList, CircularBuffer, PriorityQueue,
     baseConvert, toBinary, toOctal, toHex,
     rgbToHsl, hslToRgb, rgbToHex, hexToRgb,
     bisect, newtonMethod, numericalIntegral,
@@ -27,8 +28,18 @@ from eapy.core import (
     ProgressBar,
     md5, sha256,
     randomChoice, shuffle, randomString, randomInt, randomFloat,
+    base64Encode, base64Decode, urlEncode, urlDecode,
+    factorial, matrixInverse, interpolate,
+    extractEmails, extractURLs, replaceMultiple,
+    lruCache, timeit,
+    tqdm,
+    isNumber, isString, isList, isDict, isCallable,
+    dotProduct, crossProduct, normalize,
+    Storage,
 )
 from math import pi
+import os
+import shutil
 
 
 # ======================================================== Timer ========================================================
@@ -492,3 +503,225 @@ class TestRandom:
 
     def test_randomFloat(self):
         assert 0.0 <= randomFloat(0.0, 1.0) < 1.0
+
+
+# ======================================================== Data structures (extended) ========================================================
+
+class TestLinkedList:
+    def test_append_and_find(self):
+        ll = LinkedList()
+        ll.append(1)
+        ll.append(2)
+        ll.append(3)
+        assert ll.find(2) is True
+        assert ll.find(5) is False
+        assert ll.to_list() == [1, 2, 3]
+
+    def test_remove(self):
+        ll = LinkedList()
+        ll.append(1)
+        ll.append(2)
+        ll.remove(2)
+        assert ll.to_list() == [1]
+
+    def test_prepend(self):
+        ll = LinkedList()
+        ll.prepend(1)
+        ll.prepend(0)
+        assert ll.to_list() == [0, 1]
+
+
+class TestCircularBuffer:
+    def test_push_pop(self):
+        cb = CircularBuffer(3)
+        cb.push(1)
+        cb.push(2)
+        cb.push(3)
+        assert cb.pop() == 1
+        assert cb.pop() == 2
+
+    def test_overwrite(self):
+        cb = CircularBuffer(2)
+        cb.push(1)
+        cb.push(2)
+        cb.push(3)  # overwrites 1
+        assert cb.pop() == 2
+        assert cb.pop() == 3
+
+
+class TestPriorityQueue:
+    def test_order(self):
+        pq = PriorityQueue()
+        pq.push("low", priority=3)
+        pq.push("high", priority=1)
+        pq.push("mid", priority=2)
+        assert pq.pop() == "high"
+        assert pq.pop() == "mid"
+        assert pq.pop() == "low"
+
+
+# ======================================================== Encoding ========================================================
+
+class TestEncoding:
+    def test_base64(self):
+        encoded = base64Encode("hello")
+        assert base64Decode(encoded) == "hello"
+
+    def test_url(self):
+        encoded = urlEncode("hello world&foo=bar")
+        assert " " not in encoded
+        assert urlDecode(encoded) == "hello world&foo=bar"
+
+
+# ======================================================== Math extensions ========================================================
+
+class TestMathExtensions:
+    def test_factorial(self):
+        assert factorial(5) == 120
+        assert factorial(0) == 1
+
+    def test_matrixInverse(self):
+        m = Matrix([[1, 2], [3, 4]])
+        inv = matrixInverse(m)
+        # m * inv should be identity
+        result = m * inv
+        assert abs(result.data[0][0] - 1) < 1e-10
+        assert abs(result.data[1][1] - 1) < 1e-10
+
+    def test_interpolate(self):
+        points = [(0, 0), (10, 100)]
+        assert interpolate(5, points) == 50.0
+
+
+# ======================================================== Regex utilities ========================================================
+
+class TestRegex:
+    def test_extractEmails(self):
+        text = "Contact us at test@example.com or admin@site.org"
+        emails = extractEmails(text)
+        assert "test@example.com" in emails
+        assert "admin@site.org" in emails
+
+    def test_extractURLs(self):
+        text = "Visit https://example.com or http://test.org"
+        urls = extractURLs(text)
+        assert "https://example.com" in urls
+        assert "http://test.org" in urls
+
+    def test_replaceMultiple(self):
+        result = replaceMultiple("hello world", {"hello": "hi", "world": "earth"})
+        assert result == "hi earth"
+
+
+# ======================================================== Cache / Performance ========================================================
+
+class TestCache:
+    def test_lruCache(self):
+        call_count = [0]
+
+        @lruCache(maxsize=2)
+        def add(a, b):
+            call_count[0] += 1
+            return a + b
+
+        assert add(1, 2) == 3
+        assert add(1, 2) == 3  # cached
+        assert call_count[0] == 1
+
+    def test_timeit(self, capsys):
+        @timeit
+        def noop():
+            pass
+        noop()
+        captured = capsys.readouterr()
+        assert "executed in" in captured.out
+
+
+# ======================================================== Progress iterator ========================================================
+
+class TestTqdm:
+    def test_iteration(self):
+        result = list(tqdm([1, 2, 3], total=3))
+        assert result == [1, 2, 3]
+
+
+# ======================================================== Type checks ========================================================
+
+class TestTypeChecks:
+    def test_isNumber(self):
+        assert isNumber(42) is True
+        assert isNumber(3.14) is True
+        assert isNumber("42") is False
+        assert isNumber(True) is False
+
+    def test_isString(self):
+        assert isString("hello") is True
+        assert isString(42) is False
+
+    def test_isList(self):
+        assert isList([1, 2]) is True
+        assert isList((1, 2)) is False
+
+    def test_isDict(self):
+        assert isDict({"a": 1}) is True
+        assert isDict([1, 2]) is False
+
+    def test_isCallable(self):
+        assert isCallable(lambda: None) is True
+        assert isCallable(42) is False
+
+
+# ======================================================== Math extensions (vector) ========================================================
+
+class TestVectorMath:
+    def test_dotProduct(self):
+        assert dotProduct([1, 2, 3], [4, 5, 6]) == 32
+
+    def test_crossProduct(self):
+        assert crossProduct([1, 0, 0], [0, 1, 0]) == [0, 0, 1]
+
+    def test_normalize(self):
+        result = normalize([3, 4])
+        assert abs(result[0] - 0.6) < 1e-10
+        assert abs(result[1] - 0.8) < 1e-10
+
+
+# ======================================================== Local storage ========================================================
+
+class TestStorage:
+    def setup_method(self):
+        self.test_dir = ".test_storage"
+        self.store = Storage(self.test_dir)
+
+    def teardown_method(self):
+        if os.path.exists(self.test_dir):
+            shutil.rmtree(self.test_dir)
+
+    def test_set_get(self):
+        self.store.set("key1", {"name": "test", "value": 42})
+        result = self.store.get("key1")
+        assert result == {"name": "test", "value": 42}
+
+    def test_get_default(self):
+        assert self.store.get("nonexistent", "default") == "default"
+
+    def test_delete(self):
+        self.store.set("key2", "value")
+        self.store.delete("key2")
+        assert self.store.exists("key2") is False
+
+    def test_subpath(self):
+        self.store.set("sub/dir/key", [1, 2, 3])
+        assert self.store.get("sub/dir/key") == [1, 2, 3]
+
+    def test_keys(self):
+        self.store.set("a", 1)
+        self.store.set("b", 2)
+        keys = self.store.keys()
+        assert "a" in keys
+        assert "b" in keys
+
+    def test_clear(self):
+        self.store.set("x", 1)
+        self.store.clear()
+        assert self.store.exists("x") is False