velesdb-common 1.9.3__tar.gz

velesdb_common-1.9.3/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: velesdb-common
+Version: 1.9.3
+Summary: Shared utilities for VelesDB Python integrations (internal use)
+Author-email: VelesDB Team <contact@wiscale.fr>
+License: MIT
+Requires-Python: >=3.9

velesdb_common-1.9.3/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "velesdb-common"
+version = "1.9.3"
+description = "Shared utilities for VelesDB Python integrations (internal use)"
+license = {text = "MIT"}
+authors = [
+    {name = "VelesDB Team", email = "contact@wiscale.fr"}
+]
+requires-python = ">=3.9"
+# No runtime dependencies beyond the stdlib — kept deliberately lean.
+dependencies = []
+
+[tool.setuptools.packages.find]
+where = ["src"]

velesdb_common-1.9.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

velesdb_common-1.9.3/src/velesdb_common/__init__.py

@@ -0,0 +1,80 @@
+"""velesdb_common — shared utilities for VelesDB Python integrations.
+
+This package contains code that is identical across the LangChain and
+LlamaIndex integration packages.  It is *not* a public API; downstream
+users should import from ``langchain_velesdb`` or ``llamaindex_velesdb``
+directly.
+"""
+
+from velesdb_common.ids import make_initial_id_counter, stable_hash_id
+from velesdb_common.memory import format_procedural_results
+from velesdb_common.security import (
+    SecurityError,
+    ALLOWED_METRICS,
+    ALLOWED_STORAGE_MODES,
+    DEFAULT_TIMEOUT_MS,
+    MAX_BATCH_SIZE,
+    MAX_DIMENSION,
+    MAX_K_VALUE,
+    MAX_PATH_LENGTH,
+    MAX_QUERY_LENGTH,
+    MAX_SPARSE_VECTOR_SIZE,
+    MAX_TEXT_LENGTH,
+    MIN_DIMENSION,
+    validate_batch_size,
+    validate_collection_name,
+    validate_dimension,
+    validate_k,
+    validate_metric,
+    validate_path,
+    validate_query,
+    validate_sparse_vector,
+    validate_storage_mode,
+    validate_text,
+    validate_timeout,
+    validate_url,
+    validate_weight,
+)
+from velesdb_common.graph import (
+    build_graph_rest_payload,
+    is_timeout_exception,
+    open_native_graph,
+)
+
+__all__ = [
+    # ids
+    "make_initial_id_counter",
+    "stable_hash_id",
+    # memory
+    "format_procedural_results",
+    # security
+    "SecurityError",
+    "ALLOWED_METRICS",
+    "ALLOWED_STORAGE_MODES",
+    "DEFAULT_TIMEOUT_MS",
+    "MAX_BATCH_SIZE",
+    "MAX_DIMENSION",
+    "MAX_K_VALUE",
+    "MAX_PATH_LENGTH",
+    "MAX_QUERY_LENGTH",
+    "MAX_SPARSE_VECTOR_SIZE",
+    "MAX_TEXT_LENGTH",
+    "MIN_DIMENSION",
+    "validate_batch_size",
+    "validate_collection_name",
+    "validate_dimension",
+    "validate_k",
+    "validate_metric",
+    "validate_path",
+    "validate_query",
+    "validate_sparse_vector",
+    "validate_storage_mode",
+    "validate_text",
+    "validate_timeout",
+    "validate_url",
+    "validate_weight",
+    # graph
+    "build_graph_rest_payload",
+    "is_timeout_exception",
+    "open_native_graph",
+]

velesdb_common-1.9.3/src/velesdb_common/graph.py

@@ -0,0 +1,97 @@
+"""Graph traversal helpers shared across VelesDB Python integrations."""
+
+from __future__ import annotations
+
+from typing import Any, List
+
+
+def build_graph_rest_payload(
+    source_id: int,
+    max_depth: int,
+    expand_k: int,
+    rel_types: List[str],
+) -> dict:
+    """Build the JSON payload for a VelesDB REST graph traversal request.
+
+    Shared by both the LangChain and LlamaIndex graph retrievers.
+
+    Args:
+        source_id: Starting node ID for the traversal.
+        max_depth: Maximum traversal depth.
+        expand_k: Maximum neighbours to request (limit = expand_k * 2).
+        rel_types: Relationship type filters (empty list means all types).
+
+    Returns:
+        Dict suitable for ``requests.post(..., json=payload)``.
+    """
+    return {
+        "source": source_id,
+        "strategy": "bfs",
+        "max_depth": max_depth,
+        "limit": expand_k * 2,
+        "rel_types": rel_types,
+    }
+
+
+def is_timeout_exception(exc: Exception) -> bool:
+    """Return True if *exc* represents a network or operation timeout.
+
+    Checks for ``requests.exceptions.Timeout`` (when *requests* is
+    installed) and the stdlib ``TimeoutError``.
+
+    Args:
+        exc: The exception to inspect.
+
+    Returns:
+        True if the exception is a timeout, False otherwise.
+    """
+    try:
+        import requests
+
+        if isinstance(exc, requests.exceptions.Timeout):
+            return True
+    except ImportError:
+        # requests is an optional dependency
+        pass
+    return isinstance(exc, TimeoutError)
+
+
+def open_native_graph(db_path: str, collection_name: str) -> Any:
+    """Open a native VelesDB graph collection.
+
+    Shared implementation for both integrations.
+
+    Note:
+        The returned graph collection holds an internal reference to the
+        ``Database`` object created here.  The database remains open and
+        alive as long as the returned collection is reachable (Python
+        reference counting keeps it alive).  Callers do not need to
+        retain a separate ``Database`` handle.
+
+    Args:
+        db_path: Filesystem path to the VelesDB database directory.
+        collection_name: Name of the graph collection to open.
+
+    Returns:
+        PyGraphCollection instance.
+
+    Raises:
+        ImportError: If the *velesdb* package is not installed.
+        ValueError: If the graph collection cannot be found.
+    """
+    try:
+        import velesdb  # type: ignore[import]
+    except ImportError as exc:
+        raise ImportError(
+            "The 'velesdb' package is required for native mode. "
+            "Install it with: pip install velesdb"
+        ) from exc
+
+    db = velesdb.Database(db_path)
+    graph = db.get_graph_collection(collection_name)
+    if graph is None:
+        raise ValueError(
+            f"Graph collection '{collection_name}' not found in database "
+            f"at '{db_path}'"
+        )
+    return graph

velesdb_common-1.9.3/src/velesdb_common/ids.py

@@ -0,0 +1,40 @@
+"""ID generation utilities shared across VelesDB Python integrations."""
+
+from __future__ import annotations
+
+import hashlib
+import random
+import time
+
+
+def make_initial_id_counter() -> int:
+    """Generate an initial counter value for ID generation.
+
+    Uses the current millisecond timestamp plus a large random offset to
+    prevent collisions between concurrent instances or process restarts.
+
+    Returns:
+        A positive integer suitable as an ID counter seed.
+    """
+    return int(time.time() * 1000) + random.randint(1_000_000, 9_999_999)
+
+
+def stable_hash_id(value: str) -> int:
+    """Generate a stable numeric ID from a string using SHA-256.
+
+    Python's ``hash()`` is non-deterministic across processes.  This
+    function uses SHA-256 for consistent IDs across runs.
+
+    Uses 63 bits from SHA-256 for a very low collision probability while
+    keeping a positive integer that is compatible with VelesDB point IDs
+    (positive i64 range).
+
+    Args:
+        value: String to hash.
+
+    Returns:
+        Positive 63-bit integer ID.
+    """
+    hash_bytes = hashlib.sha256(value.encode("utf-8")).digest()
+    # Use 8 bytes (64 bits) and clear the sign bit to stay in positive i64 range.
+    return int.from_bytes(hash_bytes[:8], byteorder="big") & 0x7FFFFFFFFFFFFFFF

velesdb_common-1.9.3/src/velesdb_common/memory.py

@@ -0,0 +1,33 @@
+"""Memory result helpers shared across VelesDB Python integrations."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List
+
+
+def format_procedural_results(results: List[Any]) -> List[Dict[str, Any]]:
+    """Normalise raw procedural-recall results into a consistent dict format.
+
+    Both the LangChain and LlamaIndex procedural memory classes receive the
+    same raw result list from VelesDB and project it to the same four keys.
+    This function is the single canonical implementation of that projection.
+
+    Args:
+        results: Raw result list returned by
+            ``procedural.recall(embedding, top_k=..., min_confidence=...)``.
+            Each element must expose ``"name"``, ``"steps"``,
+            ``"confidence"``, and ``"score"`` keys.
+
+    Returns:
+        List of dicts with exactly the keys ``name``, ``steps``,
+        ``confidence``, and ``score``.
+    """
+    return [
+        {
+            "name": r["name"],
+            "steps": r["steps"],
+            "confidence": r["confidence"],
+            "score": r["score"],
+        }
+        for r in results
+    ]

velesdb_common-1.9.3/src/velesdb_common/security.py

@@ -0,0 +1,398 @@
+"""Security utilities shared across all VelesDB Python integrations.
+
+Provides input validation, sanitisation, and security constants used by both
+the ``langchain_velesdb`` and ``llamaindex_velesdb`` packages.
+
+All public names are re-exported from ``velesdb_common`` for convenience.
+"""
+
+from __future__ import annotations
+
+import math
+import os
+import re
+from typing import Any
+
+# ---------------------------------------------------------------------------
+# Security constants
+# ---------------------------------------------------------------------------
+
+MAX_QUERY_LENGTH = 10_000        # Max characters for VelesQL queries
+MAX_TEXT_LENGTH = 1_000_000      # Max characters per document (1 MB)
+MAX_BATCH_SIZE = 10_000          # Max documents per batch operation
+MAX_K_VALUE = 10_000             # Max top_k for search
+MAX_DIMENSION = 65_536           # Max vector dimension (reasonable for any model)
+MIN_DIMENSION = 1
+MAX_PATH_LENGTH = 4096           # Max path length
+ALLOWED_METRICS = frozenset({"cosine", "euclidean", "dot", "hamming", "jaccard"})
+ALLOWED_STORAGE_MODES = frozenset({"full", "sq8", "binary"})
+MAX_SPARSE_VECTOR_SIZE = 100_000  # Max entries in a sparse vector
+DEFAULT_TIMEOUT_MS = 30_000      # 30 seconds maximum timeout
+
+
+class SecurityError(ValueError):
+    """Raised when a security validation fails."""
+
+
+# ---------------------------------------------------------------------------
+# Path validation
+# ---------------------------------------------------------------------------
+
+def validate_path(path: str) -> str:
+    """Validate and normalise a filesystem path.
+
+    Prevents path traversal attacks and validates path safety.
+
+    Args:
+        path: The path to validate.
+
+    Returns:
+        Normalised absolute path.
+
+    Raises:
+        SecurityError: If path is invalid or potentially malicious.
+    """
+    if not path:
+        raise SecurityError("Path cannot be empty")
+
+    if len(path) > MAX_PATH_LENGTH:
+        raise SecurityError(f"Path exceeds maximum length of {MAX_PATH_LENGTH}")
+
+    # Check for null bytes (path injection) before normalising
+    if "\x00" in path:
+        raise SecurityError("Path contains null bytes")
+
+    # Check for suspicious patterns
+    suspicious_patterns = [
+        r"\.\.[/\\]",  # Parent directory traversal
+        r"^[/\\]{2}",  # UNC paths (network shares)
+    ]
+    for pattern in suspicious_patterns:
+        if re.search(pattern, path):
+            raise SecurityError("Suspicious path pattern detected")
+
+    # Normalise the path
+    try:
+        normalized = os.path.normpath(path)
+        abs_path = os.path.abspath(normalized)
+    except (ValueError, OSError) as exc:
+        raise SecurityError(f"Invalid path: {exc}") from exc
+
+    return abs_path
+
+
+# ---------------------------------------------------------------------------
+# Numeric / range validators
+# ---------------------------------------------------------------------------
+
+def validate_dimension(dimension: int) -> int:
+    """Validate vector dimension.
+
+    Args:
+        dimension: Vector dimension to validate.
+
+    Returns:
+        Validated dimension.
+
+    Raises:
+        SecurityError: If dimension is out of valid range.
+    """
+    if not isinstance(dimension, int):
+        raise SecurityError(
+            f"Dimension must be an integer, got {type(dimension).__name__}"
+        )
+    if dimension < MIN_DIMENSION:
+        raise SecurityError(f"Dimension must be at least {MIN_DIMENSION}")
+    if dimension > MAX_DIMENSION:
+        raise SecurityError(f"Dimension exceeds maximum of {MAX_DIMENSION}")
+    return dimension
+
+
+def validate_k(k: int, param_name: str = "k") -> int:
+    """Validate top-k parameter.
+
+    Args:
+        k: Number of results to return.
+        param_name: Parameter name for error messages.
+
+    Returns:
+        Validated k value.
+
+    Raises:
+        SecurityError: If k is invalid.
+    """
+    if not isinstance(k, int):
+        raise SecurityError(
+            f"{param_name} must be an integer, got {type(k).__name__}"
+        )
+    if k < 1:
+        raise SecurityError(f"{param_name} must be at least 1")
+    if k > MAX_K_VALUE:
+        raise SecurityError(f"{param_name} exceeds maximum of {MAX_K_VALUE}")
+    return k
+
+
+def validate_batch_size(size: int) -> int:
+    """Validate batch operation size.
+
+    Args:
+        size: Number of items in batch.
+
+    Returns:
+        Validated size.
+
+    Raises:
+        SecurityError: If size is negative or exceeds limit.
+    """
+    if size < 0:
+        raise SecurityError(f"Batch size must be non-negative, got {size}")
+    if size > MAX_BATCH_SIZE:
+        raise SecurityError(
+            f"Batch size {size} exceeds maximum of {MAX_BATCH_SIZE}. "
+            f"Process in smaller batches."
+        )
+    return size
+
+
+def validate_weight(weight: float, name: str = "weight") -> float:
+    """Validate a weight parameter (0.0 to 1.0).
+
+    Args:
+        weight: Weight value.
+        name: Parameter name for error messages.
+
+    Returns:
+        Validated weight.
+
+    Raises:
+        SecurityError: If weight is out of range.
+    """
+    if isinstance(weight, bool):
+        raise SecurityError("Weight must be a number, not bool")
+    if not isinstance(weight, (int, float)):
+        raise SecurityError(f"{name} must be a number, got {type(weight).__name__}")
+    if weight < 0.0 or weight > 1.0:
+        raise SecurityError(f"{name} must be between 0.0 and 1.0, got {weight}")
+    return float(weight)
+
+
+def validate_timeout(timeout_ms: int) -> int:
+    """Validate timeout in milliseconds.
+
+    Args:
+        timeout_ms: Timeout value in milliseconds.
+
+    Returns:
+        Validated timeout.
+
+    Raises:
+        SecurityError: If timeout is invalid.
+    """
+    if not isinstance(timeout_ms, int):
+        raise SecurityError(
+            f"Timeout must be an integer, got {type(timeout_ms).__name__}"
+        )
+    if timeout_ms < 1:
+        raise SecurityError("Timeout must be at least 1ms")
+    if timeout_ms > DEFAULT_TIMEOUT_MS:
+        raise SecurityError(
+            f"Timeout exceeds maximum of {DEFAULT_TIMEOUT_MS}ms (30s)"
+        )
+    return timeout_ms
+
+
+# ---------------------------------------------------------------------------
+# String / enum validators
+# ---------------------------------------------------------------------------
+
+def validate_text(text: str, max_length: int = MAX_TEXT_LENGTH) -> str:
+    """Validate text content.
+
+    Args:
+        text: Text to validate.
+        max_length: Maximum allowed length.
+
+    Returns:
+        Validated text.
+
+    Raises:
+        SecurityError: If text is invalid.
+    """
+    if not isinstance(text, str):
+        raise SecurityError(f"Text must be a string, got {type(text).__name__}")
+    if len(text) > max_length:
+        raise SecurityError(f"Text exceeds maximum length of {max_length}")
+    return text
+
+
+def validate_query(query: str) -> str:
+    """Validate a VelesQL query string.
+
+    Args:
+        query: VelesQL query to validate.
+
+    Returns:
+        Validated query.
+
+    Raises:
+        SecurityError: If query is invalid or potentially dangerous.
+    """
+    if not isinstance(query, str):
+        raise SecurityError(f"Query must be a string, got {type(query).__name__}")
+    if len(query) > MAX_QUERY_LENGTH:
+        raise SecurityError(f"Query exceeds maximum length of {MAX_QUERY_LENGTH}")
+    # Null bytes could cause truncation issues
+    if "\x00" in query:
+        raise SecurityError("Query contains null bytes")
+    return query
+
+
+def validate_metric(metric: str) -> str:
+    """Validate distance metric.
+
+    Args:
+        metric: Distance metric name.
+
+    Returns:
+        Validated metric (lowercase).
+
+    Raises:
+        SecurityError: If metric is not allowed.
+    """
+    if not isinstance(metric, str):
+        raise SecurityError(f"Metric must be a string, got {type(metric).__name__}")
+    metric_lower = metric.lower()
+    if metric_lower not in ALLOWED_METRICS:
+        raise SecurityError(
+            f"Invalid metric '{metric}'. Allowed: {', '.join(sorted(ALLOWED_METRICS))}"
+        )
+    return metric_lower
+
+
+def validate_storage_mode(mode: str) -> str:
+    """Validate vector storage mode.
+
+    Args:
+        mode: Storage mode name.
+
+    Returns:
+        Validated storage mode (lowercase).
+
+    Raises:
+        SecurityError: If storage mode is not allowed.
+    """
+    if not isinstance(mode, str):
+        raise SecurityError(
+            f"Storage mode must be a string, got {type(mode).__name__}"
+        )
+    mode_lower = mode.lower()
+    if mode_lower not in ALLOWED_STORAGE_MODES:
+        raise SecurityError(
+            f"Invalid storage mode '{mode}'. "
+            f"Allowed: {', '.join(sorted(ALLOWED_STORAGE_MODES))}"
+        )
+    return mode_lower
+
+
+def validate_collection_name(name: str) -> str:
+    """Validate collection name.
+
+    Args:
+        name: Collection name.
+
+    Returns:
+        Validated name.
+
+    Raises:
+        SecurityError: If name is invalid.
+    """
+    if not isinstance(name, str):
+        raise SecurityError(
+            f"Collection name must be a string, got {type(name).__name__}"
+        )
+    if not name:
+        raise SecurityError("Collection name cannot be empty")
+    if len(name) > 256:
+        raise SecurityError("Collection name exceeds maximum length of 256")
+    # Only allow alphanumeric, underscore, hyphen
+    if not re.match(r"^[a-zA-Z0-9_-]+$", name):
+        raise SecurityError(
+            "Collection name can only contain alphanumeric characters, "
+            "underscores, and hyphens"
+        )
+    return name
+
+
+def validate_url(url: str) -> str:
+    """Validate server URL.
+
+    Args:
+        url: Server URL.
+
+    Returns:
+        Validated URL.
+
+    Raises:
+        SecurityError: If URL is invalid or potentially dangerous.
+    """
+    if not isinstance(url, str):
+        raise SecurityError(f"URL must be a string, got {type(url).__name__}")
+    if not url:
+        raise SecurityError("URL cannot be empty")
+    # Only allow http/https
+    if not url.startswith(("http://", "https://")):
+        raise SecurityError("URL must start with http:// or https://")
+    # Check for common injection patterns
+    if any(c in url for c in ("\n", "\r", "\x00")):
+        raise SecurityError("URL contains invalid characters")
+    return url
+
+
+# ---------------------------------------------------------------------------
+# Sparse vector validators
+# ---------------------------------------------------------------------------
+
+def _validate_sparse_entry(key: Any, value: Any) -> None:
+    """Validate a single sparse vector key-value pair."""
+    if isinstance(key, bool) or not isinstance(key, int):
+        raise SecurityError(
+            f"Sparse vector keys must be int (term IDs), "
+            f"got {type(key).__name__} for key {key!r}"
+        )
+    if not isinstance(value, (int, float)) or isinstance(value, bool):
+        raise SecurityError(
+            f"Sparse vector values must be int or float (weights), "
+            f"got {type(value).__name__} for key {key}"
+        )
+    if isinstance(value, float) and not math.isfinite(value):
+        raise SecurityError(
+            f"Sparse vector weights must be finite, got {value} for key {key}"
+        )
+
+
+def validate_sparse_vector(sparse_vector: Any) -> dict:
+    """Validate a sparse vector dict.
+
+    Sparse vectors map integer term IDs to float weights.
+
+    Args:
+        sparse_vector: Dict mapping int keys to int/float values.
+
+    Returns:
+        Validated sparse vector dict.
+
+    Raises:
+        SecurityError: If sparse vector is invalid.
+    """
+    if not isinstance(sparse_vector, dict):
+        raise SecurityError(
+            f"Sparse vector must be a dict, got {type(sparse_vector).__name__}"
+        )
+    if len(sparse_vector) > MAX_SPARSE_VECTOR_SIZE:
+        raise SecurityError(
+            f"Sparse vector has {len(sparse_vector)} entries, "
+            f"exceeds maximum of {MAX_SPARSE_VECTOR_SIZE}"
+        )
+    for key, value in sparse_vector.items():
+        _validate_sparse_entry(key, value)
+    return sparse_vector

velesdb_common-1.9.3/src/velesdb_common.egg-info/PKG-INFO

@@ -0,0 +1,7 @@
+Metadata-Version: 2.4
+Name: velesdb-common
+Version: 1.9.3
+Summary: Shared utilities for VelesDB Python integrations (internal use)
+Author-email: VelesDB Team <contact@wiscale.fr>
+License: MIT
+Requires-Python: >=3.9

velesdb_common-1.9.3/src/velesdb_common.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+pyproject.toml
+src/velesdb_common/__init__.py
+src/velesdb_common/graph.py
+src/velesdb_common/ids.py
+src/velesdb_common/memory.py
+src/velesdb_common/security.py
+src/velesdb_common.egg-info/PKG-INFO
+src/velesdb_common.egg-info/SOURCES.txt
+src/velesdb_common.egg-info/dependency_links.txt
+src/velesdb_common.egg-info/top_level.txt
+tests/test_graph.py
+tests/test_ids.py
+tests/test_memory.py
+tests/test_security.py

velesdb_common-1.9.3/src/velesdb_common.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

velesdb_common-1.9.3/src/velesdb_common.egg-info/top_level.txt

@@ -0,0 +1 @@
+velesdb_common

velesdb_common-1.9.3/tests/test_graph.py

@@ -0,0 +1,34 @@
+import pytest
+from velesdb_common.graph import (
+    build_graph_rest_payload,
+    is_timeout_exception,
+)
+
+
+def test_build_graph_rest_payload_basic():
+    payload = build_graph_rest_payload("node-1", max_depth=3, expand_k=10, rel_types=[])
+    assert payload["source"] == "node-1"
+    assert payload["max_depth"] == 3
+    assert payload["limit"] == 20  # expand_k * 2
+
+
+def test_build_graph_rest_payload_with_rel_types():
+    payload = build_graph_rest_payload(
+        "node-1", max_depth=2, expand_k=5, rel_types=["KNOWS", "LIKES"]
+    )
+    assert payload["rel_types"] == ["KNOWS", "LIKES"]
+
+
+def test_build_graph_rest_payload_empty_rel_types():
+    payload = build_graph_rest_payload("node-1", max_depth=1, expand_k=10, rel_types=[])
+    assert payload["rel_types"] == []
+
+
+def test_is_timeout_exception_with_timeout():
+    exc = TimeoutError("Connection timed out")
+    assert is_timeout_exception(exc) is True
+
+
+def test_is_timeout_exception_with_other():
+    exc = ValueError("Some error")
+    assert is_timeout_exception(exc) is False

velesdb_common-1.9.3/tests/test_ids.py

@@ -0,0 +1,27 @@
+from velesdb_common.ids import make_initial_id_counter, stable_hash_id
+
+
+def test_make_initial_id_counter_returns_positive_int():
+    counter = make_initial_id_counter()
+    assert isinstance(counter, int)
+    assert counter > 0
+
+
+def test_make_initial_id_counter_unique():
+    counters = {make_initial_id_counter() for _ in range(100)}
+    # At least 90% unique (accounting for rare collisions)
+    assert len(counters) >= 90
+
+
+def test_stable_hash_id_deterministic():
+    assert stable_hash_id("hello") == stable_hash_id("hello")
+
+
+def test_stable_hash_id_different_inputs():
+    assert stable_hash_id("hello") != stable_hash_id("world")
+
+
+def test_stable_hash_id_returns_positive_int():
+    result = stable_hash_id("test")
+    assert isinstance(result, int)
+    assert result > 0

velesdb_common-1.9.3/tests/test_memory.py

@@ -0,0 +1,17 @@
+from velesdb_common.memory import format_procedural_results
+
+
+def test_format_procedural_results_basic():
+    results = [
+        {"name": "proc1", "steps": ["a", "b"], "confidence": 0.9, "score": 0.85},
+    ]
+    formatted = format_procedural_results(results)
+    assert len(formatted) == 1
+    assert formatted[0]["name"] == "proc1"
+    assert formatted[0]["steps"] == ["a", "b"]
+    assert formatted[0]["confidence"] == 0.9
+    assert formatted[0]["score"] == 0.85
+
+
+def test_format_procedural_results_empty():
+    assert format_procedural_results([]) == []

velesdb_common-1.9.3/tests/test_security.py

@@ -0,0 +1,47 @@
+import pytest
+from velesdb_common.security import (
+    validate_batch_size,
+    validate_weight,
+    SecurityError,
+    validate_k,
+    validate_text,
+    ALLOWED_METRICS,
+    ALLOWED_STORAGE_MODES,
+)
+
+
+def test_validate_batch_size_rejects_negative():
+    with pytest.raises(SecurityError, match="non-negative"):
+        validate_batch_size(-1)
+
+
+def test_validate_batch_size_accepts_zero():
+    assert validate_batch_size(0) == 0
+
+
+def test_validate_batch_size_accepts_valid():
+    assert validate_batch_size(100) == 100
+
+
+def test_validate_weight_rejects_bool_true():
+    with pytest.raises(SecurityError, match="not bool"):
+        validate_weight(True)
+
+
+def test_validate_weight_rejects_bool_false():
+    with pytest.raises(SecurityError, match="not bool"):
+        validate_weight(False)
+
+
+def test_validate_weight_accepts_valid_float():
+    assert validate_weight(0.5) == 0.5
+    assert validate_weight(0.0) == 0.0
+    assert validate_weight(1.0) == 1.0
+
+
+def test_allowed_metrics_is_frozenset():
+    assert isinstance(ALLOWED_METRICS, frozenset)
+
+
+def test_allowed_storage_modes_is_frozenset():
+    assert isinstance(ALLOWED_STORAGE_MODES, frozenset)