vectorwave 0.1.3__py3-none-any.whl

vectorwave/monitoring/tracer.py

@@ -0,0 +1,131 @@
+import logging
+import inspect
+import time
+import traceback
+from functools import wraps
+from contextvars import ContextVar
+from typing import Optional, List, Dict, Any, Callable
+from uuid import uuid4
+from datetime import datetime, timezone
+
+from ..batch.batch import get_batch_manager
+from ..models.db_config import get_weaviate_settings, WeaviateSettings
+
+# Create module-level logger
+logger = logging.getLogger(__name__)
+
+class TraceCollector:
+    def __init__(self, trace_id: str):
+        self.trace_id = trace_id
+        self.settings: WeaviateSettings = get_weaviate_settings()
+        self.batch = get_batch_manager()
+
+
+current_tracer_var: ContextVar[Optional[TraceCollector]] = ContextVar('current_tracer', default=None)
+
+
+def trace_root() -> Callable:
+    """
+    Decorator factory for the workflow's entry point function.
+    Creates and sets the TraceCollector in ContextVar.
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            if current_tracer_var.get() is not None:
+                return func(*args, **kwargs)
+
+            trace_id = kwargs.pop('trace_id', str(uuid4()))
+            tracer = TraceCollector(trace_id=trace_id)
+            token = current_tracer_var.set(tracer)
+
+            try:
+                # ⭐️ Key: Here, func is the wrapper of @trace_span.
+                return func(*args, **kwargs)
+            finally:
+                current_tracer_var.reset(token)
+
+        return wrapper
+
+    return decorator
+
+
+def trace_span(
+        _func: Optional[Callable] = None,
+        *,
+        attributes_to_capture: Optional[List[str]] = None
+) -> Callable:
+    """
+    Decorator to capture function execution as a 'span'.
+    Can be used as @trace_span or @trace_span(attributes_to_capture=[...]).
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            tracer = current_tracer_var.get()
+            if not tracer:
+                return func(*args, **kwargs)
+
+            start_time = time.perf_counter()
+            status = "SUCCESS"
+            error_msg = None
+            result = None
+
+            captured_attributes = {}
+            if attributes_to_capture:
+                try:
+                    # Directly checks the kwargs dictionary.
+                    for attr_name in attributes_to_capture:
+                        if attr_name in kwargs:
+                            value = kwargs[attr_name]
+                            if not isinstance(value, (str, int, float, bool, list, dict, type(None))):
+                                value = str(value)
+                            captured_attributes[attr_name] = value
+                except Exception as e:
+                    logger.warning("Failed to capture attributes for '%s': %s", func.__name__, e)
+
+            try:
+                result = func(*args, **kwargs)
+            except Exception as e:
+                status = "ERROR"
+                error_msg = traceback.format_exc()
+                raise e
+            finally:
+                duration_ms = (time.perf_counter() - start_time) * 1000
+
+                span_properties = {
+                    "trace_id": tracer.trace_id,
+                    "span_id": str(uuid4()),
+                    "function_name": func.__name__,
+                    "timestamp_utc": datetime.now(timezone.utc).isoformat(),
+                    "duration_ms": duration_ms,
+                    "status": status,
+                    "error_message": error_msg,
+                }
+
+                # 1. Apply global tags first.
+                if tracer.settings.global_custom_values:
+                    span_properties.update(tracer.settings.global_custom_values)
+
+                # 2. Apply captured attributes second (overriding global values if necessary).
+                # (If 'run_id' was captured, this value (e.g., override-run-xyz) overrides the global value.)
+                span_properties.update(captured_attributes)
+
+                try:
+                    tracer.batch.add_object(
+                        collection=tracer.settings.EXECUTION_COLLECTION_NAME,
+                        properties=span_properties
+                    )
+                except Exception as e:
+                    logger.error("Failed to log span for '%s' (trace_id: %s): %s", func.__name__, tracer.trace_id, e)
+
+            return result
+
+        return wrapper
+
+    if _func is None:
+        return decorator
+    else:
+        return decorator(_func)

