graphite-engine 0.3.0__tar.gz → 0.3.2__tar.gz

graphite_engine-0.3.2/PKG-INFO

@@ -0,0 +1,251 @@
+Metadata-Version: 2.4
+Name: graphite-engine
+Version: 0.3.2
+Summary: Open-source claim verification engine for agent-generated assertions in high-stakes domains
+Author: Min Jun Kim
+License: Apache-2.0
+Project-URL: Homepage, https://github.com/minjun1/graphite-core
+Project-URL: Documentation, https://github.com/minjun1/graphite-core#readme
+Project-URL: Repository, https://github.com/minjun1/graphite-core
+Project-URL: Issues, https://github.com/minjun1/graphite-core/issues
+Keywords: verification,claims,evidence,provenance,trust,graph
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: networkx>=3.0
+Requires-Dist: pydantic>=2.0
+Provides-Extra: llm
+Requires-Dist: openai>=1.0; extra == "llm"
+Requires-Dist: google-genai>=1.0; extra == "llm"
+Provides-Extra: geo
+Requires-Dist: rasterio>=1.3; extra == "geo"
+Requires-Dist: numpy>=1.24; extra == "geo"
+Provides-Extra: all
+Requires-Dist: graphite-engine[geo,llm]; extra == "all"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
+Requires-Dist: python-dotenv>=1.0; extra == "dev"
+Dynamic: license-file
+
+  <div align="center">
+    <h1>⛏️ Graphite</h1>
+    <p><strong>Claim verification engine for AI agent outputs.</strong></p>
+    <p><em>LLMs judge. Graphs remember.</em></p>
+    <p>Graphite extracts claims from agent-generated text, retrieves evidence, verifies support and contradiction, flags unsupported reasoning leaps, and stores every verdict with a full provenance trail — building a verification memory that gets stronger with every review.</p>
+    <p>
+      <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache--2.0-blue.svg" alt="License"></a>
+      <a href="https://python.org"><img src="https://img.shields.io/badge/python-3.10%2B-brightgreen.svg" alt="Python"></a>
+    </p>
+  </div>
+
+  > ⚠️ **v0.3.x — Experimental**. Usable and tested, but API may change before 1.0. Pin your version.
+
+  ---
+
+  ### How it works
+
+  Graphite turns raw agent output into a structured verification report.
+
+  ```python
+  from graphite.pipeline import verify_agent_output
+
+  report = verify_agent_output(
+      text=agent_memo_markdown,
+      corpus=sec_filings_corpus,
+      model="gemini-2.5-flash"  # any OpenAI-compatible model works
+  )
+
+  print(f"Supported: {report.supported_count} | Conflicted: {report.conflicted_count}")
+  print(f"Requires Human Review: {len(report.risky_claim_ids)} claims")
+  ```
+
+  This single API wraps a 5-step pipeline:
+
+  1. **Extract**: Parses the document into atomic claims using LLMs.
+  2. **Retrieve**: Finds candidate evidence spans across the corpus for each claim.
+  3. **Verify**: Judges claims against the retrieved spans (Supported, Conflicted, Insufficient).
+  4. **Analyze**: Flags argument-level reasoning leaps (`CONCLUSION_JUMP`).
+  5. **Report**: Aggregates the findings into a `VerificationReport` with structured rationale, review flags, and full provenance.
+
+  ---
+
+  ### Handling Logic Leaps & Human Review
+
+  Downstream UI and review workflows can be built directly on top of the structured output.
+
+  ```python
+  from graphite.claim import ArgumentVerdictEnum
+
+  # Check for logic leaps (Argument-level verification)
+  for argument in report.argument_verdicts:
+      if argument.verdict == ArgumentVerdictEnum.CONCLUSION_JUMP:
+          print(f"⚠️ LOGIC LEAP: {argument.text}")
+
+  # Route high-risk factual claims to a Human-in-the-loop review queue
+  for claim_id in report.risky_claim_ids:
+      verdict = report.get_verdict(claim_id)
+      if verdict.needs_human_review:
+          print(f"🚨 REVIEW NEEDED: {verdict.claim_text}")
+          print(f"   Reason: {verdict.rationale.missing_evidence_reason or verdict.rationale.contradiction_type}")
+  ```
+
+  ---
+
+  ### Quickstart
+
+  ```bash
+  pip install "graphite-engine[llm]"
+  export GEMINI_API_KEY="your-api-key-here"
+  python examples/quickstart_verification/run.py
+  ```
+
+  Or from source:
+
+  ```bash
+  git clone https://github.com/minjun1/graphite-core.git
+  cd graphite-core
+  pip install -e ".[llm]"
+  export GEMINI_API_KEY="your-api-key-here"
+  python examples/quickstart_verification/run.py
+  ```
+
+  Graphite defaults to Gemini via the OpenAI-compatible endpoint, so any OpenAI-compatible provider also works — including local models via Ollama or vLLM, or hosted endpoints like Together and Groq. Set `OPENAI_API_KEY` and `OPENAI_BASE_URL` to point at any compatible endpoint.
+
+  ---
+
+  ## Why a Graph?
+
+  Most verification tools run once and forget. Graphite anchors every judgment into a persistent graph — turning disposable LLM outputs into a living verification memory.
+
+  **Claims are first-class objects.** The same assertion can be identified, revisited, and re-evaluated across documents and time — not lost in prompt logs.
+
+  **Evidence accumulates, not overwrites.** When a second source confirms (or contradicts) a claim, Graphite appends the new evidence to the existing node instead of starting from scratch.
+
+  **Review history becomes lineage.** AI verdict → analyst override → re-evaluation with new data — every step is recorded as a relationship in the graph, not a flat log entry.
+
+  **Cross-document deduplication.** When the same claim appears in TSMC's 10-K and Nvidia's 10-K, Graphite recognizes it as one canonical claim backed by two independent sources.
+
+  **Reasoning structure, not just fact-checking.** Claims don't exist in isolation. Graphite can represent claim-to-conclusion relationships, enabling checks like `CONCLUSION_JUMP` when the logical link between premises and conclusion is unsupported.
+
+  ---
+
+  ## Stateful Verification Memory
+
+  Unlike stateless evaluators that produce a score and discard context, Graphite's `ClaimStore` builds a persistent fact base that strengthens over time.
+
+  ```
+  Run 1: Extract "TSMC supplies CoWoS to Nvidia" from TSMC 10-K
+          → 1 evidence source recorded
+
+  Run 2: Same claim found in Nvidia 10-K
+          → evidence accumulates → 2 independent sources
+
+  Run 3: Exact duplicate from same source
+          → deduplicated, no change
+
+  Run 4: Related claim "Nvidia depends on TSMC" extracted
+          → cross-claim linkage via shared entities
+  ```
+
+  What this looks like as a graph:
+
+  ```
+  Claim: "TSMC supplies CoWoS to Nvidia"
+    ├── supported_by → TSMC 10-K (cited span)
+    ├── supported_by → Nvidia 10-K (cited span)
+    ├── reviewed_as → SUPPORTED (model verdict)
+    └── contributes_to → "Nvidia depends on TSMC"
+  ```
+
+  Each claim is a deduplicated node. Evidence merges across extraction runs. Analyst overrides persist. The result is a verification memory where repeated reviews compound — not repeat.
+
+  *Most verification tools forget. Graphite remembers — and gets stronger with every review.*
+
+  *(See `examples/evidence_accumulation/` for a runnable demo — no API keys required.)*
+
+  ---
+
+  ## Graphite vs. Existing Tools
+
+  *Evaluators grade your prompts. Graphite audits your agent's claims — and remembers every verdict.*
+
+  These tools solve adjacent but different problems:
+
+  | Dimension | Ragas / TruLens / DeepEval | Graphite |
+  |-----------|---------------------------|----------|
+  | **Purpose** | Prompt/model evaluation (CI/CD) | Production output verification (runtime) |
+  | **State** | Stateless — each run is independent | Stateful — evidence accumulates across runs |
+  | **Output** | Scores (faithfulness, relevance) | Structured `VerificationReport` with provenance |
+  | **Logic Leaps** | Not addressed | `CONCLUSION_JUMP` / `OVERSTATED` detection |
+  | **Human Review** | Manual review of score dashboards | `needs_human_review` routing with analyst override |
+  | **Audit Trail** | Execution logs | Every verdict links to exact `cited_span` with full lineage |
+
+  ---
+
+  ## Evaluation Snapshot
+
+  Representative verification cases from our golden test suite (current snapshot run on GPT-4o; `evals/verify_eval.py`):
+
+  | Test Case | Type | Expected | Graphite Output |
+  |-----------|------|----------|-----------------|
+  | Paraphrased contradiction | Semantic | CONFLICTED | CONFLICTED |
+  | Numeric mismatch (10× error) | Factual | CONFLICTED | CONFLICTED |
+  | Temporal mismatch (stale CEO) | Temporal | CONFLICTED | CONFLICTED |
+  | Unsupported revenue prediction | Reasoning Leap | CONCLUSION_JUMP | CONCLUSION_JUMP |
+
+  - Claim-level verdict: correct in 3/3 factual cases
+  - Argument-level verdict: correct in 1/1 reasoning case
+  - These cases are intended as regression checks for key failure modes, not as a broad accuracy benchmark.
+
+  > *This is a representative snapshot, not a comprehensive benchmark. See `evals/` for the full test suite and `examples/` for runnable demos. A larger-scale evaluation suite (100+ memos) is on the roadmap.*
+
+  ---
+
+  ## Core Primitives
+
+  | Object | What it does |
+  |-----------|-------------|
+  | `VerificationReport` | Top-level summary of the entire review, ready for product UI integrations |
+  | `Verdict` | Claim-level judgment (`SUPPORTED`, `CONFLICTED`, `INSUFFICIENT`) with structured rationale |
+  | `ArgumentVerdict` | Argument-level judgment (`GROUNDED`, `CONCLUSION_JUMP`, `OVERSTATED`) |
+  | `ClaimStore` | Persistent verification memory — deduplicates claims, merges evidence, and preserves review history across runs |
+
+  ---
+
+  ## Reference Applications
+
+  Graphite is designed as the verification engine for high-stakes workflows across multiple domains:
+
+  - **Compliance & Legal Review**: Checking internal policy documents or marketing copy against regulatory guidelines.
+  - **Healthcare & Scientific Fact-checking**: Cross-referencing generated medical or scientific summaries against peer-reviewed journals.
+  - **Investment & Research QA**: Verifying AI-generated analyst memos against SEC filings or earnings call transcripts.
+
+  *(See `examples/quickstart_verification/` for end-to-end verification, `examples/evidence_accumulation/` for stateful memory, and `examples/lineage_override_demo/` for analyst override workflows.)*
+
+  ---
+
+  ## Optional extras
+
+  **Core** (always included): `networkx` + `pydantic`
+
+  ```bash
+  pip install -e ".[llm]"     # LLM support (OpenAI-compatible providers)
+  pip install -e ".[all]"     # Everything
+  ```
+
+  > Set `GEMINI_API_KEY` to get started. To use other providers, set `OPENAI_API_KEY` and `OPENAI_BASE_URL`.
+
+  ---
+
+  ## License
+
+  Apache-2.0 — see [LICENSE](LICENSE).

