speedy-utils 1.1.26__tar.gz → 1.1.28__tar.gz

{speedy_utils-1.1.26 → speedy_utils-1.1.28}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: speedy-utils
-Version: 1.1.26
+Version: 1.1.28
 Summary: Fast and easy-to-use package for data science
 Project-URL: Homepage, https://github.com/anhvth/speedy
 Project-URL: Repository, https://github.com/anhvth/speedy

{speedy_utils-1.1.26 → speedy_utils-1.1.28}/examples/temperature_range_example.py

@@ -1,8 +1,9 @@
 """Example demonstrating temperature range sampling with LLM."""
 
-from llm_utils import LLM
 from pydantic import BaseModel
 
+from llm_utils import LLM
+
 
 class CreativeStory(BaseModel):
     """A creative story output."""
@@ -76,7 +77,9 @@ def example_two_step_parsing():
     print("=" * 60)
 
     llm = LLM(
-        instruction=("Analyze the given text and extract structured information. Think through your analysis first."),
+        instruction=(
+            "Analyze the given text and extract structured information. Think through your analysis first."
+        ),
         output_model=CreativeStory,
     )
 

speedy_utils-1.1.28/examples/vision_utils_example.py

@@ -0,0 +1,110 @@
+"""
+Example usage of vision_utils.plot_images_notebook
+"""
+
+import numpy as np
+
+from vision_utils import plot_images_notebook
+
+
+def test_auto_grid():
+    """Test auto grid layout with sqrt calculation."""
+    print("Testing auto grid (sqrt) with 9 images...")
+    images = np.random.rand(9, 64, 64, 3)
+    plot_images_notebook(images)  # Should create 3x3 grid
+
+
+def test_auto_grid_non_square():
+    """Test auto grid with non-perfect square number of images."""
+    print("Testing auto grid with 8 images...")
+    images = np.random.rand(8, 64, 64, 3)
+    plot_images_notebook(images)  # Should create 3x3 grid (with 1 empty)
+
+
+def test_manual_grid():
+    """Test with manual grid specification."""
+    print("Testing manual 2x4 grid...")
+    images = np.random.rand(8, 64, 64, 3)
+    plot_images_notebook(images, nrows=2, ncols=4)
+
+
+def test_many_images():
+    """Test with many images (adaptive sizing)."""
+    print("Testing with 25 images (adaptive sizing)...")
+    images = np.random.rand(25, 64, 64, 3)
+    plot_images_notebook(images)  # Should create 5x5 grid with smaller cells
+
+
+def test_numpy_bhwc():
+    """Test with numpy array in (B, H, W, C) format."""
+    print("Testing numpy array (B, H, W, C) format...")
+    images = np.random.rand(8, 64, 64, 3)
+    plot_images_notebook(images)
+
+
+def test_numpy_bchw():
+    """Test with numpy array in (B, C, H, W) format."""
+    print("Testing numpy array (B, C, H, W) format...")
+    images = np.random.rand(8, 3, 64, 64)
+    plot_images_notebook(images)
+
+
+def test_list_of_arrays():
+    """Test with list of numpy arrays in different formats."""
+    print("Testing list of numpy arrays...")
+    images = [
+        np.random.rand(64, 64, 3),  # (H, W, C)
+        np.random.rand(3, 64, 64),  # (C, H, W)
+        np.random.rand(64, 64),  # Grayscale (H, W)
+        np.random.rand(64, 64, 1),  # Grayscale (H, W, 1)
+    ]
+    plot_images_notebook(images, titles=["HWC", "CHW", "Gray", "Gray1"])
+
+
+def test_torch_tensor():
+    """Test with PyTorch tensor."""
+    try:
+        import torch
+
+        print("Testing PyTorch tensor (B, C, H, W) format...")
+        images = torch.rand(8, 3, 64, 64)
+        plot_images_notebook(images)
+    except ImportError:
+        print("PyTorch not installed, skipping torch test")
+
+
+def test_single_image():
+    """Test with single image."""
+    print("Testing single image...")
+    image = np.random.rand(128, 128, 3)
+    plot_images_notebook(image)
+
+
+def test_custom_dpi():
+    """Test with custom DPI for high resolution."""
+    print("Testing custom DPI...")
+    images = np.random.rand(4, 64, 64, 3)
+    plot_images_notebook(images, dpi=100)
+
+
+if __name__ == "__main__":
+    # Run examples
+    print("=== Auto Grid Tests ===")
+    test_auto_grid()
+    test_auto_grid_non_square()
+
+    print("\n=== Manual Grid Test ===")
+    test_manual_grid()
+
+    print("\n=== Adaptive Sizing Test ===")
+    test_many_images()
+
+    print("\n=== Format Tests ===")
+    test_numpy_bhwc()
+    test_numpy_bchw()
+    test_list_of_arrays()
+    test_torch_tensor()
+
+    print("\n=== Edge Cases ===")
+    test_single_image()
+    test_custom_dpi()

