policyengine-us 1.450.0__py3-none-any.whl → 1.504.0__py3-none-any.whl

policyengine_us/tests/policy/contrib/states/va/exemption_reform_test.yaml

@@ -0,0 +1,182 @@
+- name: VA exemption reform - restrict to children under 18
+  period: 2025
+  reforms: policyengine_us.reforms.states.va.dependent_exemption.va_dependent_exemption_reform.va_dependent_exemption_reform
+  input:
+    gov.contrib.states.va.dependent_exemption.in_effect: true
+    gov.contrib.states.va.dependent_exemption.amount: 930
+    gov.contrib.states.va.dependent_exemption.age_limit.in_effect: true
+    gov.contrib.states.va.dependent_exemption.age_limit.threshold: 18
+    people:
+      parent:
+        age: 40
+        employment_income: 60_000
+      child1:
+        age: 16
+        is_tax_unit_dependent: true
+      child2:
+        age: 20
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [parent, child1, child2]
+        filing_status: SINGLE
+    households:
+      household:
+        members: [parent, child1, child2]
+        state_name: VA
+  output:
+    # 1 personal (930) + 1 eligible dependent (930) + 1 older dependent (930)
+    va_personal_exemption: 2_790
+
+- name: VA exemption reform - restrict to children under 13
+  period: 2025
+  reforms: policyengine_us.reforms.states.va.dependent_exemption.va_dependent_exemption_reform.va_dependent_exemption_reform
+  input:
+    gov.contrib.states.va.dependent_exemption.in_effect: true
+    gov.contrib.states.va.dependent_exemption.amount: 930
+    gov.contrib.states.va.dependent_exemption.age_limit.in_effect: true
+    gov.contrib.states.va.dependent_exemption.age_limit.threshold: 13
+    people:
+      parent:
+        age: 40
+        employment_income: 60_000
+      child1:
+        age: 10
+        is_tax_unit_dependent: true
+      child2:
+        age: 16
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [parent, child1, child2]
+        filing_status: SINGLE
+    households:
+      household:
+        members: [parent, child1, child2]
+        state_name: VA
+  output:
+    # 1 personal (930) + 1 eligible dependent (930) + 1 older dependent (930)
+    va_personal_exemption: 2_790
+
+- name: VA exemption reform - different amounts for dependent children
+  period: 2025
+  reforms: policyengine_us.reforms.states.va.dependent_exemption.va_dependent_exemption_reform.va_dependent_exemption_reform
+  input:
+    gov.contrib.states.va.dependent_exemption.in_effect: true
+    gov.contrib.states.va.dependent_exemption.amount: 2_000
+    gov.contrib.states.va.dependent_exemption.age_limit.in_effect: true
+    gov.contrib.states.va.dependent_exemption.age_limit.threshold: 18
+    people:
+      parent:
+        age: 40
+        employment_income: 60_000
+      child1:
+        age: 10
+        is_tax_unit_dependent: true
+      child2:
+        age: 16
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [parent, child1, child2]
+        filing_status: SINGLE
+    households:
+      household:
+        members: [parent, child1, child2]
+        state_name: VA
+  output:
+    # 1 personal (930) + 2 eligible dependents (2_000 each = 4_000) = 4_930
+    va_personal_exemption: 4_930
+
+- name: VA exemption reform - AGI phaseout
+  period: 2025
+  reforms: policyengine_us.reforms.states.va.dependent_exemption.va_dependent_exemption_reform.va_dependent_exemption_reform
+  input:
+    gov.contrib.states.va.dependent_exemption.in_effect: true
+    gov.contrib.states.va.dependent_exemption.amount: 930
+    gov.contrib.states.va.dependent_exemption.phaseout.threshold.SINGLE: 100_000
+    gov.contrib.states.va.dependent_exemption.phaseout.rate: 0.05
+    people:
+      parent:
+        age: 40
+        employment_income: 120_000
+      child1:
+        age: 10
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [parent, child1]
+        filing_status: SINGLE
+    households:
+      household:
+        members: [parent, child1]
+        state_name: VA
+  output:
+    # Personal exemption: 930 (baseline)
+    # Dependent exemption before phaseout: 930
+    # Phaseout: (120_000 - 100_000) * 0.05 = 1_000 (only applies to dependent exemption)
+    # Dependent exemption after phaseout: max(930 - 1_000, 0) = 0
+    # Final: 930 (personal) + 0 (dependent) = 930
+    va_personal_exemption: 930
+
+- name: VA exemption reform - joint filing
+  period: 2025
+  reforms: policyengine_us.reforms.states.va.dependent_exemption.va_dependent_exemption_reform.va_dependent_exemption_reform
+  input:
+    gov.contrib.states.va.dependent_exemption.in_effect: true
+    gov.contrib.states.va.dependent_exemption.amount: 2_000
+    gov.contrib.states.va.dependent_exemption.age_limit.in_effect: true
+    gov.contrib.states.va.dependent_exemption.age_limit.threshold: 18
+    people:
+      parent1:
+        age: 40
+        is_tax_unit_head: true
+        employment_income: 60_000
+      parent2:
+        age: 38
+        is_tax_unit_spouse: true
+        employment_income: 40_000
+      child1:
+        age: 10
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [parent1, parent2, child1]
+        filing_status: JOINT
+    households:
+      household:
+        members: [parent1, parent2, child1]
+        state_name: VA
+  output:
+    # 2 personal exemptions (930 * 2 = 1_860) + 1 eligible dependent (2_000) = 3_860
+    va_personal_exemption: 3_860
+
+- name: VA exemption reform - no age limit (all dependents eligible)
+  period: 2025
+  reforms: policyengine_us.reforms.states.va.dependent_exemption.va_dependent_exemption_reform.va_dependent_exemption_reform
+  input:
+    gov.contrib.states.va.dependent_exemption.in_effect: true
+    gov.contrib.states.va.dependent_exemption.amount: 2_000
+    gov.contrib.states.va.dependent_exemption.age_limit.in_effect: false
+    people:
+      parent:
+        age: 40
+        employment_income: 60_000
+      child1:
+        age: 10
+        is_tax_unit_dependent: true
+      child2:
+        age: 22
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [parent, child1, child2]
+        filing_status: SINGLE
+    households:
+      household:
+        members: [parent, child1, child2]
+        state_name: VA
+  output:
+    # 1 personal (930) + 2 eligible dependents (2_000 each = 4_000) = 4_930
+    # No older dependents since age limit is not in effect
+    va_personal_exemption: 4_930

