feat: re-export Verification Context v1.0 types from qwed_sdk

.github/workflows/sonar.yml

@@ -25,14 +25,15 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install pytest pytest-cov pytest-asyncio
+          pip install pytest pytest-cov pytest-asyncio coverage
           pip install PyYAML matplotlib docker cryptography jsonschema
           if [ -f requirements.txt ]; then pip install -r requirements.txt; fi
           pip install -e .
 
       - name: Run Tests and Generate Coverage
         run: |
-          pytest --cov=src/qwed_new --cov=qwed_sdk --cov-report=xml tests/
+          coverage run --source=src/qwed_new,qwed_sdk -m pytest tests/
+          coverage xml -o coverage.xml
 
       - name: SonarCloud Scan
         uses: SonarSource/sonarqube-scan-action@fd88b7d7ccbaefd23d8f36f73b59db7a3d246602 # v6

qwed_sdk/__init__.py

@@ -36,6 +36,25 @@
     BatchResult,
     VerificationType,
 )
+from qwed_new.core.verification_context import (
+    Verdict,
+    Admission,
+    VerificationContext,
+    VerificationContextDocument,
+    VerificationContextValidationError,
+    Formalization,
+    VerifiedObject,
+    Interpretation,
+    Proof,
+    Evidence,
+    Decision,
+    compute_context_proof_ref,
+    compute_document_proof_ref,
+    resolve_document_proof_ref,
+    resolve_context_proof_ref,
+    validate_document,
+    is_valid_document,
+)
 
 __version__ = "7.0.0"
 __all__ = [
@@ -45,6 +64,23 @@
     "VerificationResult",
     "BatchResult",
     "VerificationType",
+    "Verdict",
+    "Admission",
+    "VerificationContext",
+    "VerificationContextDocument",
+    "VerificationContextValidationError",
+    "Formalization",
+    "VerifiedObject",
+    "Interpretation",
+    "Proof",
+    "Evidence",
+    "Decision",
+    "compute_context_proof_ref",
+    "compute_document_proof_ref",
+    "resolve_document_proof_ref",
+    "resolve_context_proof_ref",
+    "validate_document",
+    "is_valid_document",
 ]
 
 # Optional framework integrations (lazy imports)

tests/test_sdk_init.py

@@ -0,0 +1,176 @@
+"""Coverage for qwed_sdk/__init__.py re-exports."""
+
+import importlib
+import sys
+
+import pytest
+
+
+def test_sdk_init_module_executes():
+    """Force re-execution of qwed_sdk/__init__.py module-level code for coverage."""
+    if "qwed_sdk" in sys.modules:
+        importlib.reload(sys.modules["qwed_sdk"])
+    else:
+        from qwed_sdk import __version__ as _  # noqa: F401
+    from qwed_sdk import __all__ as sdk_all, __version__ as sdk_version
+    assert sdk_all is not None
+    assert sdk_version == "7.0.0"
+
+
+def test_sdk_init_exports_verdict_enum():
+    from qwed_sdk import Verdict
+    assert Verdict.VERIFIED.value == "VERIFIED"
+    assert Verdict.UNVERIFIABLE.value == "UNVERIFIABLE"
+    assert Verdict.BLOCKED.value == "BLOCKED"
+    assert len(Verdict) == 3
+
+
+def test_sdk_init_exports_admission_enum():
+    from qwed_sdk import Admission
+    assert Admission.ADMIT.value == "ADMIT"
+    assert Admission.DENY.value == "DENY"
+    assert len(Admission) == 2
+
+
+def test_sdk_init_exports_model_classes():
+    from qwed_sdk import (
+        VerificationContext,
+        VerificationContextDocument,
+        Formalization,
+        VerifiedObject,
+        Interpretation,
+        Proof,
+        Evidence,
+        Decision,
+    )
+    assert VerificationContext is not None
+    assert VerificationContextDocument is not None
+    assert Formalization is not None
+    assert VerifiedObject is not None
+    assert Interpretation is not None
+    assert Proof is not None
+    assert Evidence is not None
+    assert Decision is not None
+
+
+def test_sdk_init_exports_validation_error():
+    from qwed_sdk import VerificationContextValidationError
+    assert issubclass(VerificationContextValidationError, ValueError)
+    err = VerificationContextValidationError("test")
+    assert str(err) == "test"
+
+
+def test_sdk_init_exports_proof_functions():
+    from qwed_sdk import (
+        VerificationContextValidationError,
+        compute_context_proof_ref,
+        compute_document_proof_ref,
+        resolve_document_proof_ref,
+        resolve_context_proof_ref,
+        validate_document,
+        is_valid_document,
+    )
+    assert callable(compute_context_proof_ref)
+    assert callable(compute_document_proof_ref)
+    assert callable(resolve_document_proof_ref)
+    assert callable(resolve_context_proof_ref)
+    assert callable(validate_document)
+    assert callable(is_valid_document)
+    with pytest.raises(VerificationContextValidationError):
+        validate_document({})
+
+
+def test_sdk_init_all_list_complete():
+    from qwed_sdk import __all__ as sdk_all
+    from qwed_sdk import (
+        QWEDClient,
+        QWEDAsyncClient,
+        QWEDLocal,
+        VerificationResult,
+        BatchResult,
+        VerificationType,
+        Verdict,
+        Admission,
+        VerificationContext,
+        VerificationContextDocument,
+        VerificationContextValidationError,
+        Formalization,
+        VerifiedObject,
+        Interpretation,
+        Proof,
+        Evidence,
+        Decision,
+        compute_context_proof_ref,
+        compute_document_proof_ref,
+        resolve_document_proof_ref,
+        resolve_context_proof_ref,
+        validate_document,
+        is_valid_document,
+    )
+    exported = {
+        "QWEDClient": QWEDClient,
+        "QWEDAsyncClient": QWEDAsyncClient,
+        "QWEDLocal": QWEDLocal,
+        "VerificationResult": VerificationResult,
+        "BatchResult": BatchResult,
+        "VerificationType": VerificationType,
+        "Verdict": Verdict,
+        "Admission": Admission,
+        "VerificationContext": VerificationContext,
+        "VerificationContextDocument": VerificationContextDocument,
+        "VerificationContextValidationError": VerificationContextValidationError,
+        "Formalization": Formalization,
+        "VerifiedObject": VerifiedObject,
+        "Interpretation": Interpretation,
+        "Proof": Proof,
+        "Evidence": Evidence,
+        "Decision": Decision,
+        "compute_context_proof_ref": compute_context_proof_ref,
+        "compute_document_proof_ref": compute_document_proof_ref,
+        "resolve_document_proof_ref": resolve_document_proof_ref,
+        "resolve_context_proof_ref": resolve_context_proof_ref,
+        "validate_document": validate_document,
+        "is_valid_document": is_valid_document,
+    }
+    for name, obj in exported.items():
+        assert name in sdk_all, f"{name} missing from __all__"
+        assert obj is not None, f"{name} is None"
+
+
+def test_sdk_init_is_valid_document_returns_false_for_invalid():
+    from qwed_sdk import is_valid_document
+    assert is_valid_document({}) is False
+    assert is_valid_document({"spec_version": "99.0"}) is False
+
+
+def test_sdk_init_resolve_document_proof_ref_returns_false_for_invalid():
+    from qwed_sdk import resolve_document_proof_ref
+    assert resolve_document_proof_ref({}) is False
+    assert resolve_document_proof_ref({"verdict": "BLOCKED"}) is False
+
+
+def test_sdk_init_get_langchain_tools():
+    from qwed_sdk import get_langchain_tools
+    try:
+        tools = get_langchain_tools()
+        assert "QWEDTool" in tools
+    except ImportError as exc:
+        pytest.skip(f"langchain is optional: {exc}")
+
+
+def test_sdk_init_get_llamaindex_tools():
+    from qwed_sdk import get_llamaindex_tools
+    try:
+        tools = get_llamaindex_tools()
+        assert "QWEDQueryEngine" in tools
+    except ImportError as exc:
+        pytest.skip(f"llamaindex is optional: {exc}")
+
+
+def test_sdk_init_get_crewai_tools():
+    from qwed_sdk import get_crewai_tools
+    try:
+        tools = get_crewai_tools()
+        assert "QWEDVerificationTool" in tools
+    except ImportError as exc:
+        pytest.skip(f"crewai is optional: {exc}")

tests/test_verification_context_sdk.py

@@ -3,6 +3,41 @@
 from qwed_sdk.client import QWEDClient
 
 
+def test_sdk_reexports_verification_context_types():
+    """All VC v1.0 types are importable from qwed_sdk without reaching into qwed_new.core."""
+    from qwed_sdk import (
+        Verdict,
+        Admission,
+        VerificationContext,
+        VerificationContextDocument,
+        VerificationContextValidationError,
+        Formalization,
+        VerifiedObject,
+        Interpretation,
+        Proof,
+        Evidence,
+        Decision,
+        compute_context_proof_ref,
+        compute_document_proof_ref,
+        resolve_document_proof_ref,
+        resolve_context_proof_ref,
+        validate_document,
+        is_valid_document,
+    )
+    assert Verdict.VERIFIED.value == "VERIFIED"
+    assert Verdict.UNVERIFIABLE.value == "UNVERIFIABLE"
+    assert Verdict.BLOCKED.value == "BLOCKED"
+    assert Admission.ADMIT.value == "ADMIT"
+    assert Admission.DENY.value == "DENY"
+    assert callable(compute_context_proof_ref)
+    assert callable(compute_document_proof_ref)
+    assert callable(resolve_document_proof_ref)
+    assert callable(resolve_context_proof_ref)
+    assert callable(validate_document)
+    assert callable(is_valid_document)
+    assert issubclass(VerificationContextValidationError, ValueError)
+
+
 def test_sdk_verification_context_methods_call_endpoints(monkeypatch):
     api_key = f"qwed-test-{secrets.token_hex(8)}"
     client = QWEDClient(api_key=api_key)