policyengine 3.0.0__py3-none-any.whl → 3.1.1__py3-none-any.whl

policyengine/utils/plotting.py

@@ -0,0 +1,179 @@
+"""Plotting utilities for PolicyEngine visualisations."""
+
+
+import plotly.graph_objects as go
+
+# PolicyEngine brand colours
+COLORS = {
+    "primary": "#319795",  # Teal
+    "primary_light": "#E6FFFA",
+    "primary_dark": "#1D4044",
+    "success": "#22C55E",  # Green (positive changes)
+    "warning": "#FEC601",  # Yellow (cautions)
+    "error": "#EF4444",  # Red (negative changes)
+    "info": "#1890FF",  # Blue (neutral info)
+    "gray_light": "#F2F4F7",
+    "gray": "#667085",
+    "gray_dark": "#101828",
+    "blue_secondary": "#026AA2",
+}
+
+# Typography
+FONT_FAMILY = (
+    "Inter, -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif"
+)
+FONT_SIZE_LABEL = 12
+FONT_SIZE_DEFAULT = 14
+FONT_SIZE_TITLE = 16
+
+
+def format_fig(
+    fig: go.Figure,
+    title: str | None = None,
+    xaxis_title: str | None = None,
+    yaxis_title: str | None = None,
+    show_legend: bool = True,
+    height: int | None = None,
+    width: int | None = None,
+) -> go.Figure:
+    """Apply PolicyEngine visual style to a plotly figure.
+
+    Applies professional, clean styling following PolicyEngine design principles:
+    - Data-driven clarity prioritising immediate understanding
+    - Professional brand colours (teal primary, semantic colours)
+    - Clean typography with Inter font family
+    - Minimal visual clutter
+    - Appropriate spacing and margins
+
+    Args:
+        fig: Plotly figure to format
+        title: Optional title to set/override
+        xaxis_title: Optional x-axis title to set/override
+        yaxis_title: Optional y-axis title to set/override
+        show_legend: Whether to show the legend (default: True)
+        height: Optional height in pixels
+        width: Optional width in pixels
+
+    Returns:
+        Formatted plotly figure (same object, modified in place)
+
+    Example:
+        >>> import plotly.graph_objects as go
+        >>> from policyengine.utils import format_fig
+        >>> fig = go.Figure(data=go.Scatter(x=[1, 2, 3], y=[4, 5, 6]))
+        >>> format_fig(fig, title="Example chart", xaxis_title="X", yaxis_title="Y")
+    """
+    # Build layout updates
+    layout_updates = {
+        "font": {
+            "family": FONT_FAMILY,
+            "size": FONT_SIZE_DEFAULT,
+            "color": COLORS["gray_dark"],
+        },
+        "plot_bgcolor": "#FAFAFA",
+        "paper_bgcolor": "white",
+        "margin": {"l": 100, "r": 60, "t": 100, "b": 80},
+        "showlegend": show_legend,
+        "xaxis": {
+            "title": {
+                "font": {
+                    "size": FONT_SIZE_DEFAULT,
+                    "family": FONT_FAMILY,
+                    "color": COLORS["gray_dark"],
+                },
+                "standoff": 20,
+            },
+            "tickfont": {
+                "size": FONT_SIZE_LABEL,
+                "family": FONT_FAMILY,
+                "color": COLORS["gray"],
+            },
+            "showgrid": False,
+            "showline": True,
+            "linewidth": 2,
+            "linecolor": COLORS["gray_light"],
+            "zeroline": False,
+            "ticks": "outside",
+            "tickwidth": 1,
+            "tickcolor": COLORS["gray_light"],
+        },
+        "yaxis": {
+            "title": {
+                "font": {
+                    "size": FONT_SIZE_DEFAULT,
+                    "family": FONT_FAMILY,
+                    "color": COLORS["gray_dark"],
+                },
+                "standoff": 20,
+            },
+            "tickfont": {
+                "size": FONT_SIZE_LABEL,
+                "family": FONT_FAMILY,
+                "color": COLORS["gray"],
+            },
+            "showgrid": True,
+            "gridwidth": 1,
+            "gridcolor": "#E5E7EB",
+            "showline": False,
+            "zeroline": False,
+        },
+        "legend": {
+            "bgcolor": "white",
+            "bordercolor": COLORS["gray_light"],
+            "borderwidth": 1,
+            "font": {"size": FONT_SIZE_LABEL, "family": FONT_FAMILY},
+            "orientation": "v",
+            "yanchor": "top",
+            "y": 0.99,
+            "xanchor": "right",
+            "x": 0.99,
+        },
+    }
+
+    # Add optional parameters
+    if title is not None:
+        layout_updates["title"] = {
+            "text": title,
+            "font": {
+                "size": 18,
+                "family": FONT_FAMILY,
+                "color": COLORS["gray_dark"],
+                "weight": 600,
+            },
+            "x": 0,
+            "xanchor": "left",
+            "y": 0.98,
+            "yanchor": "top",
+        }
+
+    if xaxis_title is not None:
+        layout_updates["xaxis"]["title"]["text"] = xaxis_title
+
+    if yaxis_title is not None:
+        layout_updates["yaxis"]["title"]["text"] = yaxis_title
+
+    if height is not None:
+        layout_updates["height"] = height
+
+    if width is not None:
+        layout_updates["width"] = width
+
+    # Apply layout
+    fig.update_layout(**layout_updates)
+
+    # Update all traces to have cleaner styling
+    fig.update_traces(
+        marker=dict(size=8, line=dict(width=0)),
+        line=dict(width=3),
+        selector=dict(mode="markers+lines"),
+    )
+    fig.update_traces(
+        marker=dict(size=8, line=dict(width=0)),
+        selector=dict(mode="markers"),
+    )
+    fig.update_traces(
+        line=dict(width=3),
+        selector=dict(mode="lines"),
+    )
+
+    return fig