graphite_engine-0.3.2/README.md

@@ -0,0 +1,213 @@
+  <div align="center">
+    <h1>⛏️ Graphite</h1>
+    <p><strong>Claim verification engine for AI agent outputs.</strong></p>
+    <p><em>LLMs judge. Graphs remember.</em></p>
+    <p>Graphite extracts claims from agent-generated text, retrieves evidence, verifies support and contradiction, flags unsupported reasoning leaps, and stores every verdict with a full provenance trail — building a verification memory that gets stronger with every review.</p>
+    <p>
+      <a href="LICENSE"><img src="https://img.shields.io/badge/license-Apache--2.0-blue.svg" alt="License"></a>
+      <a href="https://python.org"><img src="https://img.shields.io/badge/python-3.10%2B-brightgreen.svg" alt="Python"></a>
+    </p>
+  </div>
+
+  > ⚠️ **v0.3.x — Experimental**. Usable and tested, but API may change before 1.0. Pin your version.
+
+  ---
+
+  ### How it works
+
+  Graphite turns raw agent output into a structured verification report.
+
+  ```python
+  from graphite.pipeline import verify_agent_output
+
+  report = verify_agent_output(
+      text=agent_memo_markdown,
+      corpus=sec_filings_corpus,
+      model="gemini-2.5-flash"  # any OpenAI-compatible model works
+  )
+
+  print(f"Supported: {report.supported_count} | Conflicted: {report.conflicted_count}")
+  print(f"Requires Human Review: {len(report.risky_claim_ids)} claims")
+  ```
+
+  This single API wraps a 5-step pipeline:
+
+  1. **Extract**: Parses the document into atomic claims using LLMs.
+  2. **Retrieve**: Finds candidate evidence spans across the corpus for each claim.
+  3. **Verify**: Judges claims against the retrieved spans (Supported, Conflicted, Insufficient).
+  4. **Analyze**: Flags argument-level reasoning leaps (`CONCLUSION_JUMP`).
+  5. **Report**: Aggregates the findings into a `VerificationReport` with structured rationale, review flags, and full provenance.
+
+  ---
+
+  ### Handling Logic Leaps & Human Review
+
+  Downstream UI and review workflows can be built directly on top of the structured output.
+
+  ```python
+  from graphite.claim import ArgumentVerdictEnum
+
+  # Check for logic leaps (Argument-level verification)
+  for argument in report.argument_verdicts:
+      if argument.verdict == ArgumentVerdictEnum.CONCLUSION_JUMP:
+          print(f"⚠️ LOGIC LEAP: {argument.text}")
+
+  # Route high-risk factual claims to a Human-in-the-loop review queue
+  for claim_id in report.risky_claim_ids:
+      verdict = report.get_verdict(claim_id)
+      if verdict.needs_human_review:
+          print(f"🚨 REVIEW NEEDED: {verdict.claim_text}")
+          print(f"   Reason: {verdict.rationale.missing_evidence_reason or verdict.rationale.contradiction_type}")
+  ```
+
+  ---
+
+  ### Quickstart
+
+  ```bash
+  pip install "graphite-engine[llm]"
+  export GEMINI_API_KEY="your-api-key-here"
+  python examples/quickstart_verification/run.py
+  ```
+
+  Or from source:
+
+  ```bash
+  git clone https://github.com/minjun1/graphite-core.git
+  cd graphite-core
+  pip install -e ".[llm]"
+  export GEMINI_API_KEY="your-api-key-here"
+  python examples/quickstart_verification/run.py
+  ```
+
+  Graphite defaults to Gemini via the OpenAI-compatible endpoint, so any OpenAI-compatible provider also works — including local models via Ollama or vLLM, or hosted endpoints like Together and Groq. Set `OPENAI_API_KEY` and `OPENAI_BASE_URL` to point at any compatible endpoint.
+
+  ---
+
+  ## Why a Graph?
+
+  Most verification tools run once and forget. Graphite anchors every judgment into a persistent graph — turning disposable LLM outputs into a living verification memory.
+
+  **Claims are first-class objects.** The same assertion can be identified, revisited, and re-evaluated across documents and time — not lost in prompt logs.
+
+  **Evidence accumulates, not overwrites.** When a second source confirms (or contradicts) a claim, Graphite appends the new evidence to the existing node instead of starting from scratch.
+
+  **Review history becomes lineage.** AI verdict → analyst override → re-evaluation with new data — every step is recorded as a relationship in the graph, not a flat log entry.
+
+  **Cross-document deduplication.** When the same claim appears in TSMC's 10-K and Nvidia's 10-K, Graphite recognizes it as one canonical claim backed by two independent sources.
+
+  **Reasoning structure, not just fact-checking.** Claims don't exist in isolation. Graphite can represent claim-to-conclusion relationships, enabling checks like `CONCLUSION_JUMP` when the logical link between premises and conclusion is unsupported.
+
+  ---
+
+  ## Stateful Verification Memory
+
+  Unlike stateless evaluators that produce a score and discard context, Graphite's `ClaimStore` builds a persistent fact base that strengthens over time.
+
+  ```
+  Run 1: Extract "TSMC supplies CoWoS to Nvidia" from TSMC 10-K
+          → 1 evidence source recorded
+
+  Run 2: Same claim found in Nvidia 10-K
+          → evidence accumulates → 2 independent sources
+
+  Run 3: Exact duplicate from same source
+          → deduplicated, no change
+
+  Run 4: Related claim "Nvidia depends on TSMC" extracted
+          → cross-claim linkage via shared entities
+  ```
+
+  What this looks like as a graph:
+
+  ```
+  Claim: "TSMC supplies CoWoS to Nvidia"
+    ├── supported_by → TSMC 10-K (cited span)
+    ├── supported_by → Nvidia 10-K (cited span)
+    ├── reviewed_as → SUPPORTED (model verdict)
+    └── contributes_to → "Nvidia depends on TSMC"
+  ```
+
+  Each claim is a deduplicated node. Evidence merges across extraction runs. Analyst overrides persist. The result is a verification memory where repeated reviews compound — not repeat.
+
+  *Most verification tools forget. Graphite remembers — and gets stronger with every review.*
+
+  *(See `examples/evidence_accumulation/` for a runnable demo — no API keys required.)*
+
+  ---
+
+  ## Graphite vs. Existing Tools
+
+  *Evaluators grade your prompts. Graphite audits your agent's claims — and remembers every verdict.*
+
+  These tools solve adjacent but different problems:
+
+  | Dimension | Ragas / TruLens / DeepEval | Graphite |
+  |-----------|---------------------------|----------|
+  | **Purpose** | Prompt/model evaluation (CI/CD) | Production output verification (runtime) |
+  | **State** | Stateless — each run is independent | Stateful — evidence accumulates across runs |
+  | **Output** | Scores (faithfulness, relevance) | Structured `VerificationReport` with provenance |
+  | **Logic Leaps** | Not addressed | `CONCLUSION_JUMP` / `OVERSTATED` detection |
+  | **Human Review** | Manual review of score dashboards | `needs_human_review` routing with analyst override |
+  | **Audit Trail** | Execution logs | Every verdict links to exact `cited_span` with full lineage |
+
+  ---
+
+  ## Evaluation Snapshot
+
+  Representative verification cases from our golden test suite (current snapshot run on GPT-4o; `evals/verify_eval.py`):
+
+  | Test Case | Type | Expected | Graphite Output |
+  |-----------|------|----------|-----------------|
+  | Paraphrased contradiction | Semantic | CONFLICTED | CONFLICTED |
+  | Numeric mismatch (10× error) | Factual | CONFLICTED | CONFLICTED |
+  | Temporal mismatch (stale CEO) | Temporal | CONFLICTED | CONFLICTED |
+  | Unsupported revenue prediction | Reasoning Leap | CONCLUSION_JUMP | CONCLUSION_JUMP |
+
+  - Claim-level verdict: correct in 3/3 factual cases
+  - Argument-level verdict: correct in 1/1 reasoning case
+  - These cases are intended as regression checks for key failure modes, not as a broad accuracy benchmark.
+
+  > *This is a representative snapshot, not a comprehensive benchmark. See `evals/` for the full test suite and `examples/` for runnable demos. A larger-scale evaluation suite (100+ memos) is on the roadmap.*
+
+  ---
+
+  ## Core Primitives
+
+  | Object | What it does |
+  |-----------|-------------|
+  | `VerificationReport` | Top-level summary of the entire review, ready for product UI integrations |
+  | `Verdict` | Claim-level judgment (`SUPPORTED`, `CONFLICTED`, `INSUFFICIENT`) with structured rationale |
+  | `ArgumentVerdict` | Argument-level judgment (`GROUNDED`, `CONCLUSION_JUMP`, `OVERSTATED`) |
+  | `ClaimStore` | Persistent verification memory — deduplicates claims, merges evidence, and preserves review history across runs |
+
+  ---
+
+  ## Reference Applications
+
+  Graphite is designed as the verification engine for high-stakes workflows across multiple domains:
+
+  - **Compliance & Legal Review**: Checking internal policy documents or marketing copy against regulatory guidelines.
+  - **Healthcare & Scientific Fact-checking**: Cross-referencing generated medical or scientific summaries against peer-reviewed journals.
+  - **Investment & Research QA**: Verifying AI-generated analyst memos against SEC filings or earnings call transcripts.
+
+  *(See `examples/quickstart_verification/` for end-to-end verification, `examples/evidence_accumulation/` for stateful memory, and `examples/lineage_override_demo/` for analyst override workflows.)*
+
+  ---
+
+  ## Optional extras
+
+  **Core** (always included): `networkx` + `pydantic`
+
+  ```bash
+  pip install -e ".[llm]"     # LLM support (OpenAI-compatible providers)
+  pip install -e ".[all]"     # Everything
+  ```
+
+  > Set `GEMINI_API_KEY` to get started. To use other providers, set `OPENAI_API_KEY` and `OPENAI_BASE_URL`.
+
+  ---
+
+  ## License
+
+  Apache-2.0 — see [LICENSE](LICENSE).

