Work with credit reports

import os

import requests

API_BASE = "https://api.lendpathway.com/api"
TOKEN = os.environ["PATHWAY_API_TOKEN"]
BOOK_ID = "99cc93e6-1f3f-42b1-9fe4-ba5a95be9c78"

response = requests.get(
    f"{API_BASE}/books/{BOOK_ID}",
    headers={"Authorization": f"Bearer {TOKEN}"},
    timeout=30,
)
response.raise_for_status()

book = response.json()
credit = book["book_meta"].get("parser_v2_credit_report")

if credit is None:
    raise RuntimeError("This Book has no parsed credit report")

from typing import Literal

from pydantic import BaseModel, Field

BureauName = Literal[
    "equifax",
    "experian",
    "transunion",
    "innovis",
    "lexisnexis",
    "other",
]
AccountType = Literal["revolving", "installment", "mortgage", "charge", "other"]
CollateralType = Literal[
    "unsecured",
    "real_estate",
    "vehicle",
    "cash_deposit",
    "education",
    "misc_asset",
]
AccountStatus = Literal[
    "current",
    "delinquent",
    "charged_off",
    "collection",
    "bankruptcy",
    "foreclosure",
    "repossession",
    "settled",
    "closed",
    "unknown",
]


class CRAddress(BaseModel):
    address_line_1: str | None = None
    city: str | None = None
    state: str | None = None
    zip_code: str | None = None
    country: str | None = None
    is_primary: bool | None = None


class CREntity(BaseModel):
    full_name: str | None = None
    address: list[CRAddress] | None = None
    date_of_birth: str | None = None
    has_fraud_alert: bool | None = None
    has_security_freeze: bool | None = None


class CreditInquiry(BaseModel):
    creditor_name: str | None = None
    inquiry_date: str | None = None


class CreditBureau(BaseModel):
    name: BureauName
    display_name: str | None = None
    inquiries: list[CreditInquiry] | None = None


class CreditAccount(BaseModel):
    account_name: str | None = None
    account_number: str | None = None
    is_open: bool | None = None
    is_authorized_user: bool | None = None
    is_self_reported: bool | None = None
    account_type_normalized: AccountType | None = None
    account_status_normalized: AccountStatus | None = None
    collateral_type: CollateralType | None = None
    date_opened: str | None = None
    date_closed: str | None = None
    recent_balance: float | None = None
    recent_balance_date: str | None = None
    credit_limit: float | None = None
    date_of_most_recent_report: str | None = None
    date_of_first_report: str | None = None
    date_last_active: str | None = None
    worst_delinquency_days: int | None = None
    payment_status: str | None = None
    monthly_payment: float | None = None
    high_credit_balance: float | None = None


class FicoScore(BaseModel):
    score: int | None = None
    date_of_score: str | None = None


class BureauReport(BaseModel):
    credit_bureau: CreditBureau
    underwritten_accounts: list[CreditAccount] = Field(default_factory=list)
    fico_score: FicoScore | None = None


class CRMeta(BaseModel):
    primary_entity: CREntity | None = None
    credit_report_body: list[BureauReport] | None = None

entity = credit.get("primary_entity") or {}

print("Subject", entity.get("full_name"))
print("Date of birth", entity.get("date_of_birth"))
print("Fraud alert", entity.get("has_fraud_alert"))
print("Security freeze", entity.get("has_security_freeze"))

primary_address = next(
    (
        address
        for address in entity.get("address") or []
        if address.get("is_primary")
    ),
    None,
)

for report in credit.get("credit_report_body") or []:
    bureau = report["credit_bureau"]
    fico = report.get("fico_score") or {}

    print(
        bureau.get("display_name") or bureau["name"],
        fico.get("score"),
        fico.get("date_of_score"),
    )

reports = credit.get("credit_report_body") or []
selected_name = book["book_meta"].get("selected_credit_bureau")


def choose_bureau(reports: list[dict], preferred: str | None) -> dict | None:
    if preferred:
        match = next(
            (
                report
                for report in reports
                if report["credit_bureau"]["name"] == preferred
            ),
            None,
        )
        if match:
            return match

    priority = ["experian", "equifax", "transunion"]
    for bureau_name in priority:
        match = next(
            (
                report
                for report in reports
                if report["credit_bureau"]["name"] == bureau_name
            ),
            None,
        )
        if match:
            return match

    return reports[0] if reports else None


selected = choose_bureau(reports, selected_name)
accounts = selected["underwritten_accounts"] if selected else []

for account in accounts:
    print({
        "name": account.get("account_name"),
        "type": account.get("account_type_normalized"),
        "status": account.get("account_status_normalized"),
        "open": account.get("is_open"),
        "balance": account.get("recent_balance"),
        "limit": account.get("credit_limit"),
        "monthly_payment": account.get("monthly_payment"),
        "worst_delinquency_days": account.get("worst_delinquency_days"),
    })

derogatory_statuses = {
    "delinquent",
    "charged_off",
    "collection",
    "bankruptcy",
    "foreclosure",
    "repossession",
    "settled",
}

accounts_with_risk = [
    account
    for account in accounts
    if account.get("account_status_normalized") in derogatory_statuses
    or (account.get("worst_delinquency_days") or 0) > 0
]

borrower_accounts = [
    account
    for account in accounts
    if not account.get("is_authorized_user")
    and not account.get("is_self_reported")
]

monthly_obligations = sum(
    account.get("monthly_payment") or 0
    for account in borrower_accounts
    if account.get("is_open")
)

print("Monthly obligations", round(monthly_obligations, 2))

revolving = [
    account
    for account in borrower_accounts
    if account.get("is_open")
    and account.get("account_type_normalized") in {"revolving", "charge"}
]

balance = sum(account.get("recent_balance") or 0 for account in revolving)
limit = sum(account.get("credit_limit") or 0 for account in revolving)
utilization = (balance / limit * 100) if limit else None

if selected:
    inquiries = selected["credit_bureau"].get("inquiries") or []

    for inquiry in inquiries:
        print(inquiry.get("inquiry_date"), inquiry.get("creditor_name"))

def summarize_credit(book: dict) -> dict | None:
    credit = book["book_meta"].get("parser_v2_credit_report")
    if not credit:
        return None

    reports = credit.get("credit_report_body") or []
    selected = choose_bureau(
        reports,
        book["book_meta"].get("selected_credit_bureau"),
    )
    if not selected:
        return None

    accounts = [
        account
        for account in selected["underwritten_accounts"]
        if not account.get("is_authorized_user")
        and not account.get("is_self_reported")
    ]

    derogatory = {
        "delinquent",
        "charged_off",
        "collection",
        "bankruptcy",
        "foreclosure",
        "repossession",
        "settled",
    }
    fico = selected.get("fico_score") or {}

    return {
        "subject": (credit.get("primary_entity") or {}).get("full_name"),
        "bureau": selected["credit_bureau"]["name"],
        "fico": fico.get("score"),
        "open_accounts": sum(bool(account.get("is_open")) for account in accounts),
        "monthly_obligations": sum(
            account.get("monthly_payment") or 0
            for account in accounts
            if account.get("is_open")
        ),
        "derogatory_accounts": sum(
            account.get("account_status_normalized") in derogatory
            or (account.get("worst_delinquency_days") or 0) > 0
            for account in accounts
        ),
        "fraud_alert": (credit.get("primary_entity") or {}).get("has_fraud_alert"),
        "security_freeze": (credit.get("primary_entity") or {}).get("has_security_freeze"),
    }