eapyTool 0.2.0__tar.gz → 0.3.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eapyTool
-Version: 0.2.0
+Version: 0.3.0
 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,23 @@ 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
+
 ## Installation
 
 ```bash

{eapytool-0.2.0 → eapytool-0.3.0}/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,23 @@ 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
+
 ## Installation
 
 ```bash

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

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "eapyTool"
-version = "0.2.0"
+version = "0.3.0"
 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.0}/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.0"
 
 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,12 @@ 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,
 )

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

@@ -1674,4 +1674,291 @@ 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

{eapytool-0.2.0 → eapytool-0.3.0}/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,6 +28,9 @@ from eapy.core import (
     ProgressBar,
     md5, sha256,
     randomChoice, shuffle, randomString, randomInt, randomFloat,
+    base64Encode, base64Decode, urlEncode, urlDecode,
+    factorial, matrixInverse, interpolate,
+    extractEmails, extractURLs, replaceMultiple,
 )
 from math import pi
 
@@ -492,3 +496,111 @@ 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"