impact-ledger 0.1.0__py3-none-any.whl

impact_ledger-0.1.0.dist-info/METADATA

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: impact-ledger
+Version: 0.1.0
+Summary: Open source impact investment portfolio tracker for CDFIs, private debt, and community development finance
+License: MIT
+Project-URL: Homepage, https://github.com/Jaypatel1511/impact-ledger
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=1.4.0
+Requires-Dist: numpy>=1.21.0
+
+# impact-ledger 📊
+
+**Open source impact investment portfolio tracker for CDFIs, private debt, and community development finance.**
+
+Track loans, NMTC deals, grants, and equity investments alongside social impact metrics —
+jobs created, affordable units financed, borrower demographics, and geographic reach.
+Generate standardized CDFI Fund-style reports in Python.
+
+---
+
+## Why impact-ledger?
+
+Impact funds tracking private debt, community facilities, and social impact metrics
+currently have two options: custom Excel spreadsheets or $50k+/year proprietary CRM software.
+impact-ledger is the open source alternative — standardized, auditable, and free.
+
+---
+
+## Installation
+
+    pip install impact-ledger
+
+---
+
+## Quickstart
+
+    from impactledger import loan, nmtc, grant, add_impact, Portfolio
+    from impactledger import cdfi_fund_report, sector_impact_report
+
+    # Create a portfolio
+    p = Portfolio(name="CDFI Impact Fund I", vintage_year=2022)
+
+    # Add a loan with impact metrics
+    inv = loan(
+        name="Southside Health Center",
+        amount=2_000_000,
+        interest_rate=0.045,
+        date_closed="2023-01-15",
+        maturity_date="2033-01-15",
+        state="IL",
+        borrower_name="Southside Health Inc",
+        borrower_type="nonprofit",
+        sector="healthcare",
+        is_low_income_area=True,
+        is_minority_borrower=True,
+    )
+    add_impact(inv, jobs_created=25, jobs_retained=40, patients_served=5000)
+    p.add(inv)
+
+    # Add an NMTC deal
+    deal = nmtc(
+        name="Detroit Manufacturing NMTC",
+        amount=8_000_000,
+        date_closed="2022-06-01",
+        maturity_date="2029-06-01",
+        state="MI",
+        borrower_name="Detroit Advanced Mfg Co",
+        sector="small_business",
+        is_low_income_area=True,
+    )
+    add_impact(deal, jobs_created=45, jobs_retained=60)
+    p.add(deal)
+
+    # Portfolio summary
+    p.summary()
+
+    # Generate reports
+    cdfi_fund_report(p)
+    sector_impact_report(p)
+
+    # Export to DataFrame
+    df = p.to_dataframe()
+
+---
+
+## Investment Types Supported
+
+- loan          - Private debt / direct lending
+- equity        - Equity investment
+- grant         - Grant or forgivable loan
+- nmtc          - New Markets Tax Credit investment
+- guarantee     - Loan guarantee
+- bond          - Bond or debenture
+
+---
+
+## Impact Metrics Tracked
+
+- Jobs created and retained
+- Affordable housing units financed
+- Community square footage
+- Businesses supported
+- Patients served
+- Students served
+- Borrower demographics (minority, women, low-income)
+- Geographic reach (state, census tract, rural/urban)
+
+---
+
+## Reports
+
+- cdfi_fund_report()      - CDFI Fund Annual Certification Report format
+- sector_impact_report()  - Impact breakdown by sector
+- watchlist_report()      - Impaired and watch-list investments
+
+---
+
+## Running Tests
+
+    PYTHONPATH=. pytest tests/ -v
+
+27 tests across all modules.
+
+---
+
+## Who This Is For
+
+- CDFI loan officers tracking portfolio performance and impact
+- Impact fund managers reporting to LPs and board
+- Researchers studying community development finance outcomes
+- Anyone replacing a bespoke Excel impact tracker with Python
+
+---
+
+## License
+
+MIT 2026 Jaypatel1511

impact_ledger-0.1.0.dist-info/RECORD

