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

policyengine_api_simulation_client/models/economy_comparison_detailed_budget_type_0.py

@@ -0,0 +1,59 @@
+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.program_specific_impact import ProgramSpecificImpact
+
+
+T = TypeVar("T", bound="EconomyComparisonDetailedBudgetType0")
+
+
+@_attrs_define
+class EconomyComparisonDetailedBudgetType0:
+    """ """
+
+    additional_properties: dict[str, ProgramSpecificImpact] = _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.program_specific_impact import ProgramSpecificImpact
+
+        d = dict(src_dict)
+        economy_comparison_detailed_budget_type_0 = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = ProgramSpecificImpact.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        economy_comparison_detailed_budget_type_0.additional_properties = additional_properties
+        return economy_comparison_detailed_budget_type_0
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> ProgramSpecificImpact:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: ProgramSpecificImpact) -> 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/gender_baseline_reform_values.py

@@ -0,0 +1,75 @@
+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.baseline_reform_values import BaselineReformValues
+
+
+T = TypeVar("T", bound="GenderBaselineReformValues")
+
+
+@_attrs_define
+class GenderBaselineReformValues:
+    """
+    Attributes:
+        male (BaselineReformValues):
+        female (BaselineReformValues):
+    """
+
+    male: BaselineReformValues
+    female: BaselineReformValues
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        male = self.male.to_dict()
+
+        female = self.female.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "male": male,
+                "female": female,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.baseline_reform_values import BaselineReformValues
+
+        d = dict(src_dict)
+        male = BaselineReformValues.from_dict(d.pop("male"))
+
+        female = BaselineReformValues.from_dict(d.pop("female"))
+
+        gender_baseline_reform_values = cls(
+            male=male,
+            female=female,
+        )
+
+        gender_baseline_reform_values.additional_properties = d
+        return gender_baseline_reform_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/health_status.py

@@ -0,0 +1,83 @@
+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.system_status import SystemStatus
+
+
+T = TypeVar("T", bound="HealthStatus")
+
+
+@_attrs_define
+class HealthStatus:
+    """
+    Attributes:
+        healthy (bool):
+        systems (list[SystemStatus]):
+    """
+
+    healthy: bool
+    systems: list[SystemStatus]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        healthy = self.healthy
+
+        systems = []
+        for systems_item_data in self.systems:
+            systems_item = systems_item_data.to_dict()
+            systems.append(systems_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "healthy": healthy,
+                "systems": systems,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.system_status import SystemStatus
+
+        d = dict(src_dict)
+        healthy = d.pop("healthy")
+
+        systems = []
+        _systems = d.pop("systems")
+        for systems_item_data in _systems:
+            systems_item = SystemStatus.from_dict(systems_item_data)
+
+            systems.append(systems_item)
+
+        health_status = cls(
+            healthy=healthy,
+            systems=systems,
+        )
+
+        health_status.additional_properties = d
+        return health_status
+
+    @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/hours_response.py

@@ -0,0 +1,93 @@
+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="HoursResponse")
+
+
+@_attrs_define
+class HoursResponse:
+    """
+    Attributes:
+        baseline (float):
+        reform (float):
+        change (float):
+        income_effect (float):
+        substitution_effect (float):
+    """
+
+    baseline: float
+    reform: float
+    change: float
+    income_effect: float
+    substitution_effect: float
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        baseline = self.baseline
+
+        reform = self.reform
+
+        change = self.change
+
+        income_effect = self.income_effect
+
+        substitution_effect = self.substitution_effect
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "baseline": baseline,
+                "reform": reform,
+                "change": change,
+                "income_effect": income_effect,
+                "substitution_effect": substitution_effect,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        baseline = d.pop("baseline")
+
+        reform = d.pop("reform")
+
+        change = d.pop("change")
+
+        income_effect = d.pop("income_effect")
+
+        substitution_effect = d.pop("substitution_effect")
+
+        hours_response = cls(
+            baseline=baseline,
+            reform=reform,
+            change=change,
+            income_effect=income_effect,
+            substitution_effect=substitution_effect,
+        )
+
+        hours_response.additional_properties = d
+        return hours_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/http_validation_error.py

