structured-eval 0.1.0__py3-none-any.whl

structured_eval/utils/paths.py

@@ -0,0 +1,58 @@
+"""Path navigation over nested dict/list documents.
+
+A pure utility (no model dependencies) shared by the node tree, the engine's
+tree builder, and array alignment. ``navigate`` walks a dot-and-bracket path;
+``MISSING`` is the sentinel for an unresolvable step (distinct from ``None`` so
+callers can tell "absent" from "present but null").
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+# Splits a dot-and-bracket path into access steps.
+#   "roles[0].name" → ["roles", "[0]", "name"]
+#   "items[0]"      → ["items", "[0]"]
+#   "a.b"           → ["a", "b"]
+_PATH_TOKEN = re.compile(r"[^.\[\]]+|\[[^\]]*\]")
+
+# Sentinel returned when a path cannot be resolved (key/index missing).
+# Distinct from None so callers can tell "absent" from "present but null".
+MISSING = object()
+
+
+def navigate(obj: Any, path: str) -> Any:
+    """Walk ``obj`` along a dot-and-bracket ``path``.
+
+    ``"$"`` returns the root unchanged. Dict keys use dot notation, list
+    indices use brackets: ``"roles[0].name"``. Returns ``MISSING`` when any
+    step cannot be resolved (missing key, out-of-range or non-integer index).
+
+    Examples:
+        >>> navigate({"a": {"b": 1}}, "a.b")
+        1
+        >>> navigate({"items": [1, 2]}, "items[0]")
+        1
+    """
+    if path in {"$", ""}:
+        return obj
+
+    current = obj
+    for token in _PATH_TOKEN.findall(path):
+        if token.startswith("["):
+            inner = token[1:-1]
+            if not isinstance(current, list):
+                return MISSING
+            try:
+                idx = int(inner)
+            except ValueError:
+                return MISSING
+            if not -len(current) <= idx < len(current):
+                return MISSING
+            current = current[idx]
+        else:
+            if not isinstance(current, dict) or token not in current:
+                return MISSING
+            current = current[token]
+    return current

structured_eval/utils/structured_diff.py

@@ -0,0 +1,159 @@
+from __future__ import annotations
+
+import re
+from enum import StrEnum
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class DiffType(StrEnum):
+    ADDED = "added"  # present in actual, absent in expected
+    REMOVED = "removed"  # present in expected, absent in actual
+    CHANGED = "changed"  # present in both but value differs
+
+
+class DiffEntry(BaseModel):
+    """Single difference between actual and expected at one field path."""
+
+    path: str = Field(description="Dot/bracket path to the differing field.")
+    diff_type: DiffType = Field(
+        description="Type of difference: added, removed, or changed."
+    )
+    actual: Any = Field(description="Value in actual (None for removed entries).")
+    expected: Any = Field(description="Value in expected (None for added entries).")
+
+
+class StructuredDiff(BaseModel):
+    """Human-readable field-level diff between actual and expected documents.
+
+    Produced by structured_diff(). Use .added, .removed, .changed for
+    filtered views, or .is_equal to check whether the documents match.
+    """
+
+    entries: list[DiffEntry] = Field(default_factory=list)
+
+    @property
+    def added(self) -> list[DiffEntry]:
+        """Fields present in actual but absent in expected."""
+        return [e for e in self.entries if e.diff_type == DiffType.ADDED]
+
+    @property
+    def removed(self) -> list[DiffEntry]:
+        """Fields present in expected but absent in actual."""
+        return [e for e in self.entries if e.diff_type == DiffType.REMOVED]
+
+    @property
+    def changed(self) -> list[DiffEntry]:
+        """Fields present in both but with different values."""
+        return [e for e in self.entries if e.diff_type == DiffType.CHANGED]
+
+    @property
+    def is_equal(self) -> bool:
+        """True when actual and expected are identical (no differences)."""
+        return len(self.entries) == 0
+
+
+def structured_diff(
+    actual: dict[str, Any],
+    expected: dict[str, Any],
+) -> StructuredDiff:
+    """Compute a readable field-level diff between actual and expected.
+
+    Uses DeepDiff to detect changes at every nesting level and converts
+    the result into DiffEntry objects with ADDED / REMOVED / CHANGED types.
+
+    Args:
+        actual: LLM output document.
+        expected: Ground truth document.
+
+    Returns:
+        StructuredDiff with one DiffEntry per differing field path.
+
+    Raises:
+        ImportError: If deepdiff is not installed.
+    """
+    try:
+        from deepdiff import DeepDiff
+    except ImportError as exc:  # pragma: no cover
+        raise ImportError(
+            "deepdiff is required for structured_diff. "
+            "Install it with: pip install 'structured-eval[diff]'"
+        ) from exc
+
+    # DeepDiff(old, new) — expected is old, actual is new
+    diff = DeepDiff(expected, actual, verbose_level=2)
+    entries: list[DiffEntry] = []
+
+    for raw_path, value in diff.get("dictionary_item_added", {}).items():
+        entries.append(
+            DiffEntry(
+                path=_to_readable_path(raw_path),
+                diff_type=DiffType.ADDED,
+                actual=value,
+                expected=None,
+            )
+        )
+
+    for raw_path, value in diff.get("dictionary_item_removed", {}).items():
+        entries.append(
+            DiffEntry(
+                path=_to_readable_path(raw_path),
+                diff_type=DiffType.REMOVED,
+                actual=None,
+                expected=value,
+            )
+        )
+
+    for raw_path, change in diff.get("values_changed", {}).items():
+        entries.append(
+            DiffEntry(
+                path=_to_readable_path(raw_path),
+                diff_type=DiffType.CHANGED,
+                actual=change["new_value"],
+                expected=change["old_value"],
+            )
+        )
+
+    for raw_path, change in diff.get("type_changes", {}).items():
+        entries.append(
+            DiffEntry(
+                path=_to_readable_path(raw_path),
+                diff_type=DiffType.CHANGED,
+                actual=change["new_value"],
+                expected=change["old_value"],
+            )
+        )
+
+    for raw_path, value in diff.get("iterable_item_added", {}).items():
+        entries.append(
+            DiffEntry(
+                path=_to_readable_path(raw_path),
+                diff_type=DiffType.ADDED,
+                actual=value,
+                expected=None,
+            )
+        )
+
+    for raw_path, value in diff.get("iterable_item_removed", {}).items():
+        entries.append(
+            DiffEntry(
+                path=_to_readable_path(raw_path),
+                diff_type=DiffType.REMOVED,
+                actual=None,
+                expected=value,
+            )
+        )
+
+    entries.sort(key=lambda e: e.path)
+    return StructuredDiff(entries=entries)
+
+
+def _to_readable_path(deepdiff_path: str) -> str:
+    """Convert DeepDiff path notation to dot/bracket notation.
+
+    root['a']['b'][0] → a.b[0]
+    """
+    path = deepdiff_path[4:]  # strip leading "root"
+    path = re.sub(r"\['([^']+)'\]", r".\1", path)
+    return path.lstrip(".")

structured_eval-0.1.0.dist-info/METADATA

@@ -0,0 +1,322 @@
+Metadata-Version: 2.4
+Name: structured-eval
+Version: 0.1.0
+Summary: The LLM Structured Output Evaluation Framework
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/kirillpechurin/structured-eval
+Project-URL: Repository, https://github.com/kirillpechurin/structured-eval
+Project-URL: Issues, https://github.com/kirillpechurin/structured-eval/issues
+Keywords: structured llm evaluation,structured eval,json eval,llm,structured output,pydantic
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Testing
+Classifier: Typing :: Typed
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.5.0
+Provides-Extra: yaml
+Requires-Dist: pyyaml>=6.0; extra == "yaml"
+Provides-Extra: fuzzy
+Requires-Dist: rapidfuzz>=3.0.0; extra == "fuzzy"
+Provides-Extra: jsonschema
+Requires-Dist: jsonschema>=4.20.0; extra == "jsonschema"
+Provides-Extra: rules
+Requires-Dist: jsonpath-ng>=1.6.0; extra == "rules"
+Provides-Extra: diff
+Requires-Dist: deepdiff>=7.0.0; extra == "diff"
+Provides-Extra: align
+Requires-Dist: scipy>=1.13.0; extra == "align"
+Provides-Extra: deepeval
+Requires-Dist: deepeval>=3.0.0; extra == "deepeval"
+Provides-Extra: langsmith
+Requires-Dist: langsmith>=0.8.0; extra == "langsmith"
+Provides-Extra: all
+Requires-Dist: structured-eval[align,diff,fuzzy,jsonschema,rules,yaml]; extra == "all"
+Dynamic: license-file
+
+# structured-eval
+
+**A declarative, field-level evaluation framework for LLM structured outputs (JSON/YAML).**
+
+Getting an LLM to return well-formed JSON is mostly a solved problem — it parses,
+it fits the schema, the types line up. But well-formed isn't the same as *right*.
+The shape can be flawless while a price is wrong, a date is invented, or a status
+quietly contradicts the rest of the record. Structural checks wave all of that
+through.
+
+structured-eval looks at what those checks skip: **the values themselves**. It
+scores your output field by field, so you don't just learn *that* a response is
+off — you see *which* fields matched and which didn't, where to look first, and,
+across a dataset, which fields your model keeps getting wrong.
+
+structured-eval lets you check not just that the JSON is valid, but that the
+data itself is correct.
+
+## The gap it closes
+
+Correctness is a ladder — each level assumes the ones below it:
+
+|           |                                                      |
+|-----------|------------------------------------------------------|
+| **L0–L3** | structure: parses · types · required · no extras     |
+| **L4**    | values are close to expected                         |
+| **L5**    | values are grounded in the source (no hallucination) |
+| **L6**    | fields are logically consistent with one another     |
+
+L0–L3 is where most tools stop. **L4–L6 is where structured-eval earns its keep.**
+See [the introduction](docs/introduction.md) for the full ladder.
+
+## Install
+
+```bash
+pip install structured-eval          # core depends only on Pydantic
+pip install "structured-eval[all]"   # + YAML, fuzzy, schema, rules, scipy alignment…
+```
+
+Optional features live behind [extras](docs/getting-started.md#install) — install
+only what you need.
+
+## Quick start
+
+A model extracted a course record; you have the canonical one to check it against.
+The two are *structurally* identical — same keys, mixed types, a nested array of
+objects — but several values are off. A small config says *how* to judge each
+field, and the report tells you exactly where the output stands:
+
+```python
+from structured_eval import evaluate
+from structured_eval.models import EvalConfig, FieldConfig
+from structured_eval.metrics import Numeric, TokenF1
+
+expected = {
+    "course_id": "COURSE-101",
+    "title": "Introduction to Python",
+    "published": True,
+    "duration_hours": 12,
+    "rating": 4.8,
+    "modules": [
+        {"name": "Basics", "lessons": 5},
+        {"name": "Functions", "lessons": 4},
+        {"name": "Classes", "lessons": 3},
+    ],
+}
+
+actual = {
+    "course_id": "COURSE-101",
+    "title": "Intro to Python",  # paraphrased
+    "published": True,
+    "duration_hours": 10,  # off by 2
+    "rating": 4.5,  # off by 0.3
+    "modules": [
+        {"name": "Basics", "lessons": 5},
+        {"name": "Functions", "lessons": 4},
+    ],  # "Classes" module missing
+}
+
+config = EvalConfig(fields={
+    "title": FieldConfig(metrics=[TokenF1()]),                # reward paraphrases
+    "duration_hours": FieldConfig(metrics=[Numeric(tolerance=2)]),
+    "rating": FieldConfig(metrics=[Numeric(tolerance=0.5)]),  # close enough is fine
+})
+
+report = evaluate(actual, expected, config)
+
+report.score  # 0.8889  — close, with the gaps pinpointed
+report.field_scores["title"].score  # 0.6667  — paraphrase gets partial credit
+report.field_scores["duration_hours"].score  # 1.0     — within tolerance
+report.field_scores["modules"].score  # 0.6667  — 2 of 3 modules recovered
+report.field_scores["modules[0]"].score  # 1.0     — first module is spot-on
+```
+
+Every field is scored — nested objects and array elements included — so you see
+not a single pass/fail but exactly which fields hold up and which don't.
+
+### Sensible default metrics
+
+The config is optional. structured-eval ships a default metric for every node
+type, so you only configure the fields where the default isn't what you want —
+the rest just work. With no config at all, the same data is scored by those
+defaults:
+
+```python
+report = evaluate(actual, expected)  # no config
+
+report.score  # 0.4444  — scored entirely by the defaults
+report.field_scores["title"].score  # 0.0  — exact match: "Intro to Python" ≠ "Introduction to Python"
+```
+
+Each node type gets a structural default, and every node's headline score (its
+*representative*) defaults to the mean of its own metrics:
+
+| Node                 | Default metric   | What it does                                   |
+|----------------------|------------------|------------------------------------------------|
+| scalar (leaf)        | `ExactMatch`     | the value must match exactly                   |
+| object               | `ObjectAccuracy` | mean correctness of its fields                 |
+| array                | `ArrayAccuracy`  | mean correctness of its aligned elements       |
+| any node (headline)  | `MeanScore`      | the node's representative = mean of its metrics |
+
+Exact match is a strict baseline — it punishes every paraphrase and rounded value
+as wrong, which is why the no-config score is low. Tuning metrics per field, as in
+the first example, is how you tell the evaluator what "close enough" means for
+*your* data. The defaults and the representative score are covered in
+[the evaluation model](docs/core-concepts/evaluation-model.md) and the
+[metric catalog](docs/metrics/index.md).
+
+## Explore — every level of correctness
+
+structured-eval covers the whole ladder, L0 through L6. Each level has a tool and
+a concept page behind it:
+
+| Level               | The question                        | Reach for                                                   | Learn more                                                             |
+|---------------------|-------------------------------------|-------------------------------------------------------------|------------------------------------------------------------------------|
+| **L0–L3** structure | does it parse / fit the schema?     | `SchemaValidity`                                            | [schema validity](docs/metrics/catalog/schema-validity.md)             |
+| **L4** values       | is each value right?                | field metrics — `ExactMatch`, `Numeric`, `TokenF1`, `Fuzzy` | [comparison is a metric](docs/core-concepts/comparison-is-a-metric.md) |
+| **L4** roll-up      | how do fields & elements aggregate? | `ObjectF1` / `ArrayF1`, alignment, weights                  | [array alignment](docs/core-concepts/array-alignment.md)               |
+| **L5** faithfulness | is it grounded in the source?       | `FieldFaithfulness(source=…)`                               | [field faithfulness](docs/metrics/catalog/field_faithfulness.md)       |
+| **L6** logic        | are fields mutually consistent?     | `RulePassRate` + `Rule` DSL                                 | [rule pass rate](docs/metrics/catalog/rule-pass-rate.md)               |
+
+**L0–L3 — structure.** Validate against a Pydantic model or JSON Schema, with no
+ground-truth answer:
+
+```python
+from pydantic import BaseModel
+from structured_eval import evaluate
+from structured_eval.models import EvalConfig
+from structured_eval.metrics import SchemaValidity
+
+
+class Course(BaseModel):
+    title: str
+    duration_hours: int
+
+
+report = evaluate(
+    actual={"title": "ML", "duration_hours": "twelve"},
+    expected=None,
+    config=EvalConfig(key_metric=SchemaValidity(Course))
+)
+report.score  # 0.0
+report.metrics["schema_validity"].root().extra["schema_errors"]
+#   {'type_errors': ['duration_hours'], 'missing_required': [], 'extra_fields': []}
+```
+
+**L4 — values.** Pick *how* each field is judged — exact match is just the default
+(*comparison is a metric*):
+
+```python
+from structured_eval import evaluate
+from structured_eval.models import EvalConfig, FieldConfig
+from structured_eval.metrics import Numeric, TokenF1
+
+report = evaluate(
+    actual={"title": "Intro to Python", "duration_hours": 11},
+    expected={"title": "Introduction to Python", "duration_hours": 12},
+    config=EvalConfig(fields={
+        "title": FieldConfig(metrics=[TokenF1()]),  # token overlap
+        "duration_hours": FieldConfig(metrics=[Numeric(tolerance=2)]),
+    }),
+)
+report.field_scores["title"].score  # 0.6667  — partial credit for a paraphrase
+report.field_scores["duration_hours"].score  # 1.0     — within tolerance
+```
+
+Fields roll up into objects and arrays with precision / recall / F1, and arrays are
+[aligned](docs/core-concepts/array-alignment.md) by index, key, or optimally:
+
+```python
+from structured_eval import evaluate
+from structured_eval.models import EvalConfig
+from structured_eval.metrics import ObjectF1
+
+report = evaluate(
+    actual={"a": 1, "b": 9},
+    expected={"a": 1, "b": 2, "c": 3},
+    config=EvalConfig(metrics=[ObjectF1()])
+)
+
+report.metrics["object_f1"].root()  # 0.4
+```
+
+**L5 — faithfulness.** Catch hallucinations by checking each value against its
+source — no `expected` required:
+
+```python
+from structured_eval import evaluate
+from structured_eval.models import EvalConfig
+from structured_eval.metrics import FieldFaithfulness
+
+report = evaluate(
+    actual={"title": "Introduction to Python", "duration_hours": 40},
+    expected=None,
+    config=EvalConfig(metrics=[FieldFaithfulness()]),
+    source="Course: Introduction to Python. Duration: 12 hours.",
+)
+
+report.metrics["field_faithfulness"].by_path  # {'title': 1.0, 'duration_hours': 0.0 ← 40 ≠ 12}
+```
+
+**L6 — logic.** Assert cross-field business rules with a small DSL:
+
+```python
+from structured_eval import evaluate
+from structured_eval.models import EvalConfig
+from structured_eval.metrics import Rule, RulePassRate
+
+report = evaluate(
+    actual={"subtotal": 100, "tax": 20, "total": 130},
+    expected=None,
+    config=EvalConfig(key_metric=RulePassRate([Rule("$.total").eq("$.subtotal + $.tax")]))
+)
+
+report.score  # 0.0  — 130 ≠ 120
+```
+
+## Scale it
+
+Evaluate a whole dataset, or measure how stable a prompt is across repeated runs:
+
+```python
+from structured_eval import evaluate_batch, evaluate_consistency
+from structured_eval.models import Sample
+
+# one report per sample + dataset aggregates
+batch = evaluate_batch([
+    Sample(actual={"x": 1}, expected={"x": 1}),
+    Sample(actual={"x": 1}, expected={"x": 2}),
+])
+batch.score  # 0.5
+batch.perfect_response_rate  # 0.5
+
+# repeated runs of the same prompt → which fields drift?
+runs = [
+    Sample(actual={"sentiment": "positive", "score": 0.9}, expected={"sentiment": "positive", "score": 0.9}),
+    Sample(actual={"sentiment": "positive", "score": 0.9}, expected={"sentiment": "positive", "score": 0.9}),
+    Sample(actual={"sentiment": "neutral", "score": 0.9}, expected={"sentiment": "positive", "score": 0.9}),
+]
+report = evaluate_consistency(runs, variance_threshold=0.05)
+report.stable_fields  # ['score']
+report.unstable_fields  # ['sentiment']  — flipped on one run
+```
+
+## Documentation
+
+- **[Introduction](docs/introduction.md)** — the L0–L6 ladder and why values matter.
+- **[Getting started](docs/getting-started.md)** — install → first evaluation →
+  reading and tuning the report.
+- **Core concepts** — [the evaluation model](docs/core-concepts/evaluation-model.md) ·
+  [comparison is a metric](docs/core-concepts/comparison-is-a-metric.md) ·
+  [array alignment](docs/core-concepts/array-alignment.md)
+- **[Evaluation functions](docs/evaluation/index.md)** — `evaluate`,
+  `evaluate_batch`, `evaluate_consistency`.
+- **[Metric catalog](docs/metrics/index.md)** — every metric, plus how to write your own.
+
+## License
+
+Apache-2.0 — see [LICENSE](LICENSE).

structured_eval-0.1.0.dist-info/RECORD

@@ -0,0 +1,94 @@
+structured_eval/__init__.py,sha256=HVWqijhPNqs4-GSFTv0Ew6i1dLlJchgGGq5Q8Vgx5I0,1142
+structured_eval/api.py,sha256=ECYaLPH6C866W8BatYyNYBhlHXUpljjmwm6gI_bwMHc,2529
+structured_eval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+structured_eval/alignment/__init__.py,sha256=wAb9899fDPt_HbclQUD0iW6QhL62DokA0Zn8TAnajtM,471
+structured_eval/alignment/base.py,sha256=Qp-VmrZkU2JSLre2pxXwkdxBhk2oemTridbgvPDvZXk,1374
+structured_eval/alignment/by_index.py,sha256=58vsTb87k7i6yaDe_AhZ1C42Ojk3OF1KNgDuZ8_LQtc,820
+structured_eval/alignment/by_key.py,sha256=nB3mdD7F0z85xfjZedpKEjsI5m-FgPt6DmI5jiX-wDQ,3260
+structured_eval/alignment/factory.py,sha256=vxdFxmCTvv0z-6tkkTDMnpErWImsjET-BgaADv8slpQ,981
+structured_eval/alignment/hungarian.py,sha256=8sOfQwwI1o4tGI816icceGNy3vm8VwmNf1cZJDMMYys,6421
+structured_eval/engine/__init__.py,sha256=WEyDiUfi-EZXEAUFiIC3vSmo6URpFSSTzh65R3gK_hg,481
+structured_eval/engine/aggregator.py,sha256=Xm7hPbv8L8dUhz3RZifHqqidEO5bprvxKoSdTheX8Yw,4125
+structured_eval/engine/evaluator.py,sha256=9vJv5aVUnWRmmag_I2p_TCtUwe8SPUGfk1dSjRKGGto,2929
+structured_eval/engine/metric_runner.py,sha256=XpjhWX2ulSdnIRkvPFpevPIbi5JN9t4TP_KmGZW5LyM,2745
+structured_eval/engine/parser.py,sha256=Ux10hDIG_TtMQ07JNO-9OaEln46sS2SG9C1SWoSQju4,1505
+structured_eval/engine/report_builder.py,sha256=EnaHevbQvbsGkYYW_W8CYvhdmE2bMUw5iSSJFGJPY_Y,2791
+structured_eval/engine/tree_builder.py,sha256=RAjXLJ42_W70QgfT0v7pZWLAmh1pmnWb3Ycf1HfazUI,12800
+structured_eval/formats/__init__.py,sha256=uJ2_LF-8KtA_oW4mOjBMDz8_1X7KYz3HzTsvavou-pE,270
+structured_eval/formats/base.py,sha256=isWyP1dYBIMGl6Uf_oH4YEnF98hqIKnesJyHf-RzW6k,547
+structured_eval/formats/json_parser.py,sha256=GDkPICl42p0tkUHUktD5AsNzLrWCAq_avDJgX_WE_KE,1334
+structured_eval/formats/yaml_parser.py,sha256=DUBGwm0YGUrRQH5jc7wJTbPcJj1KIGSIojczB1bUMk0,779
+structured_eval/integrations/__init__.py,sha256=PMcSdcjDWcKBjWWf9koeqWs8DoT2gbeHMzs-ajN4q-Q,440
+structured_eval/integrations/_adapter.py,sha256=iAza_T-85cEWLezW8NTFa2iO5-phLHN5e_67qOGJlks,1721
+structured_eval/integrations/deepeval.py,sha256=efHjgJp2006cQiUygUq5Con25BaZgP8IaTqJ2Pk-30Y,2567
+structured_eval/integrations/langsmith.py,sha256=7yUJ-4AK6UgoYsUWlGNGz9gQ1aX0rD4ufwGUb4XapFY,3232
+structured_eval/metrics/__init__.py,sha256=NqCKu0nbhF7ZUpvUnDTLRNPJ15qrV3RZf9wzHph_i3s,3553
+structured_eval/metrics/array_accuracy.py,sha256=NSvotfYyK3FrU8XjkY8LCwt4w7oVMZabDvQ5iSorkXU,959
+structured_eval/metrics/array_cardinality.py,sha256=XzXZvZhICszt7GcMqyYVV2dh1hZL9xaKiPzNDuvWR0M,825
+structured_eval/metrics/array_exact_match.py,sha256=15uL2fQ6x-2r-61VYavV1qfKVwS40YSF0dX7Y6SE_nY,1789
+structured_eval/metrics/array_f1.py,sha256=SBZLNxVUDeog37Iini-LGwE2_OsI0bmJDYRTLkOU_mg,1107
+structured_eval/metrics/array_jaccard_similarity.py,sha256=FZ7J5KOfG2rQX_22QcVqqNV9SVXtnHIQmYJuDtwvwAI,1947
+structured_eval/metrics/array_precision.py,sha256=UUYXeSHMNNpuGSTCqblYOG6PHOYHA1CJvUYZ_aKBzOQ,1175
+structured_eval/metrics/array_prf1.py,sha256=l8W6-ayc-REi96i5kQxYmgj0S5Fwh0lEb3aj8DevzbY,1331
+structured_eval/metrics/array_recall.py,sha256=MK84b-KV18otCYDbPD4e4AcWFnTtMW_D7RVyaYIHJvQ,1050
+structured_eval/metrics/base.py,sha256=wuxWK6pNTo-RsIhpDaFWjGsTWXO6Xtvpj4Q3CgsEa5s,5776
+structured_eval/metrics/character_f1.py,sha256=ofYuOR0NnF6f-rBfjmJCCe9HpgMSFb1LvqwcnZPOhKk,1476
+structured_eval/metrics/composite_score.py,sha256=okiZNzeKltBktavcIEFcP_kOCrvhJ41o_-jK-GM3RBQ,1788
+structured_eval/metrics/coverage_leaf_score.py,sha256=5SjCIlA9XfrbvjELNRmuuCZJdtEyJlcgXDkIKGgsOxk,967
+structured_eval/metrics/date_distance_score.py,sha256=In9VdFjFmazCHPK7GBDAfl8kIu1wh1POh0l28SkIZ7I,1960
+structured_eval/metrics/exact.py,sha256=etBVsT9aJEqwiuorBaxOo75imMjwidk9CrPjZVaMJVQ,689
+structured_eval/metrics/exponential_numeric_score.py,sha256=nfSVGCx6wlO8bJfsKWCLVAFWsrYgLuWu5nfoiV4AEAM,1608
+structured_eval/metrics/field_faithfulness.py,sha256=0C8ye79C9o0esxp7SE46H6TN6-QI-GDXHByqnFfooBE,1519
+structured_eval/metrics/fuzzy.py,sha256=ytjjkvYLx3dPT32tP9ivT8s_Se-QX5ol1lQfbddU88s,2181
+structured_eval/metrics/invoker.py,sha256=P3RrJMXVLvBXpUihov-axAmehiexUuTFEyWttept7VM,3618
+structured_eval/metrics/levenshtein.py,sha256=84zqiSmcRwzuS6ww0WyHFTsQ3CPDqy5MgwCkvJnqNwE,540
+structured_eval/metrics/mean_score.py,sha256=Vjh9SHVVq1XyC_iLvvv60sjbFikd9tMC83mRsP-Aoj4,1283
+structured_eval/metrics/numeric.py,sha256=Uw7d7r6ATzZKk__iy3vKKne_HoQV-U8VKFOSKMRrbf8,3094
+structured_eval/metrics/numeric_closeness.py,sha256=1xcaRW8zBWcyiuuc2Y6XF1OpoErGISYmSeDXH-p_KWw,1423
+structured_eval/metrics/object_accuracy.py,sha256=ZNFoRUKt4j7jbePbWswvuebdOeyzAVKI-gw0avToRxM,1849
+structured_eval/metrics/object_exact_match.py,sha256=oGH3P2ciSoM4nAh_-41IL_WSA5TVARAQfu6QlRKgPeI,1526
+structured_eval/metrics/object_f1.py,sha256=d-sNwb3ZPpB3dFN5zlw7Ukd89ogyYv7w_9VUfiRWsEQ,1645
+structured_eval/metrics/object_precision.py,sha256=tNhfGE8bHVjSor9dmvnYE9OMEVNdm95LpWWMhznk9tI,1884
+structured_eval/metrics/object_prf1.py,sha256=LThknlAb58QhP_GagYPE7N5C6ld7iAPedZ25XvOO3EM,1742
+structured_eval/metrics/object_recall.py,sha256=vI2UV0FZyx4EEgWYeIzGlgcWeUTPbNexCuJEWyeryiY,1518
+structured_eval/metrics/object_type_validity.py,sha256=apGdukmyFFaBP8XHumaWCVPJGSYxqAR4lxBAEZmLnDs,1186
+structured_eval/metrics/overall_leaf_score.py,sha256=rQDg9RRLefjt_iyzE6mGKINMre--aDL7GPdHJxOsnsU,1148
+structured_eval/metrics/presence.py,sha256=D9PChEw3Cy_Fm9BBj-gUjill4ddtmQrjg5emalz7HxY,678
+structured_eval/metrics/regex_match.py,sha256=-Kp4uoffrz_fLWj8f1U9Fq0Qg94gxKCKNNubgX-gr-s,1806
+structured_eval/metrics/structural_similarity.py,sha256=N6MY-decMEK3MHPSOd_BLTf0ZS-JKwWh08boOuSt1rc,1466
+structured_eval/metrics/token_f1.py,sha256=E2lE5398JbaQdZ3RwC54Liyyw_A1Lz5hTlI2dq3Mw6U,1466
+structured_eval/metrics/type_match.py,sha256=n1KBgLYVaDvfSmapvoAzLR7vlpYH2ttgnvtMWowOjFg,996
+structured_eval/metrics/rule_pass_rate/__init__.py,sha256=oFt5_NOdjFtmOrMPE2lemrTduxlO2RPRF6uvUi3wWhM,256
+structured_eval/metrics/rule_pass_rate/dsl.py,sha256=sPKdRgr7cmGC5DPf7fWtcqEVMXVWVWxX3vguOfebEEg,7788
+structured_eval/metrics/rule_pass_rate/engine.py,sha256=m02eH7DL6HD4KyASLlkGzmOnvVkTqI4lEzLfOTx6Cjg,820
+structured_eval/metrics/rule_pass_rate/metric.py,sha256=Cr67SY2kF5UbfEmBZeTeuelfSYhKtK33FsZrjVJ5e-A,1211
+structured_eval/metrics/schema_validity/__init__.py,sha256=9OBRWGFPL_Z_0NmQLyJs0E358Y4hS4qsMiiUMzNwLd0,244
+structured_eval/metrics/schema_validity/metric.py,sha256=-PCg4-0clke0UVVQa1nH2QKK36nuGnMEBfSblq05tTI,1205
+structured_eval/metrics/schema_validity/validator.py,sha256=aBoxB7Txq4Quf2n3Sjkwj4Q6wSQ4Q1mEhcIQIn4nhOA,4507
+structured_eval/metrics/utils/__init__.py,sha256=JggEJ034wTR1QIBOsT6M0gQyKjiRm59ncWddOBJFb14,479
+structured_eval/metrics/utils/array.py,sha256=c9YS66yHZGQrWVTCGVNR5SVkYF_M3GBwvef0IU_O-sQ,1181
+structured_eval/metrics/utils/calculate.py,sha256=Cwwxd-d5-so3S4z1lvvpv2eLLGMrMkuCSZwJ0Ogo_Hs,2799
+structured_eval/metrics/utils/number.py,sha256=JQ2x19GtZGIXQm5uJ1KL8Z87Fo6l-8ZNmUIlo9PGkcg,1638
+structured_eval/metrics/utils/object_utils.py,sha256=8N0Z9Fy02r_D8I2nTBeeeRbca2CWnsvoB89a2-gHFgc,3533
+structured_eval/models/__init__.py,sha256=Cb123VhFlVG7EOfdc32F4zRpkrdMsENQn-0axb8cBsU,1903
+structured_eval/models/config.py,sha256=te4clYdn1CR5RQ_AYgvQdCQQ4u_w2qeUli0poW3kPg0,5069
+structured_eval/models/context.py,sha256=FxnsdA3DyK5pmFnA6ubj5bmO9qHPLnnXy0TIaFMM7_Y,684
+structured_eval/models/metric_result.py,sha256=n0w-AN5Fd2lXUUi1GJaao6jczp7C1X1ocZhjZfWpLWE,4351
+structured_eval/models/result.py,sha256=uKJ_M3_Y_T4gKGincCrLuhax0JabOJS8pF_ftr8CwJM,14517
+structured_eval/models/sample.py,sha256=0KfX6a78NyYNkkh9BTWhyFyweKjm5MnRng2B3qF6cOQ,593
+structured_eval/models/nodes/__init__.py,sha256=mEKvtT5qWypdaOZiW3rV1JDeQ0ERgQZJbwql-0gvdGY,392
+structured_eval/models/nodes/array_node.py,sha256=259OXuamXZecfkce-HgLJ3zi9xFI3LioWGggP_L5RXg,1207
+structured_eval/models/nodes/base.py,sha256=P4dHPdvZa9KgeA7Oafhha6dSVJpRuF2cXhujWdYyNws,4756
+structured_eval/models/nodes/object_node.py,sha256=DAvrc7OedJkmu7RUpHUoKpyyJwmJ6YAcKkpxBQ-Ama4,626
+structured_eval/models/nodes/scalar.py,sha256=nE1KTH88gmqFBYoBam43qeT4HnpXeFWGEVCXVP3ADwc,559
+structured_eval/reporting/__init__.py,sha256=NCR1g2TlWvTChC-gjZMR0g3MkyDlw_anHBwWAJp6iCU,151
+structured_eval/reporting/console.py,sha256=ee4CM_yjrHR4ymCZYpNUGT7xcYDX5cf37geMNctAulU,7576
+structured_eval/utils/__init__.py,sha256=2azRMRqcHctvvHPQIhwL3IT7hsjefq5uCVgSBvDRJyU,318
+structured_eval/utils/flatten.py,sha256=1aSlCxCh-tl3BomYldQC3pPGcDCUIpq9-F-1Lfw8_LA,2550
+structured_eval/utils/paths.py,sha256=WHBh6nZxvTmZhvlLjDOHP5dGnl6y0rGlis63jC1IeE8,1930
+structured_eval/utils/structured_diff.py,sha256=hDz749pKcklMel4tNEexZKi3zqWU4kpXGasQsva0Kj0,5078
+structured_eval-0.1.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+structured_eval-0.1.0.dist-info/METADATA,sha256=l480hpihBw_NBj7XW9v837QFGGZFC4xXIMbeG7tS-6k,13434
+structured_eval-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+structured_eval-0.1.0.dist-info/top_level.txt,sha256=lXeN2DTo1LTRN5ujZgaxlssE0DDw0NdQqLI0VfhON2A,16
+structured_eval-0.1.0.dist-info/RECORD,,

structured_eval-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+