@@ -0,0 +1,13 @@
+impactledger/__init__.py,sha256=jOgPholOg0ED9jviq-On4YW7kDJR65h3I6KsTJeCE9M,619
+impactledger/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+impactledger/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+impactledger/data/schema.py,sha256=Q6fRm8HiAND0EiWh-KkhhE-ggtLWs5JgYsozU6pjKdA,4992
+impactledger/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+impactledger/models/investment.py,sha256=xX__EPpqLjjC554E7wN9SakR2HRYgjEbtqL43qk0_kY,3169
+impactledger/models/portfolio.py,sha256=zH0JsI6xBA0bphF_zsD_XWzsR9pXdWljR89yyAuD6fg,8892
+impactledger/models/report.py,sha256=8zmp09x-SyHu30W8q7mTgZnDIn715Ih0EGIs0EcZzfY,3176
+impactledger/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+impact_ledger-0.1.0.dist-info/METADATA,sha256=yAOn4y_tKB6gONbBQmd5h9U0doGVnh_C98uIIs9ryZE,3595
+impact_ledger-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+impact_ledger-0.1.0.dist-info/top_level.txt,sha256=odTOoyFDU3onL3lRz11Gs5_wxql0MFJZ0uG7l7etYLk,13
+impact_ledger-0.1.0.dist-info/RECORD,,

impact_ledger-0.1.0.dist-info/WHEEL

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

impact_ledger-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+impactledger

impactledger/__init__.py

@@ -0,0 +1,17 @@
+from impactledger.data.schema import (
+    Investment, ImpactMetrics,
+    INVESTMENT_TYPES, SECTORS, BORROWER_TYPES, STATUSES,
+)
+from impactledger.models.investment import loan, nmtc, grant, add_impact
+from impactledger.models.portfolio import Portfolio
+from impactledger.models.report import (
+    cdfi_fund_report, sector_impact_report, watchlist_report
+)
+
+__version__ = "0.1.0"
+__all__ = [
+    "Investment", "ImpactMetrics", "Portfolio",
+    "loan", "nmtc", "grant", "add_impact",
+    "cdfi_fund_report", "sector_impact_report", "watchlist_report",
+    "INVESTMENT_TYPES", "SECTORS", "BORROWER_TYPES", "STATUSES",
+]

impactledger/data/schema.py

@@ -0,0 +1,156 @@
+from dataclasses import dataclass, field
+from typing import Optional
+from datetime import date
+
+
+# Supported investment types
+INVESTMENT_TYPES = {
+    "loan":             "Private debt / direct lending",
+    "equity":           "Equity investment",
+    "grant":            "Grant or forgivable loan",
+    "nmtc":             "New Markets Tax Credit investment",
+    "guarantee":        "Loan guarantee",
+    "bond":             "Bond or debenture",
+}
+
+# Supported sectors
+SECTORS = {
+    "affordable_housing":   "Affordable housing development",
+    "small_business":       "Small business lending",
+    "community_facility":   "Community facility (health, education, etc.)",
+    "healthcare":           "Healthcare facility",
+    "education":            "Educational facility",
+    "food_access":          "Food access / grocery",
+    "childcare":            "Childcare facility",
+    "mixed_use":            "Mixed-use development",
+    "commercial_re":        "Commercial real estate",
+    "microenterprise":      "Microenterprise lending",
+    "other":                "Other",
+}
+
+# Borrower types
+BORROWER_TYPES = {
+    "nonprofit":        "Nonprofit organization",
+    "for_profit":       "For-profit business",
+    "cdfi":             "Community Development Financial Institution",
+    "government":       "Government entity",
+    "individual":       "Individual borrower",
+    "cooperative":      "Cooperative",
+}
+
+# Investment status
+STATUSES = {
+    "active":       "Active / performing",
+    "watch":        "Watch list",
+    "default":      "In default",
+    "repaid":       "Fully repaid",
+    "written_off":  "Written off",
+}
+
+
+@dataclass
+class ImpactMetrics:
+    """
+    Social impact metrics associated with a single investment.
+    All metrics are optional — track what is relevant to your portfolio.
+    """
+    investment_id: str
+    jobs_created: int = 0
+    jobs_retained: int = 0
+    affordable_units: int = 0
+    sq_ft_community_space: float = 0.0
+    businesses_supported: int = 0
+    patients_served: int = 0
+    students_served: int = 0
+    meals_served: int = 0
+    childcare_slots: int = 0
+    notes: Optional[str] = None
+
+    @property
+    def total_jobs(self) -> int:
+        return self.jobs_created + self.jobs_retained
+
+
+@dataclass
+class Investment:
+    """
+    Core investment record for an impact portfolio.
+    Covers loans, equity, grants, NMTC deals, and guarantees.
+    """
+    id: str
+    name: str
+    investment_type: str
+    sector: str
+    amount: float
+    date_closed: str
+    maturity_date: str
+    interest_rate: float
+    state: str
+    borrower_name: str
+    borrower_type: str
+    status: str = "active"
+    census_tract: Optional[str] = None
+    county: Optional[str] = None
+    is_low_income_area: bool = False
+    is_distressed_area: bool = False
+    is_minority_borrower: bool = False
+    is_women_borrower: bool = False
+    is_rural: bool = False
+    outstanding_balance: Optional[float] = None
+    interest_received: float = 0.0
+    principal_received: float = 0.0
+    impact: Optional[ImpactMetrics] = None
+    notes: Optional[str] = None
+
+    def __post_init__(self):
+        if self.amount <= 0:
+            raise ValueError(f"Investment '{self.name}': amount must be positive")
+        if self.investment_type not in INVESTMENT_TYPES:
+            raise ValueError(
+                f"Investment '{self.name}': investment_type must be one of "
+                f"{list(INVESTMENT_TYPES.keys())}"
+            )
+        if self.sector not in SECTORS:
+            raise ValueError(
+                f"Investment '{self.name}': sector must be one of "
+                f"{list(SECTORS.keys())}"
+            )
+        if self.borrower_type not in BORROWER_TYPES:
+            raise ValueError(
+                f"Investment '{self.name}': borrower_type must be one of "
+                f"{list(BORROWER_TYPES.keys())}"
+            )
+        if self.status not in STATUSES:
+            raise ValueError(
+                f"Investment '{self.name}': status must be one of "
+                f"{list(STATUSES.keys())}"
+            )
+        if not (0 <= self.interest_rate < 1):
+            raise ValueError(
+                f"Investment '{self.name}': interest_rate must be between 0 and 1"
+            )
+        if self.outstanding_balance is None:
+            self.outstanding_balance = self.amount
+
+    @property
+    def amount_mm(self) -> float:
+        return self.amount / 1_000_000
+
+    @property
+    def annual_income(self) -> float:
+        return self.outstanding_balance * self.interest_rate
+
+    @property
+    def is_active(self) -> bool:
+        return self.status == "active"
+
+    @property
+    def is_impaired(self) -> bool:
+        return self.status in ("watch", "default")
+
+    def __repr__(self):
+        return (
+            f"Investment(id='{self.id}', name='{self.name}', "
+            f"type='{self.investment_type}', amount=${self.amount_mm:.2f}MM, "
+            f"state='{self.state}', status='{self.status}')"
+        )