@@ -0,0 +1,79 @@
+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
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.validation_error import ValidationError
+
+
+T = TypeVar("T", bound="HTTPValidationError")
+
+
+@_attrs_define
+class HTTPValidationError:
+    """
+    Attributes:
+        detail (list[ValidationError] | Unset):
+    """
+
+    detail: list[ValidationError] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        detail: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.detail, Unset):
+            detail = []
+            for detail_item_data in self.detail:
+                detail_item = detail_item_data.to_dict()
+                detail.append(detail_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if detail is not UNSET:
+            field_dict["detail"] = detail
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.validation_error import ValidationError
+
+        d = dict(src_dict)
+        _detail = d.pop("detail", UNSET)
+        detail: list[ValidationError] | Unset = UNSET
+        if _detail is not UNSET:
+            detail = []
+            for detail_item_data in _detail:
+                detail_item = ValidationError.from_dict(detail_item_data)
+
+                detail.append(detail_item)
+
+        http_validation_error = cls(
+            detail=detail,
+        )
+
+        http_validation_error.additional_properties = d
+        return http_validation_error
+
+    @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/inequality_impact.py

@@ -0,0 +1,83 @@
+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.baseline_reform_values import BaselineReformValues
+
+
+T = TypeVar("T", bound="InequalityImpact")
+
+
+@_attrs_define
+class InequalityImpact:
+    """
+    Attributes:
+        gini (BaselineReformValues):
+        top_10_pct_share (BaselineReformValues):
+        top_1_pct_share (BaselineReformValues):
+    """
+
+    gini: BaselineReformValues
+    top_10_pct_share: BaselineReformValues
+    top_1_pct_share: BaselineReformValues
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        gini = self.gini.to_dict()
+
+        top_10_pct_share = self.top_10_pct_share.to_dict()
+
+        top_1_pct_share = self.top_1_pct_share.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "gini": gini,
+                "top_10_pct_share": top_10_pct_share,
+                "top_1_pct_share": top_1_pct_share,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.baseline_reform_values import BaselineReformValues
+
+        d = dict(src_dict)
+        gini = BaselineReformValues.from_dict(d.pop("gini"))
+
+        top_10_pct_share = BaselineReformValues.from_dict(d.pop("top_10_pct_share"))
+
+        top_1_pct_share = BaselineReformValues.from_dict(d.pop("top_1_pct_share"))
+
+        inequality_impact = cls(
+            gini=gini,
+            top_10_pct_share=top_10_pct_share,
+            top_1_pct_share=top_1_pct_share,
+        )
+
+        inequality_impact.additional_properties = d
+        return inequality_impact
+
+    @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_decile_impact.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_decile_impact_all import IntraDecileImpactAll
+    from ..models.intra_decile_impact_deciles import IntraDecileImpactDeciles
+
+
+T = TypeVar("T", bound="IntraDecileImpact")
+
+
+@_attrs_define
+class IntraDecileImpact:
+    """
+    Attributes:
+        deciles (IntraDecileImpactDeciles):
+        all_ (IntraDecileImpactAll):
+    """
+
+    deciles: IntraDecileImpactDeciles
+    all_: IntraDecileImpactAll
+    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_decile_impact_all import IntraDecileImpactAll
+        from ..models.intra_decile_impact_deciles import IntraDecileImpactDeciles
+
+        d = dict(src_dict)
+        deciles = IntraDecileImpactDeciles.from_dict(d.pop("deciles"))
+
+        all_ = IntraDecileImpactAll.from_dict(d.pop("all"))
+
+        intra_decile_impact = cls(
+            deciles=deciles,
+            all_=all_,
+        )
+
+        intra_decile_impact.additional_properties = d
+        return intra_decile_impact
+
+    @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_decile_impact_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="IntraDecileImpactAll")
+
+
+@_attrs_define
+class IntraDecileImpactAll:
+    """ """
+
+    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_decile_impact_all = cls()
+
+        intra_decile_impact_all.additional_properties = d
+        return intra_decile_impact_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_decile_impact_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="IntraDecileImpactDeciles")
+
+
+@_attrs_define
+class IntraDecileImpactDeciles:
+    """ """
+
+    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_decile_impact_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_decile_impact_deciles.additional_properties = additional_properties
+        return intra_decile_impact_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