algo-cli-runtime 0.14.0__py3-none-any.whl

algo_cli/intelligence/finance/reconciliations.py

@@ -0,0 +1,254 @@
+"""B89/B99. Reconciliation triage and bank matching."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from datetime import date, datetime
+from decimal import Decimal
+from itertools import combinations
+from typing import Any, Iterable
+
+from .common import RiskLevel, SourceRef, decimalize, stable_exception_id, within_tolerance
+
+
+@dataclass(frozen=True)
+class ReconciliationAccount:
+    account: str
+    balance: Decimal | int | str
+    last_reconciled: date | None = None
+    unreconciled_items: int = 0
+    risk_level: RiskLevel = RiskLevel.MEDIUM
+    owner: str | None = None
+    source_refs: list[SourceRef] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "balance", decimalize(self.balance))
+
+
+@dataclass(frozen=True)
+class RiskScore:
+    account: str
+    score: Decimal
+    level: RiskLevel
+    reasons: list[str]
+    source_refs: list[SourceRef] = field(default_factory=list)
+
+
+class ReconciliationTriage:
+    """Rank balance-sheet reconciliations by materiality, age, and risk."""
+
+    def __init__(self, materiality: Decimal | int | str = Decimal("1000"), as_of: date | None = None) -> None:
+        self.materiality = decimalize(materiality)
+        self.as_of = as_of or date.today()
+
+    def score(self, account: ReconciliationAccount) -> RiskScore:
+        amount_score = Decimal("0") if self.materiality == 0 else min(abs(account.balance) / self.materiality, Decimal("10")) * 100
+        age_score = Decimal("0")
+        reasons: list[str] = []
+        if account.last_reconciled is None:
+            age_score = Decimal("500")
+            reasons.append("never reconciled")
+        else:
+            days = (self.as_of - account.last_reconciled).days
+            if days > 60:
+                age_score = Decimal("300")
+                reasons.append("stale >60 days")
+            elif days > 30:
+                age_score = Decimal("150")
+                reasons.append("stale >30 days")
+        item_score = Decimal(account.unreconciled_items) * Decimal("25")
+        if account.unreconciled_items:
+            reasons.append(f"{account.unreconciled_items} unreconciled items")
+        risk_score = Decimal(int(account.risk_level)) * Decimal("250")
+        score = amount_score + age_score + item_score + risk_score
+        level = RiskLevel.CRITICAL if score >= 1200 else RiskLevel.HIGH if score >= 800 else RiskLevel.MEDIUM if score >= 400 else RiskLevel.LOW
+        return RiskScore(account=account.account, score=score, level=level, reasons=reasons, source_refs=list(account.source_refs))
+
+    def prioritize(self, accounts: Iterable[ReconciliationAccount]) -> list[ReconciliationAccount]:
+        return sorted(accounts, key=lambda account: (self.score(account).score, abs(account.balance), account.account), reverse=True)
+
+
+@dataclass(frozen=True)
+class BankItem:
+    id: str
+    amount: Decimal | int | str
+    date: date | str
+    description: str = ""
+    reference: str | None = None
+    source_refs: list[SourceRef] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "amount", decimalize(self.amount))
+        if isinstance(self.date, str):
+            object.__setattr__(self, "date", datetime.fromisoformat(self.date[:10]).date())
+
+
+@dataclass(frozen=True)
+class BankMatch:
+    id: str
+    book_ids: list[str]
+    bank_ids: list[str]
+    amount_difference: Decimal
+    date_difference_days: int
+    score: Decimal
+    match_type: str
+    source_refs: list[SourceRef] = field(default_factory=list)
+
+
+@dataclass
+class MatchResult:
+    matches: list[BankMatch]
+    unmatched_book: list[BankItem]
+    unmatched_bank: list[BankItem]
+    tolerance_used: Decimal
+    date_window_days: int
+
+
+class BankMatcher:
+    """Deterministic bank reconciliation matcher.
+
+    Uses exact/reference matches first, greedy one-to-one fuzzy matching second,
+    and bounded subset matching for small many-to-one receipt/disbursement groups.
+    """
+
+    def match(
+        self,
+        book_items: Iterable[BankItem | dict[str, Any]],
+        bank_items: Iterable[BankItem | dict[str, Any]],
+        tolerance: Decimal | int | str = Decimal("0"),
+        date_window_days: int = 3,
+        subset_size: int = 3,
+    ) -> MatchResult:
+        tolerance = decimalize(tolerance)
+        book = [_coerce_item(item) for item in book_items]
+        bank = [_coerce_item(item) for item in bank_items]
+        matched_book: set[str] = set()
+        matched_bank: set[str] = set()
+        matches: list[BankMatch] = []
+
+        # Pass 1: exact amount/date/reference.
+        for b in book:
+            for k in bank:
+                if b.id in matched_book or k.id in matched_bank:
+                    continue
+                if _reference_equal(b.reference, k.reference) and b.date == k.date and within_tolerance(b.amount, k.amount, tolerance):
+                    matches.append(_make_match([b], [k], "exact-reference"))
+                    matched_book.add(b.id)
+                    matched_bank.add(k.id)
+
+        # Pass 2: one-to-one fuzzy amount/date/description.
+        candidates: list[tuple[Decimal, BankItem, BankItem]] = []
+        for b in book:
+            if b.id in matched_book:
+                continue
+            for k in bank:
+                if k.id in matched_bank:
+                    continue
+                days = abs((b.date - k.date).days)
+                if days <= date_window_days and within_tolerance(b.amount, k.amount, tolerance):
+                    amount_diff = abs(b.amount - k.amount)
+                    score = amount_diff + Decimal(days) / Decimal("100") - (_description_overlap(b.description, k.description) / Decimal("1000"))
+                    candidates.append((score, b, k))
+        for _score, b, k in sorted(candidates, key=lambda row: (row[0], row[1].id, row[2].id)):
+            if b.id in matched_book or k.id in matched_bank:
+                continue
+            matches.append(_make_match([b], [k], "fuzzy-one-to-one"))
+            matched_book.add(b.id)
+            matched_bank.add(k.id)
+
+        # Pass 3: bounded many-to-one/one-to-many subset matching.
+        remaining_book = [b for b in book if b.id not in matched_book]
+        remaining_bank = [k for k in bank if k.id not in matched_bank]
+        subset_matches = self._subset_matches(remaining_book, remaining_bank, tolerance, date_window_days, subset_size)
+        for match in subset_matches:
+            if any(book_id in matched_book for book_id in match.book_ids) or any(bank_id in matched_bank for bank_id in match.bank_ids):
+                continue
+            matches.append(match)
+            matched_book.update(match.book_ids)
+            matched_bank.update(match.bank_ids)
+
+        return MatchResult(
+            matches=sorted(matches, key=lambda m: (m.match_type, m.id)),
+            unmatched_book=[b for b in book if b.id not in matched_book],
+            unmatched_bank=[k for k in bank if k.id not in matched_bank],
+            tolerance_used=tolerance,
+            date_window_days=date_window_days,
+        )
+
+    def _subset_matches(
+        self,
+        book: list[BankItem],
+        bank: list[BankItem],
+        tolerance: Decimal,
+        date_window_days: int,
+        subset_size: int,
+    ) -> list[BankMatch]:
+        out: list[BankMatch] = []
+        # many book to one bank
+        for size in range(2, min(subset_size, len(book)) + 1):
+            for group in combinations(book, size):
+                amount = sum((item.amount for item in group), Decimal("0"))
+                latest = max(item.date for item in group)
+                earliest = min(item.date for item in group)
+                for bank_item in bank:
+                    if within_tolerance(amount, bank_item.amount, tolerance) and min(
+                        abs((latest - bank_item.date).days), abs((earliest - bank_item.date).days)
+                    ) <= date_window_days:
+                        out.append(_make_match(list(group), [bank_item], "many-book-to-one-bank"))
+        # one book to many bank
+        for size in range(2, min(subset_size, len(bank)) + 1):
+            for group in combinations(bank, size):
+                amount = sum((item.amount for item in group), Decimal("0"))
+                latest = max(item.date for item in group)
+                earliest = min(item.date for item in group)
+                for book_item in book:
+                    if within_tolerance(book_item.amount, amount, tolerance) and min(
+                        abs((latest - book_item.date).days), abs((earliest - book_item.date).days)
+                    ) <= date_window_days:
+                        out.append(_make_match([book_item], list(group), "one-book-to-many-bank"))
+        return sorted(out, key=lambda m: (abs(m.amount_difference), m.date_difference_days, m.id))
+
+
+def _coerce_item(item: BankItem | dict[str, Any]) -> BankItem:
+    if isinstance(item, BankItem):
+        return item
+    return BankItem(
+        id=str(item["id"]),
+        amount=item.get("amount", 0),
+        date=item.get("date"),
+        description=str(item.get("description", "")),
+        reference=item.get("reference"),
+        source_refs=list(item.get("source_refs", [])),
+    )
+
+
+def _reference_equal(left: str | None, right: str | None) -> bool:
+    if not left or not right:
+        return False
+    return "".join(str(left).lower().split()) == "".join(str(right).lower().split())
+
+
+def _description_overlap(left: str, right: str) -> Decimal:
+    a = {token for token in left.lower().split() if len(token) > 2}
+    b = {token for token in right.lower().split() if len(token) > 2}
+    if not a or not b:
+        return Decimal("0")
+    return Decimal(len(a & b)) / Decimal(len(a | b))
+
+
+def _make_match(book: list[BankItem], bank: list[BankItem], match_type: str) -> BankMatch:
+    book_amount = sum((item.amount for item in book), Decimal("0"))
+    bank_amount = sum((item.amount for item in bank), Decimal("0"))
+    book_date = max(item.date for item in book)
+    bank_date = max(item.date for item in bank)
+    refs = [ref for item in [*book, *bank] for ref in item.source_refs]
+    return BankMatch(
+        id=stable_exception_id("B99", [sorted(item.id for item in book), sorted(item.id for item in bank), match_type]),
+        book_ids=[item.id for item in book],
+        bank_ids=[item.id for item in bank],
+        amount_difference=book_amount - bank_amount,
+        date_difference_days=abs((book_date - bank_date).days),
+        score=abs(book_amount - bank_amount) + Decimal(abs((book_date - bank_date).days)) / Decimal("100"),
+        match_type=match_type,
+        source_refs=refs,
+    )

algo_cli/intelligence/finance/revenue.py

@@ -0,0 +1,109 @@
+"""B95. ASC 606 Revenue Recognition Decision DAG."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from decimal import Decimal
+from typing import Any
+
+from .common import ReviewGate, SourceRef, decimalize, stable_exception_id
+
+
+@dataclass(frozen=True)
+class PerformanceObligation:
+    id: str
+    description: str
+    transaction_price: Decimal | int | str
+    satisfied: bool = False
+    measure: str | None = None
+    source_refs: list[SourceRef] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "transaction_price", decimalize(self.transaction_price))
+
+
+@dataclass(frozen=True)
+class RevenueContract:
+    id: str
+    customer: str
+    approved: bool
+    rights_identified: bool
+    payment_terms_identified: bool
+    commercial_substance: bool
+    collectability_probable: bool
+    obligations: list[PerformanceObligation]
+    source_refs: list[SourceRef] = field(default_factory=list)
+
+
+@dataclass(frozen=True)
+class RevenueDecision:
+    contract_id: str
+    recognized_amount: Decimal
+    review_required: bool
+    reasons: list[str]
+    review_gate: ReviewGate
+    source_refs: list[SourceRef]
+
+
+class ASC606DecisionDAG:
+    """Five-step ASC 606 decision support, not accounting sign-off."""
+
+    def evaluate(self, contract: RevenueContract | dict[str, Any]) -> RevenueDecision:
+        c = _coerce_contract(contract)
+        reasons: list[str] = []
+        criteria = {
+            "contract not approved": c.approved,
+            "rights not identified": c.rights_identified,
+            "payment terms not identified": c.payment_terms_identified,
+            "commercial substance missing": c.commercial_substance,
+            "collectability not probable": c.collectability_probable,
+        }
+        for reason, ok in criteria.items():
+            if not ok:
+                reasons.append(reason)
+        if not c.obligations:
+            reasons.append("missing performance obligations")
+        source_refs = list(c.source_refs)
+        for obligation in c.obligations:
+            source_refs.extend(obligation.source_refs)
+            if not obligation.source_refs:
+                reasons.append(f"performance obligation {obligation.id} lacks source evidence")
+        recognized = sum((ob.transaction_price for ob in c.obligations if ob.satisfied and ob.source_refs), Decimal("0"))
+        review_required = bool(reasons)
+        return RevenueDecision(
+            contract_id=c.id,
+            recognized_amount=recognized if not reasons else Decimal("0") if any("contract" in r or "collectability" in r for r in reasons) else recognized,
+            review_required=review_required,
+            reasons=reasons,
+            review_gate=ReviewGate.CPA_REVIEW if review_required else ReviewGate.CONTROLLER_REVIEW,
+            source_refs=source_refs,
+        )
+
+
+def _coerce_contract(contract: RevenueContract | dict[str, Any]) -> RevenueContract:
+    if isinstance(contract, RevenueContract):
+        return contract
+    obligations = []
+    for row in contract.get("obligations", []):
+        if isinstance(row, PerformanceObligation):
+            obligations.append(row)
+        else:
+            obligations.append(PerformanceObligation(
+                id=str(row.get("id") or stable_exception_id("B95", [row.get("description"), row.get("transaction_price")])) ,
+                description=str(row.get("description", "")),
+                transaction_price=row.get("transaction_price", 0),
+                satisfied=bool(row.get("satisfied", False)),
+                measure=row.get("measure"),
+                source_refs=list(row.get("source_refs", [])),
+            ))
+    return RevenueContract(
+        id=str(contract.get("id", "")),
+        customer=str(contract.get("customer", "")),
+        approved=bool(contract.get("approved", False)),
+        rights_identified=bool(contract.get("rights_identified", False)),
+        payment_terms_identified=bool(contract.get("payment_terms_identified", False)),
+        commercial_substance=bool(contract.get("commercial_substance", False)),
+        collectability_probable=bool(contract.get("collectability_probable", False)),
+        obligations=obligations,
+        source_refs=list(contract.get("source_refs", [])),
+    )

