nmtc-calc 0.1.0__tar.gz

nmtc_calc-0.1.0/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: nmtc-calc
+Version: 0.1.0
+Summary: Python calculator for New Markets Tax Credit (NMTC) leveraged transactions
+License: MIT
+Project-URL: Homepage, https://github.com/Jaypatel1511/nmtc-calc
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=1.4.0
+Requires-Dist: numpy>=1.21.0
+
+# nmtc-calc 🏗️
+
+**Python calculator for New Markets Tax Credit (NMTC) leveraged transactions.**
+
+Built for CDFI practitioners, CDEs, tax credit investors, and project sponsors who need
+reproducible, auditable NMTC deal math — without starting from scratch in Excel.
+
+---
+
+## Why nmtc-calc?
+
+New Markets Tax Credit transactions involve complex layered capital structures — QEIs,
+QLICIs, leverage loans, 7-year credit schedules, investor IRR, and net subsidy calculations.
+Every practitioner builds these models from scratch in Excel. `nmtc-calc` standardizes
+and automates the math.
+
+---
+
+## Installation
+
+```bash
+cat > README.md << 'EOF'
+# nmtc-calc 🏗️
+
+**Python calculator for New Markets Tax Credit (NMTC) leveraged transactions.**
+
+Built for CDFI practitioners, CDEs, tax credit investors, and project sponsors who need
+reproducible, auditable NMTC deal math — without starting from scratch in Excel.
+
+---
+
+## Why nmtc-calc?
+
+New Markets Tax Credit transactions involve complex layered capital structures — QEIs,
+QLICIs, leverage loans, 7-year credit schedules, investor IRR, and net subsidy calculations.
+Every practitioner builds these models from scratch in Excel. `nmtc-calc` standardizes
+and automates the math.
+
+---
+
+## Installation
+
+```bash
+pip install nmtc-calc
+```
+
+---
+
+## Quickstart
+
+```python
+from nmtccalc import NMTCDeal, transaction, credits, investor, subsidy
+
+deal = NMTCDeal(
+    project_name="Southside Community Health Center",
+    total_project_cost=10_000_000,
+    nmtc_allocation=10_000_000,
+    credit_price=0.83,
+    leverage_loan_rate=0.045,
+    qlici_a_loan_rate=0.045,
+    qlici_b_loan_rate=0.010,
+    cde_fee_rate=0.02,
+    compliance_years=7,
+    discount_rate=0.08,
+)
+
+# Full capital stack
+transaction.structure(deal).summary()
+
+# 7-year credit schedule
+credits.schedule(deal).summary()
+
+# Investor economics & IRR
+investor.analyze(deal).summary()
+
+# Net subsidy to project
+subsidy.analyze(deal).summary()
+```
+
+---
+
+## Modules
+
+| Module | What It Computes |
+|--------|-----------------|
+| `transaction` | QEI, NMTCs, investor equity, leverage loan, QLICI A/B split |
+| `credits` | 7-year credit schedule (5%/5%/5%/6%/6%/6%/6%), PV of credits |
+| `investor` | Investor IRR, MOIC, gross/net benefit |
+| `subsidy` | Net subsidy to QALICB, effective cost of capital, interest savings |
+
+---
+
+## Key NMTC Concepts
+
+| Term | Definition |
+|------|-----------|
+| QEI | Qualified Equity Investment — the total investment made into the CDE |
+| QLICI | Qualified Low-Income Community Investment — loans from CDE to QALICB |
+| QALICB | Qualified Active Low-Income Community Business — the project borrower |
+| CDE | Community Development Entity — allocatee of NMTC authority |
+| A Loan | Senior QLICI mirroring the leverage loan |
+| B Loan | Subordinate QLICI mirroring investor equity, typically forgiven at year 7 |
+| Credit Price | $ per $1 of NMTC benefit paid by investor (typically $0.70–$0.85) |
+
+---
+
+## Running Tests
+
+```bash
+PYTHONPATH=. pytest tests/ -v
+```
+
+32 tests across all modules.
+
+---
+
+## Who This Is For
+
+- **CDEs** structuring NMTC allocations for projects
+- **Tax credit investors** evaluating deal economics
+- **Project sponsors** understanding subsidy and cost of capital
+- **CDFI analysts** modeling NMTC transactions in IC memos
+
+---
+
+## License
+
+MIT © 2026 Jaypatel1511

nmtc_calc-0.1.0/README.md

@@ -0,0 +1,128 @@
+# nmtc-calc 🏗️
+
+**Python calculator for New Markets Tax Credit (NMTC) leveraged transactions.**
+
+Built for CDFI practitioners, CDEs, tax credit investors, and project sponsors who need
+reproducible, auditable NMTC deal math — without starting from scratch in Excel.
+
+---
+
+## Why nmtc-calc?
+
+New Markets Tax Credit transactions involve complex layered capital structures — QEIs,
+QLICIs, leverage loans, 7-year credit schedules, investor IRR, and net subsidy calculations.
+Every practitioner builds these models from scratch in Excel. `nmtc-calc` standardizes
+and automates the math.
+
+---
+
+## Installation
+
+```bash
+cat > README.md << 'EOF'
+# nmtc-calc 🏗️
+
+**Python calculator for New Markets Tax Credit (NMTC) leveraged transactions.**
+
+Built for CDFI practitioners, CDEs, tax credit investors, and project sponsors who need
+reproducible, auditable NMTC deal math — without starting from scratch in Excel.
+
+---
+
+## Why nmtc-calc?
+
+New Markets Tax Credit transactions involve complex layered capital structures — QEIs,
+QLICIs, leverage loans, 7-year credit schedules, investor IRR, and net subsidy calculations.
+Every practitioner builds these models from scratch in Excel. `nmtc-calc` standardizes
+and automates the math.
+
+---
+
+## Installation
+
+```bash
+pip install nmtc-calc
+```
+
+---
+
+## Quickstart
+
+```python
+from nmtccalc import NMTCDeal, transaction, credits, investor, subsidy
+
+deal = NMTCDeal(
+    project_name="Southside Community Health Center",
+    total_project_cost=10_000_000,
+    nmtc_allocation=10_000_000,
+    credit_price=0.83,
+    leverage_loan_rate=0.045,
+    qlici_a_loan_rate=0.045,
+    qlici_b_loan_rate=0.010,
+    cde_fee_rate=0.02,
+    compliance_years=7,
+    discount_rate=0.08,
+)
+
+# Full capital stack
+transaction.structure(deal).summary()
+
+# 7-year credit schedule
+credits.schedule(deal).summary()
+
+# Investor economics & IRR
+investor.analyze(deal).summary()
+
+# Net subsidy to project
+subsidy.analyze(deal).summary()
+```
+
+---
+
+## Modules
+
+| Module | What It Computes |
+|--------|-----------------|
+| `transaction` | QEI, NMTCs, investor equity, leverage loan, QLICI A/B split |
+| `credits` | 7-year credit schedule (5%/5%/5%/6%/6%/6%/6%), PV of credits |
+| `investor` | Investor IRR, MOIC, gross/net benefit |
+| `subsidy` | Net subsidy to QALICB, effective cost of capital, interest savings |
+
+---
+
+## Key NMTC Concepts
+
+| Term | Definition |
+|------|-----------|
+| QEI | Qualified Equity Investment — the total investment made into the CDE |
+| QLICI | Qualified Low-Income Community Investment — loans from CDE to QALICB |
+| QALICB | Qualified Active Low-Income Community Business — the project borrower |
+| CDE | Community Development Entity — allocatee of NMTC authority |
+| A Loan | Senior QLICI mirroring the leverage loan |
+| B Loan | Subordinate QLICI mirroring investor equity, typically forgiven at year 7 |
+| Credit Price | $ per $1 of NMTC benefit paid by investor (typically $0.70–$0.85) |
+
+---
+
+## Running Tests
+
+```bash
+PYTHONPATH=. pytest tests/ -v
+```
+
+32 tests across all modules.
+
+---
+
+## Who This Is For
+
+- **CDEs** structuring NMTC allocations for projects
+- **Tax credit investors** evaluating deal economics
+- **Project sponsors** understanding subsidy and cost of capital
+- **CDFI analysts** modeling NMTC transactions in IC memos
+
+---
+
+## License
+
+MIT © 2026 Jaypatel1511

