jsonld-ex 0.1.0__py3-none-any.whl → 0.1.3__py3-none-any.whl

jsonld_ex/__init__.py

@@ -5,7 +5,7 @@ Reference implementation of proposed JSON-LD 1.2 extensions.
 Wraps PyLD for core JSON-LD processing and adds extension layers.
 """
 
-__version__ = "0.1.0"
+__version__ = "0.1.3"
 
 from jsonld_ex.processor import JsonLdEx
 from jsonld_ex.ai_ml import annotate, get_confidence, get_provenance, filter_by_confidence

jsonld_ex/ai_ml.py

@@ -124,7 +124,14 @@ def aggregate_confidence(
     elif strategy == "weighted":
         if weights is None or len(weights) != len(scores):
             raise ValueError("Weights must match scores length")
+        for w in weights:
+            if not isinstance(w, (int, float)) or isinstance(w, bool):
+                raise TypeError(f"Weight must be a number, got: {type(w).__name__}")
+            if w < 0:
+                raise ValueError(f"Weight must be non-negative, got: {w}")
         total_weight = sum(weights)
+        if total_weight == 0:
+            raise ValueError("Total weight must be greater than zero")
         return sum(s * w for s, w in zip(scores, weights)) / total_weight
     else:  # mean
         return sum(scores) / len(scores)
@@ -133,7 +140,11 @@ def aggregate_confidence(
 # ── Internal ───────────────────────────────────────────────────────
 
 def _validate_confidence(score: float) -> None:
-    if not isinstance(score, (int, float)) or score < 0 or score > 1:
+    if not isinstance(score, (int, float)) or isinstance(score, bool):
+        raise TypeError(f"@confidence must be a number, got: {type(score).__name__}")
+    if math.isnan(score) or math.isinf(score):
+        raise ValueError(f"@confidence must be finite, got: {score}")
+    if score < 0 or score > 1:
         raise ValueError(f"@confidence must be between 0.0 and 1.0, got: {score}")
 
 

jsonld_ex/security.py

@@ -22,9 +22,14 @@ def compute_integrity(
     context: str | dict | Any, algorithm: str = "sha256"
 ) -> str:
     """Compute an integrity hash for a context."""
+    if context is None:
+        raise TypeError("Context must not be None")
     if algorithm not in SUPPORTED_ALGORITHMS:
         raise ValueError(f"Unsupported algorithm: {algorithm}")
-    content = context if isinstance(context, str) else json.dumps(context)
+    try:
+        content = context if isinstance(context, str) else json.dumps(context, sort_keys=True)
+    except (TypeError, ValueError) as exc:
+        raise TypeError(f"Context is not JSON-serializable: {exc}") from exc
     h = hashlib.new(algorithm, content.encode("utf-8")).digest()
     b64 = base64.b64encode(h).decode("ascii")
     return f"{algorithm}-{b64}"
@@ -63,18 +68,39 @@ def is_context_allowed(url: str, config: dict[str, Any]) -> bool:
     return True
 
 
+_MAX_RECURSION_DEPTH = 500  # Safety cap for _measure_depth
+
+
 def enforce_resource_limits(
     document: str | dict | Any,
     limits: Optional[dict[str, int]] = None,
 ) -> None:
     """Validate document against resource limits before processing."""
+    if document is None:
+        raise TypeError("Document must not be None")
     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
+    if isinstance(document, str):
+        content = document
+        if len(content) > resolved["max_document_size"]:
+            raise ValueError(
+                f"Document size {len(content)} exceeds limit {resolved['max_document_size']}"
+            )
+        try:
+            parsed = json.loads(content)
+        except json.JSONDecodeError as exc:
+            raise ValueError(f"Document is not valid JSON: {exc}") from exc
+    elif isinstance(document, (dict, list)):
+        try:
+            content = json.dumps(document)
+        except (TypeError, ValueError) as exc:
+            raise TypeError(f"Document is not JSON-serializable: {exc}") from exc
+        if len(content) > resolved["max_document_size"]:
+            raise ValueError(
+                f"Document size {len(content)} exceeds limit {resolved['max_document_size']}"
+            )
+        parsed = document
+    else:
+        raise TypeError(f"Document must be a str, dict, or list, got: {type(document).__name__}")
     depth = _measure_depth(parsed)
     if depth > resolved["max_graph_depth"]:
         raise ValueError(
@@ -83,6 +109,8 @@ def enforce_resource_limits(
 
 
 def _measure_depth(obj: Any, current: int = 0) -> int:
+    if current > _MAX_RECURSION_DEPTH:
+        return current  # Safety cap to prevent stack overflow
     if obj is None or not isinstance(obj, (dict, list)):
         return current
     max_depth = current

jsonld_ex/validation.py

@@ -73,15 +73,15 @@ def validate_node(node: dict[str, Any], shape: dict[str, Any]) -> ValidationResu
             if type_err:
                 errors.append(ValidationError(prop, "type", type_err, raw))
 
-        # Numeric
-        if "@minimum" in constraint and isinstance(raw, (int, float)):
+        # Numeric (exclude booleans — they are int subclass in Python)
+        if "@minimum" in constraint and isinstance(raw, (int, float)) and not isinstance(raw, bool):
             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 "@maximum" in constraint and isinstance(raw, (int, float)) and not isinstance(raw, bool):
             if raw > constraint["@maximum"]:
                 errors.append(ValidationError(
                     prop, "maximum",
@@ -105,10 +105,16 @@ def validate_node(node: dict[str, Any], shape: dict[str, Any]) -> ValidationResu
 
         # Pattern
         if "@pattern" in constraint and isinstance(raw, str):
-            if not re.search(constraint["@pattern"], raw):
+            try:
+                if not re.search(constraint["@pattern"], raw):
+                    errors.append(ValidationError(
+                        prop, "pattern",
+                        f'"{raw}" does not match pattern "{constraint["@pattern"]}"', raw,
+                    ))
+            except re.error as exc:
                 errors.append(ValidationError(
                     prop, "pattern",
-                    f'"{raw}" does not match pattern "{constraint["@pattern"]}"', raw,
+                    f'Invalid regex pattern "{constraint["@pattern"]}": {exc}', raw,
                 ))
 
     return ValidationResult(len(errors) == 0, errors, warnings)
@@ -148,8 +154,12 @@ def _extract_raw(value: Any) -> Any:
         return None
     if isinstance(value, dict) and "@value" in value:
         return value["@value"]
+    if isinstance(value, dict) and not any(k.startswith("@") for k in value):
+        return None  # Plain dict without JSON-LD keywords — treat as absent
     if isinstance(value, list) and len(value) > 0:
         return _extract_raw(value[0])
+    if isinstance(value, list) and len(value) == 0:
+        return None
     return value
 
 
@@ -174,9 +184,9 @@ def _validate_type(value: Any, expected: str) -> Optional[str]:
     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}double": lambda v: isinstance(v, (int, float)) and not isinstance(v, bool),
+        f"{XSD}float": lambda v: isinstance(v, (int, float)) and not isinstance(v, bool),
+        f"{XSD}decimal": lambda v: isinstance(v, (int, float)) and not isinstance(v, bool),
         f"{XSD}boolean": lambda v: isinstance(v, bool),
     }
     checker = checks.get(xsd_type)

jsonld_ex/vector.py

@@ -11,7 +11,7 @@ def vector_term_definition(
     """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:
+        if not isinstance(dimensions, int) or isinstance(dimensions, bool) or dimensions < 1:
             raise ValueError(f"@dimensions must be a positive integer, got: {dimensions}")
         defn["@dimensions"] = dimensions
     return {term_name: defn}
@@ -29,7 +29,7 @@ def validate_vector(
         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):
+        if isinstance(v, bool) or 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(
@@ -39,9 +39,20 @@ def validate_vector(
 
 
 def cosine_similarity(a: list[float], b: list[float]) -> float:
-    """Compute cosine similarity between two vectors."""
+    """Compute cosine similarity between two vectors.
+
+    Returns 0.0 when either vector is a zero vector (norm == 0).
+    """
     if len(a) != len(b):
         raise ValueError(f"Vector dimension mismatch: {len(a)} vs {len(b)}")
+    if len(a) == 0:
+        raise ValueError("Vectors must not be empty")
+    for i, (x, y) in enumerate(zip(a, b)):
+        for label, v in (("a", x), ("b", y)):
+            if isinstance(v, bool) or not isinstance(v, (int, float)):
+                raise TypeError(f"Vector {label}[{i}] must be a number, got: {type(v).__name__}")
+            if math.isnan(v) or math.isinf(v):
+                raise ValueError(f"Vector {label}[{i}] must be finite, got: {v}")
     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))

