speedy-utils 1.1.26__py3-none-any.whl → 1.1.28__py3-none-any.whl

speedy_utils/common/logger.py

@@ -1,13 +1,4 @@
-# utils/utils_print.py
-
-import inspect
-import re
-import sys
-import time
-from collections import OrderedDict
-from typing import Annotated, Literal, Union
-
-from loguru import logger
+from ..__imports import *
 
 
 # A subclass of OrderedDict to automatically evict the oldest item after max_size is exceeded
@@ -34,26 +25,26 @@ _last_log_times = _RateLimitCache(max_size=2000)
 def setup_logger(
     level: Annotated[
         Literal[
-            "Trace",
-            "Debug",
-            "Info",
-            "Success",
-            "Warning",
-            "Error",
-            "Critical",
-            "Disable",
-            "T",
-            "D",
-            "I",
-            "S",
-            "W",
-            "E",
-            "C",
+            'Trace',
+            'Debug',
+            'Info',
+            'Success',
+            'Warning',
+            'Error',
+            'Critical',
+            'Disable',
+            'T',
+            'D',
+            'I',
+            'S',
+            'W',
+            'E',
+            'C',
         ],
-        "The desired log level",
-    ] = "Info",
-    enable_grep: Annotated[str, "Comma-separated patterns for enabling logs"] = "",
-    disable_grep: Annotated[str, "Comma-separated patterns for disabling logs"] = "",
+        'The desired log level',
+    ] = 'Info',
+    enable_grep: Annotated[str, 'Comma-separated patterns for enabling logs'] = '',
+    disable_grep: Annotated[str, 'Comma-separated patterns for disabling logs'] = '',
     min_interval: float = -1,
     max_cache_entries: int = 2000,
 ) -> None:
@@ -67,13 +58,13 @@ def setup_logger(
 
     # Map the shorthand level to the full name
     level_mapping = {
-        "T": "TRACE",
-        "D": "DEBUG",
-        "I": "INFO",
-        "S": "SUCCESS",
-        "W": "WARNING",
-        "E": "ERROR",
-        "C": "CRITICAL",
+        'T': 'TRACE',
+        'D': 'DEBUG',
+        'I': 'INFO',
+        'S': 'SUCCESS',
+        'W': 'WARNING',
+        'E': 'ERROR',
+        'C': 'CRITICAL',
     }
     level_str = level_mapping.get(level.upper(), level.upper())
 
@@ -84,8 +75,8 @@ def setup_logger(
     logger.remove()
 
     # Prepare grep patterns
-    enable_patterns = [p.strip() for p in enable_grep.split(",") if p.strip()]
-    disable_patterns = [p.strip() for p in disable_grep.split(",") if p.strip()]
+    enable_patterns = [p.strip() for p in enable_grep.split(',') if p.strip()]
+    disable_patterns = [p.strip() for p in disable_grep.split(',') if p.strip()]
 
     def log_filter(record):
         """
@@ -95,11 +86,11 @@ def setup_logger(
         4. Enforces a max size on the (file:line) dictionary.
         """
         # ---------- 1) Log-level check ----------
-        if record["level"].no < logger.level(level_str).no:
+        if record['level'].no < logger.level(level_str).no:
             return False
 
         # ---------- 2) Grep pattern handling ----------
-        log_message = f"{record['file']}:{record['line']} ({record['function']})"
+        log_message = f'{record["file"]}:{record["line"]} ({record["function"]})'
         if enable_patterns and not any(
             re.search(p, log_message) for p in enable_patterns
         ):
@@ -110,7 +101,7 @@ def setup_logger(
             return False
 
         # ---------- 3) Rate limiting by file:line ----------
-        file_line_key = f"{record['file']}:{record['line']}"
+        file_line_key = f'{record["file"]}:{record["line"]}'
         now = time.time()
 
         last_time = _last_log_times.get(file_line_key)
@@ -131,20 +122,20 @@ def setup_logger(
         sys.stdout,
         colorize=True,
         format=(
-            "<green>{time:HH:mm:ss}</green> | "
-            "<level>{level: <8}</level> | "
-            "<cyan>{file}:{line} ({function})</cyan> - <level>{message}</level>"
+            '<green>{time:HH:mm:ss}</green> | '
+            '<level>{level: <8}</level> | '
+            '<cyan>{file}:{line} ({function})</cyan> - <level>{message}</level>'
         ),
         filter=log_filter,
     )
 
     # ---------- 4) Handle "DISABLE" level ----------
-    if level_str.upper() == "DISABLE":
-        logger.disable("")
-        logger.info("Logging disabled")
+    if level_str.upper() == 'DISABLE':
+        logger.disable('')
+        logger.info('Logging disabled')
     else:
-        logger.enable("")
-        logger.debug(f"Logging set to {level_str}")
+        logger.enable('')
+        logger.debug(f'Logging set to {level_str}')
 
 
 _logged_once_set = set()
@@ -158,15 +149,15 @@ def _get_call_site_id(depth=2) -> str:
     """
     frame = inspect.stack()[depth]
     # Use a stable identifier in test environment to handle mocking
-    return f"{frame.filename}:{frame.lineno}"
+    return f'{frame.filename}:{frame.lineno}'
 
 
 def log(
     msg: str,
     *,
-    level: Literal["info", "warning", "error", "critical", "success"] = "info",
+    level: Literal['info', 'warning', 'error', 'critical', 'success'] = 'info',
     once: bool = False,
-    interval: Union[float, None] = None,
+    interval: float | None = None,
 ) -> None:
     """
     Log a message using loguru with optional `once` and `interval` control.

speedy_utils/common/notebook_utils.py

@@ -1,27 +1,20 @@
-# jupyter notebook utilities
-import json
-import os
-import pathlib
-from typing import Any
+from ..__imports import *
 
-from IPython.display import HTML, display
-from tabulate import tabulate
 
-
-def change_dir(target_directory: str = "POLY") -> None:
+def change_dir(target_directory: str = 'POLY') -> None:
     """Change directory to the first occurrence of x in the current path."""
-    cur_dir = pathlib.Path("./")
+    cur_dir = pathlib.Path('./')
     target_dir = str(cur_dir.absolute()).split(target_directory)[0] + target_directory
     os.chdir(target_dir)
-    print(f"Current dir: {target_dir}")
+    print(f'Current dir: {target_dir}')
 
 
 def display_pretty_table_html(data: dict) -> None:
     """Display a pretty HTML table in Jupyter notebooks."""
-    table = "<table>"
+    table = '<table>'
     for key, value in data.items():
-        table += f"<tr><td>{key}</td><td>{value}</td></tr>"
-    table += "</table>"
+        table += f'<tr><td>{key}</td><td>{value}</td></tr>'
+    table += '</table>'
     display(HTML(table))
 
 
@@ -33,27 +26,26 @@ def print_table(data: Any, use_html: bool = True) -> None:
             try:
                 data = json.loads(data)
             except json.JSONDecodeError as exc:
-                raise ValueError("String input could not be decoded as JSON") from exc
+                raise ValueError('String input could not be decoded as JSON') from exc
 
         if isinstance(data, list):
             if all(isinstance(item, dict) for item in data):
                 headers = list(data[0].keys())
                 rows = [list(item.values()) for item in data]
                 return tabulate(
-                    rows, headers=headers, tablefmt="html" if use_html else "grid"
+                    rows, headers=headers, tablefmt='html' if use_html else 'grid'
                 )
-            else:
-                raise ValueError("List must contain dictionaries")
+            raise ValueError('List must contain dictionaries')
 
         if isinstance(data, dict):
-            headers = ["Key", "Value"]
+            headers = ['Key', 'Value']
             rows = list(data.items())
             return tabulate(
-                rows, headers=headers, tablefmt="html" if use_html else "grid"
+                rows, headers=headers, tablefmt='html' if use_html else 'grid'
             )
 
         raise TypeError(
-            "Input data must be a list of dictionaries, a dictionary, or a JSON string"
+            'Input data must be a list of dictionaries, a dictionary, or a JSON string'
         )
 
     table = __get_table(data)

speedy_utils/common/patcher.py

@@ -1,17 +1,15 @@
 # utils/patching.py
-import inspect
-import types
-import re
-from typing import Annotated, Union
+from ..__imports import *
+
 
 def patch_method(
-    cls: Annotated[type, "Class containing the method"],
-    method_name: Annotated[str, "Name of the method to patch"],
+    cls: Annotated[type, 'Class containing the method'],
+    method_name: Annotated[str, 'Name of the method to patch'],
     replacements: Annotated[
-        dict[Union[str, re.Pattern], str],
-        "Mapping of {old_substring_or_regex: new_string} replacements"
+        dict[str | re.Pattern, str],
+        'Mapping of {old_substring_or_regex: new_string} replacements',
     ],
-    tag: Annotated[str, "Optional logging tag"] = "",
+    tag: Annotated[str, 'Optional logging tag'] = '',
 ) -> bool:
     """
     Generic patcher for replacing substrings or regex matches in a method's source code.
@@ -29,13 +27,17 @@ def patch_method(
     try:
         method = getattr(cls, method_name)
     except AttributeError:
-        print(f"[patcher{':' + tag if tag else ''}] No method {method_name} in {cls.__name__}")
+        print(
+            f'[patcher{":" + tag if tag else ""}] No method {method_name} in {cls.__name__}'
+        )
         return False
 
     try:
         src = inspect.getsource(method)
     except (OSError, TypeError):
-        print(f"[patcher{':' + tag if tag else ''}] Could not get source for {cls.__name__}.{method_name}")
+        print(
+            f'[patcher{":" + tag if tag else ""}] Could not get source for {cls.__name__}.{method_name}'
+        )
         return False
 
     new_src = src
@@ -51,18 +53,20 @@ def patch_method(
                 new_src = new_src.replace(old, new)
                 did_patch = True
         else:
-            raise TypeError("Replacement keys must be str or re.Pattern")
+            raise TypeError('Replacement keys must be str or re.Pattern')
 
     if not did_patch:
-        print(f"[patcher{':' + tag if tag else ''}] No matching patterns found in {cls.__name__}.{method_name}")
+        print(
+            f'[patcher{":" + tag if tag else ""}] No matching patterns found in {cls.__name__}.{method_name}'
+        )
         return False
 
     # Recompile the patched function
-    code_obj = compile(new_src, filename=f"<patched_{method_name}>", mode="exec")
+    code_obj = compile(new_src, filename=f'<patched_{method_name}>', mode='exec')
     ns = {}
-    exec(code_obj, cls.__dict__, ns) # type: ignore
+    exec(code_obj, cls.__dict__, ns)  # type: ignore
 
     # Attach patched method back
-    setattr(cls, method_name, types.MethodType(ns[method_name], None, cls)) # type: ignore
-    print(f"[patcher{':' + tag if tag else ''}] Patched {cls.__name__}.{method_name}")
+    setattr(cls, method_name, types.MethodType(ns[method_name], None, cls))  # type: ignore
+    print(f'[patcher{":" + tag if tag else ""}] Patched {cls.__name__}.{method_name}')
     return True

speedy_utils/common/report_manager.py

@@ -1,110 +1,108 @@
-import os
-from collections import defaultdict
-from datetime import datetime
+from ..__imports import *
 
 
 class ReportManager:
     def __init__(self):
-        self.cache_dir = os.path.expanduser("~/.cache/speedy_utils")
+        self.cache_dir = os.path.expanduser('~/.cache/speedy_utils')
         os.makedirs(self.cache_dir, exist_ok=True)
 
     def save_report(self, errors, results, execution_time=None, metadata=None):
         report_path = os.path.join(
-            self.cache_dir, f"report_{datetime.now().strftime('%m%d_%H%M')}.md"
+            self.cache_dir, f'report_{datetime.now().strftime("%m%d_%H%M")}.md'
         )
         os.makedirs(os.path.dirname(report_path), exist_ok=True)
 
         # Group errors by error type
         error_groups = defaultdict(list)
         for err in errors[:10]:
-            error_type = err["error"].__class__.__name__
+            error_type = err['error'].__class__.__name__
             error_groups[error_type].append(err)
 
         md_content = [
-            "# Multi-thread Execution Report",
-            f"\n## Summary (Generated at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')})",
+            '# Multi-thread Execution Report',
+            f'\n## Summary (Generated at {datetime.now().strftime("%Y-%m-%d %H:%M:%S")})',
         ]
 
         if metadata:
             md_content.extend(
                 [
-                    "\n### Execution Configuration",
-                    f"- Mode: {metadata['mode']}",
-                    f"- Workers: {metadata['max_workers']}",
-                    f"- Execution type: {metadata['execution_mode']}",
-                    f"- Total inputs: {metadata['total_inputs']}",
+                    '\n### Execution Configuration',
+                    f'- Mode: {metadata["mode"]}',
+                    f'- Workers: {metadata["max_workers"]}',
+                    f'- Execution type: {metadata["execution_mode"]}',
+                    f'- Total inputs: {metadata["total_inputs"]}',
                 ]
             )
 
         md_content.extend(
             [
-                "\n### Results Overview",
-                f"- Total items processed: {len(results)}",
-                f"- Success rate: {(len(results) - len(errors)) / len(results) * 100:.1f}%",
-                f"- Total errors: {len(errors)}",
+                '\n### Results Overview',
+                f'- Total items processed: {len(results)}',
+                f'- Success rate: {(len(results) - len(errors)) / len(results) * 100:.1f}%',
+                f'- Total errors: {len(errors)}',
             ]
         )
 
         if execution_time:
-            md_content.append(f"- Execution time: {execution_time:.2f}s")
+            md_content.append(f'- Execution time: {execution_time:.2f}s')
             md_content.append(
-                f"- Average speed: {len(results) / execution_time:.1f} items/second"
+                f'- Average speed: {len(results) / execution_time:.1f} items/second'
             )
 
         if error_groups:
             md_content.extend(
-                ["\n## Errors by Type", "Click headers to expand error details."]
+                ['\n## Errors by Type', 'Click headers to expand error details.']
             )
 
             for error_type, errs in error_groups.items():
                 md_content.extend(
                     [
-                        "\n<details>",
-                        f"<summary><b>{error_type}</b> ({len(errs)} occurrences)</summary>\n",
-                        "| Index | Input | Error Message |",
-                        "|-------|-------|---------------|",
+                        '\n<details>',
+                        f'<summary><b>{error_type}</b> ({len(errs)} occurrences)</summary>\n',
+                        '| Index | Input | Error Message |',
+                        '|-------|-------|---------------|',
                     ]
                 )
 
                 for err in errs:
                     md_content.append(
-                        f"| {err['index']} | `{err['input']}` | {str(err['error'])} |"
+                        f'| {err["index"]} | `{err["input"]}` | {str(err["error"])} |'
                     )
 
                 # Add first traceback as example
                 md_content.extend(
                     [
-                        "\nExample traceback:",
-                        "```python",
-                        errs[0]["traceback"],
-                        "```",
-                        "</details>",
+                        '\nExample traceback:',
+                        '```python',
+                        errs[0]['traceback'],
+                        '```',
+                        '</details>',
                     ]
                 )
 
             # Add a section listing all error indices
             md_content.extend(
                 [
-                    "\n## Error Indices",
-                    "List of indices for items that encountered errors:",
-                    ", ".join(str(err["index"]) for err in errors),
+                    '\n## Error Indices',
+                    'List of indices for items that encountered errors:',
+                    ', '.join(str(err['index']) for err in errors),
                 ]
             )
 
         md_content.extend(
             [
-                "\n## Results Summary",
-                f"- Successful executions: {len(results) - len(errors)}",
-                f"- Failed executions: {len(errors)}",
-                "\n<details>",
-                "<summary>First 5 successful results</summary>\n",
-                "```python",
+                '\n## Results Summary',
+                f'- Successful executions: {len(results) - len(errors)}',
+                f'- Failed executions: {len(errors)}',
+                '\n<details>',
+                '<summary>First 5 successful results</summary>\n',
+                '```python',
                 str([r for r in results[:5] if r is not None]),
-                "```",
-                "</details>",
+                '```',
+                '</details>',
             ]
         )
 
-        with open(report_path, "w", encoding="utf-8") as f:
-            f.write("\n".join(md_content))
-        print(f"Report saved at: {report_path}")
+        with open(report_path, 'w', encoding='utf-8') as f:
+            f.write('\n'.join(md_content))
+        print(f'Report saved at: {report_path}')