policyengine 3.2.1__tar.gz → 3.2.4__tar.gz

policyengine-3.2.4/.github/check-changelog.sh

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+FRAGMENTS=$(find changelog.d -type f ! -name '.gitkeep' | wc -l)
+if [ "$FRAGMENTS" -eq 0 ]; then
+  echo "::error::No changelog fragment found in changelog.d/"
+  echo "Add one with: echo 'Description.' > changelog.d/\$(git branch --show-current).<type>.md"
+  echo "Types: added, changed, fixed, removed, breaking"
+  exit 1
+fi

{policyengine-3.2.1 → policyengine-3.2.4}/.github/workflows/pr_code_changes.yaml

@@ -7,14 +7,21 @@ on:
       - src/**
       - tests/**
       - .github/**
+      - changelog.d/**
   workflow_dispatch:
 
 jobs:
+  check-changelog:
+    name: Check changelog fragment
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Check for changelog fragment
+        run: .github/check-changelog.sh
   Lint:
     runs-on: ubuntu-latest
     steps:
         - uses: actions/checkout@v4
-        # Check formatting with ruff
         - name: Install ruff
           run: pip install ruff
 
@@ -62,4 +69,4 @@ jobs:
         - name: Run tests with coverage
           run: make test
           env:
-            HUGGING_FACE_TOKEN: ${{ secrets.HUGGING_FACE_TOKEN }}
+            HUGGING_FACE_TOKEN: ${{ secrets.HUGGING_FACE_TOKEN }}

policyengine-3.2.4/.github/workflows/push.yaml

@@ -0,0 +1,160 @@
+# Unified workflow for pushes to main.
+#
+# Phase 1 (normal push): Lint + Test → Docs + Versioning
+#   Versioning commits with message "Update package version".
+#   The commit pushes to main, re-triggering this workflow for Phase 2.
+#
+# Phase 2 (sentinel commit): Publish to PyPI + GitHub Release
+#   Skips Lint + Test since the code is identical to Phase 1.
+
+name: Push to main
+
+on:
+  push:
+    branches:
+      - main
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pages: write
+  id-token: write
+
+jobs:
+  # ── Phase 1 gates (skip on sentinel commit) ─────────────────
+  Lint:
+    if: github.event.head_commit.message != 'Update package version'
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install ruff
+        run: pip install ruff
+      - name: Run ruff format check
+        run: ruff format --check .
+      - name: Run ruff check
+        run: ruff check .
+
+  Test:
+    if: github.event.head_commit.message != 'Update package version'
+    runs-on: macos-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.13', '3.14']
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+          allow-prereleases: true
+      - name: Install package
+        run: uv pip install -e .[dev] --system
+      - name: Install policyengine
+        run: uv pip install policyengine --system
+      - name: Run tests with coverage
+        run: make test
+        env:
+          HUGGING_FACE_TOKEN: ${{ secrets.HUGGING_FACE_TOKEN }}
+
+  # ── Phase 1: Docs + Versioning (skip on sentinel commit) ──
+  Docs:
+    name: Deploy documentation
+    runs-on: ubuntu-latest
+    needs: [Lint, Test]
+    if: github.event.head_commit.message != 'Update package version'
+    concurrency:
+      group: 'pages'
+      cancel-in-progress: false
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    env:
+      BASE_URL: /${{ github.event.repository.name }}
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Pages
+        uses: actions/configure-pages@v3
+      - uses: actions/setup-node@v4
+        with:
+          node-version: 18.x
+      - name: Install MyST
+        run: npm install -g mystmd
+      - name: Build HTML Assets
+        run: cd docs && myst build --html
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: './docs/_build/html'
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
+
+  Versioning:
+    runs-on: ubuntu-latest
+    needs: [Lint, Test]
+    if: github.event.head_commit.message != 'Update package version'
+    steps:
+      - name: Generate GitHub App token
+        id: app-token
+        uses: actions/create-github-app-token@v1
+        with:
+          app-id: ${{ secrets.APP_ID }}
+          private-key: ${{ secrets.APP_PRIVATE_KEY }}
+      - name: Checkout repo
+        uses: actions/checkout@v4
+        with:
+          token: ${{ steps.app-token.outputs.token }}
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.13'
+      - name: Build changelog
+        run: pip install yaml-changelog towncrier && make changelog
+      - name: Preview changelog update
+        run: ".github/get-changelog-diff.sh"
+      - name: Update changelog
+        uses: EndBug/add-and-commit@v9
+        with:
+          add: "."
+          message: Update package version
+
+  # ── Phase 2: Publish (only on sentinel commit) ────────────
+  Publish:
+    runs-on: ubuntu-latest
+    if: github.event.head_commit.message == 'Update package version'
+    env:
+      GH_TOKEN: ${{ github.token }}
+    steps:
+      - name: Checkout repo
+        uses: actions/checkout@v4
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.13'
+      - name: Install package
+        run: uv pip install -e .[dev] --system
+      - name: Install policyengine
+        run: uv pip install policyengine --system
+      - name: Publish a git tag
+        run: ".github/publish-git-tag.sh"
+      - name: Build package
+        run: python -m build
+      - name: Publish a Python distribution to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          user: __token__
+          password: ${{ secrets.PYPI }}
+          skip_existing: true
+      - name: Create GitHub Release
+        run: |
+          VERSION=$(python .github/fetch_version.py)
+          gh release create "$VERSION" \
+            --title "v$VERSION" \
+            --notes "See [CHANGELOG.md](https://github.com/PolicyEngine/policyengine.py/blob/main/CHANGELOG.md) for details." \
+            --latest

{policyengine-3.2.1 → policyengine-3.2.4}/CHANGELOG.md

@@ -1,3 +1,28 @@
+## [3.2.4] - 2026-03-17
+
+### Changed
+
+- Skip redundant Lint and Test in Phase 2 of push workflow since code is identical to Phase 1
+
+
+## [3.2.3] - 2026-03-17
+
+### Fixed
+
+- Use GitHub App token in push workflow Versioning job to enable auto-triggering of Phase 2 (Publish)
+
+
+## [3.2.2] - 2026-03-17
+
+### Changed
+
+- Consolidate CI/CD workflows into a unified push workflow with two-phase sentinel pattern, enforce changelog fragments on PRs
+
+### Fixed
+
+- Use GITHUB_TOKEN instead of missing POLICYENGINE_GITHUB PAT in push workflow
+
+
 ## [3.2.1] - 2026-03-10
 
 ### Changed

{policyengine-3.2.1 → policyengine-3.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: policyengine
-Version: 3.2.1
+Version: 3.2.4
 Summary: A package to conduct policy analysis using PolicyEngine tax-benefit models.
 Author-email: PolicyEngine <hello@policyengine.org>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE

{policyengine-3.2.1 → policyengine-3.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "policyengine"
-version = "3.2.1"
+version = "3.2.4"
 description = "A package to conduct policy analysis using PolicyEngine tax-benefit models."
 readme = "README.md"
 authors = [

{policyengine-3.2.1 → policyengine-3.2.4}/src/policyengine/core/__init__.py

@@ -6,11 +6,18 @@ from .dynamic import Dynamic as Dynamic
 from .output import Output as Output
 from .output import OutputCollection as OutputCollection
 from .parameter import Parameter as Parameter
+from .parameter_node import ParameterNode as ParameterNode
 from .parameter_value import ParameterValue as ParameterValue
 from .policy import Policy as Policy
 from .region import Region as Region
 from .region import RegionRegistry as RegionRegistry
 from .region import RegionType as RegionType
+from .scoping_strategy import RegionScopingStrategy as RegionScopingStrategy
+from .scoping_strategy import RowFilterStrategy as RowFilterStrategy
+from .scoping_strategy import ScopingStrategy as ScopingStrategy
+from .scoping_strategy import (
+    WeightReplacementStrategy as WeightReplacementStrategy,
+)
 from .simulation import Simulation as Simulation
 from .tax_benefit_model import TaxBenefitModel as TaxBenefitModel
 from .tax_benefit_model_version import (
@@ -23,4 +30,5 @@ Dataset.model_rebuild()
 TaxBenefitModelVersion.model_rebuild()
 Variable.model_rebuild()
 Parameter.model_rebuild()
+ParameterNode.model_rebuild()
 ParameterValue.model_rebuild()

policyengine-3.2.4/src/policyengine/core/parameter_node.py

@@ -0,0 +1,29 @@
+from typing import TYPE_CHECKING
+from uuid import uuid4
+
+from pydantic import BaseModel, Field
+
+if TYPE_CHECKING:
+    from .tax_benefit_model_version import TaxBenefitModelVersion
+
+
+class ParameterNode(BaseModel):
+    """Represents a folder/category node in the parameter hierarchy.
+
+    Parameter nodes are intermediate nodes in the parameter tree (e.g., "gov",
+    "gov.hmrc", "gov.hmrc.income_tax"). They provide structure and human-readable
+    labels for navigating the parameter tree, but don't have values themselves.
+
+    Unlike Parameter objects (which are leaf nodes with actual values),
+    ParameterNode objects are purely organizational.
+    """
+
+    model_config = {"arbitrary_types_allowed": True}
+
+    id: str = Field(default_factory=lambda: str(uuid4()))
+    name: str = Field(description="Full path of the node (e.g., 'gov.hmrc')")
+    label: str | None = Field(
+        default=None, description="Human-readable label (e.g., 'HMRC')"
+    )
+    description: str | None = Field(default=None, description="Node description")
+    tax_benefit_model_version: "TaxBenefitModelVersion"

{policyengine-3.2.1 → policyengine-3.2.4}/src/policyengine/core/region.py

@@ -10,6 +10,8 @@ from typing import Literal
 
 from pydantic import BaseModel, Field, PrivateAttr
 
+from .scoping_strategy import ScopingStrategy
+
 # Region type literals for US and UK
 USRegionType = Literal["national", "state", "congressional_district", "place"]
 UKRegionType = Literal["national", "country", "constituency", "local_authority"]
@@ -55,7 +57,13 @@ class Region(BaseModel):
         description="GCS path to dedicated dataset (e.g., 'gs://policyengine-us-data/states/CA.h5')",
     )
 
-    # Filtering configuration (for regions that filter from parent datasets)
+    # Scoping strategy (preferred over legacy filter fields)
+    scoping_strategy: ScopingStrategy | None = Field(
+        default=None,
+        description="Strategy for scoping dataset to this region (row filtering or weight replacement)",
+    )
+
+    # Legacy filtering configuration (kept for backward compatibility)
     requires_filter: bool = Field(
         default=False,
         description="True if this region filters from a parent dataset rather than having its own",

policyengine-3.2.4/src/policyengine/core/scoping_strategy.py

@@ -0,0 +1,224 @@
+"""Region scoping strategies for geographic simulations.
+
+Provides two concrete strategies for scoping datasets to sub-national regions:
+
+1. RowFilterStrategy: Filters dataset rows where a household variable matches
+   a specific value (e.g., UK countries by 'country' field, US places by 'place_fips').
+
+2. WeightReplacementStrategy: Replaces household weights from a pre-computed weight
+   matrix stored in GCS (e.g., UK constituencies and local authorities).
+"""
+
+import logging
+from abc import abstractmethod
+from pathlib import Path
+from typing import Annotated, Literal
+
+import h5py
+import numpy as np
+import pandas as pd
+from microdf import MicroDataFrame
+from pydantic import BaseModel, Discriminator
+
+from policyengine.utils.entity_utils import (
+    filter_dataset_by_household_variable,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class RegionScopingStrategy(BaseModel):
+    """Base class for region scoping strategies.
+
+    Subclasses implement apply() to scope a dataset's entity data
+    to a specific sub-national region.
+    """
+
+    strategy_type: str
+
+    @abstractmethod
+    def apply(
+        self,
+        entity_data: dict[str, MicroDataFrame],
+        group_entities: list[str],
+        year: int,
+    ) -> dict[str, MicroDataFrame]:
+        """Apply the scoping strategy to entity data.
+
+        Args:
+            entity_data: Dict mapping entity names to their MicroDataFrames.
+            group_entities: List of group entity names for this country.
+            year: The simulation year (used for time-indexed weight matrices).
+
+        Returns:
+            A dict mapping entity names to scoped MicroDataFrames.
+        """
+
+    @property
+    def cache_key(self) -> str:
+        """Return a string key for deterministic simulation ID hashing."""
+        return f"{self.strategy_type}:{self.model_dump_json()}"
+
+
+class RowFilterStrategy(RegionScopingStrategy):
+    """Scoping strategy that filters dataset rows by a household variable.
+
+    Used for regions where we want to keep only households matching a
+    specific variable value (e.g., UK countries, US places/cities).
+    """
+
+    strategy_type: Literal["row_filter"] = "row_filter"
+    variable_name: str
+    variable_value: str
+
+    def apply(
+        self,
+        entity_data: dict[str, MicroDataFrame],
+        group_entities: list[str],
+        year: int,
+    ) -> dict[str, MicroDataFrame]:
+        return filter_dataset_by_household_variable(
+            entity_data=entity_data,
+            group_entities=group_entities,
+            variable_name=self.variable_name,
+            variable_value=self.variable_value,
+        )
+
+    @property
+    def cache_key(self) -> str:
+        return f"row_filter:{self.variable_name}={self.variable_value}"
+
+
+class WeightReplacementStrategy(RegionScopingStrategy):
+    """Scoping strategy that replaces household weights from a pre-computed matrix.
+
+    Used for UK constituencies and local authorities. Instead of removing
+    households, this strategy keeps all households but replaces their weights
+    with region-specific values from a weight matrix stored in GCS.
+
+    The weight matrix is an HDF5 file with shape (N_regions x N_households),
+    where each row contains household weights for a specific region.
+    A companion CSV maps region codes/names to row indices.
+    """
+
+    strategy_type: Literal["weight_replacement"] = "weight_replacement"
+    weight_matrix_bucket: str
+    weight_matrix_key: str
+    lookup_csv_bucket: str
+    lookup_csv_key: str
+    region_code: str
+
+    def apply(
+        self,
+        entity_data: dict[str, MicroDataFrame],
+        group_entities: list[str],
+        year: int,
+    ) -> dict[str, MicroDataFrame]:
+        from policyengine_core.tools.google_cloud import download_gcs_file
+
+        # Download lookup CSV and find region index
+        lookup_path = Path(
+            download_gcs_file(
+                bucket=self.lookup_csv_bucket,
+                file_path=self.lookup_csv_key,
+            )
+        )
+        lookup_df = pd.read_csv(lookup_path)
+
+        region_id = self._find_region_index(lookup_df, self.region_code)
+
+        # Download weight matrix and extract weights for this region
+        weights_path = download_gcs_file(
+            bucket=self.weight_matrix_bucket,
+            file_path=self.weight_matrix_key,
+        )
+        with h5py.File(weights_path, "r") as f:
+            weights = f[str(year)][...]
+
+        region_weights = weights[region_id]
+
+        # Validate weight row length matches household count
+        household_df = pd.DataFrame(entity_data["household"])
+        if len(region_weights) != len(household_df):
+            raise ValueError(
+                f"Weight matrix row length ({len(region_weights)}) does not match "
+                f"household count ({len(household_df)}) for region '{self.region_code}'. "
+                f"The weight matrix may be out of date."
+            )
+
+        # Replace household weights
+        result = {}
+        for entity_name, mdf in entity_data.items():
+            df = pd.DataFrame(mdf)
+            if entity_name == "household":
+                df["household_weight"] = region_weights
+                result[entity_name] = MicroDataFrame(df, weights="household_weight")
+            else:
+                weight_col = f"{entity_name}_weight"
+                if weight_col in df.columns:
+                    # Map new household weights to sub-entities via their
+                    # household membership. Build a mapping from household_id
+                    # to new weight.
+                    hh_ids = household_df["household_id"].values
+                    weight_map = dict(zip(hh_ids, region_weights))
+
+                    # Find the entity's household ID column
+                    person_hh_col = self._find_household_id_column(df, entity_name)
+                    if person_hh_col:
+                        new_weights = np.array(
+                            [
+                                weight_map.get(hh_id, 0.0)
+                                for hh_id in df[person_hh_col].values
+                            ]
+                        )
+                        df[weight_col] = new_weights
+
+                result[entity_name] = MicroDataFrame(
+                    df,
+                    weights=(
+                        f"{entity_name}_weight"
+                        if f"{entity_name}_weight" in df.columns
+                        else None
+                    ),
+                )
+
+        return result
+
+    @staticmethod
+    def _find_region_index(lookup_df: pd.DataFrame, region_code: str) -> int:
+        """Find the row index for a region in the lookup CSV.
+
+        Searches by 'code' column first, then 'name' column.
+        """
+        if "code" in lookup_df.columns and region_code in lookup_df["code"].values:
+            return lookup_df[lookup_df["code"] == region_code].index[0]
+        if "name" in lookup_df.columns and region_code in lookup_df["name"].values:
+            return lookup_df[lookup_df["name"] == region_code].index[0]
+        raise ValueError(
+            f"Region '{region_code}' not found in lookup CSV. "
+            f"Available columns: {list(lookup_df.columns)}. "
+            f"Searched 'code' and 'name' columns."
+        )
+
+    @staticmethod
+    def _find_household_id_column(df: pd.DataFrame, entity_name: str) -> str | None:
+        """Find the column linking an entity to its household."""
+        candidates = [
+            "person_household_id",
+            f"{entity_name}_household_id",
+            "household_id",
+        ]
+        for col in candidates:
+            if col in df.columns:
+                return col
+        return None
+
+    @property
+    def cache_key(self) -> str:
+        return f"weight_replacement:{self.weight_matrix_key}:{self.region_code}"
+
+
+ScopingStrategy = Annotated[
+    RowFilterStrategy | WeightReplacementStrategy,
+    Discriminator("strategy_type"),
+]

{policyengine-3.2.1 → policyengine-3.2.4}/src/policyengine/core/simulation.py

@@ -2,12 +2,13 @@ import logging
 from datetime import datetime
 from uuid import uuid4
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, model_validator
 
 from .cache import LRUCache
 from .dataset import Dataset
 from .dynamic import Dynamic
 from .policy import Policy
+from .scoping_strategy import RowFilterStrategy, ScopingStrategy
 from .tax_benefit_model_version import TaxBenefitModelVersion
 
 logger = logging.getLogger(__name__)
@@ -24,7 +25,13 @@ class Simulation(BaseModel):
     dynamic: Dynamic | None = None
     dataset: Dataset = None
 
-    # Regional filtering parameters
+    # Scoping strategy (preferred over legacy filter fields)
+    scoping_strategy: ScopingStrategy | None = Field(
+        default=None,
+        description="Strategy for scoping dataset to a sub-national region",
+    )
+
+    # Legacy regional filtering parameters (kept for backward compatibility)
     filter_field: str | None = Field(
         default=None,
         description="Household-level variable to filter dataset by (e.g., 'place_fips', 'country')",
@@ -35,6 +42,25 @@ class Simulation(BaseModel):
     )
 
     tax_benefit_model_version: TaxBenefitModelVersion = None
+
+    @model_validator(mode="after")
+    def _auto_construct_strategy(self) -> "Simulation":
+        """Auto-construct a RowFilterStrategy from legacy filter fields.
+
+        If filter_field and filter_value are set but scoping_strategy is not,
+        create a RowFilterStrategy for backward compatibility.
+        """
+        if (
+            self.scoping_strategy is None
+            and self.filter_field is not None
+            and self.filter_value is not None
+        ):
+            self.scoping_strategy = RowFilterStrategy(
+                variable_name=self.filter_field,
+                variable_value=self.filter_value,
+            )
+        return self
+
     output_dataset: Dataset | None = None
 
     def run(self):

{policyengine-3.2.1 → policyengine-3.2.4}/src/policyengine/core/tax_benefit_model_version.py

@@ -8,6 +8,7 @@ from .tax_benefit_model import TaxBenefitModel
 
 if TYPE_CHECKING:
     from .parameter import Parameter
+    from .parameter_node import ParameterNode
     from .parameter_value import ParameterValue
     from .region import Region, RegionRegistry
     from .simulation import Simulation
@@ -25,6 +26,7 @@ class TaxBenefitModelVersion(BaseModel):
 
     variables: list["Variable"] = Field(default_factory=list)
     parameters: list["Parameter"] = Field(default_factory=list)
+    parameter_nodes: list["ParameterNode"] = Field(default_factory=list)
 
     # Region registry for geographic simulations
     region_registry: "RegionRegistry | None" = Field(
@@ -43,6 +45,9 @@ class TaxBenefitModelVersion(BaseModel):
     parameters_by_name: dict[str, "Parameter"] = Field(
         default_factory=dict, exclude=True
     )
+    parameter_nodes_by_name: dict[str, "ParameterNode"] = Field(
+        default_factory=dict, exclude=True
+    )
 
     def run(self, simulation: "Simulation") -> "Simulation":
         raise NotImplementedError(
@@ -69,6 +74,11 @@ class TaxBenefitModelVersion(BaseModel):
         self.variables.append(var)
         self.variables_by_name[var.name] = var
 
+    def add_parameter_node(self, node: "ParameterNode") -> None:
+        """Add a parameter node and index it for fast lookup."""
+        self.parameter_nodes.append(node)
+        self.parameter_nodes_by_name[node.name] = node
+
     def get_parameter(self, name: str) -> "Parameter":
         """Get a parameter by name (O(1) lookup)."""
         if name in self.parameters_by_name:
@@ -85,6 +95,14 @@ class TaxBenefitModelVersion(BaseModel):
             f"Variable '{name}' not found in {self.model.id} version {self.version}"
         )
 
+    def get_parameter_node(self, name: str) -> "ParameterNode":
+        """Get a parameter node by name (O(1) lookup)."""
+        if name in self.parameter_nodes_by_name:
+            return self.parameter_nodes_by_name[name]
+        raise ValueError(
+            f"ParameterNode '{name}' not found in {self.model.id} version {self.version}"
+        )
+
     def get_region(self, code: str) -> "Region | None":
         """Get a region by its code.
 
@@ -99,5 +117,5 @@ class TaxBenefitModelVersion(BaseModel):
         return self.region_registry.get(code)
 
     def __repr__(self) -> str:
-        # Give the id and version, and the number of variables, parameters, parameter values
-        return f"<TaxBenefitModelVersion id={self.id} variables={len(self.variables)} parameters={len(self.parameters)} parameter_values={len(self.parameter_values)}>"
+        # Give the id and version, and the number of variables, parameters, parameter nodes, parameter values
+        return f"<TaxBenefitModelVersion id={self.id} variables={len(self.variables)} parameters={len(self.parameters)} parameter_nodes={len(self.parameter_nodes)} parameter_values={len(self.parameter_values)}>"

{policyengine-3.2.1 → policyengine-3.2.4}/src/policyengine/core/variable.py

@@ -8,6 +8,7 @@ from .tax_benefit_model_version import TaxBenefitModelVersion
 class Variable(BaseModel):
     id: str
     name: str
+    label: str | None = None
     tax_benefit_model_version: TaxBenefitModelVersion
     entity: str
     description: str | None = None
@@ -15,3 +16,5 @@ class Variable(BaseModel):
     possible_values: list[Any] | None = None
     default_value: Any = None
     value_type: type | None = None
+    adds: list[str] | None = None
+    subtracts: list[str] | None = None