impactledger/models/investment.py

@@ -0,0 +1,118 @@
+"""
+Investment model — factory functions and helpers for creating investments.
+"""
+from impactledger.data.schema import Investment, ImpactMetrics
+import uuid
+
+
+def make_id() -> str:
+    """Generate a short unique investment ID."""
+    return str(uuid.uuid4())[:8].upper()
+
+
+def loan(
+    name: str,
+    amount: float,
+    interest_rate: float,
+    date_closed: str,
+    maturity_date: str,
+    state: str,
+    borrower_name: str,
+    borrower_type: str = "nonprofit",
+    sector: str = "community_facility",
+    **kwargs,
+) -> Investment:
+    """Convenience factory for creating a loan investment."""
+    return Investment(
+        id=make_id(),
+        name=name,
+        investment_type="loan",
+        sector=sector,
+        amount=amount,
+        date_closed=date_closed,
+        maturity_date=maturity_date,
+        interest_rate=interest_rate,
+        state=state,
+        borrower_name=borrower_name,
+        borrower_type=borrower_type,
+        **kwargs,
+    )
+
+
+def nmtc(
+    name: str,
+    amount: float,
+    date_closed: str,
+    maturity_date: str,
+    state: str,
+    borrower_name: str,
+    **kwargs,
+) -> Investment:
+    """Convenience factory for creating an NMTC investment."""
+    return Investment(
+        id=make_id(),
+        name=name,
+        investment_type="nmtc",
+        sector=kwargs.pop("sector", "community_facility"),
+        amount=amount,
+        date_closed=date_closed,
+        maturity_date=maturity_date,
+        interest_rate=kwargs.pop("interest_rate", 0.01),
+        state=state,
+        borrower_name=borrower_name,
+        borrower_type=kwargs.pop("borrower_type", "nonprofit"),
+        is_low_income_area=kwargs.pop("is_low_income_area", True),
+        **kwargs,
+    )
+
+
+def grant(
+    name: str,
+    amount: float,
+    date_closed: str,
+    state: str,
+    borrower_name: str,
+    **kwargs,
+) -> Investment:
+    """Convenience factory for creating a grant."""
+    return Investment(
+        id=make_id(),
+        name=name,
+        investment_type="grant",
+        sector=kwargs.pop("sector", "community_facility"),
+        amount=amount,
+        date_closed=date_closed,
+        maturity_date=kwargs.pop("maturity_date", date_closed),
+        interest_rate=0.0,
+        state=state,
+        borrower_name=borrower_name,
+        borrower_type=kwargs.pop("borrower_type", "nonprofit"),
+        outstanding_balance=0.0,
+        **kwargs,
+    )
+
+
+def add_impact(
+    investment: Investment,
+    jobs_created: int = 0,
+    jobs_retained: int = 0,
+    affordable_units: int = 0,
+    sq_ft_community_space: float = 0.0,
+    businesses_supported: int = 0,
+    patients_served: int = 0,
+    students_served: int = 0,
+    **kwargs,
+) -> Investment:
+    """Attach impact metrics to an existing investment."""
+    investment.impact = ImpactMetrics(
+        investment_id=investment.id,
+        jobs_created=jobs_created,
+        jobs_retained=jobs_retained,
+        affordable_units=affordable_units,
+        sq_ft_community_space=sq_ft_community_space,
+        businesses_supported=businesses_supported,
+        patients_served=patients_served,
+        students_served=students_served,
+        **kwargs,
+    )
+    return investment

