speedy-utils 1.1.27__py3-none-any.whl → 1.1.29__py3-none-any.whl

speedy_utils/all.py

@@ -1,231 +1,129 @@
-# ----------------------------------------------------------------------------
-# speedy_utils/all.py
-#
-# Consolidated import collection for comprehensive library access
-#
-# This module provides a unified collection of standard library, third-party,
-# and internal imports commonly used across data science and development
-# workflows. It serves as a convenience module for interactive environments
-# and rapid prototyping by reducing boilerplate import statements.
-#
-# Public API / Data Contracts:
-# • All standard library modules: collections, concurrent.futures, pathlib, etc.
-# • Third-party dependencies: loguru.logger, pydantic.BaseModel, tqdm, tabulate
-# • Core utilities: Counter, defaultdict, ThreadPoolExecutor, as_completed
-# • Development tools: IPython.display.HTML, get_ipython for notebook detection
-# • Type system: Any, Dict, List, Optional, Union, TypeVar, Generic, Literal
-#
-# Invariants / Constraints:
-# • MUST only import stable, widely-used packages
-# • SHOULD handle import failures gracefully for optional dependencies
-# • MUST maintain consistent import aliases across the library
-# • SHOULD group imports by category (stdlib, third-party, internal)
-#
-# Usage Example:
-# ```python
-# from speedy_utils.all import *
-#
-# # Now have access to common utilities without individual imports
-# data = defaultdict(list)
-# results = []
-# for item in tqdm(items):
-#     results.append(process(item))
-#
-# df = tabulate(results, headers=['Item', 'Result'])
-# display(HTML(df))
-# ```
-#
-# TODO & Future Work:
-# • Add conditional imports for ML libraries (torch, numpy, pandas)
-# • Implement import health checking
-# • Add version compatibility warnings
-# ----------------------------------------------------------------------------
+# from speedy_utils import (  # Clock module; Function decorators; Cache utilities; IO utilities; Misc utilities; Print utilities; Multi-worker processing
+#     Clock,
+#     convert_to_builtin_python,
+#     display_pretty_table_html,
+#     dump_json_or_pickle,
+#     dump_jsonl,
+#     flatten_dict,
+#     flatten_list,
+#     fprint,
+#     get_arg_names,
+#     identify,
+#     identify_uuid,
+#     is_notebook,
+#     jdumps,
+#     jloads,
+#     load_by_ext,
+#     load_json_or_pickle,
+#     load_jsonl,
+#     log,
+#     memoize,
+#     mkdir_or_exist,
+#     multi_process,
+#     multi_thread,
+#     print_table,
+#     retry_runtime,
+#     setup_logger,
+#     speedy_timer,
+#     timef,
+# )
 
-# speedy_utils/all.py
+# from .__imports import *
 
-# Provide a consolidated set of imports for convenience
 
-# Standard library imports
-import copy
-import functools
-import gc
-import inspect
-import json
-import multiprocessing
-import os
-import os.path as osp
-import pickle
-import pprint
-import random
-import re
-import sys
-import textwrap
-import threading
-import time
-import traceback
-import uuid
-from collections import Counter, defaultdict
-from collections.abc import Callable
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from glob import glob
-from multiprocessing import Pool
-from pathlib import Path
-from threading import Lock
-from typing import (
-    Any,
-    Awaitable,
-    Callable as TypingCallable,
-    Dict,
-    Generic,
-    Iterable,
-    List,
-    Literal,
-    Mapping,
-    Optional,
-    Sequence,
-    Set,
-    Tuple,
-    Type,
-    TypeVar,
-    Union,
-)
+# choice = random.choice
 
