vectorwave 0.1.8__tar.gz → 0.2.0__tar.gz

{vectorwave-0.1.8/src/vectorwave.egg-info → vectorwave-0.2.0}/PKG-INFO

@@ -1,10 +1,10 @@
 Metadata-Version: 2.4
 Name: vectorwave
-Version: 0.1.8
+Version: 0.2.0
 Summary: VectorWave: Seamless Auto-Vectorization Framework
 Author-email: junyeonggim <junyeonggim5@gmail.com>
 License-Expression: MIT
-Project-URL: Repository, https://github.com/republicofgamja/vtm
+Project-URL: Repository, https://github.com/cozymori/vectorwave
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -130,62 +130,56 @@ process_payment("user_789", 5000)
 
 To use the LLM feature, you must specify dependencies and environment variables.
 
-> #### Prerequisites for AI Auto-Documentation
->
-> To use the AI-powered documentation feature, you must have the `openai` library installed and configure your API key.
->
-> 1.  **Install Library:**
-      >
-      >     ```bash
->     pip install openai
->     ```
->
-> 2.  **Set API Key:** Add your valid OpenAI API key to your `.env` file.
-      >
-      >     ```text
->     OPENAI_API_KEY="sk-proj-YOUR_API_KEY_HERE"
->     # WEAVIATE_GENERATIVE_MODULE="generative-openai" (Required to enable the Weaviate module when using OpenAI LLM)
->     ```
+#### Prerequisites for AI Auto-Documentation
+
+To use the AI-powered documentation feature, you must have the `openai` library installed and configure your API key.
+
+1. **Install Library:**
+    ```bash
+    pip install openai
+    ```
+
+2. **Set API Key:** Add your valid OpenAI API key to your `.env` file.
+    ```ini
+    OPENAI_API_KEY="sk-proj-YOUR_API_KEY_HERE"
+    # WEAVIATE_GENERATIVE_MODULE="generative-openai" (Required to enable the Weaviate module when using OpenAI LLM)
+    ```
 
 ### 2.2. 🚀 Usage: Auto-Generating Function Metadata (Auto=True)
 
 Instead of manually defining `search_description` and `sequence_narrative`, you can use the `auto=True` flag.
 