policyengine_us/tests/policy/reform/cdcc_single_parent_work_requirement.yaml

@@ -0,0 +1,154 @@
+# Tests for CDCTC reform that makes families eligible if at least one parent works
+# instead of requiring both parents to work
+#
+# NOTE: This reform overrides cdcc_relevant_expenses directly (not min_head_spouse_earned)
+# to avoid affecting state programs that use min_head_spouse_earned.
+
+- name: One-earner married couple gets CDCC under reform
+  period: 2024
+  reforms: policyengine_us.reforms.cdcc.cdcc_single_parent_work_requirement.cdcc_single_parent_work_requirement
+  input:
+    people:
+      adult1:
+        age: 35
+        is_tax_unit_head: true
+        employment_income: 50_000
+      adult2:
+        age: 35
+        is_tax_unit_spouse: true
+        employment_income: 0
+      child:
+        age: 5
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [adult1, adult2, child]
+        tax_unit_childcare_expenses: 5_000
+    households:
+      household:
+        members: [adult1, adult2, child]
+        state_code: CA
+  output:
+    # min_head_spouse_earned is NOT modified by this reform (unchanged from baseline)
+    min_head_spouse_earned: 0
+    # Reform calculates: min(expenses, cdcc_limit, max(head, spouse))
+    # = min($5,000, $3,000, max($50,000, $0)) = min($5,000, $3,000, $50,000) = $3,000
+    cdcc_relevant_expenses: 3_000
+
+- name: One-earner married couple - baseline would give zero
+  period: 2024
+  # No reform - baseline behavior
+  input:
+    people:
+      adult1:
+        age: 35
+        is_tax_unit_head: true
+        employment_income: 50_000
+      adult2:
+        age: 35
+        is_tax_unit_spouse: true
+        employment_income: 0
+      child:
+        age: 5
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [adult1, adult2, child]
+        tax_unit_childcare_expenses: 5_000
+    households:
+      household:
+        members: [adult1, adult2, child]
+        state_code: CA
+  output:
+    # Baseline uses min(head_earned, spouse_earned) = min($50,000, $0) = $0
+    min_head_spouse_earned: 0
+    # No relevant expenses since capped at $0
+    cdcc_relevant_expenses: 0
+    cdcc: 0
+
+- name: Two-earner married couple unchanged by reform
+  period: 2024
+  reforms: policyengine_us.reforms.cdcc.cdcc_single_parent_work_requirement.cdcc_single_parent_work_requirement
+  input:
+    people:
+      adult1:
+        age: 35
+        is_tax_unit_head: true
+        employment_income: 50_000
+      adult2:
+        age: 35
+        is_tax_unit_spouse: true
+        employment_income: 30_000
+      child:
+        age: 5
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [adult1, adult2, child]
+        tax_unit_childcare_expenses: 5_000
+    households:
+      household:
+        members: [adult1, adult2, child]
+        state_code: CA
+  output:
+    # min_head_spouse_earned unchanged: min($50,000, $30,000) = $30,000
+    min_head_spouse_earned: 30_000
+    # Reform: min($5,000, $3,000, max($50,000, $30,000)) = min($5,000, $3,000, $50,000) = $3,000
+    # Same as baseline since both earnings exceed the $3,000 limit
+    cdcc_relevant_expenses: 3_000
+
+- name: Single parent unaffected by reform
+  period: 2024
+  reforms: policyengine_us.reforms.cdcc.cdcc_single_parent_work_requirement.cdcc_single_parent_work_requirement
+  input:
+    people:
+      adult:
+        age: 35
+        is_tax_unit_head: true
+        employment_income: 40_000
+      child:
+        age: 5
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [adult, child]
+        tax_unit_childcare_expenses: 4_000
+    households:
+      household:
+        members: [adult, child]
+        state_code: CA
+  output:
+    # Single filer - min_head_spouse_earned uses head_earned
+    min_head_spouse_earned: 40_000
+    # Reform: min($4,000, $3,000, $40,000) = $3,000 (same as baseline)
+    cdcc_relevant_expenses: 3_000
+
+- name: Spouse is the only earner - reform enables credit
+  period: 2024
+  reforms: policyengine_us.reforms.cdcc.cdcc_single_parent_work_requirement.cdcc_single_parent_work_requirement
+  input:
+    people:
+      adult1:
+        age: 35
+        is_tax_unit_head: true
+        employment_income: 0
+      adult2:
+        age: 35
+        is_tax_unit_spouse: true
+        employment_income: 60_000
+      child:
+        age: 3
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [adult1, adult2, child]
+        tax_unit_childcare_expenses: 8_000
+    households:
+      household:
+        members: [adult1, adult2, child]
+        state_code: CA
+  output:
+    # min_head_spouse_earned unchanged: min($0, $60,000) = $0
+    min_head_spouse_earned: 0
+    # Reform: min($8,000, $3,000, max($0, $60,000)) = min($8,000, $3,000, $60,000) = $3,000
+    cdcc_relevant_expenses: 3_000