-# Third-party imports
-import numpy as np
-import pandas as pd
-import xxhash
-from IPython.core.getipython import get_ipython
-from IPython.display import HTML, display
-from loguru import logger
-from pydantic import BaseModel
-from tabulate import tabulate
-from tqdm import tqdm
-
-# Import specific functions from speedy_utils
-from speedy_utils import (  # Clock module; Function decorators; Cache utilities; IO utilities; Misc utilities; Print utilities; Multi-worker processing
-    Clock,
-    convert_to_builtin_python,
-    display_pretty_table_html,
-    dump_json_or_pickle,
-    dump_jsonl,
-    flatten_dict,
-    flatten_list,
-    fprint,
-    get_arg_names,
-    identify,
-    identify_uuid,
-    is_notebook,
-    jdumps,
-    jloads,
-    load_by_ext,
-    load_json_or_pickle,
-    load_jsonl,
-    log,
-    memoize,
-    mkdir_or_exist,
-    multi_process,
-    multi_thread,
-    print_table,
-    retry_runtime,
-    setup_logger,
-    speedy_timer,
-    timef,
-)
-
-
-choice = random.choice
-
-# Define __all__ explicitly with all exports
-__all__ = [
-    # Standard library
-    "random",
-    "copy",
-    "functools",
-    "gc",
-    "inspect",
-    "json",
-    "multiprocessing",
-    "os",
-    "osp",
-    "pickle",
-    "pprint",
-    "re",
-    "sys",
-    "textwrap",
-    "threading",
-    "time",
-    "traceback",
-    "uuid",
-    "Counter",
-    "ThreadPoolExecutor",
-    "as_completed",
-    "glob",
-    "Pool",
-    "Path",
-    "Lock",
-    "defaultdict",
-    # Typing
-    "Any",
-    "Awaitable",
-    "Callable",
-    "TypingCallable",
-    "Dict",
-    "Generic",
-    "Iterable",
-    "List",
-    "Literal",
-    "Mapping",
-    "Optional",
-    "Sequence",
-    "Set",
-    "Tuple",
-    "Type",
-    "TypeVar",
-    "Union",
-    # Third-party
-    "pd",
-    "xxhash",
-    "get_ipython",
-    "HTML",
-    "display",
-    "logger",
-    "BaseModel",
-    "tabulate",
-    "tqdm",
-    "np",
-    # Clock module
-    "Clock",
-    "speedy_timer",
-    "timef",
-    # Function decorators
-    "retry_runtime",
-    # Cache utilities
-    "memoize",
-    "identify",
-    "identify_uuid",
-    # IO utilities
-    "dump_json_or_pickle",
-    "dump_jsonl",
-    "load_by_ext",
-    "load_json_or_pickle",
-    "load_jsonl",
-    "jdumps",
-    "jloads",
-    # Misc utilities
-    "mkdir_or_exist",
-    "flatten_list",
-    "get_arg_names",
-    "is_notebook",
-    "convert_to_builtin_python",
-    # Print utilities
-    "display_pretty_table_html",
-    "flatten_dict",
-    "fprint",
-    "print_table",
-    "setup_logger",
-    "log",
-    # Multi-worker processing
-    "multi_process",
-    "multi_thread",
-    "choice",
-]
+# # Define __all__ explicitly with all exports
+# __all__ = [
+#     # Standard library
+#     'random',
+#     'copy',
+#     'functools',
+#     'gc',
+#     'inspect',
+#     'json',
+#     'multiprocessing',
+#     'os',
+#     'osp',
+#     'pickle',
+#     'pprint',
+#     're',
+#     'sys',
+#     'textwrap',
+#     'threading',
+#     'time',
+#     'traceback',
+#     'uuid',
+#     'Counter',
+#     'ThreadPoolExecutor',
+#     'as_completed',
+#     'glob',
+#     'Pool',
+#     'Path',
+#     'Lock',
+#     'defaultdict',
+#     # Typing
+#     'Any',
+#     'Awaitable',
+#     'Callable',
+#     'TypingCallable',
+#     'Dict',
+#     'Generic',
+#     'Iterable',
+#     'List',
+#     'Literal',
+#     'Mapping',
+#     'Optional',
+#     'Sequence',
+#     'Set',
+#     'Tuple',
+#     'Type',
+#     'TypeVar',
+#     'Union',
+#     # Third-party
+#     'pd',
+#     'xxhash',
+#     'get_ipython',
+#     'HTML',
+#     'display',
+#     'logger',
+#     'BaseModel',
+#     'tabulate',
+#     'tqdm',
+#     'np',
+#     # Clock module
+#     'Clock',
+#     'speedy_timer',
+#     'timef',
+#     # Function decorators
+#     'retry_runtime',
+#     # Cache utilities
+#     'memoize',
+#     'identify',
+#     'identify_uuid',
+#     # IO utilities
+#     'dump_json_or_pickle',
+#     'dump_jsonl',
+#     'load_by_ext',
+#     'load_json_or_pickle',
+#     'load_jsonl',
+#     'jdumps',
+#     'jloads',
+#     # Misc utilities
+#     'mkdir_or_exist',
+#     'flatten_list',
+#     'get_arg_names',
+#     'is_notebook',
+#     'convert_to_builtin_python',
+#     # Print utilities
+#     'display_pretty_table_html',
+#     'flatten_dict',
+#     'fprint',
+#     'print_table',
+#     'setup_logger',
+#     'log',
+#     # Multi-worker processing
+#     'multi_process',
+#     'multi_thread',
+#     'choice',
+# ]

