policyengine-us 1.449.6__py3-none-any.whl → 1.465.0__py3-none-any.whl

policyengine_us/tests/test_batched.py

@@ -21,37 +21,33 @@ def count_yaml_files(directory: Path) -> int:
     return len(list(directory.rglob("*.yaml")))
 
 
-def get_test_directories(base_path: Path) -> Dict[str, int]:
-    """Get all subdirectories and their test counts."""
-    dir_counts = {}
-
-    # Check for yaml files directly in base directory
-    root_count = len(list(base_path.glob("*.yaml")))
-    if root_count > 0:
-        dir_counts["."] = root_count
-
-    # Get all subdirectories with their test counts
-    for item in base_path.iterdir():
-        if item.is_dir():
-            yaml_count = count_yaml_files(item)
-            if yaml_count > 0:
-                dir_counts[item.name] = yaml_count
-
-    return dir_counts
-
-
-def split_into_batches(base_path: Path, num_batches: int) -> List[List[str]]:
+def split_into_batches(
+    base_path: Path, num_batches: int, exclude: List[str] = None
+) -> List[List[str]]:
     """
     Split test directories into specified number of batches.
     Special handling for baseline tests to separate states.
     Special handling for contrib tests to divide by folder count.
+
+    Args:
+        base_path: Path to the test directory
+        num_batches: Number of batches to split into
+        exclude: List of directory names to exclude (for contrib tests)
     """
+    if exclude is None:
+        exclude = []
+
     # Special handling for contrib tests - each folder is its own batch
     # Only apply to policy/contrib (structural tests), not baseline/contrib
     if str(base_path).endswith("policy/contrib"):
         # Get all subdirectories and sort them alphabetically
+        # Exclude specified directories
         subdirs = sorted(
-            [item for item in base_path.iterdir() if item.is_dir()]
+            [
+                item
+                for item in base_path.iterdir()
+                if item.is_dir() and item.name not in exclude
+            ]
         )
 
         # Get root level YAML files and sort them
@@ -73,19 +69,17 @@ def split_into_batches(base_path: Path, num_batches: int) -> List[List[str]]:
     if "reform" in str(base_path):
         return [[str(base_path)]]
 
-    # Special handling for baseline tests with 2 batches
-    if "baseline" in str(base_path) and num_batches == 2:
+    # Special handling for baseline tests
+    if "baseline" in str(base_path) and str(base_path).endswith("baseline"):
         states_path = base_path / "gov" / "states"
-        if states_path.exists() and count_yaml_files(states_path) > 0:
-            # Batch 1: Only states
-            batch1 = [str(states_path)]
 
-            # Batch 2: Everything else (excluding states, household, and contrib)
-            batch2 = []
+        # If --exclude states, skip states and run everything else
+        if "states" in exclude:
+            batch = []
 
             # Add root level files if any
             for yaml_file in base_path.glob("*.yaml"):
-                batch2.append(str(yaml_file))
+                batch.append(str(yaml_file))
 
             # Add all directories except gov/states, household, and contrib
             for item in base_path.iterdir():
@@ -97,49 +91,17 @@ def split_into_batches(base_path: Path, num_batches: int) -> List[List[str]]:
                         # Add gov subdirectories except states
                         for gov_item in item.iterdir():
                             if gov_item.is_dir() and gov_item.name != "states":
-                                batch2.append(str(gov_item))
+                                batch.append(str(gov_item))
                             elif gov_item.suffix == ".yaml":
-                                batch2.append(str(gov_item))
+                                batch.append(str(gov_item))
                     else:
                         # Other non-gov directories
-                        batch2.append(str(item))
-
-            return [batch1, batch2] if batch2 else [batch1]
-
-    # Default behavior for non-baseline or different batch counts
-    dir_counts = get_test_directories(base_path)
-
-    if num_batches <= 0:
-        num_batches = 1
+                        batch.append(str(item))
 
-    # If only 1 batch, return everything
-    if num_batches == 1:
-        return [[str(base_path)]]
-
-    # Sort directories by test count (largest first)
-    sorted_dirs = sorted(dir_counts.items(), key=lambda x: x[1], reverse=True)
-
-    # Initialize batches
-    batches = [[] for _ in range(num_batches)]
-    batch_counts = [0] * num_batches
-
-    # Distribute directories to batches (greedy algorithm - add to smallest batch)
-    for dir_name, count in sorted_dirs:
-        # Find batch with fewest tests
-        min_batch_idx = batch_counts.index(min(batch_counts))
-
-        # Add directory to that batch
-        if dir_name == ".":
-            # Root level files - add individually
-            for yaml_file in base_path.glob("*.yaml"):
-                batches[min_batch_idx].append(str(yaml_file))
-        else:
-            batches[min_batch_idx].append(str(base_path / dir_name))
-
-        batch_counts[min_batch_idx] += count
+            return [batch] if batch else []
 
-    # Filter out empty batches
-    return [batch for batch in batches if batch]
+    # Default: return the entire path as a single batch
+    return [[str(base_path)]]
 
 
 def run_batch(test_paths: List[str], batch_name: str) -> Dict:
@@ -298,8 +260,15 @@ def main():
         default=2,
         help="Number of batches to split tests into (default: 2)",
     )
+    parser.add_argument(
+        "--exclude",
+        type=str,
+        default="",
+        help="Comma-separated list of directory names to exclude (for contrib tests)",
+    )
 
     args = parser.parse_args()
+    exclude_list = [x.strip() for x in args.exclude.split(",") if x.strip()]
 
     if not os.path.exists("policyengine_us"):
         print("Error: Must run from PolicyEngine US root directory")
@@ -314,13 +283,15 @@ def main():
     print("=" * 60)
     print(f"Test path: {test_path}")
     print(f"Requested batches: {args.batches}")
+    if exclude_list:
+        print(f"Excluding: {', '.join(exclude_list)}")
 
     # Count total tests
     total_tests = count_yaml_files(test_path)
     print(f"Total test files: {total_tests}")
 
     # Split into batches