-> #### 3\. Automatic Function Metadata Generation (Auto=True)
->
-> You can use the `auto=True` flag instead of manually defining `search_description` and `sequence_narrative`.
->
-> 1.  **Mark Function:** Set `auto=True`. It is **strongly recommended to include a detailed Docstring** to enhance the LLM's analysis quality.
-      >
-      >     ```python
->     # Code from vectorwave/test_ex/example.py
->     @vectorize(auto=True, team="loyalty-program")
->     def calculate_loyalty_points(purchase_amount: int, is_vip: bool):
->         """
->         Function to calculate loyalty points based on purchase amount.
->         VIP customers earn double points.
->         """
->         points = purchase_amount // 10
->         if is_vip:
->             points *= 2
->         return {"points": points, "tier": "VIP" if is_vip else "Regular"}
->     ```
->
-> 2.  **Trigger Generation:** Call `generate_and_register_metadata()` **immediately after** all `@vectorize` function definitions are complete. This function calls the LLM, vectorizes the generated metadata, and registers it to the DB.
-      >
-      >     ```python
->     # ... (After defining the calculate_loyalty_points function above)
->     ```
-
-> ````
-> # [Mandatory] Must be called after all function definitions are complete.
-> print("🚀 Checking for functions needing auto-documentation...")
-> generate_and_register_metadata()
-> ```
-> ````
->
-> *Note: Since this process involves LLM API calls, it can cause **latency** if run during server startup. It is recommended to execute this via a separate management script or an admin API endpoint in a production environment.*
+#### 3. Automatic Function Metadata Generation (Auto=True)
+
+You can use the `auto=True` flag instead of manually defining `search_description` and `sequence_narrative`.
+
+1. **Mark Function:** Set `auto=True`. It is **strongly recommended to include a detailed Docstring** to enhance the LLM's analysis quality.
+
+    ```python
+    # Code from vectorwave/test_ex/example.py
+    @vectorize(auto=True, team="loyalty-program")
+    def calculate_loyalty_points(purchase_amount: int, is_vip: bool):
+        """
+        Function to calculate loyalty points based on purchase amount.
+        VIP customers earn double points.
+        """
+        points = purchase_amount // 10
+        if is_vip:
+            points *= 2
+        return {"points": points, "tier": "VIP" if is_vip else "Regular"}
+    ```
+
+2. **Trigger Generation:** Call `generate_and_register_metadata()` **immediately after** all `@vectorize` function definitions are complete. This function calls the LLM, vectorizes the generated metadata, and registers it to the DB.
+
+    ```python
+    # ... (After defining the calculate_loyalty_points function above)
+
+    # [Mandatory] Must be called after all function definitions are complete.
+    print("🚀 Checking for functions needing auto-documentation...")
+    generate_and_register_metadata()
+    ```
 
+> **Note:** Since this process involves LLM API calls, it can cause **latency** if run during server startup. It is recommended to execute this via a separate management script or an admin API endpoint in a production environment.
 -----
 
 #### Semantic Caching Example

{vectorwave-0.1.8 → vectorwave-0.2.0}/Readme.md

@@ -104,62 +104,56 @@ process_payment("user_789", 5000)
 
 To use the LLM feature, you must specify dependencies and environment variables.
 
-> #### Prerequisites for AI Auto-Documentation
->
-> To use the AI-powered documentation feature, you must have the `openai` library installed and configure your API key.
->
-> 1.  **Install Library:**
-      >
-      >     ```bash
->     pip install openai
->     ```
->
-> 2.  **Set API Key:** Add your valid OpenAI API key to your `.env` file.
-      >
-      >     ```text
->     OPENAI_API_KEY="sk-proj-YOUR_API_KEY_HERE"
->     # WEAVIATE_GENERATIVE_MODULE="generative-openai" (Required to enable the Weaviate module when using OpenAI LLM)
->     ```
+#### Prerequisites for AI Auto-Documentation
+
+To use the AI-powered documentation feature, you must have the `openai` library installed and configure your API key.
+
+1. **Install Library:**
+    ```bash
+    pip install openai
+    ```
+
+2. **Set API Key:** Add your valid OpenAI API key to your `.env` file.
+    ```ini
+    OPENAI_API_KEY="sk-proj-YOUR_API_KEY_HERE"
+    # WEAVIATE_GENERATIVE_MODULE="generative-openai" (Required to enable the Weaviate module when using OpenAI LLM)
+    ```
 
 ### 2.2. 🚀 Usage: Auto-Generating Function Metadata (Auto=True)
 
 Instead of manually defining `search_description` and `sequence_narrative`, you can use the `auto=True` flag.
 
-> #### 3\. Automatic Function Metadata Generation (Auto=True)
->
-> You can use the `auto=True` flag instead of manually defining `search_description` and `sequence_narrative`.
->
-> 1.  **Mark Function:** Set `auto=True`. It is **strongly recommended to include a detailed Docstring** to enhance the LLM's analysis quality.
-      >
-      >     ```python
->     # Code from vectorwave/test_ex/example.py
->     @vectorize(auto=True, team="loyalty-program")
->     def calculate_loyalty_points(purchase_amount: int, is_vip: bool):
->         """
->         Function to calculate loyalty points based on purchase amount.
->         VIP customers earn double points.
->         """
->         points = purchase_amount // 10
->         if is_vip:
->             points *= 2
->         return {"points": points, "tier": "VIP" if is_vip else "Regular"}
->     ```
->
-> 2.  **Trigger Generation:** Call `generate_and_register_metadata()` **immediately after** all `@vectorize` function definitions are complete. This function calls the LLM, vectorizes the generated metadata, and registers it to the DB.
-      >
-      >     ```python
->     # ... (After defining the calculate_loyalty_points function above)
->     ```
-
-> ````
-> # [Mandatory] Must be called after all function definitions are complete.
-> print("🚀 Checking for functions needing auto-documentation...")
-> generate_and_register_metadata()
-> ```
-> ````
->
-> *Note: Since this process involves LLM API calls, it can cause **latency** if run during server startup. It is recommended to execute this via a separate management script or an admin API endpoint in a production environment.*
+#### 3. Automatic Function Metadata Generation (Auto=True)
+
+You can use the `auto=True` flag instead of manually defining `search_description` and `sequence_narrative`.
+
+1. **Mark Function:** Set `auto=True`. It is **strongly recommended to include a detailed Docstring** to enhance the LLM's analysis quality.
+
+    ```python
+    # Code from vectorwave/test_ex/example.py
+    @vectorize(auto=True, team="loyalty-program")
+    def calculate_loyalty_points(purchase_amount: int, is_vip: bool):
+        """
+        Function to calculate loyalty points based on purchase amount.
+        VIP customers earn double points.
+        """
+        points = purchase_amount // 10
+        if is_vip:
+            points *= 2
+        return {"points": points, "tier": "VIP" if is_vip else "Regular"}
+    ```
+
+2. **Trigger Generation:** Call `generate_and_register_metadata()` **immediately after** all `@vectorize` function definitions are complete. This function calls the LLM, vectorizes the generated metadata, and registers it to the DB.
+
+    ```python
+    # ... (After defining the calculate_loyalty_points function above)
+
+    # [Mandatory] Must be called after all function definitions are complete.
+    print("🚀 Checking for functions needing auto-documentation...")
+    generate_and_register_metadata()
+    ```
 
+> **Note:** Since this process involves LLM API calls, it can cause **latency** if run during server startup. It is recommended to execute this via a separate management script or an admin API endpoint in a production environment.
 -----
 
 #### Semantic Caching Example

{vectorwave-0.1.8 → vectorwave-0.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "vectorwave"
-version = "0.1.8"
+version = "0.2.0"
 authors = [
     { name = "junyeonggim", email = "junyeonggim5@gmail.com" },
 ]
@@ -32,7 +32,7 @@ dependencies = [
 ]
 
 [project.urls]
-Repository = "https://github.com/republicofgamja/vtm"
+Repository = "https://github.com/cozymori/vectorwave"
 
 [tool.setuptools.packages.find]
 where = ["src"]

{vectorwave-0.1.8 → vectorwave-0.2.0}/src/tests/core/test_semantic_caching.py

@@ -14,6 +14,8 @@ from vectorwave.batch.batch import get_batch_manager as real_get_batch_manager
 from vectorwave.database.db import get_cached_client as real_get_cached_client
 from vectorwave.models.db_config import get_weaviate_settings as real_get_settings
 from vectorwave.vectorizer.factory import get_vectorizer as real_get_vectorizer
+from vectorwave.monitoring.tracer import _create_input_vector_data
+
 
 # --- Fixture Setup ---
 
@@ -326,7 +328,6 @@ def test_tracer_input_vector_data_and_masking(mock_caching_deps):
     """
     Tests that the _create_input_vector_data function masks sensitive keys.
     """
-    from vectorwave.monitoring.tracer import _create_input_vector_data
 
     # Arrange: settings has sensitive_keys={"secret_key"}
     settings = mock_caching_deps["settings"]
@@ -343,10 +344,12 @@ def test_tracer_input_vector_data_and_masking(mock_caching_deps):
     text_content = input_data["text"]
     assert "test_func" in text_content
     assert "amount" in text_content
-    assert "[MASKED]" in text_content
+
+    assert "[MASKED]" not in text_content
+    assert "secret_key" not in text_content
     assert "my_top_secret" not in text_content
 
-    # 2. Verification: Check if masking is included in the properties dictionary
+    # 2. Verification: Check stored properties
     props = input_data["properties"]
     assert props["function"] == "test_func"
     assert props["kwargs"]["amount"] == 100

{vectorwave-0.1.8 → vectorwave-0.2.0}/src/tests/search/test_execution_search.py

@@ -54,7 +54,6 @@ mock_db_errors = [
     {"timestamp_utc": (mock_now - timedelta(minutes=15)).isoformat(), "error_code": "INVALID_INPUT"},  # Too old
 ]
 
-
 # [Core Fix] Create mock datetime class
 # Replaces the datetime.datetime class itself.
 MockDateTime = MagicMock()
@@ -80,10 +79,31 @@ def test_find_recent_errors(mock_find_executions):
     filters_arg = call_args.kwargs['filters']
 
     assert filters_arg['status'] == 'ERROR'
-    assert filters_arg['error_code'] == 'INVALID_INPUT'
+    assert filters_arg['error_code'] == ['INVALID_INPUT']
     assert filters_arg['timestamp_utc__gte'] == expected_time_limit_iso
 
 
+@patch('vectorwave.search.execution_search.datetime', MockDateTime)
+@patch('vectorwave.search.execution_search.find_executions')
+def test_find_recent_errors_multi_code(mock_find_executions):
+    """
+    Tests if find_recent_errors handles multiple error codes correctly by passing the list.
+    (Tests the newly implemented multi-code filtering path)
+    """
+    error_list = ["INVALID_INPUT", "TIMEOUT_ERROR"]
+    find_recent_errors(minutes_ago=20, limit=5, error_codes=error_list)
+
+    call_args = mock_find_executions.call_args
+    filters_arg = call_args.kwargs['filters']
+
+    assert filters_arg['status'] == 'ERROR'
+    assert filters_arg['error_code'] == error_list
+    assert call_args.kwargs['limit'] == 5
+
+    expected_time_limit_iso_20 = (mock_now - timedelta(minutes=20)).isoformat()
+    assert filters_arg['timestamp_utc__gte'] == expected_time_limit_iso_20
+
+
 @patch('vectorwave.search.execution_search.find_executions')
 def test_find_slowest_executions(mock_find_executions):
     """
@@ -122,4 +142,4 @@ def test_find_by_trace_id(mock_find_executions):
     # 2. Verify sort order (time ascending)
     assert call_args.kwargs['sort_by'] == 'timestamp_utc'
     assert call_args.kwargs['sort_ascending'] == True
-    assert call_args.kwargs['limit'] == 100
+    assert call_args.kwargs['limit'] == 100

{vectorwave-0.1.8 → vectorwave-0.2.0}/src/tests/utils/test_replayer.py

@@ -1,5 +1,7 @@
 import pytest
 import json
+import asyncio
+import inspect
 from unittest.mock import MagicMock, patch
 from vectorwave.utils.replayer import VectorWaveReplayer
 
@@ -194,4 +196,46 @@ def test_replay_argument_filtering(mock_replayer_deps):
 
     # Assert
     # Should only be called with 'a=10', excluding 'team' and 'priority'
-    mock_func.assert_called_once_with(a=10)
+    mock_func.assert_called_once_with(a=10)
+
+def test_replay_async_function_execution_fixed(mock_replayer_deps):
+    """
+    [Case 5] Async Function Test (FIXED): Tests the async execution path using patching
+    of the import mechanism and executing the actual async function via asyncio.run.
+    """
+    # Arrange
+    replayer = VectorWaveReplayer()
+
+    # 1. DB Mock Data
+    inputs = {"a": 1, "b": 2}
+    expected_result = 3
+    mock_logs = [create_mock_log("uuid-async-1", inputs, expected_result)]
+    mock_replayer_deps["query"].fetch_objects.return_value.objects = mock_logs
+
+    # 2. Define the actual ASYNC function for replayer to execute
+    async def real_async_add(a, b):
+        # This function will be called and executed by asyncio.run
+        await asyncio.sleep(0.001)
+        return a + b
+
+    # Manually attach the signature for the replayer's inspection check to pass
+    setattr(real_async_add, '__signature__', inspect.Signature([
+        inspect.Parameter('a', inspect.Parameter.POSITIONAL_OR_KEYWORD),
+        inspect.Parameter('b', inspect.Parameter.POSITIONAL_OR_KEYWORD)
+    ]))
+
+    # 3. Patch importlib.import_module to return a mock module that contains the target function
+    mock_module = MagicMock()
+    mock_module.async_add = real_async_add # The mock module must have the function
+
+    with patch("vectorwave.utils.replayer.importlib.import_module", return_value=mock_module):
+
+        # Act
+        # replayer.replay (sync function) calls asyncio.run(real_async_add(**inputs)) internally.
+        result = replayer.replay("my_module.async_add", limit=1)
+
+    # Assert
+    # 1. The result should be successful and match the expected output
+    assert result["passed"] == 1
+    assert result["failed"] == 0
+    assert result["failures"] == []

vectorwave-0.2.0/src/tests/utils/test_return_caching.py

@@ -0,0 +1,126 @@
+import pytest
+from unittest.mock import MagicMock, patch
+import json
+from vectorwave.utils.return_caching_utils import _check_and_return_cached_result
+from vectorwave.models.db_config import WeaviateSettings
+
+
+# --- Mock Fixtures ---
+
+@pytest.fixture
+def mock_caching_utils_deps(monkeypatch):
+    """
+    Mocks external dependencies of return_caching_utils.py (BatchManager, Tracer, DB search, etc.).
+    """
+    # 1. Mock Settings
+    mock_settings = WeaviateSettings(
+        EXECUTION_COLLECTION_NAME="TestExecutions",
+        global_custom_values={"run_id": "test-run-123"}
+    )
+    mock_get_settings = MagicMock(return_value=mock_settings)
+
+    # 2. Mock Batch Manager (Key verification target)
+    mock_batch_manager = MagicMock()
+    mock_batch_manager.add_object = MagicMock()
+    mock_get_batch = MagicMock(return_value=mock_batch_manager)
+
+    # 3. Mock Vectorizer
+    mock_vectorizer = MagicMock()
+    mock_vectorizer.embed.return_value = [0.1, 0.2, 0.3]  # Dummy Vector
+    mock_get_vectorizer = MagicMock(return_value=mock_vectorizer)
+
+    # 4. Mock Tracer Context (Provides current Trace ID)
+    mock_tracer = MagicMock()
+    mock_tracer.trace_id = "existing-trace-id-abc"
+
+    # 5. Apply Monkeypatches
+    TARGET_MODULE = "vectorwave.utils.return_caching_utils"
+
+    monkeypatch.setattr(f"{TARGET_MODULE}.get_weaviate_settings", mock_get_settings)
+    monkeypatch.setattr(f"{TARGET_MODULE}.get_batch_manager", mock_get_batch)
+    monkeypatch.setattr(f"{TARGET_MODULE}.get_vectorizer", mock_get_vectorizer)
+
+    return {
+        "batch_manager": mock_batch_manager,
+        "vectorizer": mock_vectorizer,
+        "tracer_obj": mock_tracer
+    }
+
+
+def test_check_and_return_cached_result_cache_hit_logging(mock_caching_utils_deps):
+    """
+    [Case 1] Verify that DB logging is correctly performed with 'CACHE_HIT' status upon a cache hit.
+    """
+    # Arrange
+    # 1. Mock cache search result (Log found in DB)
+    mock_cached_log = {
+        "return_value": json.dumps({"result": "cached_data"}),
+        "metadata": {"distance": 0.1},
+        "uuid": "cached-log-uuid"
+    }
+
+    # 2. Mock search_similar_execution to return the above result (Simulate Cache Hit)
+    with patch("vectorwave.utils.return_caching_utils.search_similar_execution", return_value=mock_cached_log):
+        # [Fix] Instead of directly patching the .get method of the ContextVar object, replace the variable itself with a Mock object.
+        with patch("vectorwave.utils.return_caching_utils.current_tracer_var") as mock_tracer_var:
+            with patch("vectorwave.utils.return_caching_utils.current_span_id_var") as mock_span_var:
+                # Set return value for .get() call on the Mock object
+                mock_tracer_var.get.return_value = mock_caching_utils_deps["tracer_obj"]
+                mock_span_var.get.return_value = "parent-span-123"
+
+                # 4. Execute the target function
+                def dummy_func(a, b): pass  # Target function
+
+                result = _check_and_return_cached_result(
+                    func=dummy_func,
+                    args=(10,),
+                    kwargs={"b": 20},
+                    function_name="dummy_func",
+                    cache_threshold=0.9,
+                    is_async=False
+                )
+
+    # Assert
+    # 1. Was the cached result returned correctly?
+    assert result == {"result": "cached_data"}
+
+    # 2. [Core] Was BatchManager.add_object called? (Check if logging occurred)
+    mock_batch = mock_caching_utils_deps["batch_manager"]
+    mock_batch.add_object.assert_called_once()
+
+    # 3. [Core] Verify properties of the saved log
+    call_kwargs = mock_batch.add_object.call_args.kwargs
+    props = call_kwargs["properties"]
+
+    assert props["status"] == "CACHE_HIT"  # Check if status is CACHE_HIT
+    assert props["duration_ms"] == 0.0  # Check if duration is 0
+    assert props["trace_id"] == "existing-trace-id-abc"  # Check if existing Trace ID is maintained
+    assert props["parent_span_id"] == "parent-span-123"  # Check for parent Span ID maintenance
+    assert props["function_name"] == "dummy_func"
+    assert props["run_id"] == "test-run-123"  # Check for inclusion of global tags
+
+
+def test_check_and_return_cached_result_cache_miss(mock_caching_utils_deps):
+    """
+    [Case 2] Verify that None is returned without logging upon a cache miss.
+    """
+    # Arrange
+    # Set search_similar_execution to return None (Cache Miss)
+    with patch("vectorwave.utils.return_caching_utils.search_similar_execution", return_value=None):
+        def dummy_func(): pass
+
+        result = _check_and_return_cached_result(
+            func=dummy_func,
+            args=(),
+            kwargs={},
+            function_name="dummy_func",
+            cache_threshold=0.9,
+            is_async=False
+        )
+
+    # Assert
+    # 1. Result should be None (To proceed to actual function execution)
+    assert result is None
+
+    # 2. BatchManager.add_object should not be called
+    mock_caching_utils_deps["batch_manager"].add_object.assert_not_called()

vectorwave-0.2.0/src/tests/utils/test_status.py

@@ -0,0 +1,126 @@
+import pytest
+from unittest.mock import MagicMock, patch
+from vectorwave.utils.status import get_db_status, get_registered_functions
+from vectorwave.models.db_config import WeaviateSettings
+
+# --- Fixtures ---
+
+@pytest.fixture
+def mock_status_deps(monkeypatch):
+    """
+    Mocks dependencies of status.py (get_cached_client, get_weaviate_settings).
+    """
+    # 1. Mock Weaviate Client
+    mock_client = MagicMock()
+    mock_get_client = MagicMock(return_value=mock_client)
+
+    # 2. Mock Settings
+    mock_settings = WeaviateSettings(COLLECTION_NAME="TestFunctions")
+    mock_get_settings = MagicMock(return_value=mock_settings)
+
+    # 3. Apply Patches
+    monkeypatch.setattr("vectorwave.utils.status.get_cached_client", mock_get_client)
+    monkeypatch.setattr("vectorwave.utils.status.get_weaviate_settings", mock_get_settings)
+
+    return {
+        "client": mock_client,
+        "settings": mock_settings,
+        "get_client": mock_get_client
+    }
+
+# --- Tests for get_db_status ---
+
+def test_get_db_status_ready(mock_status_deps):
+    """
+    Case 1: Test if True is returned when DB is connected and ready.
+    """
+    mock_status_deps["client"].is_ready.return_value = True
+
+    assert get_db_status() is True
+    mock_status_deps["client"].is_ready.assert_called_once()
+
+def test_get_db_status_not_ready(mock_status_deps):
+    """
+    Case 2: Test if False is returned when DB is connected but not ready.
+    """
+    mock_status_deps["client"].is_ready.return_value = False
+
+    assert get_db_status() is False
+
+def test_get_db_status_exception(mock_status_deps):
+    """
+    Case 3: Test if False is returned and error is logged when an exception occurs during DB connection.
+    """
+    # Set exception to occur on client call
+    mock_status_deps["get_client"].side_effect = Exception("Connection Error")
+
+    assert get_db_status() is False
+
+# --- Tests for get_registered_functions ---
+
+@patch("vectorwave.utils.status.get_db_status")
+def test_get_registered_functions_db_offline(mock_get_db_status, mock_status_deps):
+    """
+    Case 4: Test if an empty list is returned when DB is offline (False).
+    """
+    mock_get_db_status.return_value = False
+
+    result = get_registered_functions()
+
+    assert result == []
+    # Should not access client or collection if DB is offline
+    mock_status_deps["client"].collections.get.assert_not_called()
+
+@patch("vectorwave.utils.status.get_db_status")
+def test_get_registered_functions_success(mock_get_db_status, mock_status_deps):
+    """
+    Case 5: Test if the list of registered functions is returned correctly.
+    """
+    # 1. Arrange
+    mock_get_db_status.return_value = True
+
+    # Mock collection and query results
+    mock_collection = MagicMock()
+    mock_status_deps["client"].collections.get.return_value = mock_collection
+
+    # Create fake Weaviate objects
+    obj1 = MagicMock()
+    obj1.properties = {"function_name": "func_a", "module_name": "mod_a"}
+    obj2 = MagicMock()
+    obj2.properties = {"function_name": "func_b", "module_name": "mod_b"}
+
+    # Mock result of fetch_objects call
+    mock_collection.iterator.return_value = [obj1, obj2]
+
+    # 2. Act
+    result = get_registered_functions()
+
+    # 3. Assert
+    assert len(result) == 2
+    assert result[0]["function_name"] == "func_a"
+    assert result[1]["function_name"] == "func_b"
+
+    # Verify correct name usage when retrieving collection
+    mock_status_deps["client"].collections.get.assert_called_with("TestFunctions")
+
+    mock_collection.iterator.assert_called_once()
+    call_kwargs = mock_collection.iterator.call_args.kwargs
+    assert "return_properties" in call_kwargs
+    assert "function_name" in call_kwargs["return_properties"]
+
+@patch("vectorwave.utils.status.get_db_status")
+def test_get_registered_functions_exception(mock_get_db_status, mock_status_deps):
+    """
+    Case 6: Test if an empty list is returned and error is handled when an exception occurs during retrieval.
+    """
+    # 1. Arrange
+    mock_get_db_status.return_value = True
+
+    # Induce exception during collection retrieval
+    mock_status_deps["client"].collections.get.side_effect = Exception("Query Failed")
+
+    # 2. Act
+    result = get_registered_functions()
+
+    # 3. Assert
+    assert result == []

{vectorwave-0.1.8 → vectorwave-0.2.0}/src/vectorwave/__init__.py

@@ -5,6 +5,9 @@ from .database.db_search import search_functions, search_executions, search_erro
 from .monitoring.tracer import trace_span
 from .search.rag_search import search_and_answer, analyze_trace_log
 from .core.generator import generate_and_register_metadata
+from .utils.healer import VectorWaveHealer
+from .utils.replayer import VectorWaveReplayer
+from .utils.replayer_semantic import SemanticReplayer
 
 __all__ = [
     'vectorize',
@@ -16,5 +19,8 @@ __all__ = [
     'trace_span',
     'search_and_answer',
     'analyze_trace_log',
-    'generate_and_register_metadata'
+    'generate_and_register_metadata',
+    'VectorWaveHealer',
+    'VectorWaveReplayer',
+    'SemanticReplayer'
 ]