speedy_utils/common/clock.py

@@ -1,11 +1,7 @@
-import inspect
-import os
-import time
+from ..__imports import *
 
-from loguru import logger
-from tabulate import tabulate
 
-__all__ = ["Clock", "timef"]
+__all__ = ['Clock', 'timef']
 
 
 def timef(func):
@@ -17,7 +13,7 @@ def timef(func):
         end_time = time.time()
         execution_time = end_time - start_time
         logger.opt(depth=2).info(
-            f"{func.__name__} took {execution_time:0.2f} seconds to execute."
+            f'{func.__name__} took {execution_time:0.2f} seconds to execute.'
         )
         return result
 
@@ -63,12 +59,12 @@ class Clock:
             self.start()
         self.print_counter = 0
         self.last_print_time = time.time()
-        self.min_depth = float("inf")
+        self.min_depth = float('inf')
 
     def start(self):
         """Start the timer or reset if already started."""
         if self.start_time is not None:
-            raise ValueError("Timer has already been started.")
+            raise ValueError('Timer has already been started.')
         self.start_time = time.time()
         self.last_checkpoint = self.start_time
         # logger.opt(depth=2).info(f"Timer started. {id(self)=}")
@@ -76,12 +72,12 @@ class Clock:
     def elapsed_time(self):
         """Return the time elapsed since the timer started."""
         if self.start_time is None:
-            raise ValueError("Timer has not been started.")
+            raise ValueError('Timer has not been started.')
         return time.time() - self.start_time
 
     def log_elapsed_time(self, custom_logger=None):
         """Log the time elapsed since the timer started."""
-        msg = f"Time elapsed: {self.elapsed_time():.2f} seconds."
+        msg = f'Time elapsed: {self.elapsed_time():.2f} seconds.'
         if custom_logger:
             custom_logger(msg)
         else:
@@ -92,15 +88,15 @@ class Clock:
         # assert self.start_time is not None, f"Timer has not been started. {id(self)=}"
         if not self.start_time:
             logger.opt(depth=2).warning(
-                "Timer has not been started. Please call start() before using this method."
+                'Timer has not been started. Please call start() before using this method.'
             )
-            return
+            return None
         current_time = time.time()
         if self.last_checkpoint is None:
             logger.opt(depth=2).warning(
-                "Last checkpoint is not set. Please call start() before using this method."
+                'Last checkpoint is not set. Please call start() before using this method.'
             )
-            return
+            return None
         elapsed = current_time - self.last_checkpoint
         self.last_checkpoint = current_time
         return elapsed
@@ -113,14 +109,14 @@ class Clock:
         if self.start_time is None:
             # raise ValueError("Timer has not been started.")
             logger.opt(depth=2).warning(
-                "Timer has not been started. Please call start() before using this method."
+                'Timer has not been started. Please call start() before using this method.'
             )
-            return
+            return None
         if self.last_checkpoint is None:
             logger.opt(depth=2).warning(
-                "Last checkpoint is not set. Please call start() before using this method."
+                'Last checkpoint is not set. Please call start() before using this method.'
             )
-            return
+            return None
         return time.time() - self.last_checkpoint
 
     def update_task(self, task_name):
@@ -131,7 +127,7 @@ class Clock:
 
         # Get the file and line number of the caller (the previous frame in the stack)
         caller_frame = stack[1]
