vectorwave 0.2.6__tar.gz → 0.2.7__tar.gz

vectorwave-0.2.7/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: vectorwave
+Version: 0.2.7
+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: Programming Language :: Rust
+Classifier: Operating System :: OS Independent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Requires-Dist: weaviate-client>=4.0.0
+Requires-Dist: pydantic-settings>=2.0.0
+Requires-Dist: sentence-transformers
+Requires-Dist: requests
+Requires-Dist: openai
+License-File: LICENSE
+License-File: NOTICE
+Summary: VectorWave: Seamless Auto-Vectorization Framework
+Author-email: junyeonggim <junyeonggim5@gmail.com>
+License-Expression: MIT
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Repository, https://github.com/cozymori/vectorwave
+
+Need more information? Visit [here](https://cozymori.github.io/vectorwave-docs/)
+
+# VectorWave
+![Star](https://badgen.net/github/stars/cozymori/vectorwave)
+![Release](https://badgen.net/github/release/cozymori/vectorwave)
+![Tag](https://badgen.net/github/tag/cozymori/vectorwave)
+![Commit](https://badgen.net/github/last-commit/cozymori/vectorwave)
+![Contributors](https://badgen.net/github/contributors/cozymori/vectorwave)
+![OpenPrs](https://badgen.net/github/open-prs/cozymori/vectorwave)
+![MergedPrs](https://badgen.net/github/merged-prs/cozymori/vectorwave)
+![Checks](https://badgen.net/github/checks/cozymori/vectorwave)
+![Pypi](https://badgen.net/pypi/v/vectorwave)
+<br>**Seamless Auto-Vectorization Framework**
+
+We transform volatile data that disappears the moment code is executed into a Searchable and Reusable permanent knowledge asset.
+
+### Requirements
+
+* **Python**: 3.10 ~ 3.13
+* **Docker**: Required to run the Weaviate database.
+* (Optional) **OpenAI API Key**: Required for AI auto-documentation and high-performance embedding.
+
+### How to reach us
+
+Have questions or found a bug? Please join our community.
+
+* **GitHub Issues**: [https://github.com/cozymori/vectorwave/issues](https://github.com/cozymori/vectorwave/issues)
+
+### Contributors
+[See the contributors of vectorwave](https://github.com/Cozymori/VectorWave/graphs/contributors)<br>
+VectorWave is an open-source project and we welcome your contributions.
+Please refer to [CONTRIBUTING.md](https://www.google.com/search?q=https://github.com/cozymori/vectorwave/blob/main/CONTRIBUTING.md) in the GitHub repository.
+
+

vectorwave-0.2.7/Readme.md

@@ -0,0 +1,33 @@
+Need more information? Visit [here](https://cozymori.github.io/vectorwave-docs/)
+
+# VectorWave
+![Star](https://badgen.net/github/stars/cozymori/vectorwave)
+![Release](https://badgen.net/github/release/cozymori/vectorwave)
+![Tag](https://badgen.net/github/tag/cozymori/vectorwave)
+![Commit](https://badgen.net/github/last-commit/cozymori/vectorwave)
+![Contributors](https://badgen.net/github/contributors/cozymori/vectorwave)
+![OpenPrs](https://badgen.net/github/open-prs/cozymori/vectorwave)
+![MergedPrs](https://badgen.net/github/merged-prs/cozymori/vectorwave)
+![Checks](https://badgen.net/github/checks/cozymori/vectorwave)
+![Pypi](https://badgen.net/pypi/v/vectorwave)
+<br>**Seamless Auto-Vectorization Framework**
+
+We transform volatile data that disappears the moment code is executed into a Searchable and Reusable permanent knowledge asset.
+
+### Requirements
+
+* **Python**: 3.10 ~ 3.13
+* **Docker**: Required to run the Weaviate database.
+* (Optional) **OpenAI API Key**: Required for AI auto-documentation and high-performance embedding.
+
+### How to reach us
+
+Have questions or found a bug? Please join our community.
+
+* **GitHub Issues**: [https://github.com/cozymori/vectorwave/issues](https://github.com/cozymori/vectorwave/issues)
+
+### Contributors
+[See the contributors of vectorwave](https://github.com/Cozymori/VectorWave/graphs/contributors)<br>
+VectorWave is an open-source project and we welcome your contributions.
+Please refer to [CONTRIBUTING.md](https://www.google.com/search?q=https://github.com/cozymori/vectorwave/blob/main/CONTRIBUTING.md) in the GitHub repository.
+

vectorwave-0.2.7/crates/src/lib.rs

@@ -0,0 +1,171 @@
+use pyo3::prelude::*;
+use pyo3::types::{PyDict, PyList, PyString, PyBool, PyFloat, PyInt};
+use std::collections::HashSet;
+use std::thread;
+use std::time::{Duration, Instant};
+use std::sync::Mutex;
+use crossbeam_channel::{bounded, Receiver, Sender, TrySendError};
+
+struct LogItem {
+    collection: PyObject,
+    properties: Py<PyDict>,
+    uuid: Option<PyObject>,
+    vector: Option<Vec<f32>>,
+}
+
+#[pyclass]
+struct RustBatchManager {
+    sender: Sender<LogItem>,
+    #[allow(dead_code)]
+    flush_callback: PyObject,
+    worker_handle: Mutex<Option<thread::JoinHandle<()>>>,
+    stop_signal: Sender<()>,
+}
+
+#[pymethods]
+impl RustBatchManager {
+    #[new]
+    fn new(
+        py: Python<'_>,
+        callback: PyObject,
+        batch_threshold: usize,
+        flush_interval_ms: u64,
+    ) -> Self {
+        let (tx, rx) = bounded::<LogItem>(10000);
+        let (stop_tx, stop_rx) = bounded(1);
+        let worker_callback = callback.clone_ref(py);
+
+        let handle = thread::spawn(move || {
+            Self::worker_loop(rx, stop_rx, worker_callback, batch_threshold, flush_interval_ms);
+        });
+
+        RustBatchManager {
+            sender: tx,
+            flush_callback: callback,
+            worker_handle: Mutex::new(Some(handle)),
+            stop_signal: stop_tx,
+        }
+    }
+
+    #[pyo3(signature = (collection, properties, uuid=None, vector=None))]
+    fn add_object(&self, collection: PyObject, properties: Py<PyDict>, uuid: Option<PyObject>, vector: Option<Vec<f32>>) {
+        let item = LogItem { collection, properties, uuid, vector };
+        let _ = self.sender.try_send(item);
+    }
+
+    fn shutdown(&self, py: Python<'_>) {
+        let _ = self.stop_signal.send(());
+        py.allow_threads(|| {
+            if let Ok(mut handle_guard) = self.worker_handle.lock() {
+                if let Some(handle) = handle_guard.take() {
+                    let _ = handle.join();
+                }
+            }
+        });
+    }
+}
+
+impl RustBatchManager {
+    fn worker_loop(rx: Receiver<LogItem>, stop_rx: Receiver<()>, callback: PyObject, threshold: usize, interval_ms: u64) {
+            let mut buffer = Vec::with_capacity(threshold);
+            let mut last_flush = Instant::now();
+            let flush_interval = Duration::from_millis(interval_ms);
+
+            loop {
+                crossbeam_channel::select! {
+                    recv(stop_rx) -> msg => {
+                        break;
+                    }
+                    recv(rx) -> msg => {
+                        match msg {
+                            Ok(item) => buffer.push(item),
+                            Err(_) => break,
+                        }
+                    }
+                    default(Duration::from_millis(100)) => {}
+                }
+
+
+                if stop_rx.is_empty() && (buffer.len() >= threshold || (last_flush.elapsed() >= flush_interval && !buffer.is_empty())) {
+
+                     let _ = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                        Self::flush_buffer(&buffer, &callback);
+                    }));
+                    buffer.clear();
+                    last_flush = Instant::now();
+                }
+            }
+        }
+
+    fn flush_buffer(buffer: &Vec<LogItem>, callback: &PyObject) {
+        Python::with_gil(|py| {
+            let py_list = PyList::empty(py);
+
+            for item in buffer {
+                let dict = PyDict::new(py);
+                let mut set_field = |key: &str, val: PyObject| -> bool {
+                    if let Err(_) = dict.set_item(key, val) { return false; }
+                    true
+                };
+
+                if !set_field("collection", item.collection.clone_ref(py)) { continue; }
+                if !set_field("properties", item.properties.to_object(py)) { continue; }
+                let uuid_val = item.uuid.as_ref().map_or(py.None(), |u| u.clone_ref(py));
+                if !set_field("uuid", uuid_val) { continue; }
+                let vector_val = item.vector.as_ref().map_or(py.None(), |v| v.to_object(py));
+                if !set_field("vector", vector_val) { continue; }
+
+                if let Err(e) = py_list.append(dict) {
+                     eprintln!("[RustCore] ⚠️ Failed to append item: {}", e);
+                }
+            }
+
+            if let Err(e) = callback.call1(py, (py_list,)) {
+                eprintln!("[RustCore] ⚠️ Flush failed: {}", e);
+            }
+        });
+    }
+}
+
+fn process_recursive(py: Python, value: &Bound<'_, PyAny>, sensitive_set: &HashSet<String>) -> PyResult<PyObject> {
+    if let Ok(dict_obj) = value.downcast::<PyDict>() {
+        let new_dict = PyDict::new(py);
+        for (k, v) in dict_obj {
+            let k_str = k.to_string().to_lowercase();
+            if sensitive_set.contains(&k_str) {
+                new_dict.set_item(k, "[MASKED]")?;
+            } else {
+                new_dict.set_item(k, process_recursive(py, &v, sensitive_set)?)?;
+            }
+        }
+        Ok(new_dict.into())
+    } else if let Ok(list_obj) = value.downcast::<PyList>() {
+        let new_list = PyList::empty(py);
+        for item in list_obj {
+            new_list.append(process_recursive(py, &item, sensitive_set)?)?;
+        }
+        Ok(new_list.into())
+    } else {
+        if value.is_none() || value.is_instance_of::<PyBool>() || value.is_instance_of::<PyFloat>() || value.is_instance_of::<PyInt>() || value.is_instance_of::<PyString>() {
+            Ok(value.clone().unbind())
+        } else {
+            match value.str() {
+                Ok(s) => Ok(s.into()),
+                Err(_) => Ok(PyString::new(py, "[SERIALIZATION_ERROR]").into())
+            }
+        }
+    }
+}
+
+#[pyfunction]
+fn mask_and_serialize(py: Python, data: &Bound<'_, PyAny>, sensitive_keys: Vec<String>) -> PyResult<PyObject> {
+    let sensitive_set: HashSet<String> = sensitive_keys.into_iter().map(|s| s.to_lowercase()).collect();
+    process_recursive(py, data, &sensitive_set)
+}
+
+#[pymodule]
+fn vectorwave_core(m: &Bound<'_, PyModule>) -> PyResult<()> {
+    m.add_class::<RustBatchManager>()?;
+    m.add_function(wrap_pyfunction!(mask_and_serialize, m)?)?;
+    Ok(())
+}

{vectorwave-0.2.6 → vectorwave-0.2.7}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "maturin"
 
 [project]
 name = "vectorwave"
-version = "0.2.06"
+version = "0.2.07"
 authors = [
     { name = "junyeonggim", email = "junyeonggim5@gmail.com" },
 ]

{vectorwave-0.2.6 → vectorwave-0.2.7}/src/vectorwave/monitoring/tracer.py

@@ -332,7 +332,7 @@ def trace_span(
                             result=return_value_log
                         )
 
-                    if tracer.settings.DRIFT_DETECTION_ENABLED and vector_to_add:
+                    if tracer.settings.DRIFT_DETECTION_ENABLED and vector_to_add and status == "SUCCESS":
                         is_drift, dist, nearest_id = check_semantic_drift(
                             vector=vector_to_add,
                             function_name=func.__name__,
@@ -465,7 +465,7 @@ def trace_span(
                             result=return_value_log
                         )
 
-                    if tracer.settings.DRIFT_DETECTION_ENABLED and vector_to_add:
+                    if tracer.settings.DRIFT_DETECTION_ENABLED and vector_to_add and status == "SUCCESS":
                         is_drift, dist, nearest_id = check_semantic_drift(
                             vector=vector_to_add,
                             function_name=func.__name__,