added few changes

Author: varshith-Git

Cargo.lock

@@ -0,0 +1,20 @@
+# Test database artifacts — tests must use pytest tmp_path, not hardcoded paths
+test_ffi_db/
+valoricore_test_db/
+valoricore_db/
+valori_db/
+valori_test_db_debug/
+*.db/
+
+# Build / dist
+dist/
+build/
+*.egg-info/
+__pycache__/
+*.pyc
+*.pyo
+*.so
+*.pyd
+
+# Snapshots written during tests
+valoricore_snapshots/

python/.gitignore

@@ -1,99 +1,32 @@
-import pytest
 #!/usr/bin/env python3
-"""Quick test to verify batch insert endpoint after Event Log configuration"""
+"""Verify batch insert endpoint after Event Log configuration."""
 
-import requests
 import os
-from dotenv import load_dotenv
+import pytest
+import requests
 
 pytestmark = pytest.mark.integration
 
-# Load environment variables from .env file
-load_dotenv()
+_BASE_URL = os.getenv("VALORI_URL", "").rstrip("/")
+
+
+def _base_url() -> str:
+    if not _BASE_URL:
+        pytest.skip("VALORI_URL not set — export VALORI_URL=https://your-node or set it in .env")
+    return _BASE_URL
 
-BASE_URL = os.getenv("VALORI_URL")
-if not BASE_URL:
-    print("❌ ERROR: VALORI_URL environment variable not set")
-    print("Please set it in .env file or export it:")
-    print("  export VALORI_URL=https://your-deployment.koyeb.app")
-    exit(1)
 
 def test_batch_insert():