-    batches = split_into_batches(test_path, args.batches)
+    batches = split_into_batches(test_path, args.batches, exclude_list)
     if len(batches) != args.batches:
         print(
             f"Actual batches: {len(batches)} (optimized for {total_tests} files)"

policyengine_us/variables/gov/hhs/medicaid/costs/medicaid_group.py

@@ -12,10 +12,10 @@ class MedicaidGroup(Enum):
 class medicaid_group(Variable):
     """Maps fine-grained Medicaid categories to broader spending groups
     Precedence order (highest → lowest):
-    1. Disabled / SSI / medically‑needy → AGED_DISABLED
+    1. Disabled / SSI / medically-needy → AGED_DISABLED
     2. Pregnant                       → NON_EXPANSION_ADULT
     3. Parent                         → NON_EXPANSION_ADULT
-    4. Young adult (19–20)            → NON_EXPANSION_ADULT
+    4. Young adult (19-20)            → NON_EXPANSION_ADULT
     5. Expansion adult                → EXPANSION_ADULT
     6. Any child category             → CHILD
     """

policyengine_us/variables/gov/hhs/medicaid/receives_medicaid.py

@@ -0,0 +1,17 @@
+from policyengine_us.model_api import *
+
+
+class receives_medicaid(Variable):
+    value_type = bool
+    entity = Person
+    label = "Currently receives Medicaid"
+    definition_period = YEAR
+    documentation = """
+    Input variable indicating a person currently has Medicaid coverage.
+    Used to model continuous coverage for existing enrollees who may no
+    longer meet eligibility criteria under new rules (e.g., CA undocumented
+    immigrant enrollment freeze starting 2026).
+
+    This differs from medicaid_enrolled which is computed based on
+    eligibility and takeup rate.
+    """

policyengine_us/variables/gov/hhs/medicare/savings_programs/category/is_qi_eligible.py

@@ -0,0 +1,33 @@
+from policyengine_us.model_api import *
+
+
+class is_qi_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Qualifying Individual (QI) eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.law.cornell.edu/cfr/text/42/435.123",
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+
+    def formula(person, period, parameters):
+        # QI requires income above 120% FPL but at or below 135% FPL
+        p = parameters(
+            period
+        ).gov.hhs.medicare.savings_programs.eligibility.income
+
+        medicare_eligible = person("is_medicare_eligible", period.this_year)
+        asset_eligible = person("msp_asset_eligible", period)
+
+        fpg = person("msp_fpg", period)
+        countable_income = person("msp_countable_income", period)
+
+        slmb_income_limit = fpg * p.slmb.fpl_limit
+        qi_income_limit = fpg * p.qi.fpl_limit
+
+        income_above_slmb = countable_income > slmb_income_limit
+        income_at_or_below_qi = countable_income <= qi_income_limit
+        income_eligible = income_above_slmb & income_at_or_below_qi
+
+        return medicare_eligible & income_eligible & asset_eligible

policyengine_us/variables/gov/hhs/medicare/savings_programs/category/is_qmb_eligible.py

@@ -0,0 +1,28 @@
+from policyengine_us.model_api import *
+
+
+class is_qmb_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Qualified Medicare Beneficiary (QMB) eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.law.cornell.edu/cfr/text/42/435.121",
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+
+    def formula(person, period, parameters):
+        # QMB requires income at or below 100% FPL
+        p = parameters(
+            period
+        ).gov.hhs.medicare.savings_programs.eligibility.income
+
+        medicare_eligible = person("is_medicare_eligible", period.this_year)
+        asset_eligible = person("msp_asset_eligible", period)
+
+        fpg = person("msp_fpg", period)
+        countable_income = person("msp_countable_income", period)
+        qmb_income_limit = fpg * p.qmb.fpl_limit
+        income_eligible = countable_income <= qmb_income_limit
+
+        return medicare_eligible & income_eligible & asset_eligible

policyengine_us/variables/gov/hhs/medicare/savings_programs/category/is_slmb_eligible.py

@@ -0,0 +1,33 @@
+from policyengine_us.model_api import *
+
+
+class is_slmb_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Specified Low-Income Medicare Beneficiary (SLMB) eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.law.cornell.edu/cfr/text/42/435.122",
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+
+    def formula(person, period, parameters):
+        # SLMB requires income above 100% FPL but at or below 120% FPL
+        p = parameters(
+            period
+        ).gov.hhs.medicare.savings_programs.eligibility.income
+
+        medicare_eligible = person("is_medicare_eligible", period.this_year)
+        asset_eligible = person("msp_asset_eligible", period)
+
+        fpg = person("msp_fpg", period)
+        countable_income = person("msp_countable_income", period)
+
+        qmb_income_limit = fpg * p.qmb.fpl_limit
+        slmb_income_limit = fpg * p.slmb.fpl_limit
+
+        income_above_qmb = countable_income > qmb_income_limit
+        income_at_or_below_slmb = countable_income <= slmb_income_limit
+        income_eligible = income_above_qmb & income_at_or_below_slmb
+
+        return medicare_eligible & income_eligible & asset_eligible

policyengine_us/variables/gov/hhs/medicare/savings_programs/category/msp_category.py

@@ -0,0 +1,33 @@
+from policyengine_us.model_api import *
+
+
+class MSPCategory(Enum):
+    NONE = "None"
+    QMB = "Qualified Medicare Beneficiary"
+    SLMB = "Specified Low-Income Medicare Beneficiary"
+    QI = "Qualifying Individual"
+
+
+class msp_category(Variable):
+    value_type = Enum
+    possible_values = MSPCategory
+    default_value = MSPCategory.NONE
+    entity = Person
+    label = "Medicare Savings Program category"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+        "https://www.law.cornell.edu/cfr/text/42/435.121",
+    )
+
+    def formula(person, period, parameters):
+        qmb = person("is_qmb_eligible", period)
+        slmb = person("is_slmb_eligible", period)
+        qi = person("is_qi_eligible", period)
+
+        # Priority: QMB > SLMB > QI (QMB is most comprehensive)
+        return select(
+            [qmb, slmb, qi],
+            [MSPCategory.QMB, MSPCategory.SLMB, MSPCategory.QI],
+            default=MSPCategory.NONE,
+        )

policyengine_us/variables/gov/hhs/medicare/savings_programs/eligibility/msp_asset_eligible.py

