rag-wright 0.1.0__py3-none-any.whl

rag_wright/okf/links.py

@@ -0,0 +1,190 @@
+"""T49 (FR-K.3): embedding-free cross-linking of the OKF bundle from shared distinctive terms.
+
+Writes standard markdown links (absolute from the bundle root) between related clauses, so a traversal can
+move laterally, not only down the category tree. Edges are derived from MEASURED structure, not guessed, and
+kept embedding-free (Option 1, 2026-07-22): two clauses are related when their bodies share distinctive (rare,
+legal) terms; the embedding-kNN structure T41 measured is the held fallback if this does not lift the ceiling.
+
+Density is bounded two ways so the graph does not degenerate into near-complete connectivity: an ultra-common
+term (appearing in more than `MAX_TERM_DF` clauses) carries no signal and is skipped, and each clause keeps at
+most `max_degree` neighbours, ranked by shared-term count. The pass is idempotent and runs INDEPENDENTLY of the
+compile (it rewrites only each concept's `## Related clauses` section), so a link recipe can be re-run or
+ablated without a full recompile. A concept's clause text stays the leading body verbatim; links are appended.
+
+Run: uv run python -m rag_wright.okf.links
+"""
+
+from __future__ import annotations
+
+import re
+from collections import defaultdict
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from rag_wright.okf.document import parse_okf, serialize_okf
+
+LINKS_RECIPE_VERSION = "okf-links-lex-v1"
+DEFAULT_MAX_DEGREE = 8
+DEFAULT_MIN_SHARED = 2  # a link needs >=2 shared distinctive terms (one rare word alone is not relatedness)
+MAX_TERM_DF = 100  # a distinctive term in more than this many clauses is boilerplate -> no signal, skipped
+_DISTINCTIVE_LEN = 8  # only long/rare tokens count as relatedness signal
+_STEM = 6
+_RELATED_HEADING = "## Related clauses"
+_INDEX = "index.md"
+_MANIFEST = ".okf_links.json"
+_LINK = re.compile(r"\[[^\]]*\]\(([^)]+)\)")
+
+_STOPWORDS = {
+    "agreement", "including", "pursuant", "provided", "otherwise", "applicable", "hereunder", "represents",
+    "respective", "obligations", "termination", "notwithstanding", "thereunder", "thereafter", "hereinafter",
+}
+
+
+class LinksManifest(BaseModel):
+    """What the cross-link pass wrote: recipe params + edge-graph shape, stamped for attributability."""
+
+    recipe_version: str
+    max_degree: int
+    min_shared: int
+    n_concepts: int
+    n_edges: int  # directed edges written (sum of out-degrees)
+    mean_degree: float
+    isolated: int  # concepts with no related link
+
+
+def _terms(text: str) -> set[str]:
+    """Distinctive-term stems of a clause body: long, non-boilerplate tokens reduced to a prefix stem."""
+    toks = [t for t in re.split(r"[^a-z0-9]+", text.lower()) if len(t) >= _DISTINCTIVE_LEN and t not in _STOPWORDS]
+    return {t[:_STEM] for t in toks}
+
+
+class _Concept(BaseModel):
+    chunk_id: str
+    rel_path: str  # bundle-root-relative, e.g. "indemnification/abc.md"
+    title: str
+    description: str
+    terms: set[str]
+
+    model_config = {"arbitrary_types_allowed": True}
+
+
+def _clause_body(body: str) -> str:
+    """The clause text (no trailing newlines) with any prior `## Related clauses` section stripped.
+
+    Returned without a trailing newline so re-linking is byte-idempotent regardless of whether a prior
+    section was present.
+    """
+    idx = body.find(_RELATED_HEADING)
+    return (body[:idx] if idx != -1 else body).rstrip("\n")
+
+
+def _load_concepts(bundle_root: Path) -> list[_Concept]:
+    concepts: list[_Concept] = []
+    for md in sorted(bundle_root.rglob("*.md")):
+        if md.name in (_INDEX, "log.md"):
+            continue
+        fm, body = parse_okf(md.read_text(encoding="utf-8"))
+        chunk_id = fm.get("chunk_id")
+        if not chunk_id:
+            continue
+        concepts.append(
+            _Concept(
+                chunk_id=str(chunk_id),
+                rel_path=str(md.relative_to(bundle_root)),
+                title=str(fm.get("title") or md.stem),
+                description=str(fm.get("description") or ""),
+                terms=_terms(_clause_body(body)),
+            )
+        )
+    return concepts
+
+
+def build_edges(
+    concepts: list[_Concept], *, max_degree: int = DEFAULT_MAX_DEGREE, min_shared: int = DEFAULT_MIN_SHARED
+) -> dict[str, list[str]]:
+    """chunk_id -> up to `max_degree` related chunk_ids (>= min_shared shared distinctive terms), by count."""
+    term_index: dict[str, list[str]] = defaultdict(list)
+    for c in concepts:
+        for t in c.terms:
+            term_index[t].append(c.chunk_id)
+
+    shared: dict[str, dict[str, int]] = defaultdict(lambda: defaultdict(int))
+    for ids in term_index.values():
+        if len(ids) > MAX_TERM_DF:  # boilerplate term -> no relatedness signal, and bounds the pair blowup
+            continue
+        for i in range(len(ids)):
+            for j in range(i + 1, len(ids)):
+                a, b = ids[i], ids[j]
+                shared[a][b] += 1
+                shared[b][a] += 1
+
+    edges: dict[str, list[str]] = {}
+    for c in concepts:
+        ranked = sorted(
+            ((nbr, cnt) for nbr, cnt in shared.get(c.chunk_id, {}).items() if cnt >= min_shared),
+            key=lambda nc: (-nc[1], nc[0]),
+        )
+        edges[c.chunk_id] = [nbr for nbr, _ in ranked[:max_degree]]
+    return edges
+
+
+def _related_section(neighbours: list[str], by_id: dict[str, _Concept]) -> str:
+    lines = [_RELATED_HEADING, ""]
+    for nbr in neighbours:
+        c = by_id[nbr]
+        suffix = f" - {c.description}" if c.description else ""
+        lines.append(f"* [{c.title}](/{c.rel_path}){suffix}")  # absolute from bundle root, per OKF §5
+    return "\n".join(lines) + "\n"
+
+
+def apply_links(
+    bundle_root: Path,
+    *,
+    max_degree: int = DEFAULT_MAX_DEGREE,
+    min_shared: int = DEFAULT_MIN_SHARED,
+    recipe_version: str = LINKS_RECIPE_VERSION,
+) -> LinksManifest:
+    """Build edges and write each concept's `## Related clauses` section. Idempotent; independent of compile."""
+    bundle_root = Path(bundle_root)
+    concepts = _load_concepts(bundle_root)
+    by_id = {c.chunk_id: c for c in concepts}
+    edges = build_edges(concepts, max_degree=max_degree, min_shared=min_shared)
+
+    n_edges = 0
+    isolated = 0
+    for c in concepts:
+        neighbours = edges.get(c.chunk_id, [])
+        n_edges += len(neighbours)
+        isolated += 1 if not neighbours else 0
+        path = bundle_root / c.rel_path
+        fm, body = parse_okf(path.read_text(encoding="utf-8"))
+        clause = _clause_body(body)  # no trailing newline
+        new_body = f"{clause}\n\n{_related_section(neighbours, by_id)}" if neighbours else f"{clause}\n"
+        path.write_text(serialize_okf(fm, new_body), encoding="utf-8")
+
+    manifest = LinksManifest(
+        recipe_version=recipe_version,
+        max_degree=max_degree,
+        min_shared=min_shared,
+        n_concepts=len(concepts),
+        n_edges=n_edges,
+        mean_degree=(n_edges / len(concepts)) if concepts else 0.0,
+        isolated=isolated,
+    )
+    (bundle_root / _MANIFEST).write_text(manifest.model_dump_json(indent=2), encoding="utf-8")
+    return manifest
+
+
+def _default_bundle() -> Path:
+    return Path("data/acord/okf/bundle")
+
+
+def main() -> None:
+    manifest = apply_links(_default_bundle())
+    print(f"[okf_links] recipe={manifest.recipe_version} concepts={manifest.n_concepts} "
+          f"edges={manifest.n_edges} mean_degree={manifest.mean_degree:.2f} isolated={manifest.isolated}")
+
+
+if __name__ == "__main__":
+    main()

rag_wright/okf/lint.py

@@ -0,0 +1,105 @@
+"""OKF conformance linter (FR-K.4, T46): parseable frontmatter, non-empty type, resolvable links.
+
+Index and description quality is the retrieval ceiling of the whole embedding-free path, so the linter is a
+quality gate, not a formality: it reports orphan rate, description coverage, and broken-link ratio as numbers,
+not pass-or-fail alone. `passes` covers only the hard OKF v0.1 conformance rules (every concept has parseable
+frontmatter with a non-empty `type`); the rates are quality signals the compile recipe is tuned against.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from pydantic import BaseModel
+
+from rag_wright.okf.document import OkfParseError, parse_okf
+
+_INDEX_NAME = "index.md"
+_RESERVED = {"index.md", "log.md"}
+_LINK = re.compile(r"\[[^\]]*\]\(([^)]+)\)")
+
+
+class LintReport(BaseModel):
+    """Bundle conformance + quality numbers. `passes` is the hard OKF v0.1 conformance verdict."""
+
+    total_concepts: int
+    frontmatter_parseable: int
+    type_non_empty: int
+    total_index_entries: int
+    description_coverage: float  # fraction of index entries carrying a description
+    orphan_rate: float  # fraction of concept files not linked from any index.md
+    broken_link_ratio: float  # fraction of intra-bundle links whose target file is absent
+    passes: bool
+
+
+def _concept_files(root: Path) -> list[Path]:
+    return [p for p in root.rglob("*.md") if p.name not in _RESERVED]
+
+
+def _resolve(link: str, source: Path, root: Path) -> Path | None:
+    """Resolve an intra-bundle markdown link to a path, or None if it is external (a URL / anchor)."""
+    target = link.split("#", 1)[0].strip()
+    if not target or "://" in target:
+        return None
+    if target.startswith("/"):
+        return root / target.lstrip("/")
+    return (source.parent / target).resolve()
+
+
+def lint_bundle(root: Path) -> LintReport:
+    """Lint an OKF bundle, returning conformance + quality numbers."""
+    root = Path(root)
+    concepts = _concept_files(root)
+
+    parseable = type_ok = 0
+    for path in concepts:
+        try:
+            fm, _ = parse_okf(path.read_text(encoding="utf-8"))
+        except OkfParseError:
+            continue
+        parseable += 1
+        if str(fm.get("type") or "").strip():
+            type_ok += 1
+
+    # Broken-link ratio is over ALL links (index entries AND concept-body cross-links); orphan_rate is over
+    # index links only, since an index entry is the progressive-disclosure entry point from the root.
+    entries_total = entries_with_desc = 0
+    links_total = links_broken = 0
+    index_linked_targets: set[Path] = set()
+    for md in root.rglob("*.md"):
+        content = md.read_text(encoding="utf-8")
+        is_index = md.name == _INDEX_NAME
+        if is_index:
+            for raw in content.splitlines():
+                line = raw.strip()
+                if not line.startswith("*"):
+                    continue
+                if not _LINK.search(line):
+                    continue
+                entries_total += 1
+                if " - " in line.split(")", 1)[-1]:
+                    entries_with_desc += 1
+        for m in _LINK.finditer(content):
+            resolved = _resolve(m.group(1), md, root)
+            if resolved is None:
+                continue
+            links_total += 1
+            if resolved.exists():
+                if is_index:
+                    index_linked_targets.add(resolved.resolve())
+            else:
+                links_broken += 1
+
+    orphans = sum(1 for c in concepts if c.resolve() not in index_linked_targets)
+    n = len(concepts) or 1
+    return LintReport(
+        total_concepts=len(concepts),
+        frontmatter_parseable=parseable,
+        type_non_empty=type_ok,
+        total_index_entries=entries_total,
+        description_coverage=(entries_with_desc / entries_total) if entries_total else 1.0,
+        orphan_rate=orphans / n,
+        broken_link_ratio=(links_broken / links_total) if links_total else 0.0,
+        passes=parseable == len(concepts) and type_ok == len(concepts),
+    )

rag_wright/ontology/__init__.py

@@ -0,0 +1,6 @@
+"""Ontology and entity-registry derivation (FR-C.8).
+
+Pulls the entity and relationship types (as Pydantic models) and the populated entity
+registry from the Data Catalog (Nessie or equivalent). Where the catalog does not exist,
+extraction degrades to the lightweight path plus an open-ended language model (assumption 3).
+"""

rag_wright/ontology/_generated_template_meta.py

@@ -0,0 +1,60 @@
+"""GENERATED FROM contract_bridge.ttl by scripts/generate_contract_python.py -- DO NOT EDIT BY HAND.
+
+ADR-0066 P1b-2 (Rule 3): the extraction template's KNOWLEDGE -- each field's LOOK-FOR description and examples,
+generated from the ttl. `clause_template.py` CONSUMES this (via `_d()` / `_ex()`); the mechanism (validators,
+normalizers, __str__, config) stays clean hand-code there. To change a description/example, edit the ttl and
+re-run the generator; a hand-edit here is caught by tests/ontology/test_generated_template_meta_in_sync.py."""
+
+from __future__ import annotations
+
+
+DESCRIPTIONS: dict[str, str] = {
+    'Clause.document_reference': "OPTIONAL. ONLY the clause's own section number or short heading if one is written in the text (e.g. 'Section 8', '8.1 Limitation of Liability'). If there is NO explicit section number or heading, leave this null/empty -- do NOT invent one and NEVER quote the clause body or any sentence of it here.",
+    'Clause.audit_frequency': "How often an audit-rights clause permits audits, a short value ONLY, e.g. 'annual', 'quarterly', 'once per year'.",
+    'Clause.clause_type': "The clause function/type LABEL ONLY (a few words), e.g. 'Cap on Liability', 'Governing Law', 'Non-Solicit of Employees'.",
+    'Clause.collateral_type': 'The collateral / assets a SECURITY-INTEREST clause attaches to (may be several), e.g. inventory, equipment, accounts receivable, all assets.',
+    'Clause.commitment_quantum': "The minimum-commitment / volume amount ONLY (a short value), e.g. '$1,000,000', '100 units/year'.",
+    'Clause.condition_type': 'The kind of condition a CONDITION-PRECEDENT clause requires: regulatory approval / financing / third-party consent / due diligence / board approval / no material adverse change / court approval / closing condition.',
+    'Clause.confidentiality_exception': 'Permitted disclosures / exceptions to a CONFIDENTIALITY obligation (may be several): required by law, publicly available, independently developed, prior possession, received from a third party.',
+    'Clause.force_majeure_event': 'Events a FORCE-MAJEURE clause lists as excusing performance (may be several): act of god, war, pandemic, government action, labor dispute, supply failure, natural disaster.',
+    'Clause.royalty_basis': 'How a ROYALTY is calculated: percentage of net sales / percentage of gross sales / per unit / fixed / tiered.',
+    'Clause.covers': 'Subjects the clause covers (ODRL target; may be several).',
+    'Clause.covers_party_scope': 'Which affiliated parties the clause extends to: affiliates (either side) / licensor_affiliates / licensee_affiliates.',
+    'Clause.dispute_method': 'How a DISPUTE-RESOLUTION clause resolves disputes: arbitration / litigation (courts) / mediation / expert determination / negotiation.',
+    'Clause.excepts': 'Carve-outs / exceptions the clause lists (may be several).',
+    'Clause.has_assignment_consent': 'How an anti-assignment clause treats consent (required / notice-only / free).',
+    'Clause.has_asymmetry': "Whether the clause's terms apply the same to both parties (symmetric) or differently per party (different_per_party).",
+    'Clause.has_claim_scope': "The scope of claims covered: first_party (the parties' own claims) / third_party (third-party claims) / broad_based (both / any).",
+    'Clause.has_coc_consent': 'How a change-of-control clause treats consent (required / notice-only / unrestricted).',
+    'Clause.has_escrow_release_trigger': 'What triggers a source-code escrow release (bankruptcy / breach / discontinuance).',
+    'Clause.has_exclusivity_type': 'The exclusivity a licensing/distribution clause grants (exclusive / sole / non-exclusive).',
+    'Clause.has_favorability': 'Which side the clause favors: buyer_favorable (the buyer / customer) or seller_favorable (the seller / vendor).',
+    'Clause.has_ip_ownership': 'How intellectual-property ownership is treated: assigned (transferred) / joint (shared) / retained (kept by the originating party).',
+    'Clause.has_mfn_scope': 'What a most-favored-nation clause covers (price / terms / both).',
+    'Clause.has_mutuality': "Whether the clause's obligation runs both ways (mutual) or one way (unilateral).",
+    'Clause.has_renewal': 'How the term renews: auto (automatic renewal) or requires_notice (renews only on notice / an affirmative election).',
+    'Clause.has_restriction_scope': 'What a non-compete restricts: geographic area, activity, or both.',
+    'Clause.has_right_of_first_type': 'The first-refusal/offer/negotiation right the clause grants (ROFR / ROFO / ROFN).',
+    'Clause.has_termination_right': 'Who may terminate for convenience (either party / one party).',
+    'Clause.has_warranty_scope': "Which warranties the clause disclaims or limits: 'implied' if it disclaims IMPLIED warranties (look for 'implied', 'merchantability', 'fitness for a particular purpose', 'in lieu of all other warranties/conditions') / 'express' if it excludes or limits EXPRESS warranties (look for 'no express warranty', 'except for the express warranties', 'express provisions ... in place of') / 'as_is' if goods or services are provided 'as is' or 'with all faults' / 'non_reliance' for a non-reliance disclaimer. A disclaimer that mentions merchantability or fitness for purpose is 'implied' (not 'as_is').",
+    'Clause.ld_trigger': "What triggers liquidated damages, e.g. 'late delivery', 'early termination'.",
+    'Clause.prohibits_damage': 'Damage types the clause waives/excludes (may be several).',
+    'Clause.prohibits_solicit': 'Whom the clause forbids soliciting (employees / customers).',
+    'Clause.requires_duty': 'A procedural duty the clause imposes (duty to defend / control of defense).',
+    'Clause.bounded_by': 'A temporal bound (term or notice period), if any.',
+    'Clause.caps': "The liability cap, if the clause limits the AMOUNT of liability (e.g. 'liability shall not exceed', 'limited to the fees paid', 'in no event shall ... exceed', 'total/aggregate liability ... capped at'). Fill its basis and quantum. Leave absent if the clause states no monetary limit (a pure exclusion or waiver of a damage TYPE is not a cap).",
+    'Clause.governed_by': 'The governing-law jurisdiction, if the clause states one.',
+    'CapConstraint.cap_basis': 'The basis of the liability cap: fixed_fee (a fixed amount) / multiple_of_fees (a multiple of fees paid) / other.',
+    'CapConstraint.cap_operator': "The comparison operator ONLY (a few words), e.g. 'lteq' (at most), 'eq' (fixed).",
+    'CapConstraint.cap_quantum': "The stated limit on liability. Look for 'shall not exceed', 'limited to', 'capped at', 'in no event ... exceed', 'total/aggregate liability ... shall not exceed'. Copy the limit VERBATIM even if it is a phrase, e.g. '$1,000,000', '12 months of fees', 'the fees paid in the prior 12 months', 'the greater of X or Y'.",
+    'TemporalConstraint.temporal_duration': "The duration ONLY (a short value), e.g. '12_months', '30_days', 'unbounded'.",
+    'TemporalConstraint.temporal_kind': "What is bounded: 'term' (temporal_bound) or 'notice_period'.",
+    'TemporalConstraint.temporal_operator': "The temporal comparison operator ONLY (a few words), e.g. 'lteq' (within / at most), 'gteq' (at least), 'eq' (exactly).",
+    'Jurisdiction.jurisdiction_name': "The jurisdiction NAME ONLY (a few words, not a sentence), e.g. 'New York', 'England and Wales', 'Delaware'.",
+    'Jurisdiction.law_multiplicity': 'Whether one law governs (single) or multiple laws govern (multiple).',
+}
+
+EXAMPLES: dict[str, tuple[str, ...]] = {
+    'Clause.document_reference': ('Section 8', '8.1 Limitation of Liability', 'Governing Law'),
+    'Jurisdiction.jurisdiction_name': ('New York', 'England and Wales', 'Delaware'),
+}

rag_wright/ontology/_generated_vocab.py

@@ -0,0 +1,52 @@
+"""GENERATED FROM contract_bridge.ttl by scripts/generate_contract_python.py -- DO NOT EDIT BY HAND.
+
+ADR-0066: the ontology `.ttl` is the single source of truth. To change the closed vocabulary, edit the ttl and
+re-run the generator; a hand-edit here (or a stale regeneration) is caught by
+tests/ontology/test_generated_vocab_in_sync.py."""
+
+from __future__ import annotations
+
+
+VOCAB: dict[str, frozenset[str]] = {
+    'assignment_consent': frozenset({'consent_required', 'free', 'notice_only'}),
+    'cap_basis': frozenset({'fixed_fee', 'multiple_of_fees', 'other'}),
+    'carve_out': frozenset({'applicable_law', 'bodily_injury', 'confidentiality', 'fraud', 'gross_negligence', 'indemnification', 'third_party_ip_infringement', 'willful_misconduct'}),
+    'claim_scope': frozenset({'broad_based', 'first_party', 'third_party'}),
+    'coc_consent': frozenset({'consent_required', 'notice_only', 'unrestricted'}),
+    'collateral_type': frozenset({'accounts_receivable', 'all_assets', 'deposit_accounts', 'equipment', 'fixtures', 'general_intangibles', 'inventory', 'ip', 'real_property'}),
+    'condition_type': frozenset({'board_approval', 'closing_condition', 'court_approval', 'due_diligence', 'financing', 'no_material_adverse_change', 'regulatory_approval', 'third_party_consent'}),
+    'confidentiality_exception': frozenset({'independently_developed', 'prior_possession', 'publicly_available', 'required_by_law', 'third_party_source'}),
+    'covered_parties': frozenset({'affiliates', 'licensee_affiliates', 'licensor_affiliates'}),
+    'covered_subject': frozenset({'copyright', 'fraud', 'gross_negligence', 'ip_infringement', 'trademark', 'violation_of_law'}),
+    'damage_type': frozenset({'consequential', 'incidental', 'indirect', 'punitive', 'special'}),
+    'dispute_method': frozenset({'arbitration', 'expert_determination', 'litigation', 'mediation', 'negotiation'}),
+    'escrow_release_trigger': frozenset({'bankruptcy', 'breach', 'discontinuance'}),
+    'exclusivity_type': frozenset({'exclusive', 'non_exclusive', 'sole'}),
+    'favorability': frozenset({'buyer_favorable', 'seller_favorable'}),
+    'force_majeure_event': frozenset({'act_of_god', 'government_action', 'labor_dispute', 'natural_disaster', 'pandemic', 'supply_failure', 'war'}),
+    'ip_ownership': frozenset({'assigned', 'joint', 'retained'}),
+    'law_multiplicity': frozenset({'multiple', 'single'}),
+    'mfn_scope': frozenset({'price', 'price_and_terms', 'terms'}),
+    'mutuality': frozenset({'mutual', 'unilateral'}),
+    'nonsolicit_target': frozenset({'customers', 'employees'}),
+    'party_asymmetry': frozenset({'different_per_party', 'symmetric'}),
+    'procedural': frozenset({'control_of_defense', 'duty_to_defend'}),
+    'renewal_mechanism': frozenset({'auto', 'requires_notice'}),
+    'restriction_scope': frozenset({'activity', 'geographic', 'geographic_and_activity'}),
+    'right_of_first_type': frozenset({'rofn', 'rofo', 'rofr'}),
+    'royalty_basis': frozenset({'fixed', 'pct_gross_sales', 'pct_net_sales', 'per_unit', 'tiered'}),
+    'termination_right': frozenset({'either_party', 'one_party'}),
+    'warranty_scope': frozenset({'as_is', 'express', 'implied', 'non_reliance'}),
+}
+
+VALUE_SYNONYMS: dict[str, dict[str, str]] = {
+    'damage_type': {'businessinterruption': 'consequential', 'costofcover': 'consequential', 'lossofdata': 'consequential', 'lossofprofit': 'consequential', 'lossofprofits': 'consequential', 'lossofrevenue': 'consequential', 'lossofsavings': 'consequential', 'lossofuse': 'consequential', 'lostbusinessrevenue': 'consequential', 'lostprofits': 'consequential', 'lostrevenue': 'consequential', 'lostsavings': 'consequential'},
+}
+
+AFFILIATE_OF = 'Affiliate Of'
+CONTRACTS_WITH = 'Contracts With'
+ORGANIZATION = 'Organization'
+PERSON = 'Person'
+
+ENTITY_TYPES: frozenset[str] = frozenset({'Organization', 'Person'})
+RELATIONSHIP_TYPES: frozenset[str] = frozenset({'Affiliate Of', 'Contracts With'})