jsonld_ex-0.1.3.dist-info/METADATA

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: jsonld-ex
+Version: 0.1.3
+Summary: JSON-LD 1.2 extensions for AI/ML data exchange, security hardening, and validation
+Author-email: Muntaser Syed <jemsbhai@gmail.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
+
+**JSON-LD 1.2 Extensions for AI/ML Data Exchange, Security, and Validation**
+
+Reference implementation of proposed JSON-LD 1.2 extensions. Wraps [PyLD](https://github.com/digitalbazaar/pyld) for core processing and adds extension layers.
+
+## Install
+
+```bash
+pip install jsonld-ex
+```
+
+## Quick Start
+
+```python
+from jsonld_ex import JsonLdEx, annotate
+
+# Annotate a value with AI/ML provenance
+name = annotate(
+    "John Smith",
+    confidence=0.95,
+    source="https://ml-model.example.org/ner-v2",
+    method="NER",
+)
+# {'@value': 'John Smith', '@confidence': 0.95, '@source': '...', '@method': 'NER'}
+
+# Validate against a shape
+from jsonld_ex import validate_node
+
+shape = {
+    "@type": "Person",
+    "name": {"@required": True, "@type": "xsd:string"},
+    "age": {"@type": "xsd:integer", "@minimum": 0, "@maximum": 150},
+}
+
+result = validate_node({"@type": "Person", "name": "John", "age": 30}, shape)
+assert result.valid
+```
+
+## Features
+
+- **AI/ML Extensions**: `@confidence`, `@source`, `@extractedAt`, `@method`, `@humanVerified`
+- **Vector Embeddings**: `@vector` container type with dimension validation
+- **Security**: `@integrity` context verification, allowlists, resource limits
+- **Validation**: `@shape` native validation framework
+
+## Documentation
+
+Full documentation and specifications: [github.com/jemsbhai/jsonld-ex](https://github.com/jemsbhai/jsonld-ex)
+
+## License
+
+MIT

jsonld_ex-0.1.3.dist-info/RECORD

@@ -0,0 +1,10 @@
+jsonld_ex/__init__.py,sha256=vO9XRRvsON6-wD2QqC8JIrEYqamJgdUqJebJxuuIQek,921
+jsonld_ex/ai_ml.py,sha256=P5UWGuFaVXcsxIQNmLZyjRlo6Q6xVKYvHGVBaPjRD14,5588
+jsonld_ex/processor.py,sha256=tRZX2aiHwZJa62ex4KT0HCbKYtzAkGV87bDBtXAhbvE,3880
+jsonld_ex/security.py,sha256=MDKW3cZREaNhYKelWI5SnnkwNGSSC0UIsc8zBMjBDpk,4374
+jsonld_ex/validation.py,sha256=kLCzaPNTlFRboFKBtkpLvaF5RYPSiUoTxnHtthD2xH4,6955
+jsonld_ex/vector.py,sha256=uJ1a7_Ds8HNmKO0ySKyh0lpNDGCafsUP1HsmSN9vJsw,3472
+jsonld_ex-0.1.3.dist-info/METADATA,sha256=4Bjwcm-gm5dkKlQiXD2y330pX6mUWqDh2PrE4seGsUQ,2573
+jsonld_ex-0.1.3.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+jsonld_ex-0.1.3.dist-info/top_level.txt,sha256=YMe-47TNES9MWZsVWecMwZUDjGxCeU51ay5fuqidBfk,10
+jsonld_ex-0.1.3.dist-info/RECORD,,

jsonld_ex-0.1.0.dist-info/METADATA

@@ -1,26 +0,0 @@
-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.dist-info/RECORD

@@ -1,10 +0,0 @@
-jsonld_ex/__init__.py,sha256=_4A1sW_AzHYtK8d0evFiOtlPyTI1IIsteiRmOf6k9SQ,921
-jsonld_ex/ai_ml.py,sha256=0SvM2RADWLAandxfYTFMMmQUMuTRzqkezpwplpGRP3A,4973
-jsonld_ex/processor.py,sha256=tRZX2aiHwZJa62ex4KT0HCbKYtzAkGV87bDBtXAhbvE,3880
-jsonld_ex/security.py,sha256=PCHZ7NTCy_WeuI_BNTKIMIH00OzLtozu47y5x1E8Fhg,3251
-jsonld_ex/validation.py,sha256=FjnRotqb9irWNARhh_eY6xBxFLCZDHJAczAHc0EUE2Q,6266
-jsonld_ex/vector.py,sha256=SHTHAcU2xa-Gh_Q4YQiOy1QX1_5O_U-vkODpwzj0Irc,2885
-jsonld_ex-0.1.0.dist-info/METADATA,sha256=0_Xm330HBmDg82a6rbk0f3B3msBeYHEo-snle1OjnX4,1167
-jsonld_ex-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-jsonld_ex-0.1.0.dist-info/top_level.txt,sha256=YMe-47TNES9MWZsVWecMwZUDjGxCeU51ay5fuqidBfk,10
-jsonld_ex-0.1.0.dist-info/RECORD,,