{policyengine-3.0.0.dist-info → policyengine-3.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: policyengine
-Version: 3.0.0
+Version: 3.1.1
 Summary: A package to conduct policy analysis using PolicyEngine tax-benefit models.
 Author-email: PolicyEngine <hello@policyengine.org>
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
@@ -668,20 +668,11 @@ License:                     GNU AFFERO GENERAL PUBLIC LICENSE
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: sqlalchemy>=2.0.0
-Requires-Dist: sqlmodel>=0.0.21
-Requires-Dist: alembic>=1.13.0
-Requires-Dist: psycopg2-binary>=2.9.0
-Requires-Dist: pymysql>=1.1.0
-Requires-Dist: google-cloud-storage>=2.10.0
-Requires-Dist: getpass4
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: pandas>=2.0.0
-Requires-Dist: rich>=13.0.0
-Requires-Dist: ipywidgets>=8.0.0
 Requires-Dist: microdf_python
-Requires-Dist: tqdm>=4.67.1
-Requires-Dist: blosc>=1.11.3
+Requires-Dist: plotly>=5.0.0
+Requires-Dist: requests>=2.31.0
 Provides-Extra: uk
 Requires-Dist: policyengine_core>=3.10; extra == "uk"
 Requires-Dist: policyengine-uk>=2.51.0; extra == "uk"
@@ -706,13 +697,187 @@ Dynamic: license-file
 
 # PolicyEngine.py
 
-Documentation
+A Python package for tax-benefit microsimulation analysis. Run policy simulations, analyse distributional impacts, and visualise results across the UK and US.
 
-- Parameters, variables, and values: `docs/01_parameters_variables.ipynb`
-- Policies and dynamic: `docs/02_policies_dynamic.ipynb`
-- Datasets: `docs/03_datasets.ipynb`
-- Simulations: `docs/04_simulations.ipynb`
-- Output data items: `docs/05_output_data_items.ipynb`
-- Reports and users: `docs/06_reports_users.ipynb`
+## Quick start
 
-Open these notebooks in Jupyter or your preferred IDE to run the examples.
+```python
+from policyengine.core import Simulation
+from policyengine.tax_benefit_models.uk import PolicyEngineUKDataset, uk_latest
+from policyengine.outputs.aggregate import Aggregate, AggregateType
+
+# Load representative microdata
+dataset = PolicyEngineUKDataset(
+    name="FRS 2023-24",
+    filepath="./data/frs_2023_24_year_2026.h5",
+    year=2026,
+)
+
+# Run simulation
+simulation = Simulation(
+    dataset=dataset,
+    tax_benefit_model_version=uk_latest,
+)
+simulation.run()
+
+# Calculate total universal credit spending
+agg = Aggregate(
+    simulation=simulation,
+    variable="universal_credit",
+    aggregate_type=AggregateType.SUM,
+    entity="benunit",
+)
+agg.run()
+print(f"Total UC spending: £{agg.result / 1e9:.1f}bn")
+```
+
+## Documentation
+
+**Core concepts:**
+- [Core concepts](docs/core-concepts.md): Architecture, datasets, simulations, outputs
+- [UK tax-benefit model](docs/country-models-uk.md): Entities, parameters, examples
+- [US tax-benefit model](docs/country-models-us.md): Entities, parameters, examples
+
+**Examples:**
+- `examples/income_distribution_us.py`: Analyse benefit distribution by decile
+- `examples/employment_income_variation_uk.py`: Model employment income phase-outs
+- `examples/policy_change_uk.py`: Analyse policy reform impacts
+
+## Installation
+
+```bash
+pip install policyengine
+```
+
+## Features
+
+- **Multi-country support**: UK and US tax-benefit systems
+- **Representative microdata**: Load FRS, CPS, or create custom scenarios
+- **Policy reforms**: Parametric reforms with date-bound parameter values
+- **Distributional analysis**: Aggregate statistics by income decile, demographics
+- **Entity mapping**: Automatic mapping between person, household, tax unit levels
+- **Visualisation**: PolicyEngine-branded charts with Plotly
+
+## Key concepts
+
+### Datasets
+
+Datasets contain microdata at entity level (person, household, tax unit). Load representative data or create custom scenarios:
+
+```python
+from policyengine.tax_benefit_models.uk import PolicyEngineUKDataset
+
+dataset = PolicyEngineUKDataset(
+    name="Representative data",
+    filepath="./data/frs_2023_24_year_2026.h5",
+    year=2026,
+)
+dataset.load()
+```
+
+### Simulations
+
+Simulations apply tax-benefit models to datasets:
+
+```python
+from policyengine.core import Simulation
+from policyengine.tax_benefit_models.uk import uk_latest
+
+simulation = Simulation(
+    dataset=dataset,
+    tax_benefit_model_version=uk_latest,
+)
+simulation.run()
+
+# Access calculated variables
+output = simulation.output_dataset.data
+print(output.household[["household_net_income", "household_benefits"]])
+```
+
+### Outputs
+
+Extract insights with aggregate statistics:
+
+```python
+from policyengine.outputs.aggregate import Aggregate, AggregateType
+
+# Mean income in top decile
+agg = Aggregate(
+    simulation=simulation,
+    variable="household_net_income",
+    aggregate_type=AggregateType.MEAN,
+    filter_variable="household_net_income",
+    quantile=10,
+    quantile_eq=10,
+)
+agg.run()
+print(f"Top decile mean income: £{agg.result:,.0f}")
+```
+
+### Policy reforms
+
+Apply parametric reforms:
+
+```python
+from policyengine.core import Policy, Parameter, ParameterValue
+import datetime
+
+parameter = Parameter(
+    name="gov.hmrc.income_tax.allowances.personal_allowance.amount",
+    tax_benefit_model_version=uk_latest,
+    data_type=float,
+)
+
+policy = Policy(
+    name="Increase personal allowance",
+    parameter_values=[
+        ParameterValue(
+            parameter=parameter,
+            start_date=datetime.date(2026, 1, 1),
+            end_date=datetime.date(2026, 12, 31),
+            value=15000,
+        )
+    ],
+)
+
+# Run reform simulation
+reform_sim = Simulation(
+    dataset=dataset,
+    tax_benefit_model_version=uk_latest,
+    policy=policy,
+)
+reform_sim.run()
+```
+
+## Country models
+
+### UK
+
+Three entity levels:
+- **Person**: Individual with income and demographics
+- **Benunit**: Benefit unit (single person or couple with children)
+- **Household**: Residence unit
+
+Key benefits: Universal Credit, Child Benefit, Pension Credit
+Key taxes: Income tax, National Insurance
+
+### US
+
+Six entity levels:
+- **Person**: Individual
+- **Tax unit**: Federal tax filing unit
+- **SPM unit**: Supplemental Poverty Measure unit
+- **Family**: Census family definition
+- **Marital unit**: Married couple or single person
+- **Household**: Residence unit
+
+Key benefits: SNAP, TANF, EITC, CTC, SSI, Social Security
+Key taxes: Federal income tax, payroll tax
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md) for development setup and guidelines.
+
+## License
+
+AGPL-3.0

