eapyTool 0.3.0__tar.gz → 0.3.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eapyTool
-Version: 0.3.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
@@ -127,6 +127,26 @@ A Python utility library that extends the standard library with math, algebra, d
 - `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.3.0 → eapytool-0.3.1}/README.md

@@ -104,6 +104,26 @@ A Python utility library that extends the standard library with math, algebra, d
 - `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.3.0 → eapytool-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "eapyTool"
-version = "0.3.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.3.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.3.0"
+__version__ = "0.3.1"
 
 from eapy.core import (
     # Timer
@@ -78,4 +78,16 @@ from eapy.core import (
     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.3.0 → eapytool-0.3.1}/src/eapy/core.py

@@ -1961,4 +1961,231 @@ 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
+    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.3.0 → eapytool-0.3.1}/tests/test_core.py

@@ -31,8 +31,15 @@ from eapy.core import (
     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 ========================================================
@@ -604,3 +611,117 @@ class TestRegex:
     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