impactledger/models/portfolio.py

@@ -0,0 +1,244 @@
+"""
+Portfolio aggregator — tracks a collection of impact investments.
+"""
+from dataclasses import dataclass
+from typing import Optional
+import pandas as pd
+
+from impactledger.data.schema import Investment, INVESTMENT_TYPES, SECTORS
+
+
+class Portfolio:
+    """
+    Tracks a collection of impact investments with financial
+    and social impact aggregation.
+
+    Usage:
+        p = Portfolio(name="CDFI Impact Fund I")
+        p.add(investment1)
+        p.add(investment2)
+        p.summary()
+        df = p.to_dataframe()
+    """
+
+    def __init__(self, name: str, vintage_year: Optional[int] = None):
+        self.name = name
+        self.vintage_year = vintage_year
+        self._investments: list[Investment] = []
+
+    def add(self, investment: Investment) -> None:
+        """Add an investment to the portfolio."""
+        if not isinstance(investment, Investment):
+            raise TypeError("Only Investment objects can be added.")
+        if any(i.id == investment.id for i in self._investments):
+            raise ValueError(f"Investment '{investment.id}' already exists.")
+        self._investments.append(investment)
+
+    def remove(self, investment_id: str) -> None:
+        """Remove an investment by ID."""
+        self._investments = [
+            i for i in self._investments if i.id != investment_id
+        ]
+
+    def count(self) -> int:
+        return len(self._investments)
+
+    def get(self, investment_id: str) -> Optional[Investment]:
+        """Get a single investment by ID."""
+        for inv in self._investments:
+            if inv.id == investment_id:
+                return inv
+        return None
+
+    def filter_state(self, state: str) -> list:
+        return [i for i in self._investments if i.state == state.upper()]
+
+    def filter_type(self, investment_type: str) -> list:
+        return [i for i in self._investments if i.investment_type == investment_type]
+
+    def filter_sector(self, sector: str) -> list:
+        return [i for i in self._investments if i.sector == sector]
+
+    def filter_status(self, status: str) -> list:
+        return [i for i in self._investments if i.status == status]
+
+    @property
+    def total_committed(self) -> float:
+        return sum(i.amount for i in self._investments)
+
+    @property
+    def total_outstanding(self) -> float:
+        return sum(
+            i.outstanding_balance for i in self._investments
+            if i.outstanding_balance is not None
+        )
+
+    @property
+    def active_investments(self) -> list:
+        return [i for i in self._investments if i.is_active]
+
+    @property
+    def impaired_investments(self) -> list:
+        return [i for i in self._investments if i.is_impaired]
+
+    @property
+    def weighted_avg_rate(self) -> float:
+        total = self.total_outstanding
+        if total == 0:
+            return 0.0
+        return sum(
+            i.outstanding_balance * i.interest_rate
+            for i in self._investments
+            if i.outstanding_balance
+        ) / total
+
+    @property
+    def annual_income(self) -> float:
+        return sum(i.annual_income for i in self._investments)
+
+    # ── Impact aggregations ───────────────────────────────────────────────────
+
+    @property
+    def total_jobs_created(self) -> int:
+        return sum(
+            i.impact.jobs_created for i in self._investments
+            if i.impact
+        )
+
+    @property
+    def total_jobs_retained(self) -> int:
+        return sum(
+            i.impact.jobs_retained for i in self._investments
+            if i.impact
+        )
+
+    @property
+    def total_jobs(self) -> int:
+        return self.total_jobs_created + self.total_jobs_retained
+
+    @property
+    def total_affordable_units(self) -> int:
+        return sum(
+            i.impact.affordable_units for i in self._investments
+            if i.impact
+        )
+
+    @property
+    def total_sq_ft(self) -> float:
+        return sum(
+            i.impact.sq_ft_community_space for i in self._investments
+            if i.impact
+        )
+
+    @property
+    def pct_low_income_area(self) -> float:
+        if not self._investments:
+            return 0.0
+        return sum(
+            1 for i in self._investments if i.is_low_income_area
+        ) / len(self._investments)
+
+    @property
+    def pct_minority_borrower(self) -> float:
+        if not self._investments:
+            return 0.0
+        return sum(
+            1 for i in self._investments if i.is_minority_borrower
+        ) / len(self._investments)
+
+    @property
+    def pct_women_borrower(self) -> float:
+        if not self._investments:
+            return 0.0
+        return sum(
+            1 for i in self._investments if i.is_women_borrower
+        ) / len(self._investments)
+
+    @property
+    def cost_per_job(self) -> float:
+        if self.total_jobs == 0:
+            return 0.0
+        return self.total_committed / self.total_jobs
+
+    def summary(self) -> None:
+        """Print a full portfolio summary."""
+        print(f"\nImpact Portfolio Summary — {self.name}")
+        print("=" * 55)
+        print(f"\nFINANCIAL METRICS")
+        print(f"  Total Committed:       ${self.total_committed/1e6:.2f}MM")
+        print(f"  Total Outstanding:     ${self.total_outstanding/1e6:.2f}MM")
+        print(f"  Annual Income:         ${self.annual_income/1e6:.2f}MM")
+        print(f"  Weighted Avg Yield:    {self.weighted_avg_rate*100:.2f}%")
+        print(f"  Total Investments:     {self.count()}")
+        print(f"  Active:                {len(self.active_investments)}")
+        print(f"  Impaired:              {len(self.impaired_investments)}")
+        print(f"\nIMPACT METRICS")
+        print(f"  Jobs Created:          {self.total_jobs_created:,}")
+        print(f"  Jobs Retained:         {self.total_jobs_retained:,}")
+        print(f"  Total Jobs:            {self.total_jobs:,}")
+        print(f"  Affordable Units:      {self.total_affordable_units:,}")
+        print(f"  Community Sq Ft:       {self.total_sq_ft:,.0f}")
+        if self.cost_per_job > 0:
+            print(f"  Cost per Job:          ${self.cost_per_job:,.0f}")
+        print(f"\nDEMOGRAPHICS")
+        print(f"  % Low-Income Area:     {self.pct_low_income_area*100:.1f}%")
+        print(f"  % Minority Borrower:   {self.pct_minority_borrower*100:.1f}%")
+        print(f"  % Women Borrower:      {self.pct_women_borrower*100:.1f}%")
+        print(f"\nGEOGRAPHIC REACH")
+        states = set(i.state for i in self._investments)
+        print(f"  States:                {len(states)}")
+        print(f"  States:                {', '.join(sorted(states))}")
+        print()
+
+    def to_dataframe(self) -> pd.DataFrame:
+        """Return all investments as a pandas DataFrame."""
+        rows = []
+        for i in self._investments:
+            row = {
+                "id": i.id,
+                "name": i.name,
+                "type": i.investment_type,
+                "sector": i.sector,
+                "amount": i.amount,
+                "outstanding": i.outstanding_balance,
+                "rate": i.interest_rate,
+                "state": i.state,
+                "borrower": i.borrower_name,
+                "borrower_type": i.borrower_type,
+                "status": i.status,
+                "date_closed": i.date_closed,
+                "maturity_date": i.maturity_date,
+                "low_income_area": i.is_low_income_area,
+                "minority_borrower": i.is_minority_borrower,
+                "women_borrower": i.is_women_borrower,
+                "rural": i.is_rural,
+            }
+            if i.impact:
+                row.update({
+                    "jobs_created": i.impact.jobs_created,
+                    "jobs_retained": i.impact.jobs_retained,
+                    "affordable_units": i.impact.affordable_units,
+                    "sq_ft": i.impact.sq_ft_community_space,
+                    "businesses": i.impact.businesses_supported,
+                    "patients": i.impact.patients_served,
+                    "students": i.impact.students_served,
+                })
+            rows.append(row)
+        return pd.DataFrame(rows)
+
+    def sector_breakdown(self) -> pd.DataFrame:
+        """Return a sector-level summary DataFrame."""
+        df = self.to_dataframe()
+        return df.groupby("sector").agg(
+            count=("amount", "count"),
+            total_amount=("amount", "sum"),
+            avg_amount=("amount", "mean"),
+        ).reset_index().sort_values("total_amount", ascending=False)
+
+    def state_breakdown(self) -> pd.DataFrame:
+        """Return a state-level summary DataFrame."""
+        df = self.to_dataframe()
+        return df.groupby("state").agg(
+            count=("amount", "count"),
+            total_amount=("amount", "sum"),
+        ).reset_index().sort_values("total_amount", ascending=False)

