policyengine-api-simulation-client 0.20251216.73__py3-none-any.whl

policyengine_api_simulation_client/models/intra_wealth_decile_impact_with_values.py

@@ -0,0 +1,77 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.intra_wealth_decile_impact_with_values_all import IntraWealthDecileImpactWithValuesAll
+    from ..models.intra_wealth_decile_impact_with_values_deciles import IntraWealthDecileImpactWithValuesDeciles
+
+
+T = TypeVar("T", bound="IntraWealthDecileImpactWithValues")
+
+
+@_attrs_define
+class IntraWealthDecileImpactWithValues:
+    """
+    Attributes:
+        deciles (IntraWealthDecileImpactWithValuesDeciles):
+        all_ (IntraWealthDecileImpactWithValuesAll):
+    """
+
+    deciles: IntraWealthDecileImpactWithValuesDeciles
+    all_: IntraWealthDecileImpactWithValuesAll
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        deciles = self.deciles.to_dict()
+
+        all_ = self.all_.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "deciles": deciles,
+                "all": all_,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.intra_wealth_decile_impact_with_values_all import IntraWealthDecileImpactWithValuesAll
+        from ..models.intra_wealth_decile_impact_with_values_deciles import IntraWealthDecileImpactWithValuesDeciles
+
+        d = dict(src_dict)
+        deciles = IntraWealthDecileImpactWithValuesDeciles.from_dict(d.pop("deciles"))
+
+        all_ = IntraWealthDecileImpactWithValuesAll.from_dict(d.pop("all"))
+
+        intra_wealth_decile_impact_with_values = cls(
+            deciles=deciles,
+            all_=all_,
+        )
+
+        intra_wealth_decile_impact_with_values.additional_properties = d
+        return intra_wealth_decile_impact_with_values
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

policyengine_api_simulation_client/models/intra_wealth_decile_impact_with_values_all.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="IntraWealthDecileImpactWithValuesAll")
+
+
+@_attrs_define
+class IntraWealthDecileImpactWithValuesAll:
+    """ """
+
+    additional_properties: dict[str, float] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        intra_wealth_decile_impact_with_values_all = cls()
+
+        intra_wealth_decile_impact_with_values_all.additional_properties = d
+        return intra_wealth_decile_impact_with_values_all
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> float:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: float) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

policyengine_api_simulation_client/models/intra_wealth_decile_impact_with_values_deciles.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="IntraWealthDecileImpactWithValuesDeciles")
+
+
+@_attrs_define
+class IntraWealthDecileImpactWithValuesDeciles:
+    """ """
+
+    additional_properties: dict[str, list[float]] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        intra_wealth_decile_impact_with_values_deciles = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = cast(list[float], prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        intra_wealth_decile_impact_with_values_deciles.additional_properties = additional_properties
+        return intra_wealth_decile_impact_with_values_deciles
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> list[float]:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: list[float]) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

policyengine_api_simulation_client/models/labor_supply_response.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.hours_response import HoursResponse
+    from ..models.labor_supply_response_decile import LaborSupplyResponseDecile
+    from ..models.labor_supply_response_relative_lsr import LaborSupplyResponseRelativeLsr
+
+
+T = TypeVar("T", bound="LaborSupplyResponse")
+
+
+@_attrs_define
+class LaborSupplyResponse:
+    """
+    Attributes:
+        substitution_lsr (float):
+        income_lsr (float):
+        relative_lsr (LaborSupplyResponseRelativeLsr):
+        total_change (float):
+        revenue_change (float):
+        decile (LaborSupplyResponseDecile):
+        hours (HoursResponse):
+    """
+
+    substitution_lsr: float
+    income_lsr: float
+    relative_lsr: LaborSupplyResponseRelativeLsr
+    total_change: float
+    revenue_change: float
+    decile: LaborSupplyResponseDecile
+    hours: HoursResponse
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        substitution_lsr = self.substitution_lsr
+
+        income_lsr = self.income_lsr
+
+        relative_lsr = self.relative_lsr.to_dict()
+
+        total_change = self.total_change
+
+        revenue_change = self.revenue_change
+
+        decile = self.decile.to_dict()
+
+        hours = self.hours.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "substitution_lsr": substitution_lsr,
+                "income_lsr": income_lsr,
+                "relative_lsr": relative_lsr,
+                "total_change": total_change,
+                "revenue_change": revenue_change,
+                "decile": decile,
+                "hours": hours,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.hours_response import HoursResponse
+        from ..models.labor_supply_response_decile import LaborSupplyResponseDecile
+        from ..models.labor_supply_response_relative_lsr import LaborSupplyResponseRelativeLsr
+
+        d = dict(src_dict)
+        substitution_lsr = d.pop("substitution_lsr")
+
+        income_lsr = d.pop("income_lsr")
+
+        relative_lsr = LaborSupplyResponseRelativeLsr.from_dict(d.pop("relative_lsr"))
+
+        total_change = d.pop("total_change")
+
+        revenue_change = d.pop("revenue_change")
+
+        decile = LaborSupplyResponseDecile.from_dict(d.pop("decile"))
+
+        hours = HoursResponse.from_dict(d.pop("hours"))
+
+        labor_supply_response = cls(
+            substitution_lsr=substitution_lsr,
+            income_lsr=income_lsr,
+            relative_lsr=relative_lsr,
+            total_change=total_change,
+            revenue_change=revenue_change,
+            decile=decile,
+            hours=hours,
+        )
+
+        labor_supply_response.additional_properties = d
+        return labor_supply_response
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