-        file_lineno = f"{os.path.basename(caller_frame.filename)}:{caller_frame.lineno}"
+        file_lineno = f'{os.path.basename(caller_frame.filename)}:{caller_frame.lineno}'
 
         # Calculate the depth of the current call (i.e., how far it is in the stack)
         call_depth = (
@@ -143,22 +139,21 @@ class Clock:
         # Update the task time in the internal task table
         if task_name not in self.task_times:
             self.task_times[task_name] = {
-                "time": 0,
-                "file_lineno": file_lineno,
-                "depth": call_depth,
+                'time': 0,
+                'file_lineno': file_lineno,
+                'depth': call_depth,
             }
-        self.task_times[task_name]["time"] += self.tick()
+        self.task_times[task_name]['time'] += self.tick()
 
     def get_percentage_color(self, percentage):
         """Return ANSI color code based on percentage."""
         if percentage >= 75:
-            return "\033[91m"  # Red
-        elif percentage >= 50:
-            return "\033[93m"  # Yellow
-        elif percentage >= 25:
-            return "\033[92m"  # Green
-        else:
-            return "\033[94m"  # Blue
+            return '\033[91m'  # Red
+        if percentage >= 50:
+            return '\033[93m'  # Yellow
+        if percentage >= 25:
+            return '\033[92m'  # Green
+        return '\033[94m'  # Blue
 
     def print_task_table(self, interval=1, max_depth=None):
         """Print the task time table at regular intervals."""
@@ -167,30 +162,30 @@ class Clock:
         if current_time - self.last_print_time > interval:
             self.print_counter += 1
             total_time = (
-                sum(data["time"] for data in self.task_times.values()) or 1
+                sum(data['time'] for data in self.task_times.values()) or 1
             )  # Avoid division by zero
 
             # Prepare data for the table
             table_data = []
             for task_name, data in self.task_times.items():
-                time_spent = data["time"]
-                file_lineno = data["file_lineno"]
-                depth = data["depth"] - self.min_depth
+                time_spent = data['time']
+                file_lineno = data['file_lineno']
+                depth = data['depth'] - self.min_depth
                 if max_depth is not None and depth > max_depth:
                     continue
                 percentage = (time_spent / total_time) * 100
 
                 # Get color code based on percentage
                 color_code = self.get_percentage_color(percentage)
-                percentage_str = f"{percentage:.2f} %"
-                colored_percentage = f"{color_code}{percentage_str}\033[0m"
+                percentage_str = f'{percentage:.2f} %'
+                colored_percentage = f'{color_code}{percentage_str}\033[0m'
 
                 table_data.append(
                     [
                         task_name,
                         file_lineno,
                         # depth,
-                        f"{time_spent:.2f} s",
+                        f'{time_spent:.2f} s',
                         colored_percentage,
                     ]
                 )
@@ -198,13 +193,13 @@ class Clock:
             # Add headers and log using tabulate
             table = tabulate(
                 table_data,
-                headers=["Task", "File:Line", "Time (s)", "Percentage (%)"],
-                tablefmt="grid",
+                headers=['Task', 'File:Line', 'Time (s)', 'Percentage (%)'],
+                tablefmt='grid',
             )
 
             self.last_print_time = current_time
             # total_time_str = f"\nTotal time elapsed: {total_time:.2f} seconds."
-            logger.opt(depth=2).info(f"\n{table}")
+            logger.opt(depth=2).info(f'\n{table}')
 
 
 # Example of how to instantiate the Timer
@@ -212,4 +207,4 @@ speedy_timer = Clock(start_now=False)
 
 
 # Clock, speedy_timer, timef
-__all__ = ["Clock", "speedy_timer", "timef"]
+__all__ = ['Clock', 'speedy_timer', 'timef']

speedy_utils/common/function_decorator.py

@@ -1,10 +1,4 @@
-import functools
-import time
-import traceback
-from collections.abc import Callable
-from typing import Any
-
-from loguru import logger
+from ..__imports import *
 
 
 def retry_runtime(
@@ -33,14 +27,14 @@ def retry_runtime(
                 except (SyntaxError, NameError, ImportError, TypeError) as e:
                     # Don't retry on syntax/compilation errors
                     logger.opt(depth=1).error(
-                        f"Critical error in {func.__name__}: {str(e)}\n{traceback.format_exc()}"
+                        f'Critical error in {func.__name__}: {str(e)}\n{traceback.format_exc()}'
                     )
                     raise
 
                 except exceptions as e:
                     if attempt == max_retry:
                         logger.opt(depth=1).error(
-                            f"Function {func.__name__} failed after {max_retry} retries: {str(e)}"
+                            f'Function {func.__name__} failed after {max_retry} retries: {str(e)}'
                         )
                         raise
 
@@ -48,8 +42,8 @@ def retry_runtime(
                         2 ** (attempt - 1)
                     )  # Exponential backoff
                     logger.opt(depth=1).warning(
-                        f"Attempt {attempt}/{max_retry} failed: {str(e)[:100]}. "
-                        f"Retrying in {backoff_time} seconds."
+                        f'Attempt {attempt}/{max_retry} failed: {str(e)[:100]}. '
+                        f'Retrying in {backoff_time} seconds.'
                     )
                     time.sleep(backoff_time)
 
@@ -60,4 +54,4 @@ def retry_runtime(
     return decorator
 
 
-__all__ = ["retry_runtime"]
+__all__ = ['retry_runtime']