impactledger/models/report.py

@@ -0,0 +1,93 @@
+"""
+Standardized impact report generator.
+Produces CDFI Fund, GIIRS, and custom report formats.
+"""
+import pandas as pd
+from impactledger.models.portfolio import Portfolio
+
+
+def cdfi_fund_report(portfolio: Portfolio) -> pd.DataFrame:
+    """
+    Generate a CDFI Fund-style impact report.
+    Matches the format used in CDFI Fund Annual Certification Reports.
+    """
+    df = portfolio.to_dataframe()
+
+    report = {
+        "Total Financing ($MM)":        round(portfolio.total_committed / 1e6, 2),
+        "Number of Transactions":       portfolio.count(),
+        "Avg Transaction Size ($)":     round(portfolio.total_committed / max(portfolio.count(), 1)),
+        "% in Low-Income Areas":        f"{portfolio.pct_low_income_area*100:.1f}%",
+        "% Minority Borrowers":         f"{portfolio.pct_minority_borrower*100:.1f}%",
+        "% Women Borrowers":            f"{portfolio.pct_women_borrower*100:.1f}%",
+        "Jobs Created":                 portfolio.total_jobs_created,
+        "Jobs Retained":                portfolio.total_jobs_retained,
+        "Affordable Units Financed":    portfolio.total_affordable_units,
+        "Community Sq Ft":              round(portfolio.total_sq_ft),
+        "States Served":                len(set(i.state for i in portfolio._investments)),
+        "Weighted Avg Interest Rate":   f"{portfolio.weighted_avg_rate*100:.2f}%",
+    }
+
+    result = pd.DataFrame(
+        list(report.items()), columns=["Metric", "Value"]
+    )
+
+    print(f"\nCDFI Fund Impact Report — {portfolio.name}")
+    print("=" * 50)
+    print(result.to_string(index=False))
+    print()
+
+    return result
+
+
+def sector_impact_report(portfolio: Portfolio) -> pd.DataFrame:
+    """
+    Generate a sector-level impact breakdown.
+    """
+    df = portfolio.to_dataframe()
+
+    impact_cols = ["jobs_created", "jobs_retained", "affordable_units",
+                   "sq_ft", "patients", "students", "businesses"]
+    available = [c for c in impact_cols if c in df.columns]
+
+    agg_dict = {"amount": ["count", "sum"]}
+    for col in available:
+        agg_dict[col] = "sum"
+
+    result = df.groupby("sector").agg(agg_dict).reset_index()
+    result.columns = ["_".join(c).strip("_") for c in result.columns]
+    result = result.sort_values("amount_sum", ascending=False)
+
+    print(f"\nSector Impact Report — {portfolio.name}")
+    print("=" * 60)
+    print(result.to_string(index=False))
+    print()
+
+    return result
+
+
+def watchlist_report(portfolio: Portfolio) -> pd.DataFrame:
+    """
+    Generate a watchlist of impaired investments.
+    """
+    impaired = portfolio.impaired_investments
+    if not impaired:
+        print(f"\nNo impaired investments in {portfolio.name}")
+        return pd.DataFrame()
+
+    rows = [{
+        "ID": i.id,
+        "Name": i.name,
+        "Status": i.status,
+        "Amount ($MM)": round(i.amount / 1e6, 2),
+        "Outstanding ($MM)": round(i.outstanding_balance / 1e6, 2),
+        "State": i.state,
+        "Sector": i.sector,
+    } for i in impaired]
+
+    df = pd.DataFrame(rows)
+    print(f"\nWatchlist Report — {portfolio.name}")
+    print("=" * 60)
+    print(df.to_string(index=False))
+    print()
+    return df