Add a lazy_import utility function (part one of our lazy import strategy)

[abrookins]

Add a new lazy_import utility function that enables lazy importing of modules and objects. This helps reduce startup time and avoid unnecessary dependencies by only importing modules when they are actually needed.

Key features:

• Lazily imports modules or objects from modules only when actually used
• Supports importing standard library modules, third-party libraries, and specific attributes
• Handles import errors gracefully with informative error messages
• Optimized to avoid unnecessary imports and reduce memory usage

Implementation

Uses a proxy class that defers the actual import until the module or attribute is accessed.

Examples

Basic usage with standard library modules

# Instead of: import json
json = lazy_import("json")
# json is not imported yet

# When we actually use the module, it gets imported
data = json.dumps({"hello": "world"})

Importing specific functions or attributes

# Instead of: from math import sqrt
sqrt = lazy_import("math.sqrt")

# When we use the function, the module gets imported
result = sqrt(16)  # Returns 4.0

Working with third-party libraries

# Instead of: import numpy as np
np = lazy_import("numpy")

# Only when we use numpy, it gets imported
if need_numerical_processing:
    array = np.array([1, 2, 3])

Error handling

# Graceful handling of missing dependencies
try:
    plt = lazy_import("matplotlib.pyplot")
    plt.plot(data)
except ImportError:
    # Fall back to text representation
    print("Visualization not available, install matplotlib")

Performance benefits

# Regular imports load immediately
import pandas  # Loads immediately, even if never used

# Lazy imports only load when needed
pd = lazy_import("pandas")  # No import overhead until pd is used

[Copilot]

Pull Request Overview

This PR introduces a new utility function lazy_import to enable lazy importing of modules and their attributes, aiming to reduce startup overhead and prevent unnecessary dependencies.

• Adds the lazy_import function in redisvl/utils/utils.py with a proxy class for delayed module import.
• Adds comprehensive unit tests in tests/unit/test_utils.py to verify lazy importing behavior for standard modules, submodules, functions, and error scenarios.

Reviewed Changes

Copilot reviewed 2 out of 2 changed files in this pull request and generated 1 comment.

File	Description
tests/unit/test_utils.py	Added tests covering lazy import functionality including favorable error handling and edge cases.
redisvl/utils/utils.py	Implemented the lazy_import function using a proxy class to delay actual import until usage.

[Copilot]

The error message for a missing attribute does not include the term "module" as expected by the tests. Consider changing it to "module '{self._parts[0]}' has no attribute '{name}'" to provide a clearer and more consistent error message.

Suggested change

	raise AttributeError(f"{self._module_path} has no attribute '{name}'")
	raise AttributeError(f"module '{self._parts[0]}' has no attribute '{name}'")