policyengine_us/tests/run_selective_tests.py

@@ -60,6 +60,11 @@ class SelectiveTestRunner:
                 "file_pattern": r"policyengine_us/variables/household/",
                 "test_pattern": r"policyengine_us/tests/policy/baseline/household",
             },
+            # Match household variables to microsimulation tests (for dataset-level tests)
+            {
+                "file_pattern": r"policyengine_us/variables/household/",
+                "test_pattern": r"policyengine_us/tests/microsimulation",
+            },
             # Match reforms in specific states
             {
                 "file_pattern": r"policyengine_us/reforms/states/([^/]+)",

policyengine_us/tests/test_batched.py

@@ -10,6 +10,7 @@ import os
 import gc
 import time
 import argparse
+import re
 from pathlib import Path
 from typing import List, Dict
 
@@ -21,71 +22,160 @@ 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)
     """
-    # Special handling for contrib tests - each folder is its own batch
+    if exclude is None:
+        exclude = []
+
+    # Special handling for contrib tests - split into 7 batches by memory usage
     # Only apply to policy/contrib (structural tests), not baseline/contrib
     if str(base_path).endswith("policy/contrib"):
-        # Get all subdirectories and sort them alphabetically
+        # Define batches by memory usage (measured empirically)
+        BATCH_1 = ["federal", "harris", "treasury"]  # ~9.0 GB
+        BATCH_2 = ["ctc", "snap_ea", "ubi_center"]  # ~8.6 GB
+        BATCH_3 = ["deductions", "aca", "snap"]  # ~8.1 GB
+        BATCH_4 = [
+            "tax_exempt",
+            "eitc",
+            "state_dependent_exemptions",
+            "additional_tax_bracket",
+        ]  # ~8.0 GB
+        # Batch 5 is the catch-all for unknown/new folders (~7.8 GB + headroom)
+        BATCH_5_DEFINED = [
+            "local",
+            "dc_single_joint_threshold_ratio.yaml",
+            "reconciliation",
+            "dc_kccatc.yaml",
+            "reported_state_income_tax.yaml",
+        ]
+        BATCH_6 = ["crfb"]  # ~8.9 GB, always alone
+        BATCH_7 = ["congress"]  # ~6.3 GB
+
+        # Get all subdirectories (excluding states which is in Heavy job)
         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
+        # Get root level YAML files
         root_files = sorted(list(base_path.glob("*.yaml")))
 
-        # Create one batch per subdirectory
-        batches = []
+        # Build batches
+        def get_batch_paths(batch_names, subdirs, root_files):
+            paths = []
+            for name in batch_names:
+                # Check if it's a directory
+                for subdir in subdirs:
+                    if subdir.name == name:
+                        paths.append(str(subdir))
+                        break
+                # Check if it's a root file
+                for f in root_files:
+                    if f.name == name:
+                        paths.append(str(f))
+                        break
+            return paths
+
+        # Collect known folders/files
+        all_known = set(
+            BATCH_1
+            + BATCH_2
+            + BATCH_3
+            + BATCH_4
+            + BATCH_5_DEFINED
+            + BATCH_6
+            + BATCH_7
+        )
+
+        # Find unknown folders/files (new additions go to Batch 5)
+        unknown = []
         for subdir in subdirs:
-            batches.append([str(subdir)])
+            if subdir.name not in all_known:
+                unknown.append(str(subdir))
+        for f in root_files:
+            if f.name not in all_known:
+                unknown.append(str(f))
+
+        # Build all batches
+        batch1 = get_batch_paths(BATCH_1, subdirs, root_files)
+        batch2 = get_batch_paths(BATCH_2, subdirs, root_files)
+        batch3 = get_batch_paths(BATCH_3, subdirs, root_files)
+        batch4 = get_batch_paths(BATCH_4, subdirs, root_files)
+        batch5 = (
+            get_batch_paths(BATCH_5_DEFINED, subdirs, root_files) + unknown
+        )
+        batch6 = get_batch_paths(BATCH_6, subdirs, root_files)
+        batch7 = get_batch_paths(BATCH_7, subdirs, root_files)
 
-        # If there are root files, group them together in their own batch
-        if root_files:
-            root_batch = [str(file) for file in root_files]
-            batches.append(root_batch)
+        # Return non-empty batches in order
+        batches = []
+        for batch in [batch1, batch2, batch3, batch4, batch5, batch6, batch7]:
+            if batch:
+                batches.append(batch)
 
         return batches
 
+    # Special handling for contrib/states - each subfolder is its own batch
+    # to allow garbage collection between state tests
+    # Memory usage per state varies significantly (1.3 GB - 5.2 GB measured)
+    # Note: contrib/congress runs all together (~6.3 GB total, under 7 GB limit)
+    if str(base_path).endswith("contrib/states"):
+        subdirs = sorted(
+            [item for item in base_path.iterdir() if item.is_dir()]
+        )
+        # Each state folder becomes its own batch
+        batches = [[str(subdir)] for subdir in subdirs]
+
+        # Also include any root-level YAML files as a separate batch
+        root_files = sorted(list(base_path.glob("*.yaml")))
+        if root_files:
+            batches.append([str(file) for file in root_files])
+
+        return batches if batches else [[str(base_path)]]
+
     # Special handling for reform tests - run all together in one batch
     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 states directory - support excluding specific states
+    if str(base_path).endswith("gov/states"):
+        subdirs = sorted(
+            [
+                item
+                for item in base_path.iterdir()
+                if item.is_dir() and item.name not in exclude
+            ]
+        )
+        # Return all non-excluded state directories as a single batch
+        if subdirs:
+            return [[str(subdir) for subdir in subdirs]]
+        return []
+
+    # 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 +187,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))
+                        batch.append(str(item))
 
-            return [batch1, batch2] if batch2 else [batch1]
+            return [batch] if batch else []
 
-    # Default behavior for non-baseline or different batch counts
-    dir_counts = get_test_directories(base_path)
-
-    if num_batches <= 0:
-        num_batches = 1
-
-    # 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
-
-    # 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:
@@ -199,15 +257,16 @@ def run_batch(test_paths: List[str], batch_name: str) -> Dict:
             # Detect pytest completion
             # Look for patterns like "====== 5638 passed in 491.24s ======"
             # or "====== 2 failed, 5636 passed in 500s ======"
-            import re
-
             if re.search(r"=+.*\d+\s+(passed|failed).*in\s+[\d.]+s.*=+", line):
                 test_completed = True
-                # Check if tests passed (no failures mentioned or 0 failed)
-                if "failed" not in line or "0 failed" in line:
-                    test_passed = True
+                # Check if tests passed by parsing actual failure count
+                failed_match = re.search(r"(\d+) failed", line)
+                if failed_match:
+                    failed_count = int(failed_match.group(1))
+                    test_passed = failed_count == 0
                 else:
-                    test_passed = False
+                    # No "X failed" in line means all passed
+                    test_passed = True
 
                 print(f"\n    Tests completed, terminating process...")
 
@@ -298,8 +357,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 +380,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/tools/variables.py

@@ -13,9 +13,7 @@ def add_n(word):
 
 def print_variable_summary(variable_name: str):
     variable = variables.get(variable_name)
-    return Markdown(
-        f"""
+    return Markdown(f"""
         ## {variable.name}
         This variable models a{add_n(variable.entity.label)}**{variable.entity.label}**'s **{variable.label}**.
-        """
-    )
+        """)