{speedy_utils-1.1.26 → speedy_utils-1.1.28}/notebooks/llm_utils/llm_as_a_judge.ipynb

@@ -26,14 +26,11 @@
    "outputs": [],
    "source": [
     "\n",
-    "from llm_utils import (\n",
-    "    LLMJudgeBase, \n",
-    "    Signature, \n",
-    "    InputField, \n",
-    "    OutputField\n",
-    ")\n",
+    "import json\n",
+    "\n",
     "from pydantic import BaseModel\n",
-    "import json"
+    "\n",
+    "from llm_utils import InputField, LLMJudgeBase, OutputField, Signature"
    ]
   },
   {
@@ -120,7 +117,7 @@
     "# Define a signature like DSPy (original syntax - no more type warnings!)\n",
     "class FactJudge(Signature):\n",
     "    \"\"\"Judge if the answer is factually correct based on the context.\"\"\"\n",
-    "    \n",
+    "\n",
     "    # No more type warnings with the updated InputField/OutputField!\n",
     "    context: str = InputField(desc=\"Context for the prediction\")\n",
     "    question: str = InputField(desc=\"Question to be answered\")\n",
@@ -194,14 +191,16 @@
     "    HUMAN_REFERENCE: str = InputField(desc=\"A reference human translation, to be used for guidance but not as ground truth.\")\n",
     "    SYSTEM_MESSAGE: str = InputField(desc=\"An automated hint about a possible structural error in the AI translation.\")\n",
     "    GLOSSARIES: str = InputField(desc=\"Optional terminology constraints; may be empty.\")\n",
-    "    \n",
+    "\n",
     "    structure_score: int = OutputField(desc=\"Score for structural correctness: 0 (wrong), 1 (partially correct), 2 (correct)\")\n",
     "    glossary_score: int = OutputField(desc=\"Score for glossary adherence: 0 (not followed), 1 (partially followed), 2 (fully followed or no glossary)\")\n",
     "    translation_score: int = OutputField(desc=\"Score for translation quality: 0 (unfaithful), 1 (somewhat faithful), 2 (faithful)\")\n",
-    "        \n",
+    "\n",
     "# --- Updated evaluation prompt ---\n",
     "\n",
     "import os\n",
+    "\n",
+    "\n",
     "judge = LLMJudgeBase(signature=Sig, client=8000) # vllm is hosted at port 8000\n",
     "judge = LLMJudgeBase(signature=Sig, model='gpt-4.1-mini', client=None) # use openai's gpt-4.1 model"
    ]

{speedy_utils-1.1.26 → speedy_utils-1.1.28}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "speedy-utils"
-version = "1.1.26"
+version = "1.1.28"
 description = "Fast and easy-to-use package for data science"
 authors = [{ name = "AnhVTH", email = "anhvth.226@gmail.com" }]
 readme = "README.md"