{graphite_engine-0.3.0 → graphite_engine-0.3.2}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "graphite-engine"
-version = "0.3.0"
-description = "Open-source claim verification engine for high-stakes decisions"
+version = "0.3.2"
+description = "Open-source claim verification engine for agent-generated assertions in high-stakes domains"
 readme = "README.md"
 requires-python = ">=3.10"
 license = {text = "Apache-2.0"}
@@ -28,24 +28,23 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
-neo4j = ["neo4j>=5.0"]
-llm = ["google-genai>=1.0"]
-pdf = ["pdfplumber>=0.9"]
+llm = ["openai>=1.0", "google-genai>=1.0"]
 geo = ["rasterio>=1.3", "numpy>=1.24"]
-all = ["graphite-engine[neo4j,llm,pdf,geo]"]
+all = ["graphite-engine[llm,geo]"]
 dev = [
     "pytest>=8.0",
     "python-dotenv>=1.0",
 ]
 
 [project.urls]
-Homepage = "https://github.com/graf-research/graphite"
-Documentation = "https://github.com/graf-research/graphite#readme"
-Repository = "https://github.com/graf-research/graphite"
-Issues = "https://github.com/graf-research/graphite/issues"
+Homepage = "https://github.com/minjun1/graphite-core"
+Documentation = "https://github.com/minjun1/graphite-core#readme"
+Repository = "https://github.com/minjun1/graphite-core"
+Issues = "https://github.com/minjun1/graphite-core/issues"
 
 [tool.setuptools.packages.find]
 where = ["src"]
