jsonld-ex 0.1.0__tar.gz

jsonld_ex-0.1.0/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: jsonld-ex
+Version: 0.1.0
+Summary: JSON-LD 1.2 extensions for AI/ML data exchange, security hardening, and validation
+Author-email: Muntaser Aljabry <muntaser@example.com>
+License: MIT
+Keywords: json-ld,linked-data,semantic-web,ai,ml,confidence,provenance,embeddings,security,validation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: PyLD>=2.0.4
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Requires-Dist: ruff>=0.2; extra == "dev"

jsonld_ex-0.1.0/pyproject.toml

@@ -0,0 +1,56 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jsonld-ex"
+version = "0.1.0"
+description = "JSON-LD 1.2 extensions for AI/ML data exchange, security hardening, and validation"
+readme = "README.md"
+license = {text = "MIT"}
+requires-python = ">=3.9"
+authors = [
+    {name = "Muntaser Aljabry", email = "muntaser@example.com"},
+]
+keywords = [
+    "json-ld", "linked-data", "semantic-web", "ai", "ml",
+    "confidence", "provenance", "embeddings", "security", "validation",
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "PyLD>=2.0.4",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.23",
+    "mypy>=1.8",
+    "ruff>=0.2",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+
+[tool.mypy]
+python_version = "3.9"
+strict = true
+
+[tool.ruff]
+target-version = "py39"
+line-length = 100

jsonld_ex-0.1.0/setup.cfg

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

jsonld_ex-0.1.0/src/jsonld_ex/__init__.py

@@ -0,0 +1,30 @@
+"""
+jsonld-ex: JSON-LD 1.2 Extensions for AI/ML, Security, and Validation
+
+Reference implementation of proposed JSON-LD 1.2 extensions.
+Wraps PyLD for core JSON-LD processing and adds extension layers.
+"""
+
+__version__ = "0.1.0"
+
+from jsonld_ex.processor import JsonLdEx
+from jsonld_ex.ai_ml import annotate, get_confidence, get_provenance, filter_by_confidence
+from jsonld_ex.vector import validate_vector, cosine_similarity, vector_term_definition
+from jsonld_ex.security import compute_integrity, verify_integrity, is_context_allowed
+from jsonld_ex.validation import validate_node, validate_document
+
+__all__ = [
+    "JsonLdEx",
+    "annotate",
+    "get_confidence",
+    "get_provenance",
+    "filter_by_confidence",
+    "validate_vector",
+    "cosine_similarity",
+    "vector_term_definition",
+    "compute_integrity",
+    "verify_integrity",
+    "is_context_allowed",
+    "validate_node",
+    "validate_document",
+]

jsonld_ex-0.1.0/src/jsonld_ex/ai_ml.py

@@ -0,0 +1,154 @@
+"""
+AI/ML Extensions for JSON-LD
+
+Provides @confidence, @source, @extractedAt, @method, @humanVerified
+"""
+
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any, Optional, Sequence, Literal
+import math
+
+JSONLD_EX_NAMESPACE = "http://www.w3.org/ns/jsonld-ex/"
+
+
+@dataclass
+class ProvenanceMetadata:
+    """AI/ML provenance metadata attached to a value."""
+    confidence: Optional[float] = None
+    source: Optional[str] = None
+    extracted_at: Optional[str] = None
+    method: Optional[str] = None
+    human_verified: Optional[bool] = None
+
+
+def annotate(
+    value: Any,
+    confidence: Optional[float] = None,
+    source: Optional[str] = None,
+    extracted_at: Optional[str] = None,
+    method: Optional[str] = None,
+    human_verified: Optional[bool] = None,
+) -> dict[str, Any]:
+    """Create an annotated JSON-LD value with provenance metadata."""
+    result: dict[str, Any] = {"@value": value}
+
+    if confidence is not None:
+        _validate_confidence(confidence)
+        result["@confidence"] = confidence
+    if source is not None:
+        result["@source"] = source
+    if extracted_at is not None:
+        result["@extractedAt"] = extracted_at
+    if method is not None:
+        result["@method"] = method
+    if human_verified is not None:
+        result["@humanVerified"] = human_verified
+
+    return result
+
+
+def get_confidence(node: Any) -> Optional[float]:
+    """Extract confidence score from a node or annotated value."""
+    if node is None or not isinstance(node, dict):
+        return None
+
+    # Compact form
+    if "@confidence" in node:
+        return node["@confidence"]
+
+    # Expanded form
+    key = f"{JSONLD_EX_NAMESPACE}confidence"
+    if key in node:
+        val = node[key]
+        if isinstance(val, list) and len(val) > 0:
+            item = val[0]
+            return item.get("@value", item) if isinstance(item, dict) else item
+        if isinstance(val, dict):
+            return val.get("@value", val)
+        return val
+
+    return None
+
+
+def get_provenance(node: Any) -> ProvenanceMetadata:
+    """Extract all provenance metadata from a node."""
+    if node is None or not isinstance(node, dict):
+        return ProvenanceMetadata()
+
+    return ProvenanceMetadata(
+        confidence=_extract_field(node, "confidence", "@confidence"),
+        source=_extract_field(node, "source", "@source"),
+        extracted_at=_extract_field(node, "extractedAt", "@extractedAt"),
+        method=_extract_field(node, "method", "@method"),
+        human_verified=_extract_field(node, "humanVerified", "@humanVerified"),
+    )
+
+
+def filter_by_confidence(
+    graph: Sequence[dict[str, Any]],
+    property_name: str,
+    min_confidence: float,
+) -> list[dict[str, Any]]:
+    """Filter graph nodes by minimum confidence on a property."""
+    _validate_confidence(min_confidence)
+    results = []
+    for node in graph:
+        prop_value = node.get(property_name)
+        if prop_value is None:
+            continue
+        values = prop_value if isinstance(prop_value, list) else [prop_value]
+        if any(
+            (c := get_confidence(v)) is not None and c >= min_confidence
+            for v in values
+        ):
+            results.append(node)
+    return results
+
+
+def aggregate_confidence(
+    scores: Sequence[float],
+    strategy: Literal["mean", "max", "min", "weighted"] = "mean",
+    weights: Optional[Sequence[float]] = None,
+) -> float:
+    """Aggregate multiple confidence scores."""
+    if len(scores) == 0:
+        return 0.0
+    for s in scores:
+        _validate_confidence(s)
+
+    if strategy == "max":
+        return max(scores)
+    elif strategy == "min":
+        return min(scores)
+    elif strategy == "weighted":
+        if weights is None or len(weights) != len(scores):
+            raise ValueError("Weights must match scores length")
+        total_weight = sum(weights)
+        return sum(s * w for s, w in zip(scores, weights)) / total_weight
+    else:  # mean
+        return sum(scores) / len(scores)
+
+
+# ── Internal ───────────────────────────────────────────────────────
+
+def _validate_confidence(score: float) -> None:
+    if not isinstance(score, (int, float)) or score < 0 or score > 1:
+        raise ValueError(f"@confidence must be between 0.0 and 1.0, got: {score}")
+
+
+def _extract_field(node: dict, compact_name: str, keyword: str) -> Any:
+    if keyword in node:
+        return node[keyword]
+    if compact_name in node:
+        return node[compact_name]
+    expanded_key = f"{JSONLD_EX_NAMESPACE}{compact_name}"
+    if expanded_key in node:
+        val = node[expanded_key]
+        if isinstance(val, list) and len(val) > 0:
+            item = val[0]
+            return item.get("@value", item) if isinstance(item, dict) else item
+        if isinstance(val, dict):
+            return val.get("@value", val)
+        return val
+    return None

jsonld_ex-0.1.0/src/jsonld_ex/processor.py

@@ -0,0 +1,91 @@
+"""
+JsonLdEx — Extended JSON-LD Processor (Python)
+
+Wraps PyLD with backward-compatible extensions for AI/ML,
+security, and validation.
+"""
+
+from __future__ import annotations
+from typing import Any, Optional
+
+from pyld import jsonld
+
+from jsonld_ex.ai_ml import (
+    annotate, get_confidence, get_provenance,
+    filter_by_confidence, aggregate_confidence, ProvenanceMetadata,
+)
+from jsonld_ex.vector import (
+    vector_term_definition, validate_vector, cosine_similarity,
+    extract_vectors, strip_vectors_for_rdf,
+)
+from jsonld_ex.security import (
+    compute_integrity, verify_integrity, integrity_context,
+    is_context_allowed, enforce_resource_limits, DEFAULT_RESOURCE_LIMITS,
+)
+from jsonld_ex.validation import validate_node, validate_document, ValidationResult
+
+
+class JsonLdEx:
+    """Extended JSON-LD processor wrapping PyLD."""
+
+    def __init__(
+        self,
+        resource_limits: Optional[dict[str, int]] = None,
+        context_allowlist: Optional[dict[str, Any]] = None,
+    ):
+        self._limits = {**DEFAULT_RESOURCE_LIMITS, **(resource_limits or {})}
+        self._allowlist = context_allowlist
+
+    # ── Core Operations ──────────────────────────────────────────
+
+    def expand(self, doc: dict[str, Any], **kwargs: Any) -> list[dict[str, Any]]:
+        """Expand a JSON-LD document with resource limit enforcement."""
+        enforce_resource_limits(doc, self._limits)
+        return jsonld.expand(doc, kwargs)
+
+    def compact(self, doc: dict[str, Any], ctx: Any, **kwargs: Any) -> dict[str, Any]:
+        """Compact a JSON-LD document."""
+        enforce_resource_limits(doc, self._limits)
+        return jsonld.compact(doc, ctx, kwargs)
+
+    def flatten(self, doc: dict[str, Any], ctx: Any = None, **kwargs: Any) -> dict[str, Any]:
+        """Flatten a JSON-LD document."""
+        enforce_resource_limits(doc, self._limits)
+        return jsonld.flatten(doc, ctx, kwargs)
+
+    def to_rdf(self, doc: dict[str, Any], **kwargs: Any) -> str:
+        """Convert to N-Quads."""
+        enforce_resource_limits(doc, self._limits)
+        return jsonld.to_rdf(doc, {**kwargs, "format": "application/n-quads"})
+
+    def from_rdf(self, nquads: str, **kwargs: Any) -> list[dict[str, Any]]:
+        """Convert N-Quads to JSON-LD."""
+        return jsonld.from_rdf(nquads, kwargs)
+
+    # ── AI/ML Extensions ─────────────────────────────────────────
+
+    annotate = staticmethod(annotate)
+    get_confidence = staticmethod(get_confidence)
+    get_provenance = staticmethod(get_provenance)
+    filter_by_confidence = staticmethod(filter_by_confidence)
+    aggregate_confidence = staticmethod(aggregate_confidence)
+
+    # ── Vector Extensions ────────────────────────────────────────
+
+    vector_term_definition = staticmethod(vector_term_definition)
+    validate_vector = staticmethod(validate_vector)
+    cosine_similarity = staticmethod(cosine_similarity)
+    extract_vectors = staticmethod(extract_vectors)
+    strip_vectors_for_rdf = staticmethod(strip_vectors_for_rdf)
+
+    # ── Security Extensions ──────────────────────────────────────
+
+    compute_integrity = staticmethod(compute_integrity)
+    verify_integrity = staticmethod(verify_integrity)
+    integrity_context = staticmethod(integrity_context)
+    is_context_allowed = staticmethod(is_context_allowed)
+
+    # ── Validation Extensions ────────────────────────────────────
+
+    validate_node = staticmethod(validate_node)
+    validate_document = staticmethod(validate_document)

jsonld_ex-0.1.0/src/jsonld_ex/security.py

@@ -0,0 +1,92 @@
+"""Security Extensions for JSON-LD."""
+
+from __future__ import annotations
+import hashlib
+import base64
+import json
+import re
+from typing import Any, Optional
+
+
+DEFAULT_RESOURCE_LIMITS = {
+    "max_context_depth": 10,
+    "max_graph_depth": 100,
+    "max_document_size": 10 * 1024 * 1024,  # 10 MB
+    "max_expansion_time": 30,  # seconds
+}
+
+SUPPORTED_ALGORITHMS = ("sha256", "sha384", "sha512")
+
+
+def compute_integrity(
+    context: str | dict | Any, algorithm: str = "sha256"
+) -> str:
+    """Compute an integrity hash for a context."""
+    if algorithm not in SUPPORTED_ALGORITHMS:
+        raise ValueError(f"Unsupported algorithm: {algorithm}")
+    content = context if isinstance(context, str) else json.dumps(context)
+    h = hashlib.new(algorithm, content.encode("utf-8")).digest()
+    b64 = base64.b64encode(h).decode("ascii")
+    return f"{algorithm}-{b64}"
+
+
+def verify_integrity(context: str | dict | Any, declared: str) -> bool:
+    """Verify context content against its declared integrity hash."""
+    parts = declared.split("-", 1)
+    if len(parts) != 2 or parts[0] not in SUPPORTED_ALGORITHMS:
+        raise ValueError(f"Invalid integrity string: {declared}")
+    computed = compute_integrity(context, parts[0])
+    return computed == declared
+
+
+def integrity_context(
+    url: str, content: str | dict | Any, algorithm: str = "sha256"
+) -> dict[str, str]:
+    """Create a context reference with integrity verification."""
+    return {"@id": url, "@integrity": compute_integrity(content, algorithm)}
+
+
+def is_context_allowed(url: str, config: dict[str, Any]) -> bool:
+    """Check if a context URL is permitted by an allowlist configuration."""
+    if config.get("block_remote_contexts", False):
+        return False
+    allowed = config.get("allowed", [])
+    if url in allowed:
+        return True
+    for pattern in config.get("patterns", []):
+        if isinstance(pattern, str):
+            regex = "^" + re.escape(pattern).replace(r"\*", ".*").replace(r"\?", ".") + "$"
+            if re.match(regex, url):
+                return True
+    if allowed or config.get("patterns"):
+        return False
+    return True
+
+
+def enforce_resource_limits(
+    document: str | dict | Any,
+    limits: Optional[dict[str, int]] = None,
+) -> None:
+    """Validate document against resource limits before processing."""
+    resolved = {**DEFAULT_RESOURCE_LIMITS, **(limits or {})}
+    content = document if isinstance(document, str) else json.dumps(document)
+    if len(content) > resolved["max_document_size"]:
+        raise ValueError(
+            f"Document size {len(content)} exceeds limit {resolved['max_document_size']}"
+        )
+    parsed = json.loads(content) if isinstance(document, str) else document
+    depth = _measure_depth(parsed)
+    if depth > resolved["max_graph_depth"]:
+        raise ValueError(
+            f"Document depth {depth} exceeds limit {resolved['max_graph_depth']}"
+        )
+
+
+def _measure_depth(obj: Any, current: int = 0) -> int:
+    if obj is None or not isinstance(obj, (dict, list)):
+        return current
+    max_depth = current
+    items = obj if isinstance(obj, list) else obj.values()
+    for item in items:
+        max_depth = max(max_depth, _measure_depth(item, current + 1))
+    return max_depth

jsonld_ex-0.1.0/src/jsonld_ex/validation.py

@@ -0,0 +1,186 @@
+"""Validation Extensions for JSON-LD (@shape)."""
+
+from __future__ import annotations
+import re
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import Any, Optional, Sequence
+
+
+@dataclass
+class ValidationError:
+    path: str
+    constraint: str
+    message: str
+    value: Any = None
+
+
+@dataclass
+class ValidationWarning:
+    path: str
+    code: str
+    message: str
+
+
+@dataclass
+class ValidationResult:
+    valid: bool
+    errors: list[ValidationError] = field(default_factory=list)
+    warnings: list[ValidationWarning] = field(default_factory=list)
+
+
+XSD = "http://www.w3.org/2001/XMLSchema#"
+
+
+def validate_node(node: dict[str, Any], shape: dict[str, Any]) -> ValidationResult:
+    """Validate a JSON-LD node against a shape definition."""
+    errors: list[ValidationError] = []
+    warnings: list[ValidationWarning] = []
+
+    if not isinstance(node, dict):
+        errors.append(ValidationError(".", "type", "Node must be a dict"))
+        return ValidationResult(False, errors, warnings)
+
+    # Type check
+    if "@type" in shape:
+        node_types = _get_types(node)
+        if shape["@type"] not in node_types:
+            errors.append(ValidationError(
+                "@type", "type",
+                f'Expected type "{shape["@type"]}", found: {node_types}',
+                node_types,
+            ))
+
+    # Property constraints
+    for prop, constraint in shape.items():
+        if prop.startswith("@") or not isinstance(constraint, dict):
+            continue
+
+        value = node.get(prop)
+        raw = _extract_raw(value)
+
+        if constraint.get("@required") and raw is None:
+            errors.append(ValidationError(prop, "required", f'Property "{prop}" is required'))
+            continue
+
+        if raw is None:
+            continue
+
+        # Type check
+        expected_type = constraint.get("@type")
+        if expected_type:
+            type_err = _validate_type(raw, expected_type)
+            if type_err:
+                errors.append(ValidationError(prop, "type", type_err, raw))
+
+        # Numeric
+        if "@minimum" in constraint and isinstance(raw, (int, float)):
+            if raw < constraint["@minimum"]:
+                errors.append(ValidationError(
+                    prop, "minimum",
+                    f"Value {raw} below minimum {constraint['@minimum']}", raw,
+                ))
+
+        if "@maximum" in constraint and isinstance(raw, (int, float)):
+            if raw > constraint["@maximum"]:
+                errors.append(ValidationError(
+                    prop, "maximum",
+                    f"Value {raw} exceeds maximum {constraint['@maximum']}", raw,
+                ))
+
+        # String length
+        if "@minLength" in constraint and isinstance(raw, str):
+            if len(raw) < constraint["@minLength"]:
+                errors.append(ValidationError(
+                    prop, "minLength",
+                    f"Length {len(raw)} below minimum {constraint['@minLength']}", raw,
+                ))
+
+        if "@maxLength" in constraint and isinstance(raw, str):
+            if len(raw) > constraint["@maxLength"]:
+                errors.append(ValidationError(
+                    prop, "maxLength",
+                    f"Length {len(raw)} exceeds maximum {constraint['@maxLength']}", raw,
+                ))
+
+        # Pattern
+        if "@pattern" in constraint and isinstance(raw, str):
+            if not re.search(constraint["@pattern"], raw):
+                errors.append(ValidationError(
+                    prop, "pattern",
+                    f'"{raw}" does not match pattern "{constraint["@pattern"]}"', raw,
+                ))
+
+    return ValidationResult(len(errors) == 0, errors, warnings)
+
+
+def validate_document(
+    doc: dict[str, Any], shapes: Sequence[dict[str, Any]]
+) -> ValidationResult:
+    """Validate all matching nodes in a document against shapes."""
+    all_errors: list[ValidationError] = []
+    all_warnings: list[ValidationWarning] = []
+
+    for node in _extract_nodes(doc):
+        node_types = _get_types(node)
+        for shape in shapes:
+            if shape.get("@type") in node_types:
+                result = validate_node(node, shape)
+                for e in result.errors:
+                    e.path = f"{node.get('@id', 'anonymous')}/{e.path}"
+                all_errors.extend(result.errors)
+                all_warnings.extend(result.warnings)
+
+    return ValidationResult(len(all_errors) == 0, all_errors, all_warnings)
+
+
+# ── Internal ───────────────────────────────────────────────────────
+
+def _get_types(node: dict) -> list[str]:
+    t = node.get("@type")
+    if t is None:
+        return []
+    return t if isinstance(t, list) else [t]
+
+
+def _extract_raw(value: Any) -> Any:
+    if value is None:
+        return None
+    if isinstance(value, dict) and "@value" in value:
+        return value["@value"]
+    if isinstance(value, list) and len(value) > 0:
+        return _extract_raw(value[0])
+    return value
+
+
+def _extract_nodes(doc: Any) -> list[dict]:
+    if isinstance(doc, list):
+        nodes = []
+        for item in doc:
+            nodes.extend(_extract_nodes(item))
+        return nodes
+    if not isinstance(doc, dict):
+        return []
+    nodes = []
+    if "@type" in doc:
+        nodes.append(doc)
+    if "@graph" in doc:
+        nodes.extend(_extract_nodes(doc["@graph"]))
+    return nodes
+
+
+def _validate_type(value: Any, expected: str) -> Optional[str]:
+    xsd_type = expected.replace("xsd:", XSD) if expected.startswith("xsd:") else expected
+    checks = {
+        f"{XSD}string": lambda v: isinstance(v, str),
+        f"{XSD}integer": lambda v: isinstance(v, int) and not isinstance(v, bool),
+        f"{XSD}double": lambda v: isinstance(v, (int, float)),
+        f"{XSD}float": lambda v: isinstance(v, (int, float)),
+        f"{XSD}decimal": lambda v: isinstance(v, (int, float)),
+        f"{XSD}boolean": lambda v: isinstance(v, bool),
+    }
+    checker = checks.get(xsd_type)
+    if checker and not checker(value):
+        short = expected if expected.startswith("xsd:") else xsd_type
+        return f"Expected {short}, got {type(value).__name__}: {value}"
+    return None

jsonld_ex-0.1.0/src/jsonld_ex/vector.py

@@ -0,0 +1,76 @@
+"""Vector Embedding Extensions for JSON-LD."""
+
+from __future__ import annotations
+import math
+from typing import Any, Optional
+
+
+def vector_term_definition(
+    term_name: str, iri: str, dimensions: Optional[int] = None
+) -> dict[str, Any]:
+    """Create a context term definition for a vector embedding property."""
+    defn: dict[str, Any] = {"@id": iri, "@container": "@vector"}
+    if dimensions is not None:
+        if not isinstance(dimensions, int) or dimensions < 1:
+            raise ValueError(f"@dimensions must be a positive integer, got: {dimensions}")
+        defn["@dimensions"] = dimensions
+    return {term_name: defn}
+
+
+def validate_vector(
+    vector: Any, expected_dimensions: Optional[int] = None
+) -> tuple[bool, list[str]]:
+    """Validate a vector embedding. Returns (valid, errors)."""
+    errors: list[str] = []
+    if not isinstance(vector, (list, tuple)):
+        errors.append(f"Vector must be a list, got: {type(vector).__name__}")
+        return False, errors
+    if len(vector) == 0:
+        errors.append("Vector must not be empty")
+        return False, errors
+    for i, v in enumerate(vector):
+        if not isinstance(v, (int, float)) or math.isnan(v) or math.isinf(v):
+            errors.append(f"Vector element [{i}] must be a finite number, got: {v}")
+    if expected_dimensions is not None and len(vector) != expected_dimensions:
+        errors.append(
+            f"Vector dimension mismatch: expected {expected_dimensions}, got {len(vector)}"
+        )
+    return len(errors) == 0, errors
+
+
+def cosine_similarity(a: list[float], b: list[float]) -> float:
+    """Compute cosine similarity between two vectors."""
+    if len(a) != len(b):
+        raise ValueError(f"Vector dimension mismatch: {len(a)} vs {len(b)}")
+    dot = sum(x * y for x, y in zip(a, b))
+    norm_a = math.sqrt(sum(x * x for x in a))
+    norm_b = math.sqrt(sum(x * x for x in b))
+    denom = norm_a * norm_b
+    return dot / denom if denom != 0 else 0.0
+
+
+def extract_vectors(
+    node: dict[str, Any], vector_properties: list[str]
+) -> dict[str, list[float]]:
+    """Extract vector embeddings from a JSON-LD node."""
+    vectors: dict[str, list[float]] = {}
+    if not isinstance(node, dict):
+        return vectors
+    for prop in vector_properties:
+        value = node.get(prop)
+        if isinstance(value, list) and len(value) > 0 and isinstance(value[0], (int, float)):
+            vectors[prop] = value
+    return vectors
+
+
+def strip_vectors_for_rdf(doc: Any, vector_properties: list[str]) -> Any:
+    """Remove vector embeddings before RDF conversion."""
+    if isinstance(doc, list):
+        return [strip_vectors_for_rdf(item, vector_properties) for item in doc]
+    if not isinstance(doc, dict):
+        return doc
+    return {
+        k: strip_vectors_for_rdf(v, vector_properties)
+        for k, v in doc.items()
+        if k not in vector_properties
+    }

jsonld_ex-0.1.0/src/jsonld_ex.egg-info/PKG-INFO

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: jsonld-ex
+Version: 0.1.0
+Summary: JSON-LD 1.2 extensions for AI/ML data exchange, security hardening, and validation
+Author-email: Muntaser Aljabry <muntaser@example.com>
+License: MIT
+Keywords: json-ld,linked-data,semantic-web,ai,ml,confidence,provenance,embeddings,security,validation
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: PyLD>=2.0.4
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.23; extra == "dev"
+Requires-Dist: mypy>=1.8; extra == "dev"
+Requires-Dist: ruff>=0.2; extra == "dev"

jsonld_ex-0.1.0/src/jsonld_ex.egg-info/SOURCES.txt

@@ -0,0 +1,14 @@
+pyproject.toml
+src/jsonld_ex/__init__.py
+src/jsonld_ex/ai_ml.py
+src/jsonld_ex/processor.py
+src/jsonld_ex/security.py
+src/jsonld_ex/validation.py
+src/jsonld_ex/vector.py
+src/jsonld_ex.egg-info/PKG-INFO
+src/jsonld_ex.egg-info/SOURCES.txt
+src/jsonld_ex.egg-info/dependency_links.txt
+src/jsonld_ex.egg-info/requires.txt
+src/jsonld_ex.egg-info/top_level.txt
+tests/test_ai_ml.py
+tests/test_validation.py

jsonld_ex-0.1.0/src/jsonld_ex.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jsonld_ex-0.1.0/src/jsonld_ex.egg-info/requires.txt

@@ -0,0 +1,7 @@
+PyLD>=2.0.4
+
+[dev]
+pytest>=7.0
+pytest-asyncio>=0.23
+mypy>=1.8
+ruff>=0.2

jsonld_ex-0.1.0/src/jsonld_ex.egg-info/top_level.txt

@@ -0,0 +1 @@
+jsonld_ex

jsonld_ex-0.1.0/tests/test_ai_ml.py

@@ -0,0 +1,96 @@
+"""Tests for AI/ML extensions."""
+
+import pytest
+from jsonld_ex.ai_ml import (
+    annotate, get_confidence, get_provenance,
+    filter_by_confidence, aggregate_confidence,
+)
+
+
+class TestAnnotate:
+    def test_basic_confidence(self):
+        result = annotate("John Smith", confidence=0.95)
+        assert result == {"@value": "John Smith", "@confidence": 0.95}
+
+    def test_full_provenance(self):
+        result = annotate(
+            "John Smith",
+            confidence=0.95,
+            source="https://model.example.org/ner-v2",
+            extracted_at="2026-01-15T10:30:00Z",
+            method="NER",
+            human_verified=False,
+        )
+        assert result["@confidence"] == 0.95
+        assert result["@source"] == "https://model.example.org/ner-v2"
+        assert result["@method"] == "NER"
+        assert result["@humanVerified"] is False
+
+    def test_rejects_invalid_confidence(self):
+        with pytest.raises(ValueError):
+            annotate("x", confidence=1.5)
+        with pytest.raises(ValueError):
+            annotate("x", confidence=-0.1)
+
+    def test_numeric_value(self):
+        result = annotate(42, confidence=0.8)
+        assert result["@value"] == 42
+
+
+class TestGetConfidence:
+    def test_compact_form(self):
+        assert get_confidence({"@value": "test", "@confidence": 0.9}) == 0.9
+
+    def test_expanded_form(self):
+        node = {
+            "http://www.w3.org/ns/jsonld-ex/confidence": [{"@value": 0.85}]
+        }
+        assert get_confidence(node) == 0.85
+
+    def test_missing(self):
+        assert get_confidence({"@value": "test"}) is None
+        assert get_confidence(None) is None
+
+
+class TestGetProvenance:
+    def test_extracts_all(self):
+        node = {"@confidence": 0.9, "@source": "https://x.org/v1", "@method": "NER"}
+        prov = get_provenance(node)
+        assert prov.confidence == 0.9
+        assert prov.source == "https://x.org/v1"
+        assert prov.method == "NER"
+
+
+class TestFilterByConfidence:
+    graph = [
+        {"@id": "#a", "name": {"@value": "Alice", "@confidence": 0.95}},
+        {"@id": "#b", "name": {"@value": "Bob", "@confidence": 0.6}},
+        {"@id": "#c", "name": {"@value": "Charlie", "@confidence": 0.3}},
+    ]
+
+    def test_filters_above_threshold(self):
+        result = filter_by_confidence(self.graph, "name", 0.5)
+        assert len(result) == 2
+        assert result[0]["@id"] == "#a"
+
+    def test_high_threshold(self):
+        result = filter_by_confidence(self.graph, "name", 0.99)
+        assert len(result) == 0
+
+
+class TestAggregateConfidence:
+    def test_mean(self):
+        assert abs(aggregate_confidence([0.8, 0.6, 0.4]) - 0.6) < 1e-9
+
+    def test_max(self):
+        assert aggregate_confidence([0.8, 0.6, 0.4], "max") == 0.8
+
+    def test_min(self):
+        assert aggregate_confidence([0.8, 0.6, 0.4], "min") == 0.4
+
+    def test_weighted(self):
+        result = aggregate_confidence([0.9, 0.5], "weighted", [3, 1])
+        assert abs(result - 0.8) < 1e-9
+
+    def test_empty(self):
+        assert aggregate_confidence([]) == 0.0

jsonld_ex-0.1.0/tests/test_validation.py

@@ -0,0 +1,63 @@
+"""Tests for validation extensions."""
+
+import pytest
+from jsonld_ex.validation import validate_node, validate_document
+
+
+PERSON_SHAPE = {
+    "@type": "Person",
+    "name": {"@required": True, "@type": "xsd:string", "@minLength": 1},
+    "email": {"@pattern": r"^[^@]+@[^@]+$"},
+    "age": {"@type": "xsd:integer", "@minimum": 0, "@maximum": 150},
+}
+
+
+class TestValidateNode:
+    def test_valid_node(self):
+        node = {"@type": "Person", "name": "John", "email": "j@x.com", "age": 30}
+        result = validate_node(node, PERSON_SHAPE)
+        assert result.valid
+
+    def test_missing_required(self):
+        node = {"@type": "Person", "email": "j@x.com"}
+        result = validate_node(node, PERSON_SHAPE)
+        assert not result.valid
+        assert any(e.constraint == "required" for e in result.errors)
+
+    def test_type_mismatch(self):
+        node = {"@type": "Person", "name": 12345}
+        result = validate_node(node, PERSON_SHAPE)
+        assert not result.valid
+
+    def test_below_minimum(self):
+        node = {"@type": "Person", "name": "Test", "age": -5}
+        result = validate_node(node, PERSON_SHAPE)
+        assert any(e.constraint == "minimum" for e in result.errors)
+
+    def test_above_maximum(self):
+        node = {"@type": "Person", "name": "Test", "age": 200}
+        result = validate_node(node, PERSON_SHAPE)
+        assert any(e.constraint == "maximum" for e in result.errors)
+
+    def test_pattern_mismatch(self):
+        node = {"@type": "Person", "name": "Test", "email": "bad"}
+        result = validate_node(node, PERSON_SHAPE)
+        assert any(e.constraint == "pattern" for e in result.errors)
+
+    def test_optional_absent(self):
+        node = {"@type": "Person", "name": "Test"}
+        result = validate_node(node, PERSON_SHAPE)
+        assert result.valid
+
+
+class TestValidateDocument:
+    def test_validates_graph(self):
+        doc = {
+            "@graph": [
+                {"@type": "Person", "name": "Alice"},
+                {"@type": "Person"},  # missing name
+            ]
+        }
+        result = validate_document(doc, [PERSON_SHAPE])
+        assert not result.valid
+        assert len(result.errors) == 1