@@ -0,0 +1,26 @@
+from policyengine_us.model_api import *
+
+
+class msp_asset_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Medicare Savings Program asset eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+        "https://www.medicareinteractive.org/understanding-medicare/"
+        "cost-saving-programs/medicare-savings-programs-qmb-slmb-qi/"
+        "medicare-savings-program-income-and-asset-limits",
+    )
+
+    def formula(person, period, parameters):
+        p = parameters(period).gov.hhs.medicare.savings_programs.eligibility
+        state_code = person.household("state_code_str", period)
+        # Check if asset test applies (some states have eliminated it)
+        asset_test_applies = p.asset.applies[state_code]
+        # If asset test doesn't apply, everyone is asset-eligible
+        cash_assets = person.spm_unit("spm_unit_cash_assets", period.this_year)
+        married = person.spm_unit("spm_unit_is_married", period)
+        asset_limit = where(married, p.asset.couple, p.asset.individual)
+        meets_asset_test = cash_assets <= asset_limit
+        return where(asset_test_applies, meets_asset_test, True)

policyengine_us/variables/gov/hhs/medicare/savings_programs/eligibility/msp_eligible.py

@@ -0,0 +1,20 @@
+from policyengine_us.model_api import *
+
+
+class msp_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Medicare Savings Program eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+        "https://www.law.cornell.edu/cfr/text/42/435.121",
+    )
+
+    def formula(person, period, parameters):
+        # Must be Medicare eligible
+        medicare_eligible = person("is_medicare_eligible", period.this_year)
+        income_eligible = person("msp_income_eligible", period)
+        asset_eligible = person("msp_asset_eligible", period)
+
+        return medicare_eligible & income_eligible & asset_eligible

policyengine_us/variables/gov/hhs/medicare/savings_programs/eligibility/msp_income_eligible.py

@@ -0,0 +1,26 @@
+from policyengine_us.model_api import *
+
+
+class msp_income_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Medicare Savings Program income eligible"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+        "https://www.law.cornell.edu/cfr/text/42/435.121",
+    )
+
+    def formula(person, period, parameters):
+        # Income eligible if under the QI threshold (135% FPL)
+        # which is the highest threshold for standard MSP levels
+        p = parameters(
+            period
+        ).gov.hhs.medicare.savings_programs.eligibility.income.qi
+        fpg = person("msp_fpg", period)
+        countable_income = person("msp_countable_income", period)
+
+        # Use QI threshold (135% FPL) as the outer bound
+        qi_income_limit = fpg * p.fpl_limit
+
+        return countable_income <= qi_income_limit

policyengine_us/variables/gov/hhs/medicare/savings_programs/income/msp_countable_income.py

@@ -0,0 +1,35 @@
+from policyengine_us.model_api import *
+from policyengine_us.variables.gov.ssa.ssi.eligibility.income._apply_ssi_exclusions import (
+    _apply_ssi_exclusions,
+)
+
+
+class msp_countable_income(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "Medicare Savings Program countable monthly income"
+    definition_period = MONTH
+    reference = (
+        "https://www.law.cornell.edu/uscode/text/42/1396d#p",
+        "https://secure.ssa.gov/apps10/poms.nsf/lnx/0501715010",
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+    documentation = """
+    MSP countable income uses SSI methodology per 42 U.S.C. 1396d(p)(1)(B),
+    which specifies income "determined under section 1382a" (SSI rules).
+    This applies the standard SSI exclusions:
+    1. $20 general income exclusion (from unearned first)
+    2. $65 earned income exclusion
+    3. 50% of remaining earned income excluded
+    """
+
+    def formula(person, period, parameters):
+        # MSP uses SSI income methodology per 42 U.S.C. 1396d(p)(1)(B)
+        earned = person("ssi_earned_income", period.this_year)
+        unearned = person("ssi_unearned_income", period.this_year)
+        # Apply SSI exclusions ($20 general, $65 earned, 50% remaining)
+        annual_countable = _apply_ssi_exclusions(
+            earned, unearned, parameters, period.this_year
+        )
+        return annual_countable / MONTHS_IN_YEAR

policyengine_us/variables/gov/hhs/medicare/savings_programs/income/msp_fpg.py

@@ -0,0 +1,40 @@
+from policyengine_us.model_api import *
+
+
+class msp_fpg(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "MSP Federal Poverty Guideline"
+    definition_period = YEAR
+    reference = (
+        "https://www.law.cornell.edu/uscode/text/42/1396d#p",
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+    documentation = """
+    The Federal Poverty Guideline used for MSP eligibility is based on
+    individual or couple status, not the full household/SPM unit size.
+    Per 42 U.S.C. 1396d(p), MSP income limits are based on the federal
+    poverty line for a family of the size involved.
+
+    Note: Published Medicare.gov limits are $20/month higher than raw FPL
+    because they include the $20 general income exclusion in the threshold.
+    Our implementation applies the $20 exclusion to income instead, which
+    is mathematically equivalent: (income - $20) <= FPL == income <= (FPL + $20)
+    """
+
+    def formula(person, period, parameters):
+        # MSP uses individual (1 person) or couple (2 persons) FPG,
+        # not the full SPM unit size.
+        # Note: These are raw FPL values. Published limits are $20 higher
+        # because we apply the $20 exclusion to income (msp_countable_income)
+        # rather than adding it to the threshold.
+        married = person.spm_unit("spm_unit_is_married", period)
+        state_group = person.household("state_group_str", period)
+        p = parameters(period).gov.hhs.fpg
+        p1 = p.first_person[state_group]
+        pn = p.additional_person[state_group]
+        # 1 person if single, 2 persons if married
+        individual_fpg = p1
+        couple_fpg = p1 + pn
+        return where(married, couple_fpg, individual_fpg)

policyengine_us/variables/gov/hhs/medicare/savings_programs/msp.py

@@ -0,0 +1,15 @@
+from policyengine_us.model_api import *
+
+
+class msp(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "Medicare Savings Program benefit"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+    defined_for = "msp_eligible"
+
+    adds = ["msp_benefit_value"]

policyengine_us/variables/gov/hhs/medicare/savings_programs/msp_benefit_value.py

@@ -0,0 +1,37 @@
+from policyengine_us.model_api import *
+from policyengine_us.variables.gov.hhs.medicare.savings_programs.category.msp_category import (
+    MSPCategory,
+)
+
+
+class msp_benefit_value(Variable):
+    value_type = float
+    entity = Person
+    unit = USD
+    label = "Medicare Savings Program estimated monthly benefit value"
+    definition_period = MONTH
+    reference = (
+        "https://www.medicare.gov/basics/costs/help/medicare-savings-programs",
+    )
+    defined_for = "msp_eligible"
+
+    def formula(person, period, parameters):
+        category = person("msp_category", period)
+
+        # Get premiums (automatically disaggregated from annual to monthly)
+        part_a_premium = person("base_part_a_premium", period)
+        part_b_premium = person("base_part_b_premium", period)
+
+        # Benefit depends on category:
+        # QMB: Part A + Part B premiums (plus deductibles/copays, not modeled)
+        # SLMB: Part B premium only
+        # QI: Part B premium only
+        is_qmb = category == MSPCategory.QMB
+        is_slmb = category == MSPCategory.SLMB
+        is_qi = category == MSPCategory.QI
+
+        return (
+            is_qmb * (part_a_premium + part_b_premium)
+            + is_slmb * part_b_premium
+            + is_qi * part_b_premium
+        )

policyengine_us/variables/gov/irs/income/taxable_income/adjusted_gross_income/irs_gross_income/social_security/taxable_social_security_tier_1.py

@@ -0,0 +1,58 @@
+from policyengine_us.model_api import *
+
+
+class taxable_social_security_tier_1(Variable):
+    value_type = float
+    entity = TaxUnit
+    definition_period = YEAR
+    label = "Taxable Social Security (tier 1)"
+    documentation = "Taxable Social Security from 0-50% taxation tier, credited to OASDI trust funds"
+    unit = USD
+    reference = "https://www.law.cornell.edu/uscode/text/26/86#a_1"
+
+    def formula(tax_unit, period, parameters):
+        p = parameters(period).gov.irs.social_security.taxability
+        gross_ss = tax_unit("tax_unit_social_security", period)
+        combined_income = tax_unit(
+            "tax_unit_combined_income_for_social_security_taxability", period
+        )
+        filing_status = tax_unit("filing_status", period)
+        status = filing_status.possible_values
+        separate = filing_status == status.SEPARATE
+        cohabitating = tax_unit("cohabitating_spouses", period)
+
+        base_amount = where(
+            separate & cohabitating,
+            p.threshold.base.separate_cohabitating,
+            p.threshold.base.main[filing_status],
+        )
+        adjusted_base_amount = where(
+            separate & cohabitating,
+            p.threshold.adjusted_base.separate_cohabitating,
+            p.threshold.adjusted_base.main[filing_status],
+        )
+
+        under_first_threshold = combined_income < base_amount
+        under_second_threshold = combined_income < adjusted_base_amount
+
+        combined_income_excess = tax_unit(
+            "tax_unit_ss_combined_income_excess", period
+        )
+
+        # Tier 1 amount (IRC §86(a)(1))
+        amount_under_paragraph_1 = min_(
+            p.rate.base.benefit_cap * gross_ss,
+            p.rate.base.excess * combined_income_excess,
+        )
+
+        # Bracket amount when in tier 2 (IRC §86(a)(2)(A)(ii))
+        bracket_amount = min_(
+            amount_under_paragraph_1,
+            p.rate.additional.bracket * (adjusted_base_amount - base_amount),
+        )
+
+        return select(
+            [under_first_threshold, under_second_threshold],
+            [0, amount_under_paragraph_1],
+            default=bracket_amount,
+        )

policyengine_us/variables/gov/irs/income/taxable_income/adjusted_gross_income/irs_gross_income/social_security/taxable_social_security_tier_2.py

@@ -0,0 +1,17 @@
+from policyengine_us.model_api import *
+
+
+class taxable_social_security_tier_2(Variable):
+    value_type = float
+    entity = TaxUnit
+    definition_period = YEAR
+    label = "Taxable Social Security (tier 2)"
+    documentation = "Taxable Social Security from 50-85% taxation tier, credited to Medicare HI trust fund"
+    unit = USD
+    reference = "https://www.law.cornell.edu/uscode/text/26/86#a_2"
+
+    # tier_2 = total_taxable - tier_1 capped at 0
+    def formula(tax_unit, period, parameters):
+        tier_1 = tax_unit("taxable_social_security_tier_1", period)
+        total_taxable = tax_unit("tax_unit_taxable_social_security", period)
+        return max_(total_taxable - tier_1, 0)

policyengine_us/variables/gov/irs/income/taxable_income/deductions/qualified_business_income_deduction/qbid_amount.py

@@ -4,14 +4,13 @@ from policyengine_us.model_api import *
 class qbid_amount(Variable):
     value_type = float
     entity = Person
-    label = (
-        "Per-cap qualified business income deduction amount for each person"
-    )
+    label = "Per-person qualified business income deduction amount"
     unit = USD
     definition_period = YEAR
     reference = (
-        "https://www.law.cornell.edu/uscode/text/26/199A#b_1"
-        "https://www.irs.gov/pub/irs-prior/p535--2018.pdf"
+        "https://www.law.cornell.edu/uscode/text/26/199A#b_1",
+        "https://www.irs.gov/pub/irs-prior/p535--2018.pdf",
+        "https://www.irs.gov/pub/irs-pdf/f8995.pdf",
     )
 
     def formula(person, period, parameters):
@@ -53,4 +52,15 @@ class qbid_amount(Variable):
         )
         line26 = max_(0, adj_qbid_max - reduction)
         line12 = where(adj_cap < adj_qbid_max, line26, 0)
-        return max_(line11, line12)  # Worksheet 12-A, line 13
+        # QBI component (Worksheet 12-A, line 13 / Form 8995 Line 5)
+        qbi_component = max_(line11, line12)
+
+        # REIT/PTP component (Form 8995 Lines 6-9)
+        # Per §199A(b)(1)(B), qualified REIT dividends and qualified PTP income
+        # receive a 20% deduction WITHOUT W-2 wage or UBIA limitations
+        reit_ptp_income = person("qualified_reit_and_ptp_income", period)
+        reit_ptp_component = p.max.reit_ptp_rate * max_(0, reit_ptp_income)
+
+        # Total QBID = QBI component + REIT/PTP component
+        # (Form 8995 Line 10: Add lines 5 and 9)
+        return qbi_component + reit_ptp_component