policyengine-3.1.1.dist-info/RECORD

@@ -0,0 +1,39 @@
+policyengine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+policyengine/__pycache__/__init__.cpython-313.pyc,sha256=dmkhqYKcUjDPvirOFgf1L-P-aV3l7JIWK6zZZ6J45LU,175
+policyengine/core/__init__.py,sha256=3vabkWXYNNmQmN4Vy1yx2kKk6RKVSsdjtToQ8s8gzUg,870
+policyengine/core/dataset.py,sha256=jGjnoyEQ6VcTiCs8Hr6PT22l59CRhK1oUT5RPaz7mC0,9256
+policyengine/core/dataset_version.py,sha256=6KeFCRGQto_Yyl4QY4Vo2JFythjaXrNAOHQiwRGESyM,378
+policyengine/core/dynamic.py,sha256=40RO3N6hmUT6-3tpJy0wSOC-9ITdFSS5LRiqPmi79f0,1605
+policyengine/core/output.py,sha256=cCW4vbzkLdQaT_nJTyDJBl7Hubm7nZeRuR7aVG1dKvg,643
+policyengine/core/parameter.py,sha256=PLDaepytqB7FVSfYQ541vnkVuMDLamFBeHtz2TmQrOE,378
+policyengine/core/parameter_value.py,sha256=b0ts1kbWcwjPSYnZm2rlCylmTLPJRLxDL8z3RmxM5OI,377
+policyengine/core/policy.py,sha256=xorVf03bcjB-3mBEmwj2YMqF1-6Xzps74SquzqtS0lo,1599
+policyengine/core/simulation.py,sha256=x9dU_nKEIgCZa11cxB-VdRNt9DZjjSML7n7M8_3STv8,941
+policyengine/core/tax_benefit_model.py,sha256=2Yc1RlQrUG7djDMZbJOQH4Ns86_lOnLeISCGR4-9zMo,176
+policyengine/core/tax_benefit_model_version.py,sha256=AJHFRaSEzR2_0FVkBBb40ID3FAaFFrFLnhSXRYYbtWs,1291
+policyengine/core/variable.py,sha256=AjSImORlRkh05xhYxyeT6GFMOfViRzYg0qRQAIj-mxo,350
+policyengine/outputs/__init__.py,sha256=IJUmLP0Og41VrwiqhJF-a9-3fIb4nlXpS7uFuVCINIs,515
+policyengine/outputs/aggregate.py,sha256=exI-U04OF5kVf2BBYV6sf8VldIWnT_IzxgkBs5wtnCw,4846
+policyengine/outputs/change_aggregate.py,sha256=tK4K87YlByKikqFaB7OHyh1SqAuGtUnLL7cSF_EhrOs,7373
+policyengine/outputs/decile_impact.py,sha256=jclhbj5U-xX8D-myy0SuWeJFVfQTqJDCh7qBXugak5U,4811
+policyengine/tax_benefit_models/uk.py,sha256=MCeJGQCTwUzBYdz0ru7IgT8Mgv-vJMqqVwFrntGWWTE,734
+policyengine/tax_benefit_models/us.py,sha256=d6rdhW2awoUvk5Ldp9mHAUiHqlnSfEQR318PkIXS_9c,794
+policyengine/tax_benefit_models/uk/__init__.py,sha256=1L1HBbOTflRefjOcU5vgEYkn6wLWOt_uG9G_PF089S0,732
+policyengine/tax_benefit_models/uk/analysis.py,sha256=O4eYJYF7tsgiuLuiWMU0OXq7ss6U8-vzlg6nC2U8sgU,3175
+policyengine/tax_benefit_models/uk/datasets.py,sha256=LvbHemfhMU1kk9sZU5eAPrix8EmTl07p9fYkwbSasIE,6542
+policyengine/tax_benefit_models/uk/model.py,sha256=5GGhscQEX1-YBgkUt4kd2RyFfVIBEd7IihaSP3ia7hg,9247
+policyengine/tax_benefit_models/uk/outputs.py,sha256=2mYLwQW4QNvrOHtHfm_ACqE9gbmuLxvcCyldRU46s0o,3543
+policyengine/tax_benefit_models/us/__init__.py,sha256=ClBkFwRa_nFQ3YU003uxBKiMG3pktaUb8jRvhzfR0vE,968
+policyengine/tax_benefit_models/us/analysis.py,sha256=Xf-DT0QjVySs0QG_koCwgvOeWI_scLtv3S3SP8u8ZWc,3253
+policyengine/tax_benefit_models/us/datasets.py,sha256=sQ0YsTsmqpaM-j7w6Cea1lKUzjMV3UPqH5Bc3hH71cI,12718
+policyengine/tax_benefit_models/us/model.py,sha256=SNQ3_pVLJDF41gRzU4NZ1yZUq8nLMPSHWwb-qGaTae0,16021
+policyengine/tax_benefit_models/us/outputs.py,sha256=GT8Eur8DfB9cPQRbSljEl9RpKSNHW80Fq_CBXCybvIU,3519
+policyengine/utils/__init__.py,sha256=1X-VYAWLyB9A0YRHwsGWrqQHns1WfeZ7ISC6DMU5myM,140
+policyengine/utils/dates.py,sha256=HnAqyl8S8EOYp8ibsnMTmECYoDWCSqwL-7A2_qKgxSc,1510
+policyengine/utils/parametric_reforms.py,sha256=4P3U39-4pYTU4BN6JjgmVLUkCkBhRfZJ6UIWTlsjyQE,1155
+policyengine/utils/plotting.py,sha256=JbMPwD7SCQqp_qbjYrXixT5zS0eG734n0Sg4JkD9nDc,5336
+policyengine-3.1.1.dist-info/licenses/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+policyengine-3.1.1.dist-info/METADATA,sha256=JuCAmXnSyBcTeeqyBm54GYmsYrrOPg8zGhWHdYoleT4,45889
+policyengine-3.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+policyengine-3.1.1.dist-info/top_level.txt,sha256=_23UPobfkneHQkpJ0e0OmDJfhCUfoXj_F2sTckCGOH4,13
+policyengine-3.1.1.dist-info/RECORD,,