@@ -65,7 +65,7 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 
 [tool.hatch.build.targets.wheel]
-packages = ["src/speedy_utils", "src/llm_utils"]
+packages = ["src/speedy_utils", "src/llm_utils", "src/vision_utils"]
 
 [tool.black]
 line-length = 88

speedy_utils-1.1.28/ruff.toml

@@ -0,0 +1,81 @@
+# Ruff configuration for speedy_utils
+# See: https://docs.astral.sh/ruff/
+
+line-length = 88
+target-version = "py310"
+respect-gitignore = true
+
+[lint]
+# Enable specific rule sets
+select = [
+    "E",      # pycodestyle errors
+    "W",      # pycodestyle warnings
+    "F",      # pyflakes
+    "I",      # isort
+    "N",      # pep8-naming
+    "UP",     # pyupgrade
+    "B",      # flake8-bugbear
+    "C4",     # flake8-comprehensions
+    "SIM",    # flake8-simplify
+    "PIE",    # flake8-pie
+    "RET",    # flake8-return
+    "PTH",    # flake8-use-pathlib
+]
+
+# Ignore specific rules
+ignore = [
+    "E501",   # Line too long (handled by formatter)
+    "E731",   # Lambda assignment
+    "E402",   # Module level import not at top
+    "F401",   # Unused imports (common in __init__.py)
+    "F403",   # Star imports
+    "F405",   # Name may be undefined from star imports
+    "N802",   # Function name should be lowercase
+    "N803",   # Argument name should be lowercase
+    "N806",   # Variable in function should be lowercase
+    "B008",   # Do not perform function calls in argument defaults
+    "SIM108", # Use ternary operator (sometimes less readable)
+    "RET504", # Unnecessary variable assignment before return
+    "PTH123", # open() should be replaced by Path.open()
+    "UP035", # f-string support for str.format()
+    "PTH",    # Pathlib usage warnings (handled by code review)
+    "UP",     # pyupgrade warnings (handled by code review)
+    "N",      # pep8-naming warnings (handled by code review)
+]
+
+# Allow autofix for all enabled rules
+fixable = ["ALL"]
+unfixable = []
+
+# Exclude patterns
+exclude = [
+    ".git",
+    ".ruff_cache",
+    ".venv",
+    "__pycache__",
+    "build",
+    "dist",
+    "*.egg-info",
+    ".pytest_cache",
+    ".mypy_cache",
+    "notebooks",
+]
+
+[lint.per-file-ignores]
+"__init__.py" = ["F401", "F403", "E402"]
+"tests/*" = ["S101"]  # Allow assert statements in tests
+"examples/*" = ["T201"]  # Allow print statements in examples
+
+[lint.isort]
+known-first-party = ["speedy_utils", "llm_utils", "vision_utils"]
+force-single-line = false
+lines-after-imports = 2
+
+[lint.mccabe]
+max-complexity = 15
+
+[format]
+quote-style = "single"
+indent-style = "space"
+line-ending = "auto"
+skip-magic-trailing-comma = false

speedy_utils-1.1.28/scripts/debug_import_time.py