nmtc_calc-0.1.0/nmtc_calc.egg-info/PKG-INFO

@@ -0,0 +1,139 @@
+Metadata-Version: 2.4
+Name: nmtc-calc
+Version: 0.1.0
+Summary: Python calculator for New Markets Tax Credit (NMTC) leveraged transactions
+License: MIT
+Project-URL: Homepage, https://github.com/Jaypatel1511/nmtc-calc
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: pandas>=1.4.0
+Requires-Dist: numpy>=1.21.0
+
+# nmtc-calc 🏗️
+
+**Python calculator for New Markets Tax Credit (NMTC) leveraged transactions.**
+
+Built for CDFI practitioners, CDEs, tax credit investors, and project sponsors who need
+reproducible, auditable NMTC deal math — without starting from scratch in Excel.
+
+---
+
+## Why nmtc-calc?
+
+New Markets Tax Credit transactions involve complex layered capital structures — QEIs,
+QLICIs, leverage loans, 7-year credit schedules, investor IRR, and net subsidy calculations.
+Every practitioner builds these models from scratch in Excel. `nmtc-calc` standardizes
+and automates the math.
+
+---
+
+## Installation
+
+```bash
+cat > README.md << 'EOF'
+# nmtc-calc 🏗️
+
+**Python calculator for New Markets Tax Credit (NMTC) leveraged transactions.**
+
+Built for CDFI practitioners, CDEs, tax credit investors, and project sponsors who need
+reproducible, auditable NMTC deal math — without starting from scratch in Excel.
+
+---
+
+## Why nmtc-calc?
+
+New Markets Tax Credit transactions involve complex layered capital structures — QEIs,
+QLICIs, leverage loans, 7-year credit schedules, investor IRR, and net subsidy calculations.
+Every practitioner builds these models from scratch in Excel. `nmtc-calc` standardizes
+and automates the math.
+
+---
+
+## Installation
+
+```bash
+pip install nmtc-calc
+```
+
+---
+
+## Quickstart
+
+```python
+from nmtccalc import NMTCDeal, transaction, credits, investor, subsidy
+
+deal = NMTCDeal(
+    project_name="Southside Community Health Center",
+    total_project_cost=10_000_000,
+    nmtc_allocation=10_000_000,
+    credit_price=0.83,
+    leverage_loan_rate=0.045,
+    qlici_a_loan_rate=0.045,
+    qlici_b_loan_rate=0.010,
+    cde_fee_rate=0.02,
+    compliance_years=7,
+    discount_rate=0.08,
+)
+
+# Full capital stack
+transaction.structure(deal).summary()
+
+# 7-year credit schedule
+credits.schedule(deal).summary()
+
+# Investor economics & IRR
+investor.analyze(deal).summary()
+
+# Net subsidy to project
+subsidy.analyze(deal).summary()
+```
+
+---
+
+## Modules
+
+| Module | What It Computes |
+|--------|-----------------|
+| `transaction` | QEI, NMTCs, investor equity, leverage loan, QLICI A/B split |
+| `credits` | 7-year credit schedule (5%/5%/5%/6%/6%/6%/6%), PV of credits |
+| `investor` | Investor IRR, MOIC, gross/net benefit |
+| `subsidy` | Net subsidy to QALICB, effective cost of capital, interest savings |
+
+---
+
+## Key NMTC Concepts
+
+| Term | Definition |
+|------|-----------|
+| QEI | Qualified Equity Investment — the total investment made into the CDE |
+| QLICI | Qualified Low-Income Community Investment — loans from CDE to QALICB |
+| QALICB | Qualified Active Low-Income Community Business — the project borrower |
+| CDE | Community Development Entity — allocatee of NMTC authority |
+| A Loan | Senior QLICI mirroring the leverage loan |
+| B Loan | Subordinate QLICI mirroring investor equity, typically forgiven at year 7 |
+| Credit Price | $ per $1 of NMTC benefit paid by investor (typically $0.70–$0.85) |
+
+---
+
+## Running Tests
+
+```bash
+PYTHONPATH=. pytest tests/ -v
+```
+
+32 tests across all modules.
+
+---
+
+## Who This Is For
+
+- **CDEs** structuring NMTC allocations for projects
+- **Tax credit investors** evaluating deal economics
+- **Project sponsors** understanding subsidy and cost of capital
+- **CDFI analysts** modeling NMTC transactions in IC memos
+
+---
+
+## License
+
+MIT © 2026 Jaypatel1511

nmtc_calc-0.1.0/nmtc_calc.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+README.md
+pyproject.toml
+setup.py
+nmtc_calc.egg-info/PKG-INFO
+nmtc_calc.egg-info/SOURCES.txt
+nmtc_calc.egg-info/dependency_links.txt
+nmtc_calc.egg-info/requires.txt
+nmtc_calc.egg-info/top_level.txt
+nmtccalc/__init__.py
+nmtccalc/data/__init__.py
+nmtccalc/data/schema.py
+nmtccalc/models/__init__.py
+nmtccalc/models/credits.py
+nmtccalc/models/investor.py
+nmtccalc/models/subsidy.py
+nmtccalc/models/transaction.py
+nmtccalc/utils/__init__.py
+tests/test_credits.py
+tests/test_investor.py
+tests/test_subsidy.py
+tests/test_transaction.py

nmtc_calc-0.1.0/nmtc_calc.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nmtc_calc-0.1.0/nmtc_calc.egg-info/requires.txt

@@ -0,0 +1,2 @@
+pandas>=1.4.0
+numpy>=1.21.0

nmtc_calc-0.1.0/nmtc_calc.egg-info/top_level.txt

@@ -0,0 +1 @@
+nmtccalc

nmtc_calc-0.1.0/nmtccalc/__init__.py

@@ -0,0 +1,5 @@
+from nmtccalc.data.schema import NMTCDeal
+from nmtccalc.models import transaction, credits, investor, subsidy
+
+__version__ = "0.1.0"
+__all__ = ["NMTCDeal", "transaction", "credits", "investor", "subsidy"]

nmtc_calc-0.1.0/nmtccalc/data/schema.py

@@ -0,0 +1,95 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+
+@dataclass
+class NMTCDeal:
+    """
+    Core input contract for an NMTC leveraged transaction.
+    All dollar amounts in whole dollars (e.g. 10_000_000 for $10MM).
+    """
+    project_name: str
+    total_project_cost: float          # total project budget
+    nmtc_allocation: float             # QEI amount
+    credit_price: float                # $ per $1 of NMTC benefit e.g. 0.83
+    leverage_loan_rate: float          # annual interest rate e.g. 0.045
+    qlici_a_loan_rate: float           # senior QLICI loan rate
+    qlici_b_loan_rate: float           # subordinate QLICI loan rate
+    cde_fee_rate: float                # CDE upfront fee as % of QEI e.g. 0.02
+    compliance_years: int = 7          # always 7 per Section 45D
+    discount_rate: float = 0.08        # for NPV/IRR calculations
+    investor_name: Optional[str] = None
+    cde_name: Optional[str] = None
+    project_location: Optional[str] = None
+
+    def __post_init__(self):
+        if self.total_project_cost <= 0:
+            raise ValueError("total_project_cost must be positive")
+        if self.nmtc_allocation <= 0:
+            raise ValueError("nmtc_allocation (QEI) must be positive")
+        if self.nmtc_allocation > self.total_project_cost:
+            raise ValueError("nmtc_allocation cannot exceed total_project_cost")
+        if not (0 < self.credit_price < 1):
+            raise ValueError("credit_price must be between 0 and 1 (e.g. 0.83)")
+        if not (0 < self.cde_fee_rate < 1):
+            raise ValueError("cde_fee_rate must be between 0 and 1 (e.g. 0.02)")
+        if self.compliance_years != 7:
+            raise ValueError("compliance_years must be 7 per Section 45D")
+        if not (0 < self.discount_rate < 1):
+            raise ValueError("discount_rate must be between 0 and 1 (e.g. 0.08)")
+
+    @property
+    def qei(self) -> float:
+        """Qualified Equity Investment amount."""
+        return self.nmtc_allocation
+
+    @property
+    def total_nmtcs(self) -> float:
+        """Total tax credits generated: 39% of QEI."""
+        return self.qei * 0.39
+
+    @property
+    def investor_equity(self) -> float:
+        """Investor equity contribution: total NMTCs × credit price."""
+        return self.total_nmtcs * self.credit_price
+
+    @property
+    def leverage_loan(self) -> float:
+        """Leverage loan amount: QEI minus investor equity."""
+        return self.qei - self.investor_equity
+
+    @property
+    def cde_fee(self) -> float:
+        """CDE upfront fee in dollars."""
+        return self.qei * self.cde_fee_rate
+
+    @property
+    def qlici_total(self) -> float:
+        """Total QLICI to QALICB: QEI minus CDE fee."""
+        return self.qei - self.cde_fee
+
+    @property
+    def qlici_a_loan(self) -> float:
+        """A Loan: mirrors leverage loan."""
+        return self.leverage_loan
+
+    @property
+    def qlici_b_loan(self) -> float:
+        """B Loan: mirrors investor equity net of CDE fee."""
+        return self.investor_equity - self.cde_fee
+
+    @property
+    def qei_mm(self) -> float:
+        return self.qei / 1_000_000
+
+    @property
+    def total_project_cost_mm(self) -> float:
+        return self.total_project_cost / 1_000_000
+
+    def __repr__(self):
+        return (
+            f"NMTCDeal(project='{self.project_name}', "
+            f"QEI=${self.qei_mm:.1f}MM, "
+            f"NMTCs=${self.total_nmtcs/1e6:.2f}MM, "
+            f"credit_price=${self.credit_price:.2f})"
+        )

nmtc_calc-0.1.0/nmtccalc/models/credits.py

@@ -0,0 +1,91 @@
+from dataclasses import dataclass
+import pandas as pd
+import numpy as np
+
+from nmtccalc.data.schema import NMTCDeal
+
+
+@dataclass
+class CreditScheduleResult:
+    """Output object from NMTC 7-year credit schedule."""
+    project_name: str
+    qei: float
+    total_nmtcs: float
+    annual_credits: list
+    cumulative_credits: list
+    pv_credits: float
+    discount_rate: float
+
+    def summary(self) -> pd.DataFrame:
+        rows = []
+        for yr, (credit, cumulative) in enumerate(
+            zip(self.annual_credits, self.cumulative_credits), 1
+        ):
+            rate = "5%" if yr <= 3 else "6%"
+            rows.append({
+                "Year": f"Y{yr}",
+                "Credit Rate": rate,
+                "Annual Credit ($)": f"${credit:,.0f}",
+                "Cumulative ($)": f"${cumulative:,.0f}",
+            })
+
+        df = pd.DataFrame(rows)
+        print(f"\n7-Year NMTC Credit Schedule — {self.project_name}")
+        print(f"QEI: ${self.qei/1e6:.2f}MM  |  Total NMTCs: ${self.total_nmtcs/1e6:.2f}MM")
+        print("-" * 60)
+        print(df.to_string(index=False))
+        print("-" * 60)
+        print(f"  Total NMTCs:        ${self.total_nmtcs:,.0f}")
+        print(f"  PV of Credits:      ${self.pv_credits:,.0f}  (@ {self.discount_rate*100:.1f}% discount rate)")
+        print()
+        return df
+
+    def to_dict(self) -> dict:
+        return {
+            "project_name": self.project_name,
+            "qei": self.qei,
+            "total_nmtcs": self.total_nmtcs,
+            "annual_credits": self.annual_credits,
+            "cumulative_credits": self.cumulative_credits,
+            "pv_credits": self.pv_credits,
+            "discount_rate": self.discount_rate,
+        }
+
+
+def schedule(deal: NMTCDeal) -> CreditScheduleResult:
+    """
+    Generate the 7-year NMTC tax credit schedule.
+
+    Credits are earned at:
+    - 5% of QEI in years 1, 2, 3
+    - 6% of QEI in years 4, 5, 6, 7
+    Total: 39% of QEI
+
+    Args:
+        deal: NMTCDeal instance
+
+    Returns:
+        CreditScheduleResult with annual and cumulative credit schedule
+    """
+    annual_credits = []
+    for yr in range(1, deal.compliance_years + 1):
+        rate = 0.05 if yr <= 3 else 0.06
+        annual_credits.append(deal.qei * rate)
+
+    cumulative_credits = list(np.cumsum(annual_credits))
+
+    # PV of credits discounted at deal.discount_rate
+    pv_credits = sum(
+        credit / ((1 + deal.discount_rate) ** yr)
+        for yr, credit in enumerate(annual_credits, 1)
+    )
+
+    return CreditScheduleResult(
+        project_name=deal.project_name,
+        qei=deal.qei,
+        total_nmtcs=deal.total_nmtcs,
+        annual_credits=annual_credits,
+        cumulative_credits=cumulative_credits,
+        pv_credits=pv_credits,
+        discount_rate=deal.discount_rate,
+    )

nmtc_calc-0.1.0/nmtccalc/models/investor.py

@@ -0,0 +1,109 @@
+from dataclasses import dataclass
+import pandas as pd
+import numpy as np
+
+from nmtccalc.data.schema import NMTCDeal
+
+
+@dataclass
+class InvestorResult:
+    """Output object from investor economics analysis."""
+    project_name: str
+    investor_equity: float
+    annual_credits: list
+    total_nmtcs: float
+    credit_price: float
+    gross_benefit: float
+    net_benefit: float
+    irr: float
+    moic: float
+
+    def summary(self) -> pd.DataFrame:
+        rows = []
+        for yr, credit in enumerate(self.annual_credits, 1):
+            rows.append({
+                "Year": f"Y{yr}",
+                "Tax Credit ($)": f"${credit:,.0f}",
+            })
+
+        df = pd.DataFrame(rows)
+        print(f"\nInvestor Economics — {self.project_name}")
+        print(f"Equity In: ${self.investor_equity/1e6:.2f}MM  |  Credit Price: ${self.credit_price:.2f}/$1")
+        print("-" * 50)
+        print(df.to_string(index=False))
+        print("-" * 50)
+        print(f"  Total NMTCs:      ${self.total_nmtcs:,.0f}")
+        print(f"  Gross Benefit:    ${self.gross_benefit:,.0f}")
+        print(f"  Net Benefit:      ${self.net_benefit:,.0f}")
+        print(f"  MOIC:             {self.moic:.2f}x")
+        print(f"  IRR:              {self.irr*100:.1f}%")
+        print()
+        return df
+
+    def to_dict(self) -> dict:
+        return {
+            "project_name": self.project_name,
+            "investor_equity": self.investor_equity,
+            "total_nmtcs": self.total_nmtcs,
+            "credit_price": self.credit_price,
+            "gross_benefit": self.gross_benefit,
+            "net_benefit": self.net_benefit,
+            "irr": self.irr,
+            "moic": self.moic,
+        }
+
+
+def _compute_irr(cash_flows: list) -> float:
+    """Compute IRR using numpy."""
+    coeffs = cash_flows[::-1]
+    try:
+        roots = np.roots(coeffs)
+        real_roots = [r.real for r in roots if abs(r.imag) < 1e-6 and r.real > 0]
+        if not real_roots:
+            return float("nan")
+        irr = min(real_roots) - 1
+        return irr
+    except Exception:
+        return float("nan")
+
+
+def analyze(deal: NMTCDeal) -> InvestorResult:
+    """
+    Compute investor economics for an NMTC transaction.
+
+    The investor puts in equity upfront and receives tax credits
+    over the 7-year compliance period.
+
+    Args:
+        deal: NMTCDeal instance
+
+    Returns:
+        InvestorResult with IRR, MOIC, and credit schedule
+    """
+    from nmtccalc.models.credits import schedule
+
+    credit_result = schedule(deal)
+    annual_credits = credit_result.annual_credits
+
+    gross_benefit = deal.total_nmtcs
+    net_benefit = gross_benefit - deal.investor_equity
+
+    # Cash flows: negative equity upfront, credits received each year
+    cash_flows = [-deal.investor_equity] + annual_credits
+
+    # IRR via numpy polynomial roots
+    irr = _compute_irr(cash_flows)
+
+    moic = sum(annual_credits) / deal.investor_equity
+
+    return InvestorResult(
+        project_name=deal.project_name,
+        investor_equity=deal.investor_equity,
+        annual_credits=annual_credits,
+        total_nmtcs=deal.total_nmtcs,
+        credit_price=deal.credit_price,
+        gross_benefit=gross_benefit,
+        net_benefit=net_benefit,
+        irr=irr,
+        moic=moic,
+    )

nmtc_calc-0.1.0/nmtccalc/models/subsidy.py

@@ -0,0 +1,98 @@
+from dataclasses import dataclass
+import pandas as pd
+
+from nmtccalc.data.schema import NMTCDeal
+
+
+@dataclass
+class SubsidyResult:
+    """Output object from NMTC net subsidy analysis."""
+    project_name: str
+    total_project_cost: float
+    qei: float
+    investor_equity: float
+    cde_fee: float
+    qlici_b_loan: float
+    net_subsidy: float
+    net_subsidy_pct: float
+    effective_cost_of_capital: float
+    interest_savings_7yr: float
+
+    def summary(self) -> pd.DataFrame:
+        rows = [
+            ("Investor Equity (into fund)",  f"${self.investor_equity/1e6:.2f}MM"),
+            ("Less: CDE Fee",                f"(${self.cde_fee/1e6:.2f}MM)"),
+            ("B Loan to QALICB",             f"${self.qlici_b_loan/1e6:.2f}MM"),
+            ("",                              ""),
+            ("Net Subsidy (est. forgiven)",   f"${self.net_subsidy/1e6:.2f}MM"),
+            ("Net Subsidy as % of Project",   f"{self.net_subsidy_pct*100:.1f}%"),
+            ("",                              ""),
+            ("Effective Cost of Capital",     f"{self.effective_cost_of_capital*100:.2f}%"),
+            ("Interest Savings (7yr)",        f"${self.interest_savings_7yr/1e6:.2f}MM"),
+        ]
+
+        df = pd.DataFrame(rows, columns=["Item", "Value"])
+        print(f"\nNet Subsidy Analysis — {self.project_name}")
+        print("=" * 50)
+        print(df.to_string(index=False))
+        print()
+        return df
+
+    def to_dict(self) -> dict:
+        return {
+            "project_name": self.project_name,
+            "net_subsidy": self.net_subsidy,
+            "net_subsidy_pct": self.net_subsidy_pct,
+            "effective_cost_of_capital": self.effective_cost_of_capital,
+            "interest_savings_7yr": self.interest_savings_7yr,
+        }
+
+
+def analyze(deal: NMTCDeal) -> SubsidyResult:
+    """
+    Compute the net subsidy and effective cost of capital for the QALICB.
+
+    The net subsidy is the B Loan amount that is typically forgiven
+    via put/call at the end of the 7-year compliance period.
+    This represents the real economic benefit to the project.
+
+    Args:
+        deal: NMTCDeal instance
+
+    Returns:
+        SubsidyResult with net subsidy and effective cost metrics
+    """
+    # Net subsidy: B Loan is typically forgiven at end of compliance period
+    net_subsidy = deal.qlici_b_loan
+    net_subsidy_pct = net_subsidy / deal.total_project_cost
+
+    # Interest savings: difference between market rate and QLICI B loan rate
+    # over the 7-year compliance period on the B loan principal
+    market_rate = deal.leverage_loan_rate  # use leverage rate as market proxy
+    interest_savings_7yr = deal.qlici_b_loan * (
+        market_rate - deal.qlici_b_loan_rate
+    ) * deal.compliance_years
+
+    # Effective cost of capital: blended rate on total QLICI
+    # weighted average of A and B loan rates by their principal amounts
+    total_qlici = deal.qlici_total
+    if total_qlici > 0:
+        effective_cost_of_capital = (
+            (deal.qlici_a_loan * deal.qlici_a_loan_rate) +
+            (deal.qlici_b_loan * deal.qlici_b_loan_rate)
+        ) / total_qlici
+    else:
+        effective_cost_of_capital = 0.0
+
+    return SubsidyResult(
+        project_name=deal.project_name,
+        total_project_cost=deal.total_project_cost,
+        qei=deal.qei,
+        investor_equity=deal.investor_equity,
+        cde_fee=deal.cde_fee,
+        qlici_b_loan=deal.qlici_b_loan,
+        net_subsidy=net_subsidy,
+        net_subsidy_pct=net_subsidy_pct,
+        effective_cost_of_capital=effective_cost_of_capital,
+        interest_savings_7yr=interest_savings_7yr,
+    )

nmtc_calc-0.1.0/nmtccalc/models/transaction.py

@@ -0,0 +1,101 @@
+from dataclasses import dataclass
+import pandas as pd
+
+from nmtccalc.data.schema import NMTCDeal
+
+
+@dataclass
+class TransactionResult:
+    """Output object from NMTC transaction structure analysis."""
+    project_name: str
+    total_project_cost: float
+    qei: float
+    total_nmtcs: float
+    investor_equity: float
+    leverage_loan: float
+    cde_fee: float
+    qlici_total: float
+    qlici_a_loan: float
+    qlici_b_loan: float
+    credit_price: float
+    nmtc_coverage: float        # NMTCs as % of total project cost
+    leverage_ratio: float       # leverage loan / investor equity
+
+    def summary(self) -> pd.DataFrame:
+        rows = [
+            ("Total Project Cost",      f"${self.total_project_cost/1e6:.2f}MM"),
+            ("── QEI (NMTC Allocation)", f"${self.qei/1e6:.2f}MM"),
+            ("── Total NMTCs (39% × QEI)", f"${self.total_nmtcs/1e6:.2f}MM"),
+            ("",                         ""),
+            ("INVESTMENT FUND",          ""),
+            ("── Investor Equity",       f"${self.investor_equity/1e6:.2f}MM"),
+            ("── Leverage Loan",         f"${self.leverage_loan/1e6:.2f}MM"),
+            ("── Total QEI",             f"${self.qei/1e6:.2f}MM"),
+            ("",                         ""),
+            ("CDE / SUB-CDE",            ""),
+            ("── CDE Fee",               f"${self.cde_fee/1e6:.2f}MM"),
+            ("── Total QLICI",           f"${self.qlici_total/1e6:.2f}MM"),
+            ("",                         ""),
+            ("QLICI TO QALICB",          ""),
+            ("── A Loan (Senior)",       f"${self.qlici_a_loan/1e6:.2f}MM"),
+            ("── B Loan (Subordinate)",  f"${self.qlici_b_loan/1e6:.2f}MM"),
+            ("",                         ""),
+            ("KEY RATIOS",               ""),
+            ("── Credit Price",          f"${self.credit_price:.2f} per $1 of NMTCs"),
+            ("── NMTC Coverage",         f"{self.nmtc_coverage*100:.1f}% of project cost"),
+            ("── Leverage Ratio",        f"{self.leverage_ratio:.2f}x"),
+        ]
+
+        df = pd.DataFrame(rows, columns=["Item", "Amount"])
+        print(f"\nNMTC Transaction Structure — {self.project_name}")
+        print("=" * 55)
+        print(df.to_string(index=False))
+        print()
+        return df
+
+    def to_dict(self) -> dict:
+        return {
+            "project_name": self.project_name,
+            "total_project_cost": self.total_project_cost,
+            "qei": self.qei,
+            "total_nmtcs": self.total_nmtcs,
+            "investor_equity": self.investor_equity,
+            "leverage_loan": self.leverage_loan,
+            "cde_fee": self.cde_fee,
+            "qlici_total": self.qlici_total,
+            "qlici_a_loan": self.qlici_a_loan,
+            "qlici_b_loan": self.qlici_b_loan,
+            "credit_price": self.credit_price,
+            "nmtc_coverage": self.nmtc_coverage,
+            "leverage_ratio": self.leverage_ratio,
+        }
+
+
+def structure(deal: NMTCDeal) -> TransactionResult:
+    """
+    Compute the full NMTC leveraged transaction structure.
+
+    Args:
+        deal: NMTCDeal instance with all deal parameters
+
+    Returns:
+        TransactionResult with complete capital stack breakdown
+    """
+    nmtc_coverage = deal.total_nmtcs / deal.total_project_cost
+    leverage_ratio = deal.leverage_loan / deal.investor_equity
+
+    return TransactionResult(
+        project_name=deal.project_name,
+        total_project_cost=deal.total_project_cost,
+        qei=deal.qei,
+        total_nmtcs=deal.total_nmtcs,
+        investor_equity=deal.investor_equity,
+        leverage_loan=deal.leverage_loan,
+        cde_fee=deal.cde_fee,
+        qlici_total=deal.qlici_total,
+        qlici_a_loan=deal.qlici_a_loan,
+        qlici_b_loan=deal.qlici_b_loan,
+        credit_price=deal.credit_price,
+        nmtc_coverage=nmtc_coverage,
+        leverage_ratio=leverage_ratio,
+    )

nmtc_calc-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nmtc-calc"
+version = "0.1.0"
+description = "Python calculator for New Markets Tax Credit (NMTC) leveraged transactions"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+dependencies = [
+    "pandas>=1.4.0",
+    "numpy>=1.21.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Jaypatel1511/nmtc-calc"

nmtc_calc-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

nmtc_calc-0.1.0/setup.py

@@ -0,0 +1,11 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="nmtc-calc",
+    version="0.1.0",
+    packages=find_packages(),
+    install_requires=[
+        "pandas>=1.4.0",
+        "numpy>=1.21.0",
+    ],
+)

nmtc_calc-0.1.0/tests/test_credits.py

@@ -0,0 +1,49 @@
+import pytest
+import pandas as pd
+from nmtccalc.models import credits
+
+
+def test_seven_years(sample_deal):
+    result = credits.schedule(sample_deal)
+    assert len(result.annual_credits) == 7
+
+
+def test_years_1_to_3_rate(sample_deal):
+    result = credits.schedule(sample_deal)
+    for yr in range(3):
+        assert result.annual_credits[yr] == pytest.approx(sample_deal.qei * 0.05)
+
+
+def test_years_4_to_7_rate(sample_deal):
+    result = credits.schedule(sample_deal)
+    for yr in range(3, 7):
+        assert result.annual_credits[yr] == pytest.approx(sample_deal.qei * 0.06)
+
+
+def test_total_credits_equals_39pct(sample_deal):
+    result = credits.schedule(sample_deal)
+    assert sum(result.annual_credits) == pytest.approx(sample_deal.qei * 0.39)
+
+
+def test_cumulative_final_equals_total(sample_deal):
+    result = credits.schedule(sample_deal)
+    assert result.cumulative_credits[-1] == pytest.approx(sample_deal.total_nmtcs)
+
+
+def test_pv_less_than_total(sample_deal):
+    result = credits.schedule(sample_deal)
+    assert result.pv_credits < result.total_nmtcs
+
+
+def test_summary_returns_dataframe(sample_deal):
+    result = credits.schedule(sample_deal)
+    df = result.summary()
+    assert isinstance(df, pd.DataFrame)
+    assert len(df) == 7
+
+
+def test_to_dict_keys(sample_deal):
+    result = credits.schedule(sample_deal)
+    d = result.to_dict()
+    assert "annual_credits" in d
+    assert "pv_credits" in d

nmtc_calc-0.1.0/tests/test_investor.py

@@ -0,0 +1,45 @@
+import pytest
+import pandas as pd
+from nmtccalc.models import investor
+
+
+def test_moic_positive(sample_deal):
+    result = investor.analyze(sample_deal)
+    assert result.moic > 0
+
+
+def test_moic_math(sample_deal):
+    result = investor.analyze(sample_deal)
+    expected_moic = sample_deal.total_nmtcs / sample_deal.investor_equity
+    assert result.moic == pytest.approx(expected_moic)
+
+
+def test_gross_benefit_equals_total_nmtcs(sample_deal):
+    result = investor.analyze(sample_deal)
+    assert result.gross_benefit == pytest.approx(sample_deal.total_nmtcs)
+
+
+def test_net_benefit_math(sample_deal):
+    result = investor.analyze(sample_deal)
+    expected = sample_deal.total_nmtcs - sample_deal.investor_equity
+    assert result.net_benefit == pytest.approx(expected)
+
+
+def test_irr_is_float(sample_deal):
+    result = investor.analyze(sample_deal)
+    assert isinstance(result.irr, float)
+
+
+def test_summary_returns_dataframe(sample_deal):
+    result = investor.analyze(sample_deal)
+    df = result.summary()
+    assert isinstance(df, pd.DataFrame)
+    assert len(df) == 7
+
+
+def test_to_dict_keys(sample_deal):
+    result = investor.analyze(sample_deal)
+    d = result.to_dict()
+    assert "irr" in d
+    assert "moic" in d
+    assert "net_benefit" in d

nmtc_calc-0.1.0/tests/test_subsidy.py

@@ -0,0 +1,42 @@
+import pytest
+import pandas as pd
+from nmtccalc.models import subsidy
+
+
+def test_net_subsidy_positive(sample_deal):
+    result = subsidy.analyze(sample_deal)
+    assert result.net_subsidy > 0
+
+
+def test_net_subsidy_equals_b_loan(sample_deal):
+    result = subsidy.analyze(sample_deal)
+    assert result.net_subsidy == pytest.approx(sample_deal.qlici_b_loan)
+
+
+def test_net_subsidy_pct_range(sample_deal):
+    result = subsidy.analyze(sample_deal)
+    assert 0.10 <= result.net_subsidy_pct <= 0.35
+
+
+def test_effective_cost_below_market(sample_deal):
+    result = subsidy.analyze(sample_deal)
+    assert result.effective_cost_of_capital < sample_deal.leverage_loan_rate
+
+
+def test_interest_savings_positive(sample_deal):
+    result = subsidy.analyze(sample_deal)
+    assert result.interest_savings_7yr > 0
+
+
+def test_summary_returns_dataframe(sample_deal):
+    result = subsidy.analyze(sample_deal)
+    df = result.summary()
+    assert isinstance(df, pd.DataFrame)
+
+
+def test_to_dict_keys(sample_deal):
+    result = subsidy.analyze(sample_deal)
+    d = result.to_dict()
+    assert "net_subsidy" in d
+    assert "net_subsidy_pct" in d
+    assert "effective_cost_of_capital" in d

nmtc_calc-0.1.0/tests/test_transaction.py

@@ -0,0 +1,68 @@
+import pytest
+from nmtccalc.data.schema import NMTCDeal
+from nmtccalc.models import transaction
+
+
+def test_total_nmtcs(sample_deal):
+    assert sample_deal.total_nmtcs == pytest.approx(10_000_000 * 0.39)
+
+
+def test_investor_equity(sample_deal):
+    expected = 10_000_000 * 0.39 * 0.83
+    assert sample_deal.investor_equity == pytest.approx(expected)
+
+
+def test_leverage_loan(sample_deal):
+    expected = 10_000_000 - (10_000_000 * 0.39 * 0.83)
+    assert sample_deal.leverage_loan == pytest.approx(expected)
+
+
+def test_qei_equals_equity_plus_loan(sample_deal):
+    assert sample_deal.qei == pytest.approx(
+        sample_deal.investor_equity + sample_deal.leverage_loan
+    )
+
+
+def test_qlici_total(sample_deal):
+    expected = 10_000_000 - (10_000_000 * 0.02)
+    assert sample_deal.qlici_total == pytest.approx(expected)
+
+
+def test_qlici_a_plus_b_equals_total(sample_deal):
+    assert pytest.approx(sample_deal.qlici_a_loan + sample_deal.qlici_b_loan,
+                         rel=1e-4) == sample_deal.qlici_total
+
+
+def test_structure_returns_result(sample_deal):
+    result = transaction.structure(sample_deal)
+    assert result.qei == sample_deal.qei
+    assert result.leverage_ratio > 0
+
+
+def test_summary_returns_dataframe(sample_deal):
+    import pandas as pd
+    result = transaction.structure(sample_deal)
+    df = result.summary()
+    assert isinstance(df, pd.DataFrame)
+
+
+def test_allocation_exceeds_project_cost_raises():
+    with pytest.raises(ValueError, match="cannot exceed"):
+        NMTCDeal(
+            project_name="Bad Deal",
+            total_project_cost=5_000_000,
+            nmtc_allocation=6_000_000,
+            credit_price=0.83,
+            leverage_loan_rate=0.045,
+            qlici_a_loan_rate=0.045,
+            qlici_b_loan_rate=0.01,
+            cde_fee_rate=0.02,
+        )
+
+
+def test_to_dict_keys(sample_deal):
+    result = transaction.structure(sample_deal)
+    d = result.to_dict()
+    assert "qei" in d
+    assert "leverage_loan" in d
+    assert "nmtc_coverage" in d