policyengine/database/__init__.py

@@ -1,56 +0,0 @@
-from .baseline_parameter_value_table import (
-    BaselineParameterValueTable,
-    baseline_parameter_value_table_link,
-)
-from .baseline_variable_table import (
-    BaselineVariableTable,
-    baseline_variable_table_link,
-)
-from .database import Database
-from .dataset_table import DatasetTable, dataset_table_link
-from .dynamic_table import DynamicTable, dynamic_table_link
-from .link import TableLink
-
-# Import all table classes and links
-from .model_table import ModelTable, model_table_link
-from .model_version_table import ModelVersionTable, model_version_table_link
-from .parameter_table import ParameterTable, parameter_table_link
-from .parameter_value_table import (
-    ParameterValueTable,
-    parameter_value_table_link,
-)
-from .policy_table import PolicyTable, policy_table_link
-from .simulation_table import SimulationTable, simulation_table_link
-from .versioned_dataset_table import (
-    VersionedDatasetTable,
-    versioned_dataset_table_link,
-)
-
-__all__ = [
-    "Database",
-    "TableLink",
-    # Tables
-    "ModelTable",
-    "ModelVersionTable",
-    "DatasetTable",
-    "VersionedDatasetTable",
-    "PolicyTable",
-    "DynamicTable",
-    "ParameterTable",
-    "ParameterValueTable",
-    "BaselineParameterValueTable",
-    "BaselineVariableTable",
-    "SimulationTable",
-    # Links
-    "model_table_link",
-    "model_version_table_link",
-    "dataset_table_link",
-    "versioned_dataset_table_link",
-    "policy_table_link",
-    "dynamic_table_link",
-    "parameter_table_link",
-    "parameter_value_table_link",
-    "baseline_parameter_value_table_link",
-    "baseline_variable_table_link",
-    "simulation_table_link",
-]

policyengine/database/aggregate.py

@@ -1,33 +0,0 @@
-from uuid import uuid4
-
-from sqlmodel import Field, SQLModel
-
-from policyengine.database.link import TableLink
-from policyengine.models.aggregate import Aggregate
-
-
-class AggregateTable(SQLModel, table=True):
-    __tablename__ = "aggregates"
-
-    id: str = Field(default_factory=lambda: str(uuid4()), primary_key=True)
-    simulation_id: str = Field(
-        foreign_key="simulations.id", ondelete="CASCADE"
-    )
-    entity: str
-    variable_name: str
-    year: int | None = None
-    filter_variable_name: str | None = None
-    filter_variable_value: str | None = None
-    filter_variable_leq: float | None = None
-    filter_variable_geq: float | None = None
-    aggregate_function: str
-    value: float | None = None
-
-
-aggregate_table_link = TableLink(
-    model_cls=Aggregate,
-    table_cls=AggregateTable,
-    model_to_table_custom_transforms=dict(
-        simulation_id=lambda a: a.simulation.id,
-    ),
-)

policyengine/database/baseline_parameter_value_table.py

@@ -1,66 +0,0 @@
-from datetime import datetime
-from typing import Any
-from uuid import uuid4
-
-from sqlmodel import JSON, Column, Field, SQLModel
-
-from policyengine.models import BaselineParameterValue
-
-from .link import TableLink
-
-
-class BaselineParameterValueTable(SQLModel, table=True):
-    __tablename__ = "baseline_parameter_values"
-    __table_args__ = ({"extend_existing": True},)
-
-    id: str = Field(default_factory=lambda: str(uuid4()), primary_key=True)
-    parameter_id: str = Field(nullable=False)  # Part of composite foreign key
-    model_id: str = Field(nullable=False)  # Part of composite foreign key
-    model_version_id: str = Field(
-        foreign_key="model_versions.id", ondelete="CASCADE"
-    )
-    value: Any | None = Field(
-        default=None, sa_column=Column(JSON)
-    )  # JSON field for any type
-    start_date: datetime = Field(nullable=False)
-    end_date: datetime | None = Field(default=None)
-
-
-def transform_value_to_table(bpv):
-    """Transform value for storage, handling special float values."""
-    import math
-
-    value = bpv.value
-    if isinstance(value, float):
-        if math.isinf(value):
-            return "Infinity" if value > 0 else "-Infinity"
-        elif math.isnan(value):
-            return "NaN"
-    return value
-
-
-def transform_value_from_table(table_row):
-    """Transform value from storage, converting special strings back to floats."""
-    value = table_row.value
-    if value == "Infinity":
-        return float("inf")
-    elif value == "-Infinity":
-        return float("-inf")
-    elif value == "NaN":
-        return float("nan")
-    return value
-
-
-baseline_parameter_value_table_link = TableLink(
-    model_cls=BaselineParameterValue,
-    table_cls=BaselineParameterValueTable,
-    model_to_table_custom_transforms=dict(
-        parameter_id=lambda bpv: bpv.parameter.id,
-        model_id=lambda bpv: bpv.parameter.model.id,  # Add model_id from parameter
-        model_version_id=lambda bpv: bpv.model_version.id,
-        value=transform_value_to_table,
-    ),
-    table_to_model_custom_transforms=dict(
-        value=transform_value_from_table,
-    ),
-)

policyengine/database/baseline_variable_table.py

@@ -1,40 +0,0 @@
-from sqlmodel import Field, SQLModel
-
-from policyengine.models import BaselineVariable
-from policyengine.utils.compress import compress_data, decompress_data
-
-from .link import TableLink
-
-
-class BaselineVariableTable(SQLModel, table=True):
-    __tablename__ = "baseline_variables"
-    __table_args__ = ({"extend_existing": True},)
-
-    id: str = Field(primary_key=True)  # Variable name
-    model_id: str = Field(
-        primary_key=True, foreign_key="models.id"
-    )  # Part of composite key
-    model_version_id: str = Field(
-        foreign_key="model_versions.id", ondelete="CASCADE"
-    )
-    entity: str = Field(nullable=False)
-    label: str | None = Field(default=None)
-    description: str | None = Field(default=None)
-    data_type: bytes | None = Field(default=None)  # Pickled type
-
-
-baseline_variable_table_link = TableLink(
-    model_cls=BaselineVariable,
-    table_cls=BaselineVariableTable,
-    primary_key=("id", "model_id"),  # Composite primary key
-    model_to_table_custom_transforms=dict(
-        model_id=lambda bv: bv.model_version.model.id,  # Add model_id from model_version
-        model_version_id=lambda bv: bv.model_version.id,
-        data_type=lambda bv: compress_data(bv.data_type)
-        if bv.data_type
-        else None,
-    ),
-    table_to_model_custom_transforms=dict(
-        data_type=lambda dt: decompress_data(dt) if dt else None,
-    ),
-)