vectorwave 0.2.3__tar.gz → 0.2.4__tar.gz

{vectorwave-0.2.3/src/vectorwave.egg-info → vectorwave-0.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectorwave
-Version: 0.2.3
+Version: 0.2.4
 Summary: VectorWave: Seamless Auto-Vectorization Framework
 Author-email: junyeonggim <junyeonggim5@gmail.com>
 License-Expression: MIT
@@ -618,6 +618,40 @@ archiver.export_and_clear(
 {"messages": [{"role": "user", "content": "{\"price\": 100, \"tax\": 0.1}"}, {"role": "assistant", "content": "110.0"}]}
 ```
 
+## 🌊 Auto-Injection (Zero-Code Change Integration)
+
+You don't need to modify your business logic to use VectorWave. Use `VectorWaveAutoInjector` to inject functionality externally.
+
+### How to use
+
+1. **Configure Global Settings**: Set default values like `team`, `priority`, or `auto` (pending mode).
+2. **Inject Modules**: Specify the target module path string.
+
+```python
+from vectorwave import initialize_database, VectorWaveAutoInjector, generate_and_register_metadata
+
+# 1. Initialize DB
+initialize_database()
+
+# 2. Configure AutoInjector (Global Settings)
+VectorWaveAutoInjector.configure(
+    team="billing-team",
+    priority=1,
+    auto=True  # True: Collect metadata in memory (Pending), False: Save immediately to DB
+)
+
+# 3. Inject VectorWave into your module
+# (No need to add @vectorize decorators in 'my_service.payment' code!)
+VectorWaveAutoInjector.inject("my_service.payment")
+
+# 4. Register Metadata (If auto=True)
+generate_and_register_metadata()
+
+# 5. Run your business logic
+import my_service.payment
+my_service.payment.process_transaction()
+```
+
 ## 🤝 Contributing
 
 We welcome all forms of contributions, including bug reports, feature requests, and code contributions. Please refer to [CONTRIBUTING.md](https://www.google.com/search?q=httpsS://www.google.com/search%3Fq%3DCONTRIBUTING.md) for details.

{vectorwave-0.2.3 → vectorwave-0.2.4}/Readme.md

@@ -592,6 +592,40 @@ archiver.export_and_clear(
 {"messages": [{"role": "user", "content": "{\"price\": 100, \"tax\": 0.1}"}, {"role": "assistant", "content": "110.0"}]}
 ```
 
+## 🌊 Auto-Injection (Zero-Code Change Integration)
+
+You don't need to modify your business logic to use VectorWave. Use `VectorWaveAutoInjector` to inject functionality externally.
+
+### How to use
+
+1. **Configure Global Settings**: Set default values like `team`, `priority`, or `auto` (pending mode).
+2. **Inject Modules**: Specify the target module path string.
+
+```python
+from vectorwave import initialize_database, VectorWaveAutoInjector, generate_and_register_metadata
+
+# 1. Initialize DB
+initialize_database()
+
+# 2. Configure AutoInjector (Global Settings)
+VectorWaveAutoInjector.configure(
+    team="billing-team",
+    priority=1,
+    auto=True  # True: Collect metadata in memory (Pending), False: Save immediately to DB
+)
+
+# 3. Inject VectorWave into your module
+# (No need to add @vectorize decorators in 'my_service.payment' code!)
+VectorWaveAutoInjector.inject("my_service.payment")
+
+# 4. Register Metadata (If auto=True)
+generate_and_register_metadata()
+
+# 5. Run your business logic
+import my_service.payment
+my_service.payment.process_transaction()
+```
+
 ## 🤝 Contributing
 
 We welcome all forms of contributions, including bug reports, feature requests, and code contributions. Please refer to [CONTRIBUTING.md](https://www.google.com/search?q=httpsS://www.google.com/search%3Fq%3DCONTRIBUTING.md) for details.

{vectorwave-0.2.3 → vectorwave-0.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vectorwave"
-version = "0.2.03"
+version = "0.2.04"
 authors = [
     { name = "junyeonggim", email = "junyeonggim5@gmail.com" },
 ]

vectorwave-0.2.4/src/tests/core/test_auto_injector.py

@@ -0,0 +1,228 @@
+import pytest
+import sys
+import types
+from unittest.mock import MagicMock, ANY
+from vectorwave.core.auto_injector import VectorWaveAutoInjector, create_smart_wrapper
+
+# --- Fixtures ---
+
+@pytest.fixture
+def mock_target_module():
+    """Dynamically creates a fake module for testing."""
+    module_name = "fake_business_logic"
+    mod = types.ModuleType(module_name)
+
+    # Define functions for testing
+    def func_a(x): return x + 1
+    def func_b(y): return y * 2
+
+    # Set __module__ attribute so the Injector recognizes them as 'functions of this module'
+    func_a.__module__ = module_name
+    func_b.__module__ = module_name
+
+    mod.func_a = func_a
+    mod.func_b = func_b
+
+    # Register to sys.modules
+    sys.modules[module_name] = mod
+    yield mod
+    # Cleanup
+    del sys.modules[module_name]
+
+@pytest.fixture
+def mock_deps(monkeypatch):
+    """
+    Mocks vectorize, trace_span, and contextvar that auto_injector depends on.
+    """
+    mock_vectorize = MagicMock()
+    mock_trace_span = MagicMock()
+    mock_tracer_var = MagicMock()
+
+    # Mock vectorize: @vectorize(...) -> decorator -> returns root_wrapper
+    def vectorize_side_effect(**kwargs):
+        def decorator(func):
+            # Return a mock acting as root_wrapper (Default behavior: execute original function)
+            root_wrapper = MagicMock(side_effect=func)
+            return root_wrapper
+        return decorator
+
+    # [Modified] Mock trace_span: Modified to accept positional arguments (*args)
+    def trace_span_side_effect(*args, **kwargs):
+        # Case 1: Called as trace_span(func, capture_return_value=True)
+        if args and callable(args[0]):
+            func = args[0]
+            def wrapper(*w_args, **w_kwargs):
+                return func(*w_args, **w_kwargs)
+            return wrapper
+
+        # Case 2: Called as a decorator factory @trace_span(...)
+        def decorator(func):
+            def wrapper(*w_args, **w_kwargs):
+                return func(*w_args, **w_kwargs)
+            return wrapper
+        return decorator
+
+    mock_vectorize.side_effect = vectorize_side_effect
+    mock_trace_span.side_effect = trace_span_side_effect
+
+    # Patch according to the module path
+    monkeypatch.setattr("vectorwave.core.auto_injector.vectorize", mock_vectorize)
+    monkeypatch.setattr("vectorwave.core.auto_injector.trace_span", mock_trace_span)
+    monkeypatch.setattr("vectorwave.core.auto_injector.current_tracer_var", mock_tracer_var)
+
+    return {
+        "vectorize": mock_vectorize,
+        "trace_span": mock_trace_span,
+        "tracer_var": mock_tracer_var
+    }
+
+@pytest.fixture
+def mock_multiple_modules():
+    """Dynamically creates two different fake modules (Payment, Auth)."""
+    name_a = "service_payment"
+    name_b = "service_auth"
+
+    mod_a = types.ModuleType(name_a)
+    mod_b = types.ModuleType(name_b)
+
+    def pay(x): return x
+    def login(x): return x
+
+    pay.__module__ = name_a
+    login.__module__ = name_b
+
+    mod_a.process_payment = pay
+    mod_b.login_user = login
+
+    sys.modules[name_a] = mod_a
+    sys.modules[name_b] = mod_b
+
+    yield mod_a, mod_b
+
+    del sys.modules[name_a]
+    del sys.modules[name_b]
+
+# --- Test Cases ---
+
+def test_inject_calls_vectorize_immediately(mock_target_module, mock_deps):
+    """
+    Case 1: Verify that vectorize is called immediately at injection time to register metadata.
+    """
+    # Act
+    VectorWaveAutoInjector.inject("fake_business_logic", team="test-team")
+
+    # Assert
+    # 1. vectorize should have been called (Immediate registration)
+    mock_deps["vectorize"].assert_called()
+
+    # 2. Verify passed configuration
+    call_kwargs = mock_deps["vectorize"].call_args.kwargs
+    assert call_kwargs["team"] == "test-team"
+
+    # 3. Verify the function is wrapped
+    assert getattr(mock_target_module.func_a, "_is_vectorized") is True
+
+def test_smart_wrapper_root_execution(mock_target_module, mock_deps):
+    """
+    Case 2: Verify that the pre-created root_wrapper is executed when there is no tracer (Root).
+    """
+    # Arrange
+    mock_deps["tracer_var"].get.return_value = None # No parent trace
+
+    # [Modified] Remove fixture's side_effect so return_value setting takes effect.
+    mock_deps["vectorize"].side_effect = None
+
+    # vectorize(...) -> decorator_mock returns -> decorator_mock(func) -> root_wrapper_mock returns
+    decorator_mock = MagicMock()
+    root_wrapper_mock = MagicMock(return_value=11)
+
+    mock_deps["vectorize"].return_value = decorator_mock
+    decorator_mock.return_value = root_wrapper_mock
+
+    VectorWaveAutoInjector.inject("fake_business_logic")
+
+    # Act
+    result = mock_target_module.func_a(10)
+
+    # Assert
+    assert result == 11
+    # root_wrapper should have been called
+    root_wrapper_mock.assert_called_once()
+    # trace_span should not be called (logic is already inside root_wrapper)
+    mock_deps["trace_span"].assert_not_called()
+
+def test_smart_wrapper_child_execution(mock_target_module, mock_deps):
+    """
+    Case 3: Verify that trace_span is dynamically called when there is a tracer (Child).
+    """
+    # Arrange
+    mock_deps["tracer_var"].get.return_value = MagicMock() # Parent trace exists
+
+    # [Modified] Remove side_effect and set Mock
+    mock_deps["vectorize"].side_effect = None
+
+    decorator_mock = MagicMock()
+    root_wrapper_mock = MagicMock(return_value=999) # Should not be called
+
+    mock_deps["vectorize"].return_value = decorator_mock
+    decorator_mock.return_value = root_wrapper_mock
+
+    VectorWaveAutoInjector.inject("fake_business_logic")
+
+    # Act
+    # trace_span mock is configured to call the original function (see fixture)
+    # func_b: y * 2 -> 5 * 2 = 10
+    result = mock_target_module.func_b(5)
+
+    # Assert
+    assert result == 10
+    # trace_span should have been called
+    mock_deps["trace_span"].assert_called()
+    # root_wrapper should not have been called
+    root_wrapper_mock.assert_not_called()
+
+def test_prevent_double_injection(mock_target_module, mock_deps):
+    """
+    Case 4: Verify that calling inject again on an already injected function does not result in double wrapping.
+    """
+    # 1. First Injection
+    VectorWaveAutoInjector.inject("fake_business_logic")
+    first_wrapped_func = mock_target_module.func_a
+    call_count_first = mock_deps["vectorize"].call_count
+
+    # 2. Second Injection
+    VectorWaveAutoInjector.inject("fake_business_logic")
+    second_wrapped_func = mock_target_module.func_a
+    call_count_second = mock_deps["vectorize"].call_count
+
+    # Assert
+    # Object addresses must be identical
+    assert first_wrapped_func is second_wrapped_func
+    # vectorize call count should not increase (Prevent duplicate registration)
+    assert call_count_first == call_count_second
+
+def test_inject_using_config_dictionary_pattern(mock_multiple_modules, mock_deps):
+    """
+    Case 5: Verify that configurations are correctly applied when injecting multiple modules in a batch.
+    """
+    mod_a, mod_b = mock_multiple_modules
+
+    # Injection
+    VectorWaveAutoInjector.configure(team="default") # Global config example
+
+    VectorWaveAutoInjector.inject("service_payment", priority=1)
+    VectorWaveAutoInjector.inject("service_auth", team="security")
+
+    # Verify: Check arguments passed to vectorize calls
+    calls = mock_deps["vectorize"].call_args_list
+    # Collect kwargs
+    configs = [c.kwargs for c in calls]
+
+    # service_payment: default team + priority 1
+    config_a = next((c for c in configs if c.get("priority") == 1), None)
+    assert config_a is not None
+    assert config_a["team"] == "default"
+
+    # service_auth: security team (override)
+    config_b = next((c for c in configs if c.get("team") == "security"), None)
+    assert config_b is not None

vectorwave-0.2.4/src/tests/core/test_auto_injector_real.py

@@ -0,0 +1,111 @@
+import pytest
+import sys
+import types
+from unittest.mock import patch, MagicMock
+
+# Import actual modules
+from vectorwave import vectorize, VectorWaveAutoInjector
+
+# --- Fixtures ---
+
+@pytest.fixture
+def mock_db_dependencies():
+    """
+    Mocks heavy dependencies to prevent @vectorize decorator from internally calling
+    DB or AI models.
+    (The wrapping logic itself runs for 'real')
+    """
+    with patch("vectorwave.core.decorator.get_batch_manager") as mock_batch, \
+            patch("vectorwave.core.decorator.get_vectorizer") as mock_vec, \
+            patch("vectorwave.core.decorator.function_cache_manager"), \
+            patch("vectorwave.core.decorator.get_weaviate_settings"), \
+            patch("vectorwave.core.decorator.generate_uuid5", return_value="mock-uuid"):
+
+        # Return fake DB settings (prevent errors)
+        mock_settings = MagicMock()
+        mock_settings.custom_properties = {}
+        mock_settings.COLLECTION_NAME = "VectorWaveFunction"
+        patch("vectorwave.core.decorator.get_weaviate_settings", return_value=mock_settings).start()
+
+        yield
+
+# --- Real Function Integration Test ---
+
+def test_real_function_mixed_usage(mock_db_dependencies):
+    """
+    [Integration Test] Verifies that double wrapping is prevented when mixing
+    actual @vectorize decorator and AutoInjector using real function objects.
+    """
+    # 1. Create a fake module (acts like a real Python module)
+    module_name = "my_real_test_module"
+    mod = types.ModuleType(module_name)
+
+    # -------------------------------------------------------
+    # (A) Manually vectorized function (Using Real Decorator)
+    # -------------------------------------------------------
+    @vectorize(team="manual_team", auto=True)
+    def manual_func(x):
+        return x + 1
+
+    # -------------------------------------------------------
+    # (B) Plain function without any decorator
+    # -------------------------------------------------------
+    def plain_func(y):
+        return y * 2
+
+    # [Important] Set __module__ so Injector recognizes them as internal functions
+    manual_func.__module__ = module_name
+    plain_func.__module__ = module_name
+
+    # Register functions to the module
+    mod.manual_func = manual_func
+    mod.plain_func = plain_func
+
+    # Register to sys.modules so importlib can find it
+    sys.modules[module_name] = mod
+
+    try:
+        # 2. Check state before injection
+        print("\n[Before Injection]")
+        print(f"manual_func vectorized? {getattr(mod.manual_func, '_is_vectorized', False)}")
+        print(f"plain_func vectorized?  {getattr(mod.plain_func, '_is_vectorized', False)}")
+
+        # manual_func should already have the decorator applied
+        assert getattr(mod.manual_func, "_is_vectorized", False) is True
+        # plain_func should be a pure function
+        assert getattr(mod.plain_func, "_is_vectorized", False) is False
+
+        # Save object ID of manual_func before injection (for comparison)
+        original_manual_func_id = id(mod.manual_func)
+
+        # -------------------------------------------------------
+        # 3. Execute AutoInjector (Real Injection)
+        # -------------------------------------------------------
+        print("\n🌊 Injecting VectorWave...")
+        VectorWaveAutoInjector.inject(module_name, team="auto_team")
+
+        # 4. Verify results
+        print("\n[After Injection]")
+
+        # (A) Verify manual_func: Prevent double wrapping
+        # If AutoInjector skipped it, the object ID should remain unchanged.
+        current_manual_func_id = id(mod.manual_func)
+
+        if current_manual_func_id == original_manual_func_id:
+            print("✅ manual_func: SKIPPED (Identity preserved)")
+        else:
+            print("❌ manual_func: WRAPPED AGAIN (Identity changed!)")
+
+        assert current_manual_func_id == original_manual_func_id, \
+            "Manually configured function was double-wrapped by AutoInjector!"
+
+        # (B) Verify plain_func: Auto-wrapping success
+        # Since it's newly wrapped, _is_vectorized should become True.
+        is_vectorized = getattr(mod.plain_func, "_is_vectorized", False)
+        print(f"plain_func vectorized?  {is_vectorized}")
+
+        assert is_vectorized is True, "Plain function was not auto-injected!"
+
+    finally:
+        # Cleanup module after test
+        del sys.modules[module_name]

{vectorwave-0.2.3 → vectorwave-0.2.4}/src/vectorwave/__init__.py

@@ -1,5 +1,4 @@
 from .core.decorator import vectorize
-
 from .database.db import initialize_database
 from .database.db_search import search_functions, search_executions, search_errors_by_message, search_functions_hybrid
 from .monitoring.tracer import trace_span
@@ -9,6 +8,7 @@ from .utils.healer import VectorWaveHealer
 from .utils.replayer import VectorWaveReplayer
 from .utils.replayer_semantic import SemanticReplayer
 from .database.dataset import VectorWaveDatasetManager
+from .core.auto_injector import VectorWaveAutoInjector
 
 __all__ = [
     'vectorize',
@@ -24,5 +24,6 @@ __all__ = [
     'VectorWaveHealer',
     'VectorWaveReplayer',
     'SemanticReplayer',
-    'VectorWaveDatasetManager'
+    'VectorWaveDatasetManager',
+    'VectorWaveAutoInjector'
 ]

vectorwave-0.2.4/src/vectorwave/core/auto_injector.py

@@ -0,0 +1,100 @@
+import inspect
+import importlib
+import logging
+from functools import wraps
+from typing import Any, Optional
+
+# VectorWave Core Modules
+from .decorator import vectorize
+from ..monitoring.tracer import trace_span, current_tracer_var
+
+logger = logging.getLogger(__name__)
+
+def create_smart_wrapper(original_func, root_wrapper):
+    """
+    Creates a wrapper that switches behavior based on the Tracing Context.
+
+    Args:
+        original_func: The original function (used when acting as a Child Span).
+        root_wrapper: The wrapper generated by vectorize (used when acting as a Root Span, includes metadata).
+    """
+    @wraps(original_func)
+    def wrapper(*args, **kwargs):
+        # Check for existing tracer at runtime
+        tracer = current_tracer_var.get()
+
+        if tracer:
+            # [Case A] Parent trace exists -> Act as Child Span
+            # (Wrap original function with trace_span and execute)
+            return trace_span(original_func, capture_return_value=True)(*args, **kwargs)
+        else:
+            # [Case B] No parent trace -> Act as Root Span
+            # (Delegate to the already configured root_wrapper)
+            return root_wrapper(*args, **kwargs)
+
+    # Mark to prevent double injection
+    wrapper._is_vectorized = True
+    return wrapper
+
+
+class VectorWaveAutoInjector:
+    """
+    Scans specified modules or packages to automatically inject (Monkey Patch) VectorWave functionality.
+    """
+
+    # Global default configuration
+    _default_config = {}
+
+    @classmethod
+    def configure(cls, **kwargs):
+        """
+        Sets the default configuration to be applied to all inject calls.
+        """
+        cls._default_config.update(kwargs)
+        logger.info(f"⚙️ VectorWave AutoInjector Configured: {cls._default_config}")
+
+    @classmethod
+    def inject(cls, target_module_path: str, recursive: bool = False, **config):
+        """
+        Finds functions within a module and injects VectorWave functionality.
+        **Metadata registration (DB save or Pending) is performed immediately at this point.**
+        """
+        try:
+            module = importlib.import_module(target_module_path)
+        except ImportError as e:
+            logger.error(f"Failed to import module '{target_module_path}': {e}")
+            return None
+
+        # Merge configurations (Defaults < Individual Config)
+        final_config = cls._default_config.copy()
+        final_config.update(config)
+
+        logger.info(f"🌊 [AutoInjector] Injecting VectorWave into: {module.__name__}")
+
+        patched_count = 0
+
+        for name, obj in inspect.getmembers(module):
+            # Target only functions defined within the module
+            if inspect.isfunction(obj) and obj.__module__ == module.__name__:
+
+                # Skip if already processed
+                if getattr(obj, "_is_vectorized", False):
+                    continue
+
+                logger.info(f"  └─ Auto-wiring: {name}()")
+
+                # [Key Change] Call vectorize immediately at injection time to perform metadata registration!
+                # - If auto=False: Immediate DB save
+                # - If auto=True: Add to PENDING list
+                # The returned root_wrapper contains the execution logic (Root Span)
+                root_wrapper = vectorize(**final_config)(obj)
+
+                # Create smart wrapper to judge Context at runtime
+                smart_wrapper = create_smart_wrapper(obj, root_wrapper)
+
+                # Replace (Monkey Patching)
+                setattr(module, name, smart_wrapper)
+                patched_count += 1
+
+        logger.info(f"✨ Injection Complete. {patched_count} functions registered & auto-wired.")
+        return module

{vectorwave-0.2.3 → vectorwave-0.2.4}/src/vectorwave/core/decorator.py

@@ -161,6 +161,7 @@ def vectorize(search_description: Optional[str] = None,
                 full_kwargs['exec_source'] = execution_source_context.get()
                 return await inner_wrapper(*args, **full_kwargs)
 
+            outer_wrapper._is_vectorized = True
             return outer_wrapper
 
         else:  # Sync wrapper
@@ -184,6 +185,7 @@ def vectorize(search_description: Optional[str] = None,
                 full_kwargs['exec_source'] = execution_source_context.get()
                 return inner_wrapper(*args, **full_kwargs)
 
+            outer_wrapper._is_vectorized = True
             return outer_wrapper
 
     return decorator

{vectorwave-0.2.3 → vectorwave-0.2.4/src/vectorwave.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectorwave
-Version: 0.2.3
+Version: 0.2.4
 Summary: VectorWave: Seamless Auto-Vectorization Framework
 Author-email: junyeonggim <junyeonggim5@gmail.com>
 License-Expression: MIT
@@ -618,6 +618,40 @@ archiver.export_and_clear(
 {"messages": [{"role": "user", "content": "{\"price\": 100, \"tax\": 0.1}"}, {"role": "assistant", "content": "110.0"}]}
 ```
 
+## 🌊 Auto-Injection (Zero-Code Change Integration)
+
+You don't need to modify your business logic to use VectorWave. Use `VectorWaveAutoInjector` to inject functionality externally.
+
+### How to use
+
+1. **Configure Global Settings**: Set default values like `team`, `priority`, or `auto` (pending mode).
+2. **Inject Modules**: Specify the target module path string.
+
+```python
+from vectorwave import initialize_database, VectorWaveAutoInjector, generate_and_register_metadata
+
+# 1. Initialize DB
+initialize_database()
+
+# 2. Configure AutoInjector (Global Settings)
+VectorWaveAutoInjector.configure(
+    team="billing-team",
+    priority=1,
+    auto=True  # True: Collect metadata in memory (Pending), False: Save immediately to DB
+)
+
+# 3. Inject VectorWave into your module
+# (No need to add @vectorize decorators in 'my_service.payment' code!)
+VectorWaveAutoInjector.inject("my_service.payment")
+
+# 4. Register Metadata (If auto=True)
+generate_and_register_metadata()
+
+# 5. Run your business logic
+import my_service.payment
+my_service.payment.process_transaction()
+```
+
 ## 🤝 Contributing
 
 We welcome all forms of contributions, including bug reports, feature requests, and code contributions. Please refer to [CONTRIBUTING.md](https://www.google.com/search?q=httpsS://www.google.com/search%3Fq%3DCONTRIBUTING.md) for details.

{vectorwave-0.2.3 → vectorwave-0.2.4}/src/vectorwave.egg-info/SOURCES.txt

@@ -8,6 +8,8 @@ src/tests/conftest.py
 src/tests/batch/__init__.py
 src/tests/batch/test_batch.py
 src/tests/core/__init__.py
+src/tests/core/test_auto_injector.py
+src/tests/core/test_auto_injector_real.py
 src/tests/core/test_decorator.py
 src/tests/core/test_semantic_caching.py
 src/tests/core/llm/__init__.py
@@ -44,6 +46,7 @@ src/vectorwave.egg-info/top_level.txt
 src/vectorwave/batch/__init__.py
 src/vectorwave/batch/batch.py
 src/vectorwave/core/__init__.py
+src/vectorwave/core/auto_injector.py
 src/vectorwave/core/core.py
 src/vectorwave/core/decorator.py
 src/vectorwave/core/generator.py