@@ -0,0 +1,148 @@
+"""Concise import-time helper.
+
+Run this script to get a short list of top-level modules that take a
+non-trivial amount of time to import. The script will try CPython's
+``-X importtime`` and parse it into aggregated per-top-level times.
+
+If the interpreter doesn't support ``-X importtime``, the script
+falls back to a small instrumented subprocess that wraps
+``builtins.__import__`` and reports per-top-level timings.
+
+Default threshold: 0.2 seconds. Use --min-sec to change.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import subprocess
+import sys
+from typing import Dict, List, Tuple
+
+
+DEFAULT_MODULES = ['speedy_utils', 'llm_utils', 'vision_utils']
+
+
+def parse_x_importtime(stderr: str) -> List[Tuple[str, float]]:
+    """Parse -X importtime stderr into per-top-level module seconds.
+
+    We use the first column (self-time) aggregated per top-level module
+    as a good approximation of which third-party or heavy packages cost
+    time during import.
+    """
+
+    times: Dict[str, float] = {}
+    pattern = re.compile(r'^\s*import time:\s*(\d+)\s*\|\s*(\d+)\s*\|\s*(.+)$')
+    for line in stderr.splitlines():
+        match = pattern.match(line)
+        if not match:
+            continue
+        try:
+            self_us = int(match.group(1))
+            mod_name = match.group(3).strip()
+        except Exception:
+            continue
+
+        top = mod_name.split('.', 1)[0]
+        times[top] = times.get(top, 0.0) + (self_us / 1_000_000.0)
+
+    # return sorted list (desc)
+    return sorted(times.items(), key=lambda it: it[1], reverse=True)
+
+
+def run_importtime(module: str) -> Tuple[bool, str]:
+    exe = sys.executable
+    cmd = [exe, '-X', 'importtime', '-c', f'from {module} import *']
+    p = subprocess.run(cmd, capture_output=True, text=True, check=False)
+    ok = p.returncode == 0 and bool(p.stderr.strip())
+    out = p.stderr if p.stderr else p.stdout
+    return ok, out
+
+
+def run_timed_import(module: str) -> Tuple[bool, str]:
+    code = (
+        'import builtins, time, json\n'
+        'orig = builtins.__import__\n'
+        'times = {}\n'
+        'def timed(name, globals=None, locals=None, fromlist=(), level=0):\n'
+        '    start = time.perf_counter()\n'
+        '    try:\n'
+        '        return orig(name, globals, locals, fromlist, level)\n'
+        '    finally:\n'
+        '        elapsed = time.perf_counter() - start\n'
+        "        key = name.split('.',1)[0]\n"
+        '        times[key] = times.get(key, 0.0) + elapsed\n'
+        'builtins.__import__ = timed\n'
+        f'from {module} import *\n'
+        'builtins.__import__ = orig\n'
+        'print(json.dumps(sorted(times.items(), key=lambda it: it[1], reverse=True)))\n'
+    )
+
+    cmd = [sys.executable, '-c', code]
+    p = subprocess.run(cmd, capture_output=True, text=True, check=False)
+    if p.returncode != 0:
+        return False, (p.stderr or p.stdout).strip()
+    return True, p.stdout.strip()
+
+
+def pretty_print_list(items: List[Tuple[str, float]]) -> None:
+    for name, sec in items:
+        print(f'{sec:6.3f}s  {name}')
+
+
+def main(argv: List[str] | None = None) -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument('modules', nargs='*', default=DEFAULT_MODULES)
+    parser.add_argument(
+        '--min-sec', type=float, default=0.2, help='Minimum seconds to show'
+    )
+    parser.add_argument('--no-x', action='store_true', help="Don't try -X importtime")
+    parser.add_argument(
+        '--raw', action='store_true', help='Show raw -X output in addition'
+    )
+    parser.add_argument('-n', '--top', type=int, default=20)
+    args = parser.parse_args(argv)
+
+    for module in args.modules:
+        print('=' * 60)
+        print(f'Module: {module}')
+        print('=' * 60)
+
+        if not args.no_x:
+            ok, out = run_importtime(module)
+            if ok:
+                parsed = parse_x_importtime(out)
+                filtered = [it for it in parsed if it[1] >= args.min_sec]
+                if filtered:
+                    print('Top heavy imports (from -X importtime):')
+                    pretty_print_list(filtered[: args.top])
+                else:
+                    print(
+                        f'No top-level modules >= {args.min_sec:.3f}s (from -X importtime)'
+                    )
+                if args.raw:
+                    print('\nRaw -X importtime output:\n')
+                    print(out)
+                continue
+
+        # Fallback instrumentation
+        ok, out = run_timed_import(module)
+        if not ok:
+            print('Failed to measure imports:\n', out)
+            continue
+
+        items = json.loads(out)
+        filtered = [it for it in items if it[1] >= args.min_sec]
+        if not filtered:
+            print(f'No imports >= {args.min_sec:.3f}s (fallback)')
+            continue
+
+        print('Top heavy imports (fallback):')
+        pretty_print_list(filtered[: args.top])
+
+    return 0
+
+
+if __name__ == '__main__':
+    raise SystemExit(main())

speedy_utils-1.1.28/scripts/imports.sh

@@ -0,0 +1,9 @@
+python -X importtime -c "from speedy_utils import *" 2>&1 \
+  | awk '
+      /import time:/ {
+        # second-last column looks like: 0.123>
+        raw=$(NF-1)
+        gsub(/[>]/,"",raw)
+        if (raw > 900) print
+      }
+    '

speedy_utils-1.1.28/scripts/lazy_import.py

@@ -0,0 +1,11 @@
+from typing import TYPE_CHECKING
+
+import lazy_loader as lazy
+
+
+torch = lazy.load('torch')
+if TYPE_CHECKING:
+    import torch
+
+ran = torch.random.rand(2, 2)
+# print(ran)

speedy_utils-1.1.28/scripts/test_import_time_vision.py

@@ -0,0 +1,9 @@
+import time
+
+
+t = time.time()
+from vision_utils import *
+
+
+load_time = time.time() - t
+print(f'Imported vision_utils in {load_time:.4f} seconds')

{speedy_utils-1.1.26 → speedy_utils-1.1.28}/src/llm_utils/__init__.py

@@ -1,8 +1,19 @@
+from llm_utils.lm import (
+    LLM,
+    AsyncLLMTask,
+    AsyncLM,
+    Input,
+    InputField,
+    LLMSignature,
+    Output,
+    OutputField,
+    Signature,
+)
+from llm_utils.lm.base_prompt_builder import BasePromptBuilder
+from llm_utils.lm.lm_base import get_model_name
 from llm_utils.lm.openai_memoize import MOpenAI
-from llm_utils.lm import LLM, AsyncLM, AsyncLLMTask, LLMSignature, Signature, InputField, OutputField, Input, Output
 from llm_utils.vector_cache import VectorCache
-from llm_utils.lm.lm_base import get_model_name
-from llm_utils.lm.base_prompt_builder import BasePromptBuilder
+
 
 LLM_TASK = LLM
 
@@ -24,13 +35,14 @@ from llm_utils.chat_format import (
     display_conversations,
     format_msgs,
     get_conversation_one_turn,
-    show_chat_v2,
     show_chat,
+    show_chat_v2,
     show_string_diff,
     transform_messages,
     transform_messages_to_chatml,
 )
 
+
 __all__ = [
     "transform_messages",
     "transform_messages_to_chatml",

{speedy_utils-1.1.26 → speedy_utils-1.1.28}/src/llm_utils/chat_format/display.py

@@ -77,7 +77,7 @@ def show_chat(
     theme: str = "default",
     as_markdown: bool = False,
     as_json: bool = False,
-) -> Optional[str]:
+) -> str | None:
     """
     Display chat messages as HTML.
 
