vectorwave 0.1.9__tar.gz → 0.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectorwave
-Version: 0.1.9
+Version: 0.2.0
 Summary: VectorWave: Seamless Auto-Vectorization Framework
 Author-email: junyeonggim <junyeonggim5@gmail.com>
 License-Expression: MIT

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

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

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.1.9 → 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'
 ]

{vectorwave-0.1.9 → vectorwave-0.2.0}/src/vectorwave/database/db_search.py

@@ -409,3 +409,55 @@ def check_semantic_drift(
     except Exception as e:
         logger.error(f"Failed to check semantic drift: {e}")
         return False, 0.0, None
+
+
+def simulate_drift_check(
+        text: str,
+        function_name: str,
+        threshold: Optional[float] = None,
+        k: Optional[int] = None
+) -> Dict[str, Any]:
+    """
+    Simulates drift detection for a hypothetical input string without executing the function.
+    Useful for 'Drift Radar' or debugging.
+    """
+    try:
+        settings = get_weaviate_settings()
+        vectorizer = get_vectorizer()
+
+        if not vectorizer:
+            return {"error": "No vectorizer configured."}
+
+        # 1. Set defaults from settings if not provided
+        if threshold is None:
+            threshold = settings.DRIFT_DISTANCE_THRESHOLD
+        if k is None:
+            k = settings.DRIFT_NEIGHBOR_AMOUNT
+
+        # 2. Vectorize the input text
+        try:
+            vector = vectorizer.embed(text)
+        except Exception as e:
+            return {"error": f"Vectorization failed: {e}"}
+
+        # 3. Perform the check using the existing logic
+        is_drift, avg_distance, nearest_uuid = check_semantic_drift(
+            vector=vector,
+            function_name=function_name,
+            threshold=threshold,
+            k=k
+        )
+
+        return {
+            "function_name": function_name,
+            "input_text": text,
+            "is_drift": is_drift,
+            "avg_distance": avg_distance,
+            "threshold": threshold,
+            "nearest_neighbor_uuid": nearest_uuid,
+            "status": "ANOMALY" if is_drift else "NORMAL"
+        }
+
+    except Exception as e:
+        logger.error(f"Simulation failed: {e}")
+        return {"error": str(e)}

{vectorwave-0.1.9 → vectorwave-0.2.0}/src/vectorwave/utils/replayer.py

@@ -5,6 +5,8 @@ import traceback
 import inspect
 from typing import Any, Dict, List, Optional
 import asyncio
+import difflib
+import pprint
 
 import weaviate.classes.query as wvc_query
 
@@ -33,6 +35,7 @@ class VectorWaveReplayer:
                update_baseline: bool = False) -> Dict[str, Any]:
         """
         Retrieves past execution history of a specific function, re-executes it (Replay), and validates the result.
+        Returns a dictionary containing diff_html for UI visualization.
         """
         # 1. Dynamic Function Loading (Dynamic Import)
         try:
@@ -72,7 +75,7 @@ class VectorWaveReplayer:
             logger.warning(f"No data found to test: {function_full_name}")
             return results
 
-        print(f"🔄 Replaying {len(response.objects)} logs for '{function_full_name}'...")
+        logger.info(f"Starting Replay: {len(response.objects)} logs for '{function_full_name}'")
 
         for obj in response.objects:
             results["total"] += 1
@@ -92,37 +95,46 @@ class VectorWaveReplayer:
 
                 if is_match:
                     results["passed"] += 1
+                    logger.debug(f"UUID {obj.uuid}: PASSED")
                 else:
                     # 5. Handle Mismatch
                     if update_baseline:
                         self._update_baseline_value(collection, obj.uuid, actual_output)
                         results["updated"] += 1
                         results["passed"] += 1
-                        print(f"  ⚠️ [Updated] UUID {obj.uuid} result updated.")
+                        logger.info(f"UUID {obj.uuid}: Baseline UPDATED")
                     else:
                         results["failed"] += 1
+
+                        # Generate Visual Diff
+                        diff_html = self._generate_diff_html(expected_output, actual_output)
+
                         results["failures"].append({
                             "uuid": str(obj.uuid),
                             "inputs": inputs,
                             "expected": expected_output,
-                            "actual": actual_output
+                            "actual": actual_output,
+                            "diff_html": diff_html  # UI visualization field
                         })
-                        print(f"  ❌ [Failed] UUID {obj.uuid} | Expected: {expected_output} != Actual: {actual_output}")
+                        logger.warning(f"UUID {obj.uuid}: FAILED (Mismatch)")
 
             except Exception as e:
-
                 results["failed"] += 1
+                error_msg = f"Exception: {str(e)}"
+                logger.error(f"UUID {obj.uuid}: EXECUTION ERROR - {e}")
 
                 results["failures"].append({
                     "uuid": str(obj.uuid),
                     "inputs": inputs,
-                    "expected": expected_output,  # <-- Added
-                    "actual": "EXCEPTION_RAISED",  # <-- Added
-                    "error": str(e),
+                    "expected": expected_output,
+                    "actual": "EXCEPTION_RAISED",
+                    "error": error_msg,
+                    "diff_html": f"<div class='error' style='color:red; padding:10px; border:1px solid red; background:#fff0f0;"
+                                 f"'><strong>Runtime Error:</strong><pre>{traceback.format_exc()}</pre></div>",
                     "traceback": traceback.format_exc()
                 })
-                print(f"  ❌ [Error] UUID {obj.uuid} exception occurred during execution: {e}")
 
+        logger.info(f"Replay Finished. Passed: {results['passed']}, Failed: {results['failed']}, Updated: {results['updated']}")
         return results
 
     def _extract_inputs(self, props: Dict[str, Any], target_func: callable) -> Dict[str, Any]:
@@ -180,3 +192,20 @@ class VectorWaveReplayer:
             )
         except Exception as e:
             logger.error(f"Failed to update baseline for {uuid}: {e}")
+
+    def _generate_diff_html(self, expected: Any, actual: Any) -> str:
+        """Generates a side-by-side HTML diff table."""
+        # Pretty print for better diff comparison
+        exp_str = pprint.pformat(expected, width=80)
+        act_str = pprint.pformat(actual, width=80)
+
+        # Generate HTML table
+        diff_html = difflib.HtmlDiff(wrapcolumn=80).make_table(
+            fromlines=exp_str.splitlines(),
+            tolines=act_str.splitlines(),
+            fromdesc='Expected (Baseline)',
+            todesc='Actual (Current)',
+            context=True,  # Show only context around changes
+            numlines=3
+        )
+        return diff_html

{vectorwave-0.1.9 → vectorwave-0.2.0}/src/vectorwave/utils/replayer_semantic.py

@@ -1,10 +1,11 @@
+import importlib
 import json
 import logging
 import traceback
 import math
 import asyncio
 import inspect
-from typing import Any, Dict, Optional
+from typing import Any, Dict, List, Optional
 
 import weaviate.classes.query as wvc_query
 
@@ -23,6 +24,7 @@ class SemanticReplayer(VectorWaveReplayer):
     """
     A subclass of VectorWaveReplayer that adds AI-powered semantic comparison capabilities.
     It supports Vector Cosine Similarity and LLM-as-a-Judge evaluation.
+    Location: src/vectorwave/utils/replayer_semantic.py
     """
 
     def __init__(self):
@@ -39,22 +41,28 @@ class SemanticReplayer(VectorWaveReplayer):
                function_full_name: str,
                limit: int = 10,
                update_baseline: bool = False,
-               similarity_threshold: Optional[float] = None,  # [New]
-               semantic_eval: bool = False  # [New]
+               similarity_threshold: Optional[float] = None,
+               semantic_eval: bool = False
                ) -> Dict[str, Any]:
         """
-        Overridden replay method to support semantic comparison options.
+        Retrieves past execution history of a specific function, re-executes it (Replay),
+        and validates the result using semantic comparison options.
+        Returns a dictionary containing diff_html for UI visualization.
         """
-        # 1. Load Function dynamically (Reuse parent method logic if possible, but here we reimplement for clarity due to local vars)
-        target_func = self._load_target_function(function_full_name)
-        if isinstance(target_func, dict) and "error" in target_func:
-            return target_func
+        # 1. Dynamic Function Loading (Dynamic Import)
+        try:
+            module_name, func_short_name = function_full_name.rsplit('.', 1)
+            module = importlib.import_module(module_name)
+            target_func = getattr(module, func_short_name)
+        except (ValueError, ImportError, AttributeError) as e:
+            logger.error(f"Could not load function: {function_full_name}. Error: {e}")
+            return {"error": f"Function loading failed: {e}"}
 
         is_async_func = inspect.iscoroutinefunction(target_func)
-        func_short_name = function_full_name.rsplit('.', 1)[-1]
 
-        # 2. Retrieve Data
+        # 2. Retrieve Test Data (Past Logs) from DB
         collection = self.client.collections.get(self.collection_name)
+
         filters = (
                 wvc_query.Filter.by_property("function_name").equal(func_short_name) &
                 wvc_query.Filter.by_property("status").equal("SUCCESS")
@@ -79,25 +87,26 @@ class SemanticReplayer(VectorWaveReplayer):
             logger.warning(f"No data found to test: {function_full_name}")
             return results
 
-        print(f"🤖 [Semantic Replay] Testing {len(response.objects)} logs for '{function_full_name}'...")
+        logger.info(f"Starting Semantic Replay: {len(response.objects)} logs for '{function_full_name}'")
         if similarity_threshold:
-            print(f"   - Mode: Vector Similarity >= {similarity_threshold}")
+            logger.info(f"   - Mode: Vector Similarity >= {similarity_threshold}")
         if semantic_eval:
-            print(f"   - Mode: Semantic Evaluation (LLM-as-a-Judge)")
+            logger.info(f"   - Mode: Semantic Evaluation (LLM-as-a-Judge)")
 
         for obj in response.objects:
             results["total"] += 1
+
             inputs = self._extract_inputs(obj.properties, target_func)
             expected_output = self._deserialize_value(obj.properties.get("return_value"))
 
             try:
-                # 3. Re-execution
+                # 3. Function Re-execution
                 if is_async_func:
                     actual_output = asyncio.run(target_func(**inputs))
                 else:
                     actual_output = target_func(**inputs)
 
-                # 4. Enhanced Comparison
+                # 4. Result Validation (Semantic Comparison)
                 is_match, match_reason = self._compare_results_semantic(
                     expected_output,
                     actual_output,
@@ -107,50 +116,49 @@ class SemanticReplayer(VectorWaveReplayer):
 
                 if is_match:
                     results["passed"] += 1
+                    logger.debug(f"UUID {obj.uuid}: PASSED ({match_reason})")
                 else:
                     # 5. Handle Mismatch
                     if update_baseline:
                         self._update_baseline_value(collection, obj.uuid, actual_output)
                         results["updated"] += 1
                         results["passed"] += 1
-                        print(f"  ⚠️ [Updated] UUID {obj.uuid} baseline updated.")
+                        logger.info(f"UUID {obj.uuid}: Baseline UPDATED")
                     else:
                         results["failed"] += 1
+
+                        # Generate Visual Diff (inherited from parent)
+                        diff_html = self._generate_diff_html(expected_output, actual_output)
+
                         results["failures"].append({
                             "uuid": str(obj.uuid),
                             "inputs": inputs,
                             "expected": expected_output,
                             "actual": actual_output,
-                            "reason": match_reason
+                            "diff_html": diff_html,  # UI visualization field
+                            "reason": match_reason   # Semantic failure reason
                         })
-                        print(f"  ❌ [Failed] UUID {obj.uuid} | {match_reason}")
-                        print(f"     Expected: {str(expected_output)[:60]}...")
-                        print(f"     Actual:   {str(actual_output)[:60]}...")
+                        logger.warning(f"UUID {obj.uuid}: FAILED ({match_reason})")
 
             except Exception as e:
                 results["failed"] += 1
+                error_msg = f"Exception: {str(e)}"
+                logger.error(f"UUID {obj.uuid}: EXECUTION ERROR - {e}")
+
                 results["failures"].append({
                     "uuid": str(obj.uuid),
                     "inputs": inputs,
                     "expected": expected_output,
                     "actual": "EXCEPTION_RAISED",
-                    "error": str(e),
+                    "error": error_msg,
+                    "diff_html": f"<div class='error' style='color:red; padding:10px; border:1px solid red; background:#fff0f0;"
+                                 f"'><strong>Runtime Error:</strong><pre>{traceback.format_exc()}</pre></div>",
                     "traceback": traceback.format_exc()
                 })
-                print(f"  ❌ [Error] UUID {obj.uuid}: {e}")
 
+        logger.info(f"Replay Finished. Passed: {results['passed']}, Failed: {results['failed']}, Updated: {results['updated']}")
         return results
 
-    def _load_target_function(self, full_name: str):
-        """Helper to load function (Refactored from original code for reuse)"""
-        try:
-            import importlib
-            module_name, func_short_name = full_name.rsplit('.', 1)
-            module = importlib.import_module(module_name)
-            return getattr(module, func_short_name)
-        except Exception as e:
-            return {"error": str(e)}
-
     def _compare_results_semantic(self, expected: Any, actual: Any,
                                   similarity_threshold: Optional[float],
                                   semantic_eval: bool) -> tuple[bool, str]:
@@ -205,10 +213,10 @@ class SemanticReplayer(VectorWaveReplayer):
         prompt = f"""
         Compare two outputs. Are they semantically equivalent?
         Ignore minor formatting differences.
-        
+
         Expected: {expected}
         Actual: {actual}
-        
+
         Respond JSON: {{"equivalent": true}} or {{"equivalent": false}}
         """
         try:
@@ -221,4 +229,4 @@ class SemanticReplayer(VectorWaveReplayer):
             return json.loads(res.choices[0].message.content).get("equivalent", False)
         except Exception as e:
             logger.error(f"LLM Eval failed: {e}")
-            return False
+            return False

vectorwave-0.2.0/src/vectorwave/utils/return_caching_utils.py

@@ -0,0 +1,134 @@
+import logging
+from typing import Optional, Tuple, Any, Dict, Callable
+import json
+import inspect
+from functools import wraps
+from datetime import datetime, timezone
+from uuid import uuid4
+
+from weaviate.util import generate_uuid5
+
+from ..models.db_config import get_weaviate_settings, WeaviateSettings
+from ..monitoring.tracer import _create_input_vector_data, _deserialize_return_value, current_tracer_var, \
+    current_span_id_var
+from ..database.db_search import search_similar_execution
+from ..vectorizer.factory import get_vectorizer
+from ..batch.batch import get_batch_manager
+
+logger = logging.getLogger(__name__)
+
+
+def _check_and_return_cached_result(
+        func: Callable,
+        args: Tuple[Any, ...],
+        kwargs: Dict[str, Any],
+        function_name: str,
+        cache_threshold: float,
+        is_async: bool
+) -> Optional[Any]:
+    """
+    Checks the VectorWaveExecutions database for a semantically similar cached result.
+    If found, returns the deserialized result; otherwise, returns None.
+
+    This function should be called from the outer_wrapper of the @vectorize decorator.
+    """
+    if not cache_threshold:  # Check if caching is effectively disabled (threshold 0 or None)
+        return None
+
+    settings: WeaviateSettings = get_weaviate_settings()
+    vectorizer = get_vectorizer()
+
+    if vectorizer is None:
+        # This case should ideally be caught in decorator setup, but defensive check remains.
+        logger.error(f"Cannot perform vectorization for caching on '{function_name}': Vectorizer is None.")
+        return None
+
+    try:
+        # (A) Create vectorization data
+        input_vector_data = _create_input_vector_data(
+            func_name=function_name,
+            args=args,  # Original positional args
+            kwargs=kwargs,  # Original keyword args
+            sensitive_keys=settings.sensitive_keys
+        )
+
+        # (B) Vectorize (Synchronous call is fine, as vectorizer.embed is sync)
+        input_vector = vectorizer.embed(input_vector_data['text'])
+
+        # (C) Search Cache (Needs to handle the fact that search_similar_execution is sync)
+        cached_log = search_similar_execution(
+            query_vector=input_vector,
+            function_name=function_name,
+            threshold=cache_threshold
+        )
+
+        if cached_log:
+            distance = cached_log['metadata'].get('distance')
+            logger.info(
+                f"[Cache Hit] '{function_name}' skipped. "
+                f"Distance: {distance:.4f}, "
+                f"Trace ID: {cached_log['uuid'][:8]}..."
+            )
+
+            # (D) Log CACHE_HIT event to DB (Analysis Requirement)
+            try:
+                batch_manager = get_batch_manager()
+
+                # 1. Resolve Trace Context
+                tracer = current_tracer_var.get()
+                parent_span_id = current_span_id_var.get()
+
+                if tracer:
+                    trace_id = tracer.trace_id
+                else:
+                    # If cache hit happens at the root (no active tracer), generate new ID
+                    trace_id = str(uuid4())
+
+                # 2. Calculate function UUID (to link with metadata)
+                module_name = getattr(func, "__module__", "__main__")
+                func_identifier = f"{module_name}.{function_name}"
+                func_uuid = generate_uuid5(func_identifier)
+
+                # 3. Prepare properties
+                hit_properties = {
+                    "trace_id": trace_id,
+                    "span_id": str(uuid4()),
+                    "parent_span_id": parent_span_id,
+                    "function_name": function_name,
+                    "function_uuid": func_uuid,
+                    "timestamp_utc": datetime.now(timezone.utc).isoformat(),
+                    "duration_ms": 0.0,  # Zero duration for cache hits
+                    "status": "CACHE_HIT",
+                    "return_value": cached_log.get('return_value'),
+                }
+
+                # 4. Inject Global/Custom Tags
+                if settings.global_custom_values:
+                    hit_properties.update(settings.global_custom_values)
+
+                if settings.custom_properties:
+                    for key in settings.custom_properties:
+                        if key in kwargs:
+                            # Simple assignment for tags (complex masking not applied here for simplicity/perf)
+                            hit_properties[key] = kwargs[key]
+
+                # 5. Add to batch (Async logging)
+                batch_manager.add_object(
+                    collection=settings.EXECUTION_COLLECTION_NAME,
+                    properties=hit_properties,
+                    vector=input_vector  # Reuse the query vector
+                )
+
+            except Exception as log_e:
+                # Non-blocking error: logging failure should not prevent returning the cached result
+                logger.error(f"Failed to log CACHE_HIT for '{function_name}': {log_e}")
+
+            # (E) Deserialize and return the cached result
+            return _deserialize_return_value(cached_log.get('return_value'))
+
+        return None
+
+    except Exception as e:
+        logger.error(f"Failed to check semantic cache for '{function_name}': {e}", exc_info=True)
+        # Cache failure must not stop execution, so return None to proceed to actual function call.
+        return None

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vectorwave
-Version: 0.1.9
+Version: 0.2.0
 Summary: VectorWave: Seamless Auto-Vectorization Framework
 Author-email: junyeonggim <junyeonggim5@gmail.com>
 License-Expression: MIT

{vectorwave-0.1.9 → vectorwave-0.2.0}/src/vectorwave.egg-info/SOURCES.txt

@@ -28,6 +28,7 @@ src/tests/search/test_execution_search.py
 src/tests/utils/__init__.py
 src/tests/utils/test_function_cahe.py
 src/tests/utils/test_replayer.py
+src/tests/utils/test_return_caching.py
 src/tests/utils/test_status.py
 src/tests/vectorizer/__init__.py
 src/vectorwave/__init__.py

vectorwave-0.1.9/src/vectorwave/utils/return_caching_utils.py

@@ -1,76 +0,0 @@
-import logging
-from typing import Optional, Tuple, Any, Dict, Callable
-import json
-import inspect
-from functools import wraps
-
-from weaviate.util import generate_uuid5
-
-from ..models.db_config import get_weaviate_settings, WeaviateSettings
-from ..monitoring.tracer import _create_input_vector_data, _deserialize_return_value
-from ..database.db_search import search_similar_execution
-from ..vectorizer.factory import get_vectorizer
-
-logger = logging.getLogger(__name__)
-
-
-def _check_and_return_cached_result(
-        func: Callable,
-        args: Tuple[Any, ...],
-        kwargs: Dict[str, Any],
-        function_name: str,
-        cache_threshold: float,
-        is_async: bool
-) -> Optional[Any]:
-    """
-    Checks the VectorWaveExecutions database for a semantically similar cached result.
-    If found, returns the deserialized result; otherwise, returns None.
-
-    This function should be called from the outer_wrapper of the @vectorize decorator.
-    """
-    if not cache_threshold: # Check if caching is effectively disabled (threshold 0 or None)
-        return None
-
-    settings: WeaviateSettings = get_weaviate_settings()
-    vectorizer = get_vectorizer()
-
-    if vectorizer is None:
-        # This case should ideally be caught in decorator setup, but defensive check remains.
-        logger.error(f"Cannot perform vectorization for caching on '{function_name}': Vectorizer is None.")
-        return None
-
-    try:
-        # (A) Create vectorization data
-        input_vector_data = _create_input_vector_data(
-            func_name=function_name,
-            args=args, # Original positional args
-            kwargs=kwargs, # Original keyword args
-            sensitive_keys=settings.sensitive_keys
-        )
-
-        # (B) Vectorize (Synchronous call is fine, as vectorizer.embed is sync)
-        input_vector = vectorizer.embed(input_vector_data['text'])
-
-        # (C) Search Cache (Needs to handle the fact that search_similar_execution is sync)
-        cached_log = search_similar_execution(
-            query_vector=input_vector,
-            function_name=function_name,
-            threshold=cache_threshold
-        )
-
-        if cached_log:
-            distance = cached_log['metadata'].get('distance')
-            logger.info(
-                f"[Cache Hit] '{function_name}' skipped. "
-                f"Distance: {distance:.4f}, "
-                f"Trace ID: {cached_log['uuid'][:8]}..."
-            )
-            # (D) Deserialize and return the cached result
-            return _deserialize_return_value(cached_log.get('return_value'))
-
-        return None
-
-    except Exception as e:
-        logger.error(f"Failed to check semantic cache for '{function_name}': {e}", exc_info=True)
-        # Cache failure must not stop execution, so return None to proceed to actual function call.
-        return None