Upload app.py with huggingface_hub

app.py

@@ -0,0 +1,151 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import gradio as gr
+
+from json_semval.pipeline import run_validation
+
+
+def load_fixtures() -> tuple[str, str]:
+    try:
+        schema = Path("tests/fixtures/sample_schema.json").read_text(encoding="utf-8")
+        bad = Path("tests/fixtures/sample_bad.json").read_text(encoding="utf-8")
+        return schema, bad
+    except Exception:
+        example_schema = '{"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}'
+        example_json = '{"name":"Alice"}'
+        return example_schema, example_json
+
+
+def infer(
+    schema_text: str, json_text: str, backend: str, apply_minimal: bool
+) -> tuple[str, str, str]:
+    try:
+        schema = json.loads(schema_text)
+        payload = json.loads(json_text)
+    except Exception as e:
+        return "[]", f"Invalid input JSON: {e}", json_text
+    report = run_validation(schema, payload, apply_fixes=apply_minimal, backend=backend)
+    rule_errors = json.dumps(report.get("rule_errors", []), indent=2)
+    ml_preds = json.dumps(report.get("ml_predictions", []), indent=2)
+    corrected = json.dumps(report.get("corrected_json", payload), indent=2)
+    return rule_errors, ml_preds, corrected
+
+
+EXAMPLES = {
+    "Example 1: Fixtures (bad)": (
+        (
+            Path("tests/fixtures/sample_schema.json").read_text(encoding="utf-8")
+            if Path("tests/fixtures/sample_schema.json").exists()
+            else '{"type":"object","properties":{"age":{"type":"integer"},"start_date":{"type":"string","format":"date"},"active":{"type":"boolean"},"status":{"type":"string","enum":["pending","approved","rejected"]}},"required":["age","start_date","active","status"]}'
+        ),
+        (
+            Path("tests/fixtures/sample_bad.json").read_text(encoding="utf-8")
+            if Path("tests/fixtures/sample_bad.json").exists()
+            else '{"age":"twenty five","active":"yes","start_date":"15 Jan 2024","status":"pendng"}'
+        ),
+    ),
+    "Example 2: Minimal valid": (
+        '{"type":"object","properties":{"name":{"type":"string"}},"required":["name"]}',
+        '{"name":"Alice"}',
+    ),
+    "Example 3: Enum/date mix": (
+        '{"type":"object","properties":{"status":{"type":"string","enum":["pending","approved","rejected"]},"d":{"type":"string","format":"date"}},"required":["status","d"]}',
+        '{"status":"Pendng","d":"01/02/2024"}',
+    ),
+}
+
+with gr.Blocks(title="JSON Semantic Validator") as demo:
+    gr.Markdown(
+        """
+    # JSON Semantic Validator
+    Hybrid rules + tiny ML to validate and auto-fix JSON against a schema.
+    """
+    )
+
+    with gr.Row():
+        schema_in = gr.Code(label="JSON Schema", language="json")
+        json_in = gr.Code(label="JSON Payload", language="json")
+
+    with gr.Row():
+        backend = gr.Dropdown(
+            ["rules-only", "local", "onnx"], value="rules-only", label="Backend"
+        )
+        apply_minimal = gr.Checkbox(value=True, label="Apply minimal fixes")
+        example_dd = gr.Dropdown(list(EXAMPLES.keys()), label="Load Example")
+        load_btn = gr.Button("Load Fixtures")
+        run_btn = gr.Button("Run Validation")
+
+    with gr.Row():
+        rule_errors_out = gr.Code(label="Rule Errors", language="json")
+        ml_preds_out = gr.Code(label="ML Predictions", language="json")
+        corrected_out = gr.Code(label="Corrected JSON", language="json")
+    validity_md = gr.Markdown(visible=True)
+
+    def _backend_value(b: str) -> str:
+        if b == "rules-only":
+            return "local"  # we will set apply_minimal False when executing
+        return b
+
+    def on_load() -> tuple[str, str]:
+        return load_fixtures()
+
+    def on_example_select(label: str) -> tuple[str, str]:
+        pair = EXAMPLES.get(label)
+        if not pair:
+            return "", ""
+        return pair
+
+    def on_run(
+        schema_text: str, json_text: str, b: str, do_fix: bool
+    ) -> tuple[str, str, str, str]:
+        # Compute rules-only and hybrid validity to show a delta badge
+        validity_text = ""
+        try:
+            schema = json.loads(schema_text)
+            payload = json.loads(json_text)
+            rules_only = run_validation(
+                schema, payload, apply_fixes=False, backend="rules-only"
+            )
+            hybrid = run_validation(
+                schema,
+                payload,
+                apply_fixes=(False if b == "rules-only" else do_fix),
+                backend=_backend_value(b),
+            )
+            r_ok = 1 if rules_only.get("valid") else 0
+            h_ok = 1 if hybrid.get("valid") else 0
+            delta = (h_ok - r_ok) * 100
+            validity_text = f"**Validity** — Rules-only: {r_ok*100}% · Hybrid: {h_ok*100}% · Δ: {delta:+d}%"
+            # Return details based on the hybrid run to keep UX consistent
+            rule_errors = json.dumps(hybrid.get("rule_errors", []), indent=2)
+            ml_preds = json.dumps(hybrid.get("ml_predictions", []), indent=2)
+            corrected = json.dumps(hybrid.get("corrected_json", payload), indent=2)
+            return rule_errors, ml_preds, corrected, validity_text
+        except Exception as e:
+            return "[]", f"Invalid input JSON: {e}", json_text, ""
+
+    load_btn.click(fn=on_load, outputs=[schema_in, json_in])
+    example_dd.change(
+        fn=on_example_select, inputs=[example_dd], outputs=[schema_in, json_in]
+    )
+    run_btn.click(
+        fn=on_run,
+        inputs=[schema_in, json_in, backend, apply_minimal],
+        outputs=[rule_errors_out, ml_preds_out, corrected_out, validity_md],
+    )
+
+    # Disable the "Apply minimal fixes" checkbox when backend == rules-only
+    def on_backend_change(b: str, current: bool):
+        if b == "rules-only":
+            return gr.update(value=False, interactive=False)
+        return gr.update(interactive=True)
+
+    backend.change(
+        fn=on_backend_change, inputs=[backend, apply_minimal], outputs=apply_minimal
+    )
+
+if __name__ == "__main__":
+    demo.launch(share=True)