ynab-cli 0.3.0__py3-none-any.whl

ynab_cli/adapters/ynab/models/hybrid_transactions_response_data.py

@@ -0,0 +1,84 @@
+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 ynab_cli.adapters.ynab.types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ynab_cli.adapters.ynab.models.hybrid_transaction import HybridTransaction
+
+
+T = TypeVar("T", bound="HybridTransactionsResponseData")
+
+
+@_attrs_define
+class HybridTransactionsResponseData:
+    """
+    Attributes:
+        transactions (list['HybridTransaction']):
+        server_knowledge (Union[Unset, int]): The knowledge of the server
+    """
+
+    transactions: list["HybridTransaction"]
+    server_knowledge: Unset | int = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        transactions = []
+        for transactions_item_data in self.transactions:
+            transactions_item = transactions_item_data.to_dict()
+            transactions.append(transactions_item)
+
+        server_knowledge = self.server_knowledge
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "transactions": transactions,
+            }
+        )
+        if server_knowledge is not UNSET:
+            field_dict["server_knowledge"] = server_knowledge
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ynab_cli.adapters.ynab.models.hybrid_transaction import HybridTransaction
+
+        d = dict(src_dict)
+        transactions = []
+        _transactions = d.pop("transactions")
+        for transactions_item_data in _transactions:
+            transactions_item = HybridTransaction.from_dict(transactions_item_data)
+
+            transactions.append(transactions_item)
+
+        server_knowledge = d.pop("server_knowledge", UNSET)
+
+        hybrid_transactions_response_data = cls(
+            transactions=transactions,
+            server_knowledge=server_knowledge,
+        )
+
+        hybrid_transactions_response_data.additional_properties = d
+        return hybrid_transactions_response_data
+
+    @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

ynab_cli/adapters/ynab/models/loan_account_periodic_value_type_0.py

@@ -0,0 +1,44 @@
+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="LoanAccountPeriodicValueType0")
+
+
+@_attrs_define
+class LoanAccountPeriodicValueType0:
+    """ """
+
+    additional_properties: dict[str, int] = _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)
+        loan_account_periodic_value_type_0 = cls()
+
+        loan_account_periodic_value_type_0.additional_properties = d
+        return loan_account_periodic_value_type_0
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> int:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: int) -> 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

ynab_cli/adapters/ynab/models/month_detail.py

@@ -0,0 +1,168 @@
+import datetime
+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
+from dateutil.parser import isoparse
+
+from ynab_cli.adapters.ynab.types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ynab_cli.adapters.ynab.models.category import Category
+
+
+T = TypeVar("T", bound="MonthDetail")
+
+
+@_attrs_define
+class MonthDetail:
+    """
+    Attributes:
+        month (datetime.date):
+        income (int): The total amount of transactions categorized to 'Inflow: Ready to Assign' in the month
+        budgeted (int): The total amount budgeted in the month
+        activity (int): The total amount of transactions in the month, excluding those categorized to 'Inflow: Ready to
+            Assign'
+        to_be_budgeted (int): The available amount for 'Ready to Assign'
+        deleted (bool): Whether or not the month has been deleted.  Deleted months will only be included in delta
+            requests.
+        categories (list['Category']): The budget month categories.  Amounts (budgeted, activity, balance, etc.) are
+            specific to the {month} parameter specified.
+        note (Union[None, Unset, str]):
+        age_of_money (Union[None, Unset, int]): The Age of Money as of the month
+    """
+
+    month: datetime.date
+    income: int
+    budgeted: int
+    activity: int
+    to_be_budgeted: int
+    deleted: bool
+    categories: list["Category"]
+    note: None | Unset | str = UNSET
+    age_of_money: None | Unset | int = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        month = self.month.isoformat()
+
+        income = self.income
+
+        budgeted = self.budgeted
+
+        activity = self.activity
+
+        to_be_budgeted = self.to_be_budgeted
+
+        deleted = self.deleted
+
+        categories = []
+        for categories_item_data in self.categories:
+            categories_item = categories_item_data.to_dict()
+            categories.append(categories_item)
+
+        note: None | Unset | str
+        if isinstance(self.note, Unset):
+            note = UNSET
+        else:
+            note = self.note
+
+        age_of_money: None | Unset | int
+        if isinstance(self.age_of_money, Unset):
+            age_of_money = UNSET
+        else:
+            age_of_money = self.age_of_money
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "month": month,
+                "income": income,
+                "budgeted": budgeted,
+                "activity": activity,
+                "to_be_budgeted": to_be_budgeted,
+                "deleted": deleted,
+                "categories": categories,
+            }
+        )
+        if note is not UNSET:
+            field_dict["note"] = note
+        if age_of_money is not UNSET:
+            field_dict["age_of_money"] = age_of_money
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ynab_cli.adapters.ynab.models.category import Category
+
+        d = dict(src_dict)
+        month = isoparse(d.pop("month")).date()
+
+        income = d.pop("income")
+
+        budgeted = d.pop("budgeted")
+
+        activity = d.pop("activity")
+
+        to_be_budgeted = d.pop("to_be_budgeted")
+
+        deleted = d.pop("deleted")
+
+        categories = []
+        _categories = d.pop("categories")
+        for categories_item_data in _categories:
+            categories_item = Category.from_dict(categories_item_data)
+
+            categories.append(categories_item)
+
+        def _parse_note(data: object) -> None | Unset | str:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | Unset | str, data)
+
+        note = _parse_note(d.pop("note", UNSET))
+
+        def _parse_age_of_money(data: object) -> None | Unset | int:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | Unset | int, data)
+
+        age_of_money = _parse_age_of_money(d.pop("age_of_money", UNSET))
+
+        month_detail = cls(
+            month=month,
+            income=income,
+            budgeted=budgeted,
+            activity=activity,
+            to_be_budgeted=to_be_budgeted,
+            deleted=deleted,
+            categories=categories,
+            note=note,
+            age_of_money=age_of_money,
+        )
+
+        month_detail.additional_properties = d
+        return month_detail
+
+    @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

ynab_cli/adapters/ynab/models/month_detail_response.py

@@ -0,0 +1,65 @@
+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 ynab_cli.adapters.ynab.models.month_detail_response_data import MonthDetailResponseData
+
+
+T = TypeVar("T", bound="MonthDetailResponse")
+
+
+@_attrs_define
+class MonthDetailResponse:
+    """
+    Attributes:
+        data (MonthDetailResponseData):
+    """
+
+    data: "MonthDetailResponseData"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        data = self.data.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "data": data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ynab_cli.adapters.ynab.models.month_detail_response_data import MonthDetailResponseData
+
+        d = dict(src_dict)
+        data = MonthDetailResponseData.from_dict(d.pop("data"))
+
+        month_detail_response = cls(
+            data=data,
+        )
+
+        month_detail_response.additional_properties = d
+        return month_detail_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

ynab_cli/adapters/ynab/models/month_detail_response_data.py

@@ -0,0 +1,65 @@
+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 ynab_cli.adapters.ynab.models.month_detail import MonthDetail
+
+
+T = TypeVar("T", bound="MonthDetailResponseData")
+
+
+@_attrs_define
+class MonthDetailResponseData:
+    """
+    Attributes:
+        month (MonthDetail):
+    """
+
+    month: "MonthDetail"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        month = self.month.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "month": month,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ynab_cli.adapters.ynab.models.month_detail import MonthDetail
+
+        d = dict(src_dict)
+        month = MonthDetail.from_dict(d.pop("month"))
+
+        month_detail_response_data = cls(
+            month=month,
+        )
+
+        month_detail_response_data.additional_properties = d
+        return month_detail_response_data
+
+    @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

ynab_cli/adapters/ynab/models/month_summaries_response.py

@@ -0,0 +1,65 @@
+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 ynab_cli.adapters.ynab.models.month_summaries_response_data import MonthSummariesResponseData
+
+
+T = TypeVar("T", bound="MonthSummariesResponse")
+
+
+@_attrs_define
+class MonthSummariesResponse:
+    """
+    Attributes:
+        data (MonthSummariesResponseData):
+    """
+
+    data: "MonthSummariesResponseData"
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        data = self.data.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "data": data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ynab_cli.adapters.ynab.models.month_summaries_response_data import MonthSummariesResponseData
+
+        d = dict(src_dict)
+        data = MonthSummariesResponseData.from_dict(d.pop("data"))
+
+        month_summaries_response = cls(
+            data=data,
+        )
+
+        month_summaries_response.additional_properties = d
+        return month_summaries_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

ynab_cli/adapters/ynab/models/month_summaries_response_data.py

@@ -0,0 +1,81 @@
+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 ynab_cli.adapters.ynab.models.month_summary import MonthSummary
+
+
+T = TypeVar("T", bound="MonthSummariesResponseData")
+
+
+@_attrs_define
+class MonthSummariesResponseData:
+    """
+    Attributes:
+        months (list['MonthSummary']):
+        server_knowledge (int): The knowledge of the server
+    """
+
+    months: list["MonthSummary"]
+    server_knowledge: int
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        months = []
+        for months_item_data in self.months:
+            months_item = months_item_data.to_dict()
+            months.append(months_item)
+
+        server_knowledge = self.server_knowledge
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "months": months,
+                "server_knowledge": server_knowledge,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ynab_cli.adapters.ynab.models.month_summary import MonthSummary
+
+        d = dict(src_dict)
+        months = []
+        _months = d.pop("months")
+        for months_item_data in _months:
+            months_item = MonthSummary.from_dict(months_item_data)
+
+            months.append(months_item)
+
+        server_knowledge = d.pop("server_knowledge")
+
+        month_summaries_response_data = cls(
+            months=months,
+            server_knowledge=server_knowledge,
+        )
+
+        month_summaries_response_data.additional_properties = d
+        return month_summaries_response_data
+
+    @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