algo_cli/intelligence/finance/tax.py

@@ -0,0 +1,74 @@
+"""B102. Sales/Use Tax and Invoice Taxability Classifier."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from decimal import Decimal
+from typing import Any, Iterable
+
+from .common import ReviewGate, SourceRef, decimalize, stable_exception_id
+
+
+@dataclass(frozen=True)
+class TaxPolicy:
+    id: str
+    taxable_categories: set[str]
+    rate: Decimal | int | str
+    exempt_categories: set[str] = field(default_factory=set)
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "rate", decimalize(self.rate))
+        object.__setattr__(self, "taxable_categories", {cat.lower() for cat in self.taxable_categories})
+        object.__setattr__(self, "exempt_categories", {cat.lower() for cat in self.exempt_categories})
+
+
+@dataclass(frozen=True)
+class TaxLineResult:
+    line_id: str
+    category: str
+    amount: Decimal
+    taxable: bool
+    tax: Decimal
+    reason: str
+    source_refs: list[SourceRef]
+
+
+@dataclass(frozen=True)
+class TaxClassification:
+    policy_id: str
+    taxable_amount: Decimal
+    tax_amount: Decimal
+    line_results: list[TaxLineResult]
+    review_gate: ReviewGate = ReviewGate.CONTROLLER_REVIEW
+
+
+class SalesUseTaxClassifier:
+    def classify_invoice(self, lines: Iterable[dict[str, Any]], jurisdiction_policy: TaxPolicy | dict[str, Any]) -> TaxClassification:
+        policy = _coerce_policy(jurisdiction_policy)
+        results: list[TaxLineResult] = []
+        for idx, line in enumerate(lines, start=1):
+            category = str(line.get("category", "")).lower()
+            amount = decimalize(line.get("amount", 0))
+            line_id = str(line.get("id") or stable_exception_id("B102", [idx, category, amount]))
+            if category in policy.exempt_categories:
+                taxable = False
+                reason = "category explicitly exempt"
+            else:
+                taxable = category in policy.taxable_categories
+                reason = "category taxable" if taxable else "category not taxable under policy"
+            tax = amount * policy.rate if taxable else Decimal("0")
+            results.append(TaxLineResult(line_id, category, amount, taxable, tax, reason, list(line.get("source_refs", []))))
+        taxable_amount = sum((row.amount for row in results if row.taxable), Decimal("0"))
+        tax_amount = sum((row.tax for row in results), Decimal("0"))
+        return TaxClassification(policy.id, taxable_amount, tax_amount, results)
+
+
+def _coerce_policy(policy: TaxPolicy | dict[str, Any]) -> TaxPolicy:
+    if isinstance(policy, TaxPolicy):
+        return policy
+    return TaxPolicy(
+        id=str(policy.get("id", "policy")),
+        taxable_categories=set(policy.get("taxable_categories", [])),
+        exempt_categories=set(policy.get("exempt_categories", [])),
+        rate=policy.get("rate", 0),
+    )

algo_cli/intelligence/finance/workpapers.py

@@ -0,0 +1,111 @@
+"""B104. CPA Workpaper Tie-Out and Crossfoot Rules."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from decimal import Decimal
+from typing import Any, Iterable
+
+from .common import ReviewGate, SourceRef, decimalize, within_tolerance
+
+
+@dataclass
+class TieOutResult:
+    clean: bool
+    check_type: str
+    expected: Decimal
+    actual: Decimal
+    difference: Decimal
+    tolerance_used: Decimal
+    message: str
+    source_refs: list[SourceRef] = field(default_factory=list)
+    review_gate: ReviewGate = ReviewGate.CONTROLLER_REVIEW
+
+
+class WorkpaperTieOut:
+    """Foot, crossfoot, trace, and sign-convention checks for schedules."""
+
+    def foot(
+        self,
+        table: Iterable[dict[str, Any]],
+        columns: Iterable[str],
+        expected_totals: dict[str, Any] | None = None,
+        tolerance: Any = Decimal("0"),
+    ) -> dict[str, TieOutResult]:
+        rows = list(table)
+        results: dict[str, TieOutResult] = {}
+        for column in columns:
+            actual = sum((decimalize(row.get(column, 0)) for row in rows), Decimal("0"))
+            expected = decimalize((expected_totals or {}).get(column, actual))
+            difference = actual - expected
+            clean = within_tolerance(actual, expected, tolerance)
+            results[column] = TieOutResult(
+                clean=clean,
+                check_type="foot",
+                expected=expected,
+                actual=actual,
+                difference=difference,
+                tolerance_used=decimalize(tolerance),
+                message="Foots" if clean else f"Column {column} does not foot",
+            )
+        return results
+
+    def crossfoot(
+        self,
+        table: Iterable[dict[str, Any]],
+        row_total_col: str,
+        component_cols: Iterable[str],
+        tolerance: Any = Decimal("0"),
+    ) -> list[TieOutResult]:
+        results: list[TieOutResult] = []
+        comps = list(component_cols)
+        for index, row in enumerate(table, start=1):
+            expected = sum((decimalize(row.get(col, 0)) for col in comps), Decimal("0"))
+            actual = decimalize(row.get(row_total_col, 0))
+            clean = within_tolerance(actual, expected, tolerance)
+            results.append(TieOutResult(
+                clean=clean,
+                check_type="crossfoot",
+                expected=expected,
+                actual=actual,
+                difference=actual - expected,
+                tolerance_used=decimalize(tolerance),
+                message="Crossfoots" if clean else f"Row {index} does not crossfoot",
+            ))
+        return results
+
+    def trace_to_source(
+        self,
+        schedule_total: Any,
+        source_total: Any,
+        tolerance: Any = Decimal("0"),
+        source_refs: Iterable[SourceRef] = (),
+    ) -> TieOutResult:
+        actual = decimalize(schedule_total)
+        expected = decimalize(source_total)
+        clean = within_tolerance(actual, expected, tolerance)
+        return TieOutResult(
+            clean=clean,
+            check_type="trace",
+            expected=expected,
+            actual=actual,
+            difference=actual - expected,
+            tolerance_used=decimalize(tolerance),
+            message="Ties to source" if clean else "Schedule total does not tie to source",
+            source_refs=list(source_refs),
+        )
+
+    def sign_convention_check(self, amount: Any, expected_sign: str, mapped: bool = False) -> TieOutResult:
+        actual = decimalize(amount)
+        expected_positive = expected_sign.lower() in {"positive", "+", "debit"}
+        sign_ok = actual >= 0 if expected_positive else actual <= 0
+        clean = sign_ok or mapped
+        return TieOutResult(
+            clean=clean,
+            check_type="sign_convention",
+            expected=Decimal("1") if expected_positive else Decimal("-1"),
+            actual=Decimal("1") if actual >= 0 else Decimal("-1"),
+            difference=Decimal("0") if clean else actual,
+            tolerance_used=Decimal("0"),
+            message="Sign convention explicit" if clean else "Sign flip requires explicit mapping",
+        )