+exclude = ["graphite._archive", "graphite._archive.*"]
 
 [tool.setuptools.package-data]
 graphite = ["py.typed"]

graphite_engine-0.3.2/src/graphite/__init__.py

@@ -0,0 +1,53 @@
+"""
+Graphite — Open-source claim verification engine for agent-generated
+assertions in high-stakes domains.
+
+Core primitives:
+  - Claim: the atomic unit of trust — structured assertion with provenance
+  - ClaimStore: evidence-accumulating registry (claims dedupe, evidence merges)
+  - Provenance: first-class evidence source (document, quote, confidence)
+  - ConfidenceScorer: explainable confidence scoring with named factors
+
+Pipeline:
+  Agent/Extractor → Claim[] → ClaimStore (accumulate) → Verify
+"""
+
+# ── Core schemas ──
+from .schemas import ExtractedEdge, NodeRef, Provenance, InferenceBasis, ExtractionError
+from .enums import (
+    EdgeType,
+    NodeType,
+    SourceType,
+    ConfidenceLevel,
+    AssertionMode,
+    EvidenceType,
+)
+from .evidence import EvidencePacket, EvidenceData
+
+# ── Trust engine primitives ──
+from .claim import (
+    Claim,
+    ClaimType,
+    ClaimStatus,
+    ClaimGranularity,
+    ReviewState,
+    ClaimOrigin,
+)
+from .claim import ConfidenceFactor, ConfidenceResult
+from .claim_store import ClaimStore
+from .confidence import ConfidenceScorer
+
+# ── Domain plugin contracts ──
+from .domain import (
+    BaseFetcher,
+    BaseExtractor,
+    BasePipeline,
+    DocumentContext,
+    DomainSpec,
+)
+from .domain import register_domain, get_domain, list_domains
+
+# ── Rules ──
+from .rules import BaseRuleEngine, RuleResult, ScoreBreakdown
+
+__version__ = "0.3.2"