policyengine_api_simulation_client/models/labor_supply_response_decile.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.labor_supply_response_decile_additional_property import LaborSupplyResponseDecileAdditionalProperty
+
+
+T = TypeVar("T", bound="LaborSupplyResponseDecile")
+
+
+@_attrs_define
+class LaborSupplyResponseDecile:
+    """ """
+
+    additional_properties: dict[str, LaborSupplyResponseDecileAdditionalProperty] = _attrs_field(
+        init=False, factory=dict
+    )
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.labor_supply_response_decile_additional_property import (
+            LaborSupplyResponseDecileAdditionalProperty,
+        )
+
+        d = dict(src_dict)
+        labor_supply_response_decile = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = LaborSupplyResponseDecileAdditionalProperty.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        labor_supply_response_decile.additional_properties = additional_properties
+        return labor_supply_response_decile
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> LaborSupplyResponseDecileAdditionalProperty:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: LaborSupplyResponseDecileAdditionalProperty) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

policyengine_api_simulation_client/models/labor_supply_response_decile_additional_property.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.labor_supply_response_decile_additional_property_additional_property import (
+        LaborSupplyResponseDecileAdditionalPropertyAdditionalProperty,
+    )
+
+
+T = TypeVar("T", bound="LaborSupplyResponseDecileAdditionalProperty")
+
+
+@_attrs_define
+class LaborSupplyResponseDecileAdditionalProperty:
+    """ """
+
+    additional_properties: dict[str, LaborSupplyResponseDecileAdditionalPropertyAdditionalProperty] = _attrs_field(
+        init=False, factory=dict
+    )
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.labor_supply_response_decile_additional_property_additional_property import (
+            LaborSupplyResponseDecileAdditionalPropertyAdditionalProperty,
+        )
+
+        d = dict(src_dict)
+        labor_supply_response_decile_additional_property = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = LaborSupplyResponseDecileAdditionalPropertyAdditionalProperty.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        labor_supply_response_decile_additional_property.additional_properties = additional_properties
+        return labor_supply_response_decile_additional_property
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> LaborSupplyResponseDecileAdditionalPropertyAdditionalProperty:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: LaborSupplyResponseDecileAdditionalPropertyAdditionalProperty) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

policyengine_api_simulation_client/models/labor_supply_response_decile_additional_property_additional_property.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="LaborSupplyResponseDecileAdditionalPropertyAdditionalProperty")
+
+
+@_attrs_define
+class LaborSupplyResponseDecileAdditionalPropertyAdditionalProperty:
+    """ """
+
+    additional_properties: dict[str, float] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        labor_supply_response_decile_additional_property_additional_property = cls()
+
+        labor_supply_response_decile_additional_property_additional_property.additional_properties = d
+        return labor_supply_response_decile_additional_property_additional_property
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> float:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: float) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

policyengine_api_simulation_client/models/labor_supply_response_relative_lsr.py

@@ -0,0 +1,46 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="LaborSupplyResponseRelativeLsr")
+
+
+@_attrs_define
+class LaborSupplyResponseRelativeLsr:
+    """ """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        labor_supply_response_relative_lsr = cls()
+
+        labor_supply_response_relative_lsr.additional_properties = d
+        return labor_supply_response_relative_lsr
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

policyengine_api_simulation_client/models/parameter_change_dict.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="ParameterChangeDict")
+
+
+@_attrs_define
+class ParameterChangeDict:
+    """A dict of changes to a parameter, with custom date string as keys
+    and various possible value types.
+
+    Keys can be formatted one of two ways:
+    1. A single year (e.g., "YYYY")
+    2. A date range (e.g., "YYYY-MM-DD.YYYY-MM-DD")
+
+    """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        parameter_change_dict = cls()
+
+        parameter_change_dict.additional_properties = d
+        return parameter_change_dict
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

policyengine_api_simulation_client/models/parametric_reform.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.parameter_change_dict import ParameterChangeDict
+
+
+T = TypeVar("T", bound="ParametricReform")
+
+
+@_attrs_define
+class ParametricReform:
+    """A reform that just changes parameter values.
+
+    This is a dict that equates a parameter name to either a single value or a dict of changes.
+
+    """
+
+    additional_properties: dict[str, Any | ParameterChangeDict] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.parameter_change_dict import ParameterChangeDict
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            if isinstance(prop, ParameterChangeDict):
+                field_dict[prop_name] = prop.to_dict()
+            else:
+                field_dict[prop_name] = prop
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.parameter_change_dict import ParameterChangeDict
+
+        d = dict(src_dict)
+        parametric_reform = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+
+            def _parse_additional_property(data: object) -> Any | ParameterChangeDict:
+                try:
+                    if not isinstance(data, dict):
+                        raise TypeError()
+                    additional_property_type_1 = ParameterChangeDict.from_dict(data)
+
+                    return additional_property_type_1
+                except (TypeError, ValueError, AttributeError, KeyError):
+                    pass
+                return cast(Any | ParameterChangeDict, data)
+
+            additional_property = _parse_additional_property(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        parametric_reform.additional_properties = additional_properties
+        return parametric_reform
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any | ParameterChangeDict:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any | ParameterChangeDict) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties