vectorwave 0.1.0__py3-none-any.whl

vectorwave/database/db_search.py

@@ -0,0 +1,100 @@
+import weaviate
+import weaviate.classes as wvc
+from typing import Dict, Any, Optional, List
+
+from weaviate.collections.classes.filters import _Filters
+
+from ..models.db_config import get_weaviate_settings, WeaviateSettings
+from .db import get_cached_client
+from ..exception.exceptions import WeaviateConnectionError
+
+import uuid
+from datetime import datetime
+
+
+def _build_weaviate_filters(filters: Optional[Dict[str, Any]]) -> _Filters | None:
+    if not filters:
+        return None
+    filter_list = [
+        wvc.query.Filter.by_property(key).equal(value)
+        for key, value in filters.items()
+    ]
+    if not filter_list:
+        return None
+    return wvc.query.Filter.all_of(filter_list)
+
+
+def search_functions(query: str, limit: int = 5, filters: Optional[Dict[str, Any]] = None) -> List[Dict[str, Any]]:
+    """
+    Searches function definitions from the [VectorWaveFunctions] collection using natural language (nearText).
+    """
+    try:
+        settings: WeaviateSettings = get_weaviate_settings()
+        client: weaviate.WeaviateClient = get_cached_client()
+
+        collection = client.collections.get(settings.COLLECTION_NAME)
+        weaviate_filter = _build_weaviate_filters(filters)
+
+        response = collection.query.near_text(
+            query=query,
+            limit=limit,
+            filters=weaviate_filter,
+            return_metadata=wvc.query.MetadataQuery(distance=True)
+        )
+
+        #todo expand custom range needed
+        results = [
+            {
+                "properties": obj.properties,
+                "metadata": obj.metadata,  # This contains the distance
+                "uuid": obj.uuid          # Add uuid separately here
+            }
+            for obj in response.objects
+        ]
+        return results
+
+    except Exception as e:
+        print(f"Error during Weaviate search: {e}")
+        raise WeaviateConnectionError(f"Failed to execute 'search_functions': {e}")
+
+
+def search_executions(
+        limit: int = 10,
+        filters: Optional[Dict[str, Any]] = None,
+        sort_by: Optional[str] = "timestamp_utc",
+        sort_ascending: bool = False
+) -> List[Dict[str, Any]]:
+    """
+    Searches execution logs from the [VectorWaveExecutions] collection using filtering and sorting.
+    """
+    try:
+        settings: WeaviateSettings = get_weaviate_settings()
+        client: weaviate.WeaviateClient = get_cached_client()
+
+        collection = client.collections.get(settings.EXECUTION_COLLECTION_NAME)
+        weaviate_filter = _build_weaviate_filters(filters)
+        weaviate_sort = None
+
+        if sort_by:
+            weaviate_sort = wvc.query.Sort.by_property(
+                name=sort_by,
+                ascending=sort_ascending
+            )
+
+        response = collection.query.fetch_objects(
+            limit=limit,
+            filters=weaviate_filter,
+            sort=weaviate_sort
+        )
+        results = []
+        for obj in response.objects:
+            props = obj.properties.copy()
+            for key, value in props.items():
+                if isinstance(value, uuid.UUID) or isinstance(value, datetime):
+                    props[key] = str(value)
+            results.append(props)
+
+        return results
+
+    except Exception as e:
+        raise WeaviateConnectionError(f"Failed to execute 'search_executions': {e}")

vectorwave/exception/exceptions.py

@@ -0,0 +1,22 @@
+"""
+Defines custom exceptions for the VectorWave project.
+"""
+
+class VectorWaveError(Exception):
+    """Base exception class for the VectorWave library."""
+    pass
+
+
+class WeaviateConnectionError(VectorWaveError):
+    """Raised when an error occurs while attempting to connect to the Weaviate server."""
+    pass
+
+
+class WeaviateNotReadyError(VectorWaveError):
+    """Raised when connected to Weaviate, but the server is not in a ready state."""
+    pass
+
+
+class SchemaCreationError(VectorWaveError):
+    """Raised when an error occurs during Weaviate collection schema creation."""
+    pass

vectorwave/models/db_config.py

@@ -0,0 +1,82 @@
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from functools import lru_cache
+from typing import Dict, Optional, Any
+import json
+import os
+
+
+class WeaviateSettings(BaseSettings):
+    """
+    Manages Weaviate database connection settings.
+
+    Reads values from environment variables or a .env file.
+    (e.g., WEAVIATE_HOST=10.0.0.1)
+    """
+    # If environment variables are not set, these default values will be used.
+    WEAVIATE_HOST: str = "localhost"
+    WEAVIATE_PORT: int = 8080
+    WEAVIATE_GRPC_PORT: int = 50051
+    COLLECTION_NAME: str = "VectorWaveFunctions"
+    EXECUTION_COLLECTION_NAME: str = "VectorWaveExecutions"
+    IS_VECTORIZE_COLLECTION_NAME: bool = True
+
+    # Configure to read from a .env file (optional)
+
+    VECTORIZER_CONFIG: str = "text2vec-openai"
+    GENERATIVE_CONFIG: str = "generative-openai"
+
+    CUSTOM_PROPERTIES_FILE_PATH: str = ".weaviate_properties"
+    custom_properties: Optional[Dict[str, Dict[str, Any]]] = None
+    global_custom_values: Optional[Dict[str, Any]] = None
+    model_config = SettingsConfigDict(env_file=".env", env_file_encoding="utf-8",extra='ignore')
+
+
+# @lru_cache ensures this function creates the Settings object only once (Singleton pattern)
+# and reuses the cached object on subsequent calls.
+@lru_cache()
+def get_weaviate_settings() -> WeaviateSettings:
+    """
+    Factory function that returns the settings object.
+    """
+    settings = WeaviateSettings()
+
+    file_path = settings.CUSTOM_PROPERTIES_FILE_PATH
+
+    if file_path and os.path.exists(file_path):
+        print(f"Loading custom properties schema from '{file_path}'...")
+        try:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                loaded_data = json.load(f)
+
+                if isinstance(loaded_data, dict):
+                    settings.custom_properties = loaded_data
+                else:
+                    print(
+                        f"Warning: Content in '{file_path}' is not a valid dictionary (JSON root). "
+                        f"Custom properties will not be loaded."
+                    )
+                    settings.custom_properties = None
+
+        except json.JSONDecodeError as e:
+            print(f"Warning: Could not parse JSON from '{file_path}'. File might be malformed. {e}")
+            settings.custom_properties = None
+        except Exception as e:
+            print(f"Warning: Could not read file '{file_path}': {e}")
+            settings.custom_properties = None
+
+    elif file_path:
+        print(f"Note: Custom properties file not found at '{file_path}'. Skipping schema.")
+
+    if settings.custom_properties:
+        settings.global_custom_values = {}
+        print(f"Loading global custom values from environment variables...")
+
+        for prop_name in settings.custom_properties.keys():
+            env_var_name = prop_name.upper()
+            value = os.environ.get(env_var_name)
+
+            if value:
+                settings.global_custom_values[prop_name] = value
+                print(f"Loaded global value for '{prop_name}' from env var '{env_var_name}'.")
+
+    return settings

vectorwave/monitoring/tracer.py

@@ -0,0 +1,128 @@
+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
+
+
+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:
+                    print(f"Warning: Failed to capture attributes for {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:
+                    print(f"Error: Failed to log span for {func.__name__} (trace_id: {tracer.trace_id}): {e}")
+
+            return result
+
+        return wrapper
+
+    if _func is None:
+        return decorator
+    else:
+        return decorator(_func)

vectorwave-0.1.0.dist-info/METADATA

@@ -0,0 +1,280 @@
+Metadata-Version: 2.4
+Name: vectorwave
+Version: 0.1.0
+Summary: VectorWave: Seamless Auto-Vectorization Framework
+Author-email: junyeonggim <junyeonggim5@gmail.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: weaviate-client>=4.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+
+
+# 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 information from **environment variables** or a `.env` file.
+
+Create a `.env` file in the root directory of your project (e.g., where `main.py` is located) and set the required values.
+
+### .env File Example
+
+```ini
+# .env
+# --- Basic Weaviate Connection Settings ---
+WEAVIATE_HOST=localhost
+WEAVIATE_PORT=8080
+WEAVIATE_GRPC_PORT=50051
+
+# --- Vectorizer , Generative Module Config ---
+# (default: text2vec-openai) Set to 'none' to disable vectorization.
+VECTORIZER_CONFIG=text2vec-openai
+# (default: generative-openai)
+GENERATIVE_CONFIG=generative-openai
+# An OpenAI API key is required if using modules like text2vec-openai.
+# OPENAI_API_KEY=sk-your-key-here
+
+# --- [Advanced] Custom Property Settings ---
+# 1. The path to the JSON file defining custom properties to add to the schema.
+CUSTOM_PROPERTIES_FILE_PATH=.weaviate_properties
+
+# 2. Environment variables to be used for 'Global Dynamic Tagging'.
+#    ("run_id" must be defined in the .weaviate_properties file)
+RUN_ID=test-run-001
+EXPERIMENT_ID=exp-abc
+```
+
+-----
+
+### Custom Properties and Dynamic Execution Tagging
+
+VectorWave can store user-defined metadata in both static definitions (`VectorWaveFunctions`) and dynamic logs (`VectorWaveExecutions`). This works in two steps.
+
+#### Step 1: Define Custom Schema (The "Allow-List")
+
+Create a JSON file at the path specified by `CUSTOM_PROPERTIES_FILE_PATH` (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"
+  }
+}
+```
+
+* Defining these will add `run_id`, `experiment_id`, `team`, and `priority` properties to *both* collections.
+
+#### Step 2: Dynamic Execution Tagging (Adding Values)
+
+When a function executes, VectorWave adds tags to the `VectorWaveExecutions` log. It does this in two ways, which are then merged:
+
+**1. Global Tags (from Environment Variables)**
+VectorWave searches for environment variables whose names match the **uppercase** keys from Step 1 (e.g., `RUN_ID`, `EXPERIMENT_ID`) and uses these for run-wide metadata.
+
+**2. Function-Specific Tags (from Decorator)**
+You can pass tags directly to the `@vectorize` decorator as keyword arguments (`**execution_tags`). This is ideal for function-specific metadata.
+
+```python
+# --- .env file ---
+# RUN_ID=global-run-abc
+# TEAM=default-team
+
+@vectorize(
+    search_description="Process a 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 (Most Important):** A tag (either global or specific) will **only** be saved to Weaviate if its key (e.g., `run_id`, `team`, `priority`) was first defined in your `.weaviate_properties` file (Step 1). Tags not defined in the schema will be **ignored**, and a warning will be printed on startup.
+
+2.  **Priority (Override):** If a tag key is defined in both places (e.g., a global `RUN_ID` in `.env` and a specific `run_id="override-run-xyz"` on the decorator), the **function-specific tag from the decorator will always win**.
+
+**Resulting Logs:**
+
+* `process_payment()` log will have: `{"run_id": "global-run-abc", "team": "billing", "priority": 1}`
+* `other_function()` log will have: `{"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.0.dist-info/RECORD

@@ -0,0 +1,35 @@
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/batch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/batch/test_batch.py,sha256=vDP-W4KTH6f6XfTof-EYgRtz5MlKSRC1kwGrQ5Z4v0k,3315
+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=m_xuEBt2EzCX-o3UuY79xQdVvpTA3k05RvVahu4bP1k,16615
+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=wdWTF4ZL9zieSMnfwUhsBtAmsJsVDC2YQbuYW0Tw-28,4823
+tests/monitoring/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/prediction/__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=gSfRjxF0Z5pCIvJndAWleMas5Ms78FkURfGVYqvtD8E,2225
+vectorwave/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/core/core.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/core/decorator.py,sha256=rX9GSpMN76aki_0y7bm-ZpQt3pJrUcqGMuDTWevp5AI,3796
+vectorwave/database/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/database/db.py,sha256=OP8LxJSFGbeArSatLzKXBhFHTzVydBuBfVyRHO6rpd0,10963
+vectorwave/database/db_search.py,sha256=iN7m8jYsIM-h-qTnPcp-1grDOQtnM3xt1Fq3TEhaz4g,3319
+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=fcijRdX6Lh_vRRWGGvxS2Zn-eQ7ukwq68OeuUeSp3DA,3106
+vectorwave/monitoring/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/monitoring/monitoring.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/monitoring/tracer.py,sha256=SH54QfGPosYzHmnz8SSEeZ08LQ9XUYscCIZuSp5pU3I,4431
+vectorwave/prediction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave/prediction/predictor.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+vectorwave-0.1.0.dist-info/METADATA,sha256=dBb61UixAxREuoUHR9pS4uSo2SmPDnplIudYknshxJk,10518
+vectorwave-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+vectorwave-0.1.0.dist-info/top_level.txt,sha256=Nce880E2pZRKbWF9XpB-FT5iZL9ETMDqSUVKF-_0m78,17
+vectorwave-0.1.0.dist-info/RECORD,,

vectorwave-0.1.0.dist-info/WHEEL

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

vectorwave-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+tests
+vectorwave