{graphite_engine-0.3.0 → graphite_engine-0.3.2}/src/graphite/adapters/alphaearth.py

@@ -12,6 +12,7 @@ AlphaEarth Foundations:
   - Earth Engine dataset: GOOGLE/SATELLITE_EMBEDDING/V1/ANNUAL
   - GCS bucket: gs://alphaearth_foundations (Requester Pays)
 """
+
 import json
 import os
 from pathlib import Path
@@ -122,7 +123,9 @@ class AlphaEarthAdapter:
         Returns:
             numpy array of shape (64,)
         """
-        cache_key = node_id or f"bbox_{bbox[0]:.4f}_{bbox[1]:.4f}_{bbox[2]:.4f}_{bbox[3]:.4f}"
+        cache_key = (
+            node_id or f"bbox_{bbox[0]:.4f}_{bbox[1]:.4f}_{bbox[2]:.4f}_{bbox[3]:.4f}"
+        )
 
         cached = self._read_cache(cache_key, year)
         if cached is not None:

{graphite_engine-0.3.0 → graphite_engine-0.3.2}/src/graphite/adapters/weathernext.py

@@ -12,6 +12,7 @@ WeatherNext 2:
   - Access: EE/BigQuery (requires data request form)
   - Note: Experimental dataset, not validated for real-world use
 """
+
 import json
 from pathlib import Path
 from typing import Any, Dict, List, Optional

{graphite_engine-0.3.0 → graphite_engine-0.3.2}/src/graphite/cache.py

@@ -4,6 +4,7 @@ graphite/cache.py — Extraction result caching.
 5-part cache key prevents pollution when anything changes:
   (source_id, content_hash, extractor_version, prompt_version, model_name)
 """
+
 import hashlib
 import json
 import os