algo_cli/intelligence/finding_record.py

@@ -0,0 +1,120 @@
+"""H1 — Algorithm Finding Record.
+
+Structured append-only findings with provenance, mined from T3MP3ST Evidence Vault §8.
+"""
+from __future__ import annotations
+
+import time
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+
+class FindingStatus(str, Enum):
+    PROPOSED = "proposed"
+    VALIDATED = "validated"
+    RETRACTED = "retracted"
+
+
+@dataclass
+class Finding:
+    """A single algorithm finding with provenance."""
+
+    id: str
+    title: str
+    description: str
+    source_repo: str
+    source_section: str
+    status: FindingStatus = FindingStatus.PROPOSED
+    created_at: float = field(default_factory=time.time)
+    provenance: dict[str, Any] = field(default_factory=dict)
+    evidence: list[str] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        return {
+            "id": self.id,
+            "title": self.title,
+            "description": self.description,
+            "source_repo": self.source_repo,
+            "source_section": self.source_section,
+            "status": self.status.value,
+            "created_at": self.created_at,
+            "provenance": dict(self.provenance),
+            "evidence": list(self.evidence),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> Finding:
+        return cls(
+            id=data["id"],
+            title=data["title"],
+            description=data["description"],
+            source_repo=data["source_repo"],
+            source_section=data["source_section"],
+            status=FindingStatus(data.get("status", "proposed")),
+            created_at=data.get("created_at", time.time()),
+            provenance=dict(data.get("provenance", {})),
+            evidence=list(data.get("evidence", [])),
+        )
+
+
+class FindingRecord:
+    """Append-only store for algorithm findings."""
+
+    def __init__(self) -> None:
+        self._findings: list[Finding] = []
+
+    def create(
+        self,
+        id: str,
+        title: str,
+        description: str,
+        source_repo: str,
+        source_section: str,
+        provenance: dict[str, Any] | None = None,
+        evidence: list[str] | None = None,
+    ) -> Finding:
+        if self.get(id) is not None:
+            raise ValueError(f"Finding {id!r} already exists — append-only store")
+        finding = Finding(
+            id=id,
+            title=title,
+            description=description,
+            source_repo=source_repo,
+            source_section=source_section,
+            provenance=provenance or {},
+            evidence=evidence or [],
+        )
+        self._findings.append(finding)
+        return finding
+
+    def get(self, id: str) -> Finding | None:
+        for f in self._findings:
+            if f.id == id:
+                return f
+        return None
+
+    def query(
+        self,
+        status: FindingStatus | None = None,
+        source_repo: str | None = None,
+    ) -> list[Finding]:
+        results = self._findings
+        if status is not None:
+            results = [f for f in results if f.status == status]
+        if source_repo is not None:
+            results = [f for f in results if f.source_repo == source_repo]
+        return list(results)
+
+    def update_status(self, id: str, status: FindingStatus) -> Finding:
+        f = self.get(id)
+        if f is None:
+            raise KeyError(f"Finding {id!r} not found")
+        f.status = status
+        return f
+
+    def all(self) -> list[Finding]:
+        return list(self._findings)
+
+    def count(self) -> int:
+        return len(self._findings)