-    """Test batch insert endpoint"""
-    print(f"Testing batch insert on {BASE_URL}")
-    
-    # Prepare batch of 5 vectors
+    base = _base_url()
     batch = [
         [0.1, 0.2, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
         [0.2, 0.3, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
         [0.3, 0.4, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
         [0.4, 0.5, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
         [0.5, 0.6, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
     ]
-    
-    payload = {"batch": batch}
-    
-    try:
-        resp = requests.post(f"{BASE_URL}/v1/vectors/batch_insert", json=payload, timeout=10)
-        
-        print(f"\nStatus Code: {resp.status_code}")
-        print(f"Response: {resp.text}\n")
-        
-        if resp.status_code == 200:
-            data = resp.json()
-            if "ids" in data:
-                print(f"✅ SUCCESS: Batch inserted {len(data['ids'])} vectors")
-                print(f"   Assigned IDs: {data['ids']}")
-                return True
-            else:
-                print(f"⚠️  Unexpected response format: {data}")
-                return False
-        else:
-            print(f"❌ FAILED: {resp.text}")
-            if "Event Log" in resp.text:
-                print("\n💡 Event Log still not initialized. Possible issues:")
-                print("   1. Koyeb deployment not restarted yet")
-                print("   2. /app/data directory doesn't exist or not writable")
-                print("   3. Persistent volume not mounted")
-            return False
-            
-    except Exception as e:
-        print(f"❌ ERROR: {e}")
-        return False
-
-if __name__ == "__main__":
-    print("="*60)
-    print("  Valoricore Batch Insert Verification")
-    print("="*60)
-    
-    # First check if service is up
-    print("\n1. Checking health...")
-    try:
-        health = requests.get(f"{BASE_URL}/health", timeout=5)
-        if health.status_code == 200:
-            print("   ✅ Service is up")
-        else:
-            print(f"   ⚠️  Health check returned {health.status_code}")
-    except Exception as e:
-        print(f"   ❌ Service unreachable: {e}")
-        print("\n   Please restart your Koyeb deployment first!")
-        exit(1)
-    
-    # Test batch insert
-    print("\n2. Testing batch insert...")
-    success = test_batch_insert()
-    
-    if success:
-        print("\n" + "="*60)
-        print("  ✅ Batch insert is now working!")
-        print("="*60)
-        exit(0)
-    else:
-        print("\n" + "="*60)
-        print("  ❌ Batch insert still failing")
-        print("="*60)
-        print("\nNext steps:")
-        print("1. Check Koyeb logs for Event Log initialization message")
-        print("2. Verify /app/data exists and is writable")
-        print("3. Check if persistent storage is mounted")
-        exit(1)
+    resp = requests.post(f"{base}/v1/vectors/batch_insert", json={"batch": batch}, timeout=10)
+    assert resp.status_code == 200, f"batch_insert failed ({resp.status_code}): {resp.text}"
+    data = resp.json()
+    assert "ids" in data, f"unexpected response format: {data}"
+    assert len(data["ids"]) == len(batch)

python/tests/test_batch_verify.py

@@ -8,8 +8,12 @@ class ConnectionError(ValoricoreError):
     """Raised when the client cannot connect to a remote Valoricore node."""
     pass
 
-class ValidationError(ValoricoreError):
-    """Raised when input data (e.g., vector dimensions) is invalid."""
+class ValidationError(ValoricoreError, ValueError):
+    """Raised when input data (e.g. vector dimensions or FXP bounds) is invalid."""
+    pass
+
+class ProtocolError(ValoricoreError):
+    """Raised for protocol-level problems (unexpected server response shape, etc.)."""
     pass
 
 class IntegrityError(ValoricoreError):

python/valoricore/exceptions.py

@@ -6,7 +6,16 @@
 from typing import Callable, List, Dict, Any, Optional, TypedDict
 
 from .memory import MemoryClient
+from .remote import _BearerAuth
 from .kinds import NODE_DOCUMENT, NODE_CHUNK, EDGE_PARENT_OF
+from .exceptions import (
+    ValoricoreError,
+    ValidationError,
+    AuthenticationError,
+    ProtocolError,
+)
+# Backward-compat alias — callers that caught AuthError still work
+AuthError = AuthenticationError
 
 EmbedFn = Callable[[str], List[float]]
 
@@ -53,23 +62,6 @@ def _validate_vector(vector: List[float]) -> None:
                 f"Embedding value at index {i} ({v}) out of allowed range [{MIN_SAFE_FLOAT}, {MAX_SAFE_FLOAT}] for Q16.16 fixed-point storage."
             )
 
-class ValoricoreError(Exception):
-    """Base class for all Valoricore exceptions."""
-    pass
-
-class ProtocolError(ValoricoreError):
-    """Raised for protocol-level problems (invalid server response, etc.)."""
-    pass
-
-class AuthError(ValoricoreError):
-    """Raised when authentication fails (401/403)."""
-    pass
-
-class ValidationError(ValoricoreError, ValueError):
-    """Raised when input validation fails (e.g. FXP bounds)."""
-    pass
-
-
 def _ensure_keys(d: dict, keys):
     missing = [k for k in keys if k not in d]
     if missing:
@@ -79,18 +71,6 @@ def _ensure_keys(d: dict, keys):
 
 # H-2: custom auth class that redacts itself in __repr__/__str__ so bearer tokens
 # do not appear in tracebacks, Sentry reports, or Python logging output.
-class _BearerAuth(requests.auth.AuthBase):
-    def __init__(self, token: str) -> None:
-        self._token = token
-
-    def __call__(self, r: requests.PreparedRequest) -> requests.PreparedRequest:
-        r.headers["Authorization"] = f"Bearer {self._token}"
-        return r
-
-    def __repr__(self) -> str:
-        return "<BearerAuth [REDACTED]>"
-
-
 class ProtocolRemoteClient:
     def __init__(self, base_url: str, embed_fn, expected_dim: int, api_key: Optional[str] = None):
         self.base_url = base_url.rstrip("/")
@@ -110,7 +90,7 @@ def _post(self, path: str, json_data: Dict[str, Any], timeout: int = 10) -> Dict
         if not resp.ok:
             # Handle Auth Errors specifically
             if resp.status_code in (401, 403):
-                 raise AuthError(f"Authentication failed ({resp.status_code}): {resp.reason}")
+                 raise AuthenticationError(f"Authentication failed ({resp.status_code}): {resp.reason}")
 
             # Try to parse JSON error message, fallback to text
             try:
@@ -185,13 +165,13 @@ def set_metadata(self, target_id: str, metadata: Dict[str, Any]):
         """Set metadata for a memory_id, record_id, or node_id."""
         url = f"{self.base_url}/v1/memory/meta/set"
         payload = {"target_id": target_id, "metadata": metadata}
-        resp = self.session.post(url, json=payload, timeout=5)
+        resp = self.session.post(url, json=payload, auth=self._auth, timeout=5)
         resp.raise_for_status()
-        
+
     def get_metadata(self, target_id: str) -> Optional[Dict[str, Any]]:
         """Get metadata for a target_id."""
         url = f"{self.base_url}/v1/memory/meta/get"
-        resp = self.session.get(url, params={"target_id": target_id}, timeout=5)
+        resp = self.session.get(url, params={"target_id": target_id}, auth=self._auth, timeout=5)
         resp.raise_for_status()
         data = resp.json()
         return data.get("metadata")
@@ -248,7 +228,7 @@ def upsert_text(self, text: str, chunk_size: int = 512, vector: Optional[List[fl
 
             record_ids.append(res["record_id"])
             chunk_node_ids.append(res["chunk_node_id"])
-            proof_hashes.append(res["proof_hash"])
+            proof_hashes.append(res.get("proof_hash", ""))
 
         memory_ids = [f"rec:{rid}" for rid in record_ids]
         return {

python/valoricore/protocol.py

@@ -37,6 +37,19 @@ def _base_of(final_url: str, path: str) -> Optional[str]:
     return None
 
 
+class _BearerAuth(requests.auth.AuthBase):
+    """Per-request auth injector that redacts itself in repr/tracebacks."""
+    def __init__(self, token: str) -> None:
+        self._token = token
+
+    def __call__(self, r: requests.PreparedRequest) -> requests.PreparedRequest:
+        r.headers["Authorization"] = f"Bearer {self._token}"
+        return r
+
+    def __repr__(self) -> str:
+        return "<BearerAuth [REDACTED]>"
+
+
 class SyncRemoteClient(ValoriClient):
     """Synchronous REST client for a Valoricore node — standalone or clustered.
 
@@ -64,8 +77,12 @@ def __init__(self, base_url: str, max_retries: int = 3, retry_backoff: float = 0
             import re
             self.ui_url = re.sub(r":\d+$", ":3001", self.base_url)
         self.session = requests.Session()
-        if token:
-            self.session.headers["Authorization"] = f"Bearer {token}"
+        # H-2: use session.auth (not session.headers) so the token is injected
+        # per-request via __call__ and never sits in the headers dict where it
+        # would appear in dict(session.headers), logging output, or tracebacks.
+        # _BearerAuth.__repr__ returns "[REDACTED]" so it's safe in logs.
+        self._auth = _BearerAuth(token) if token else None
+        self.session.auth = self._auth
         self._auto_snapshot_interval = None
         self._insert_count = 0
         # M-4: default snapshot dir to ~/.valori/snapshots/ instead of CWD.