vectorwave/vectorizer/base.py

@@ -0,0 +1,12 @@
+from abc import ABC, abstractmethod
+from typing import List
+
+class BaseVectorizer(ABC):
+
+    @abstractmethod
+    def embed(self, text: str) -> List[float]:
+        pass
+
+    @abstractmethod
+    def embed_batch(self, texts: List[str]) -> List[List[float]]:
+        pass

vectorwave/vectorizer/factory.py

@@ -0,0 +1,49 @@
+# [NEW] File: src/vectorwave/vectorizer/factory.py
+from functools import lru_cache
+from typing import Optional
+
+from ..models.db_config import get_weaviate_settings, WeaviateSettings
+from .base import BaseVectorizer
+from .huggingface_vectorizer import HuggingFaceVectorizer
+from .openai_vectorizer import OpenAIVectorizer
+
+@lru_cache()
+def get_vectorizer() -> Optional[BaseVectorizer]:
+    """
+    Reads the configuration file (.env) and returns an appropriate Python Vectorizer instance.
+    - "weaviate_module" or "none": Returns None as Weaviate handles processing.
+    - "huggingface", "openai_client": Returns the actual instance as Python handles processing.
+    """
+    settings: WeaviateSettings = get_weaviate_settings()
+    vectorizer_name = settings.VECTORIZER.lower()
+
+    print(f"[VectorWave] Initializing vectorizer based on setting: '{vectorizer_name}'")
+
+    if vectorizer_name == "huggingface":
+        try:
+            return HuggingFaceVectorizer(model_name=settings.HF_MODEL_NAME)
+        except Exception as e:
+            print(f"Error: Failed to initialize HuggingFaceVectorizer: {e}")
+            return None
+
+    elif vectorizer_name == "openai_client":
+        if not settings.OPENAI_API_KEY:
+            print("Warning: VECTORIZER='openai_client' but OPENAI_API_KEY is not set. Vectorizer disabled.")
+            return None
+        try:
+            return OpenAIVectorizer(api_key=settings.OPENAI_API_KEY)
+        except Exception as e:
+            print(f"Error: Failed to initialize OpenAIVectorizer: {e}")
+            return None
+
+    elif vectorizer_name == "weaviate_module":
+        print("[VectorWave] Using Weaviate's internal module for vectorization.")
+        return None
+
+    elif vectorizer_name == "none":
+        print("[VectorWave] Vectorization is disabled ('none').")
+        return None
+
+    else:
+        print(f"Warning: Unknown VECTORIZER setting: '{vectorizer_name}'. Disabling vectorizer.")
+        return None

vectorwave/vectorizer/huggingface_vectorizer.py

@@ -0,0 +1,33 @@
+from .base import BaseVectorizer
+from typing import List
+import os
+
+try:
+    from sentence_transformers import SentenceTransformer
+except ImportError:
+    # Warning: The 'sentence-transformers' library is not installed.
+    print("Warning: The 'sentence-transformers' library is not installed.")
+    # To use HuggingFaceVectorizer, run 'pip install sentence-transformers'.
+    print("To use HuggingFaceVectorizer, run 'pip install sentence-transformers'.")
+    SentenceTransformer = None
+
+class HuggingFaceVectorizer(BaseVectorizer):
+    """[NEW] HuggingFace SentenceTransformer (Python Client) implementation"""
+
+    def __init__(self, model_name: str):
+        if SentenceTransformer is None:
+            # Could not find the 'sentence-transformers' library.
+            raise ImportError("Could not find the 'sentence-transformers' library.")
+
+        # Force use of CPU (can be changed to 'cuda', etc., if needed)
+        self.model = SentenceTransformer(model_name, device='cpu')
+        print(f"[VectorWave] HuggingFaceVectorizer loaded model '{model_name}' on CPU.")
+
+    def embed(self, text: str) -> List[float]:
+        # convert_to_numpy=True is faster on CPU
+        vector = self.model.encode([text], convert_to_numpy=True)[0]
+        return vector.tolist()
+
+    def embed_batch(self, texts: List[str]) -> List[List[float]]:
+        vectors = self.model.encode(texts, convert_to_numpy=True)
+        return vectors.tolist()

vectorwave/vectorizer/openai_vectorizer.py

@@ -0,0 +1,35 @@
+from .base import BaseVectorizer
+from typing import List
+
+try:
+    from openai import OpenAI
+except ImportError:
+    # Warning: The 'openai' library is not installed.
+    print("Warning: The 'openai' library is not installed.")
+    # To use OpenAIVectorizer, run 'pip install openai'.
+    print("To use OpenAIVectorizer, run 'pip install openai'.")
+    OpenAI = None
+
+
+class OpenAIVectorizer(BaseVectorizer):
+
+    def __init__(self, api_key: str, model: str = "text-embedding-3-small"):
+        if OpenAI is None:
+            # Could not find the 'openai' library.
+            raise ImportError("Could not find the 'openai' library.")
+        if not api_key:
+            raise ValueError("OpenAI API key is required for OpenAIVectorizer.")
+
+        self.client = OpenAI(api_key=api_key)
+        self.model = model
+        print(f"[VectorWave] OpenAIVectorizer initialized with model '{self.model}'.")
+
+    def embed(self, text: str) -> List[float]:
+        text = text.replace("\n", " ")
+        response = self.client.embeddings.create(input=[text], model=self.model)
+        return response.data[0].embedding
+
+    def embed_batch(self, texts: List[str]) -> List[List[float]]:
+        texts = [t.replace("\n", " ") for t in texts]
+        response = self.client.embeddings.create(input=texts, model=self.model)
+        return [d.embedding for d in response.data]

vectorwave-0.1.3.dist-info/METADATA

@@ -0,0 +1,352 @@
+Metadata-Version: 2.4
+Name: vectorwave
+Version: 0.1.3
+Summary: VectorWave: Seamless Auto-Vectorization Framework
+Author-email: junyeonggim <junyeonggim5@gmail.com>
+License-Expression: MIT
+Project-URL: Repository, https://github.com/republicofgamja/vtm
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: weaviate-client>=4.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Dynamic: license-file
+
+
+# VectorWave: Seamless Auto-Vectorization Framework
+
+[](https://www.google.com/search?q=LICENSE)
+
+## 🌟 Overview
+
+**VectorWave** is an innovative framework that uses a **decorator** to automatically save and manage the output of Python functions/methods in a **Vector Database (Vector DB)**. Developers can convert function outputs into intelligent vector data with a single line of code (`@vectorize`), without worrying about the complex processes of data collection, embedding generation, or storage in a Vector DB.
+
+---
+
+## ✨ Features
+
+* **`@vectorize` Decorator:**
+  1.  **Static Data Collection:** Saves the function's source code, docstring, and metadata to the `VectorWaveFunctions` collection once when the script is loaded.
+  2.  **Dynamic Data Logging:** Records the execution time, success/failure status, error logs, and 'dynamic tags' to the `VectorWaveExecutions` collection every time the function is called.
+* **Distributed Tracing:** By combining the `@vectorize` and `@trace_span` decorators, you can analyze the execution of complex multi-step workflows, grouped under a single **`trace_id`**.
+* **Search Interface:** Provides `search_functions` (for vector search) and `search_executions` (for log filtering) to facilitate the construction of RAG and monitoring systems.
+
+---
+
+## 🚀 Usage
+
+VectorWave consists of 'storing' via decorators and 'searching' via functions, and now includes **execution flow tracing**.
+
+### 1. (Required) Initialize the Database and Configuration
+
+```python
+import time
+from vectorwave import (
+    vectorize, 
+    initialize_database, 
+    search_functions, 
+    search_executions
+)
+# [ADDITION] Import trace_span separately for distributed tracing.
+from vectorwave.monitoring.tracer import trace_span 
+
+# This only needs to be called once when the script starts.
+try:
+    client = initialize_database()
+    print("VectorWave DB initialized successfully.")
+except Exception as e:
+    print(f"DB initialization failed: {e}")
+    exit()
+````
+
+### 2\. [Store] Use `@vectorize` with Distributed Tracing
+
+The `@vectorize` acts as the **Root** for tracing, and `@trace_span` is used on internal functions to group the execution flow under a single `trace_id`.
+
+```python
+# --- Child Span Function: Captures arguments ---
+@trace_span(attributes_to_capture=['user_id', 'amount'])
+def step_1_validate_payment(user_id: str, amount: int):
+    """(Span) Payment validation. Records user_id and amount in the log."""
+    print(f"  [SPAN 1] Validating payment for {user_id}...")
+    time.sleep(0.1)
+    return True
+
+@trace_span(attributes_to_capture=['user_id', 'receipt_id'])
+def step_2_send_receipt(user_id: str, receipt_id: str):
+    """(Span) Sends the receipt."""
+    print(f"  [SPAN 2] Sending receipt {receipt_id}...")
+    time.sleep(0.2)
+
+
+# --- Root Function (@trace_root role) ---
+@vectorize(
+    search_description="Charges a user in the payment system.",
+    sequence_narrative="Returns a receipt ID upon successful payment.",
+    team="billing",  # <-- Custom Tag (recorded in all execution logs)
+    priority=1       # <-- Custom Tag (execution priority)
+)
+def process_payment(user_id: str, amount: int):
+    """(Root Span) Executes the user payment workflow."""
+    print(f"  [ROOT EXEC] process_payment: Starting workflow for {user_id}...")
+    
+    # When calling child functions, the same trace_id is automatically inherited via ContextVar.
+    step_1_validate_payment(user_id=user_id, amount=amount) 
+    
+    receipt_id = f"receipt_{user_id}_{amount}"
+    step_2_send_receipt(user_id=user_id, receipt_id=receipt_id)
+
+    print(f"  [ROOT DONE] process_payment")
+    return {"status": "success", "receipt_id": receipt_id}
+
+# --- Execute the Function ---
+print("Now calling 'process_payment'...")
+# This single call records 3 execution logs (spans) in the DB,
+# all grouped under one 'trace_id'.
+process_payment("user_789", 5000)
+```
+
+### 3\. [Search ①] Function Definition Search (for RAG)
+
+```python
+# Search for functions related to 'payment' using natural language (vector search).
+print("\n--- Searching for 'payment' functions ---")
+payment_funcs = search_functions(
+    query="user payment processing",
+    limit=3
+)
+for func in payment_funcs:
+    print(f"  - Function: {func['properties']['function_name']}")
+    print(f"  - Description: {func['properties']['search_description']}")
+    print(f"  - Similarity (Distance): {func['metadata'].distance:.4f}")
+```
+
+### 4\. [Search ②] Execution Log Search (Monitoring and Tracing)
+
+The `search_executions` function can now search for all related execution logs (spans) based on the `trace_id`.
+
+```python
+# 1. Find the Trace ID of a specific workflow (process_payment).
+latest_payment_span = search_executions(
+    limit=1, 
+    filters={"function_name": "process_payment"},
+    sort_by="timestamp_utc",
+    sort_ascending=False
+)
+trace_id = latest_payment_span[0]["trace_id"] 
+
+# 2. Search all spans belonging to that Trace ID, sorted chronologically.
+print(f"\n--- Full Trace for ID ({trace_id[:8]}...) ---")
+trace_spans = search_executions(
+    limit=10,
+    filters={"trace_id": trace_id},
+    sort_by="timestamp_utc",
+    sort_ascending=True # Ascending sort for workflow flow analysis
+)
+
+for i, span in enumerate(trace_spans):
+    print(f"  - [Span {i+1}] {span['function_name']} ({span['duration_ms']:.2f}ms)")
+    # Captured arguments (user_id, amount, etc.) are displayed for the child spans.
+    
+# Example Output:
+# - [Span 1] step_1_validate_payment (100.81ms)
+# - [Span 2] step_2_send_receipt (202.06ms)
+# - [Span 3] process_payment (333.18ms)
+```
+-----
+
+## ⚙️ Configuration
+
+VectorWave automatically reads Weaviate database connection info and **vectorization strategy** from **environment variables** or a `.env` file.
+
+Create a `.env` file in your project's root directory (e.g., where `test_ex/example.py` is located) and set the required values.
+
+### Vectorizer Strategy (VECTORIZER)
+
+You can select the text vectorization method via the `VECTORIZER` environment variable in your `test_ex/.env` file.
+
+| `VECTORIZER` Setting | Description | Required Additional Settings |
+| :--- | :--- | :--- |
+| **`huggingface`** | (Default Recommended) Uses the `sentence-transformers` library to vectorize on your local CPU. No API key is needed, making it great for immediate testing. | `HF_MODEL_NAME` (e.g., "sentence-transformers/all-MiniLM-L6-v2") |
+| **`openai_client`** | (High-Performance) Uses the OpenAI Python client to vectorize with modern models like `text-embedding-3-small`. | `OPENAI_API_KEY` (A valid OpenAI API key) |
+| **`weaviate_module`** | (Docker Delegate) Delegates the vectorization task to the Weaviate container's built-in module (e.g., `text2vec-openai`). | `WEAVIATE_VECTORIZER_MODULE`, `OPENAI_API_KEY` |
+| **`none`** | Disables vectorization. Data will be stored without vectors. | None |
+
+-----
+
+### .env File Examples
+
+Configure your `.env` file according to the strategy you want to use.
+
+#### Example 1: Using `huggingface` (Local, No API Key)
+
+Uses a `sentence-transformers` model on your local machine. Ideal for testing without API keys.
+
+```ini
+# .env (Using HuggingFace)
+# --- Basic Weaviate Connection ---
+WEAVIATE_HOST=localhost
+WEAVIATE_PORT=8080
+WEAVIATE_GRPC_PORT=50051
+
+# --- [Strategy 1] HuggingFace Config ---
+VECTORIZER="huggingface"
+HF_MODEL_NAME="sentence-transformers/all-MiniLM-L6-v2"
+
+# (OPENAI_API_KEY is not required for this mode)
+OPENAI_API_KEY=sk-...
+
+# --- [Advanced] Custom Properties ---
+CUSTOM_PROPERTIES_FILE_PATH=.weaviate_properties
+RUN_ID=test-run-001
+```
+
+#### Example 2: Using `openai_client` (Python Client, High-Performance)
+
+Directly calls the OpenAI API via the `openai` Python library.
+
+```ini
+# .env (Using OpenAI Python Client)
+# --- Basic Weaviate Connection ---
+WEAVIATE_HOST=localhost
+WEAVIATE_PORT=8080
+WEAVIATE_GRPC_PORT=50051
+
+# --- [Strategy 2] OpenAI Client Config ---
+VECTORIZER="openai_client"
+
+# [Required] You must enter a valid OpenAI API key.
+OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+# (HF_MODEL_NAME is not used in this mode)
+HF_MODEL_NAME=...
+
+# --- [Advanced] Custom Properties ---
+CUSTOM_PROPERTIES_FILE_PATH=.weaviate_properties
+RUN_ID=test-run-001
+```
+
+#### Example 3: Using `weaviate_module` (Docker Delegate)
+
+Delegates vectorization to the Weaviate Docker container instead of Python. (See `vw_docker.yml` config).
+
+```ini
+# .env (Delegating to Weaviate Module)
+# --- Basic Weaviate Connection ---
+WEAVIATE_HOST=localhost
+WEAVIATE_PORT=8080
+WEAVIATE_GRPC_PORT=50051
+
+# --- [Strategy 3] Weaviate Module Config ---
+VECTORIZER="weaviate_module"
+WEAVIATE_VECTORIZER_MODULE=text2vec-openai
+WEAVIATE_GENERATIVE_MODULE=generative-openai
+
+# [Required] The Weaviate container will read this API key.
+OPENAI_API_KEY=sk-xxxxxxxxxxxxxxxxxxxxxxxxxxxx
+
+# --- [Advanced] Custom Properties ---
+CUSTOM_PROPERTIES_FILE_PATH=.weaviate_properties
+RUN_ID=test-run-001
+```
+
+-----
+
+### Custom Properties and Dynamic Execution Tagging
+
+VectorWave can store user-defined metadata in addition to static data (function definitions) and dynamic data (execution logs). This works in two steps.
+
+#### Step 1: Define Custom Schema (Tag "Allow-list")
+
+Create a JSON file at the path specified by `CUSTOM_PROPERTIES_FILE_PATH` in your `.env` file (default: `.weaviate_properties`).
+
+This file instructs VectorWave to add **new properties (columns)** to the Weaviate collections. This file acts as an **"allow-list"** for all custom tags.
+
+**`.weaviate_properties` Example:**
+
+```json
+{
+  "run_id": {
+    "data_type": "TEXT",
+    "description": "The ID of the specific test run"
+  },
+  "experiment_id": {
+    "data_type": "TEXT",
+    "description": "Identifier for the experiment"
+  },
+  "team": {
+    "data_type": "TEXT",
+    "description": "The team responsible for this function"
+  },
+  "priority": {
+    "data_type": "INT",
+    "description": "Execution priority level"
+  }
+}
+```
+
+* This definition will add `run_id`, `experiment_id`, `team`, and `priority` properties to both the `VectorWaveFunctions` and `VectorWaveExecutions` collections.
+
+#### Step 2: Dynamic Execution Tagging (Adding Values)
+
+When a function is executed, VectorWave adds tags to the `VectorWaveExecutions` log. These tags are collected and merged from two sources.
+
+**1. Global Tags (Environment Variables)**
+VectorWave looks for environment variables matching the **UPPERCASE name** of the keys defined in Step 1 (e.g., `RUN_ID`, `EXPERIMENT_ID`). Found values are loaded as `global_custom_values` and added to *all* execution logs. Ideal for run-wide metadata.
+
+**2. Function-Specific Tags (Decorator)**
+You can pass tags as keyword arguments (`**execution_tags`) directly to the `@vectorize` decorator. Ideal for function-specific metadata.
+
+```python
+# --- .env file ---
+# RUN_ID=global-run-abc
+# TEAM=default-team
+
+@vectorize(
+    search_description="Process payment",
+    sequence_narrative="...",
+    team="billing",  # <-- Function-specific tag
+    priority=1       # <-- Function-specific tag
+)
+def process_payment():
+    pass
+
+@vectorize(
+    search_description="Another function",
+    sequence_narrative="...",
+    run_id="override-run-xyz" # <-- Overrides the global tag
+)
+def other_function():
+    pass
+```
+
+**Tag Merging and Validation Rules**
+
+1.  **Validation (Important):** Tags (global or function-specific) will **only** be saved to Weaviate if their key (e.g., `run_id`, `team`, `priority`) was first defined in the `.weaviate_properties` file (Step 1). Tags not defined in the schema are **ignored**, and a warning is printed at script startup.
+
+2.  **Priority (Override):** If a tag key is defined in both places (e.g., global `RUN_ID` in `.env` and `run_id="override-xyz"` in the decorator), the **function-specific tag from the decorator always wins**.
+
+**Resulting Logs:**
+
+* `process_payment()` execution log: `{"run_id": "global-run-abc", "team": "billing", "priority": 1}`
+* `other_function()` execution log: `{"run_id": "override-run-xyz", "team": "default-team"}`
+
+-----
+
+## 🤝 Contributing
+
+All forms of contribution are welcome, including bug reports, feature requests, and code contributions. For details, please refer to [CONTRIBUTING.md](https://www.google.com/search?q=httpsS://www.google.com/search%3Fq%3DCONTRIBUTING.md).
+
+## 📜 License
+
+This project is distributed under the MIT License. See the [LICENSE](https://www.google.com/search?q=httpsS://www.google.com/search%3Fq%3DLICENSE) file for details.
+

vectorwave-0.1.3.dist-info/RECORD

@@ -0,0 +1,44 @@
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/batch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/batch/test_batch.py,sha256=Urv7loLV5OZJoe7sU-NcWtR-ALLG_gw_5jLcoXWV5Sk,3336
+tests/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/core/test_decorator.py,sha256=uLlqBoGJ83Emu5qCdBmhvR12jd5tfDhWUzfCchgL6l8,12852
+tests/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/database/test_db.py,sha256=5SAiYqXa4OFAQmtStmni-wWsnczYHwGlrY5hweXspM0,16708
+tests/database/test_db_search.py,sha256=fM75zvHhJ06meMbRN_T9cMoXVdcFaC5dwzjHu0nc3-g,5456
+tests/exception/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/models/test_db_config.py,sha256=IfP8yLMdf6Im8c2YAEBiwOnOYF4yCMC55gsVOIwfz24,5149
+tests/monitoring/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/monitoring/test_tracer.py,sha256=alhHfMBTYJ-ECOYj_eB_OHO_lE0WjwkTM92g_VYtUyk,6384
+tests/prediction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/vectorizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/__init__.py,sha256=6EC-i4Ty_H_mZb4ZdsyryQpj_uobRf84mp8fPMNui3w,318
+vectorwave/batch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/batch/batch.py,sha256=TGXrvRTAH-1dEU-sRaXqLi7w_4qyoLlr7VsAzf32g3M,2353
+vectorwave/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/core/core.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/core/decorator.py,sha256=K3BKHuKeP8oCQEz86_W_idMGl0TzuZ68o2ZG1FBl6TA,4648
+vectorwave/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/database/db.py,sha256=ll5YfE3Ts3rzbiwW-f8FbU9OvPE1mKoN8dKj3F53Sfk,12021
+vectorwave/database/db_search.py,sha256=R7jONkMipHoTQwIh0uBH6O1WXxak3ow4ZIEwEgD54Io,4124
+vectorwave/exception/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/exception/exceptions.py,sha256=A7NuY3NyctYlQRtDhU4uvDjdSWormddf-Pk-kR0vMsQ,592
+vectorwave/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/models/db_config.py,sha256=brcwPkrs7LY3J9BfXWZsm_rZyeUNlGgBCbOM5m1DIs8,3402
+vectorwave/monitoring/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/monitoring/monitoring.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/monitoring/tracer.py,sha256=cRKy8pNXKkaBgB2Hwr7UGNfgBC2kEqQ2Xil_5i4Hi1E,4524
+vectorwave/prediction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/prediction/predictor.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/vectorizer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/vectorizer/base.py,sha256=rKGnNgSBo53KUY2KstTMZBHBaUFfphdTKV9FNqTk0mc,268
+vectorwave/vectorizer/factory.py,sha256=CQLiowI1jtAgCsf7WI5DfUtZ9LwNoJJQ4mwe0--7fok,1962
+vectorwave/vectorizer/huggingface_vectorizer.py,sha256=3rIN19gHloNNv0Ex69mZivg5oxftUYCNAYqI3cnXdUA,1435
+vectorwave/vectorizer/openai_vectorizer.py,sha256=unX6r-8XEFy1aLJqJyJYIVJgD9X7Ho8lgbNnGgKVujk,1363
+vectorwave-0.1.3.dist-info/licenses/LICENSE,sha256=FOpD5rUxH-F-Dcf4NsQeGs_VDKnpKQFM-NHS-E1UTw8,1069
+vectorwave-0.1.3.dist-info/licenses/NOTICE,sha256=I24P0Y4XwtWaKgt-nFANdZp6PwYkEeNZyAtfcJ9JAHg,1324
+vectorwave-0.1.3.dist-info/METADATA,sha256=eTAJU_0a4tDdShW48o_ZCO34n5gQLsQaakHPBHrGuxQ,13269
+vectorwave-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vectorwave-0.1.3.dist-info/top_level.txt,sha256=Nce880E2pZRKbWF9XpB-FT5iZL9ETMDqSUVKF-_0m78,17
+vectorwave-0.1.3.dist-info/RECORD,,

vectorwave-0.1.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+