@@ -168,7 +168,10 @@ def show_chat(
             content = content.replace("\t", "    ")
             content = content.replace("  ", "  ")
             content = (
-                content.replace("<br>", "TEMP_BR").replace("<", "&lt;").replace(">", "&gt;").replace("TEMP_BR", "<br>")
+                content.replace("<br>", "TEMP_BR")
+                .replace("<", "&lt;")
+                .replace(">", "&gt;")
+                .replace("TEMP_BR", "<br>")
             )
         if role in color_scheme:
             background_color = color_scheme[role]["background"]
@@ -239,15 +242,15 @@ def show_chat(
             f.write(html)
     if return_html:
         return html
-    else:
-        display(HTML(html))
+    display(HTML(html))
+    return None
 
 
 def get_conversation_one_turn(
-    system_msg: Optional[str] = None,
-    user_msg: Optional[str] = None,
-    assistant_msg: Optional[str] = None,
-    assistant_prefix: Optional[str] = None,
+    system_msg: str | None = None,
+    user_msg: str | None = None,
+    assistant_msg: str | None = None,
+    assistant_prefix: str | None = None,
     return_format: str = "chatml",
 ) -> Any:
     """
@@ -261,7 +264,9 @@ def get_conversation_one_turn(
     if assistant_msg is not None:
         messages.append({"role": "assistant", "content": assistant_msg})
     if assistant_prefix is not None:
-        assert return_format != "chatml", 'Change return_format to "text" if you want to use assistant_prefix'
+        assert (
+            return_format != "chatml"
+        ), 'Change return_format to "text" if you want to use assistant_prefix'
         assert messages[-1]["role"] == "user"
         from .transform import transform_messages
 
@@ -270,9 +275,8 @@ def get_conversation_one_turn(
             msg = str(msg)
         msg += assistant_prefix
         return msg
-    else:
-        assert return_format in ["chatml"]
-        return messages
+    assert return_format in ["chatml"]
+    return messages
 
 
 def highlight_diff_chars(text1: str, text2: str) -> str:
@@ -286,13 +290,21 @@ def highlight_diff_chars(text1: str, text2: str) -> str:
             html.append(text1[i1:i2])
         elif tag == "replace":
             if i1 != i2:
-                html.append(f'<span style="background-color:#ffd6d6; color:#b20000;">{text1[i1:i2]}</span>')
+                html.append(
+                    f'<span style="background-color:#ffd6d6; color:#b20000;">{text1[i1:i2]}</span>'
+                )
             if j1 != j2:
-                html.append(f'<span style="background-color:#d6ffd6; color:#006600;">{text2[j1:j2]}</span>')
+                html.append(
+                    f'<span style="background-color:#d6ffd6; color:#006600;">{text2[j1:j2]}</span>'
+                )
         elif tag == "delete":
-            html.append(f'<span style="background-color:#ffd6d6; color:#b20000;">{text1[i1:i2]}</span>')
+            html.append(
+                f'<span style="background-color:#ffd6d6; color:#b20000;">{text1[i1:i2]}</span>'
+            )
         elif tag == "insert":
-            html.append(f'<span style="background-color:#d6ffd6; color:#006600;">{text2[j1:j2]}</span>')
+            html.append(
+                f'<span style="background-color:#d6ffd6; color:#006600;">{text2[j1:j2]}</span>'
+            )
     return "".join(html)
 
 
@@ -321,7 +333,7 @@ def show_chat_v2(messages: list[dict[str, str]]):
 
     if is_notebook:
         # Use HTML display in notebook
-        from IPython.display import display, HTML
+        from IPython.display import HTML, display
 
         role_colors = {
             "system": "red",
@@ -353,9 +365,7 @@ def show_chat_v2(messages: list[dict[str, str]]):
             html += f"<div style='color:{color}'><strong>{label}</strong><br>{content}</div>"
             # Add separator except after last message
             if i < len(messages) - 1:
-                html += (
-                    "<div style='color:#888; margin:0.5em 0;'>───────────────────────────────────────────────────</div>"
-                )
+                html += "<div style='color:#888; margin:0.5em 0;'>───────────────────────────────────────────────────</div>"
         html += "</div>"
 
         display(HTML(html))
@@ -385,7 +395,9 @@ def show_chat_v2(messages: list[dict[str, str]]):
             print(f"{color}{content}{reset}")
             # Add separator except after last message
             if i < len(messages) - 1:
-                print(f"{separator_color}─────────────────────────────────────────────────────────{reset}")
+                print(
+                    f"{separator_color}─────────────────────────────────────────────────────────{reset}"
+                )
 
 
 def display_conversations(data1: Any, data2: Any, theme: str = "light") -> None: