bibinprathap/veritasgraph/validate

from veritasreason.pipeline.pipeline_builder import PipelineBuilder
from veritasreason.pipeline.pipeline_validator import PipelineValidator
builder = PipelineBuilder()
if config_json:
    import json
    builder.build_pipeline(json.loads(config_json))
# PipelineBuilder has its own quick validate
quick = builder.validate_pipeline()  # returns Dict
# PipelineValidator gives full ValidationResult(valid, errors, warnings)
# Does NOT raise — always returns a result object
validator = PipelineValidator()
result = validator.validate(builder)
# Also check inter-step dependencies
deps = validator.check_dependencies(builder)

Pipeline Validation:  VALID ✓  |  INVALID ✗
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Steps:    N registered
Valid:    M steps
 
Errors (K):
  ✗ [step_name] <error message>
 
Warnings (J):
  ⚠ [step_name] <warning message>
 
Dependencies:
  ✓ All dependencies resolved
  ✗ Step "<name>" depends on missing step "<dep>"
 
Result: <valid> — K errors, J warnings

from veritasreason.pipeline.pipeline_builder import PipelineBuilder
from veritasreason.pipeline.pipeline_validator import PipelineValidator
import json
builder = PipelineBuilder()
step = builder.get_step(step_name)
validator = PipelineValidator()
result = validator.validate_step(
    step=step,
    **json.loads(constraints_json) if constraints_json else {},
)

from veritasreason.pipeline.pipeline_builder import PipelineBuilder
from veritasreason.pipeline.pipeline_validator import PipelineValidator
builder = PipelineBuilder()
validator = PipelineValidator()
deps = validator.check_dependencies(builder)

Dependency Graph:
  | Step | Depends On | Status |
  | step_A | — | ✓ |
  | step_B | step_A | ✓ |
  | step_C | step_X | ✗ MISSING |
 
Cycles detected: YES / NO
Missing steps:   [list]

from veritasreason.semantic_extract.extraction_validator import ExtractionValidator
from veritasreason.semantic_extract import (
    NamedEntityRecognizer,
    RelationExtractor,
)
from veritasreason.semantic_extract.cache import _result_cache
_result_cache.clear()  # prevent cross-invocation cache pollution
text = open(file_path).read()
ner = NamedEntityRecognizer()
rel = RelationExtractor()
entities = ner.extract(text)
relations = rel.extract(text)
validator = ExtractionValidator()
issues = validator.validate(entities, relations)

Extraction Validation: <file_path>
  Entities:    N extracted
  Relations:   M extracted
  Avg confidence: 0.83
 
Errors (K):
  ✗ <issue>
 
Warnings (J):
  ⚠ <warning>
 
Quality score: X/100

from veritasreason.kg.graph_validator import GraphValidator
from veritasreason.context import ContextGraph
graph = ContextGraph()
validator = GraphValidator(graph)
result = validator.validate()

Graph Validation:
  Nodes:         N  |  Edges: M
  Node types:    K valid, J unknown
  
Referential integrity:
  ✗ Dangling edge: <source> → <missing target>
 
Schema conformance:
  ✗ Node "<id>" missing required property "<prop>"
 
Result: N errors, M warnings

from veritasreason.ontology import OntologyValidator
validator = OntologyValidator()
result = validator.validate()
cq_results = validator.evaluate_competency_questions()

Ontology Validation:
  Classes:      N
  Properties:   M
  Consistent:   YES ✓  |  NO ✗
 
Competency questions:
  ✓ "Can we find all instances of X?" — answered
  ✗ "Is Y a subclass of Z?" — failed: <reason>
 
Result: N consistency errors, M CQ failures

from veritasreason.pipeline.pipeline_builder import PipelineBuilder
from veritasreason.pipeline.pipeline_validator import PipelineValidator
builder = PipelineBuilder()
pipeline = builder.build()
validator = PipelineValidator()
perf = validator.validate_performance(pipeline)