holder-python 0.2.5__py3-none-any.whl

holder/generated/models/get_git_providers_json_response_200.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
+from typing_extensions import Self
+
+T = TypeVar("T", bound="GetGitProvidersJsonResponse200")
+
+
+@_attrs_define
+class GetGitProvidersJsonResponse200:
+    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, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        get_git_providers_json_response_200 = cls()
+
+        get_git_providers_json_response_200.additional_properties = d
+        return get_git_providers_json_response_200
+
+    @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

holder/generated/models/get_locations_location_id_response_200.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
+from typing_extensions import Self
+
+T = TypeVar("T", bound="GetLocationsLocationIdResponse200")
+
+
+@_attrs_define
+class GetLocationsLocationIdResponse200:
+    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, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        get_locations_location_id_response_200 = cls()
+
+        get_locations_location_id_response_200.additional_properties = d
+        return get_locations_location_id_response_200
+
+    @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

holder/generated/models/get_ping_response_200.py

@@ -0,0 +1,8 @@
+from enum import StrEnum
+
+
+class GetPingResponse200(StrEnum):
+    PONG = "pong"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/get_projects_order.py

@@ -0,0 +1,13 @@
+from enum import StrEnum
+
+
+class GetProjectsOrder(StrEnum):
+    CREATED_AT_ASC = "created_at_asc"
+    CREATED_AT_DESC = "created_at_desc"
+    NAME_ASC = "name_asc"
+    NAME_DESC = "name_desc"
+    UPDATED_AT_ASC = "updated_at_asc"
+    UPDATED_AT_DESC = "updated_at_desc"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/get_projects_project_id_cards_order.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+
+class GetProjectsProjectIdCardsOrder(StrEnum):
+    CARD_ID_ASC = "card_id_asc"
+    UPDATED_DESC = "updated_desc"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/get_projects_project_id_cards_parent_type_0.py

@@ -0,0 +1,8 @@
+from enum import StrEnum
+
+
+class GetProjectsProjectIdCardsParentType0(StrEnum):
+    ROOTS = "roots"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/get_projects_project_id_history_cards_card_id_compare_mode.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+
+class GetProjectsProjectIdHistoryCardsCardIdCompareMode(StrEnum):
+    CHANGE = "change"
+    SINCE = "since"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/get_projects_project_id_history_kind.py

@@ -0,0 +1,13 @@
+from enum import StrEnum
+
+
+class GetProjectsProjectIdHistoryKind(StrEnum):
+    AI_DATA = "ai_data"
+    CARD = "card"
+    LOCATION = "location"
+    PROJECT_SETTINGS = "project_settings"
+    RESOURCE = "resource"
+    UNKNOWN = "unknown"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/health_data.py

@@ -0,0 +1,110 @@
+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 typing_extensions import Self
+
+if TYPE_CHECKING:
+    from ..models.health_data_crypt_filter import HealthDataCryptFilter
+
+
+T = TypeVar("T", bound="HealthData")
+
+
+@_attrs_define
+class HealthData:
+    """
+    Attributes:
+        db_ok (bool):
+        uptime_ms (int):
+        api_version (str):
+        server_version (str):
+        pid (int):
+        crypt_filter (HealthDataCryptFilter):
+    """
+
+    db_ok: bool
+    uptime_ms: int
+    api_version: str
+    server_version: str
+    pid: int
+    crypt_filter: HealthDataCryptFilter
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        db_ok = self.db_ok
+
+        uptime_ms = self.uptime_ms
+
+        api_version = self.api_version
+
+        server_version = self.server_version
+
+        pid = self.pid
+
+        crypt_filter = self.crypt_filter.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "db_ok": db_ok,
+                "uptime_ms": uptime_ms,
+                "api_version": api_version,
+                "server_version": server_version,
+                "pid": pid,
+                "crypt_filter": crypt_filter,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.health_data_crypt_filter import (
+            HealthDataCryptFilter,
+        )
+
+        d = dict(src_dict)
+        db_ok = d.pop("db_ok")
+
+        uptime_ms = d.pop("uptime_ms")
+
+        api_version = d.pop("api_version")
+
+        server_version = d.pop("server_version")
+
+        pid = d.pop("pid")
+
+        crypt_filter = HealthDataCryptFilter.from_dict(d.pop("crypt_filter"))
+
+        health_data = cls(
+            db_ok=db_ok,
+            uptime_ms=uptime_ms,
+            api_version=api_version,
+            server_version=server_version,
+            pid=pid,
+            crypt_filter=crypt_filter,
+        )
+
+        health_data.additional_properties = d
+        return health_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

holder/generated/models/health_data_crypt_filter.py

@@ -0,0 +1,78 @@
+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
+from typing_extensions import Self
+
+T = TypeVar("T", bound="HealthDataCryptFilter")
+
+
+@_attrs_define
+class HealthDataCryptFilter:
+    """
+    Attributes:
+        path (str):
+        exists (bool):
+        executable (bool):
+    """
+
+    path: str
+    exists: bool
+    executable: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        path = self.path
+
+        exists = self.exists
+
+        executable = self.executable
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "path": path,
+                "exists": exists,
+                "executable": executable,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        path = d.pop("path")
+
+        exists = d.pop("exists")
+
+        executable = d.pop("executable")
+
+        health_data_crypt_filter = cls(
+            path=path,
+            exists=exists,
+            executable=executable,
+        )
+
+        health_data_crypt_filter.additional_properties = d
+        return health_data_crypt_filter
+
+    @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

holder/generated/models/health_response.py

@@ -0,0 +1,76 @@
+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 typing_extensions import Self
+
+if TYPE_CHECKING:
+    from ..models.health_data import HealthData
+
+
+T = TypeVar("T", bound="HealthResponse")
+
+
+@_attrs_define
+class HealthResponse:
+    """
+    Attributes:
+        ok (bool):
+        data (HealthData):
+    """
+
+    ok: bool
+    data: HealthData
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        ok = self.ok
+
+        data = self.data.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "ok": ok,
+                "data": data,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.health_data import HealthData
+
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        data = HealthData.from_dict(d.pop("data"))
+
+        health_response = cls(
+            ok=ok,
+            data=data,
+        )
+
+        health_response.additional_properties = d
+        return health_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

holder/generated/models/hierarchy_repair.py

@@ -0,0 +1,100 @@
+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
+from typing_extensions import Self
+
+if TYPE_CHECKING:
+    from ..models.hierarchy_repair_move import HierarchyRepairMove
+
+
+T = TypeVar("T", bound="HierarchyRepair")
+
+
+@_attrs_define
+class HierarchyRepair:
+    """
+    Attributes:
+        applied (bool): True when changes were written.
+        moved (list[HierarchyRepairMove]):
+        changed_card_count (int): Cards whose placement changes, counting siblings re-spaced to make room.
+        cycle_card_ids (list[str]): Live cards whose parent chain loops. They are left alone and need moving by hand.
+    """
+
+    applied: bool
+    moved: list[HierarchyRepairMove]
+    changed_card_count: int
+    cycle_card_ids: list[str]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        applied = self.applied
+
+        moved = []
+        for moved_item_data in self.moved:
+            moved_item = moved_item_data.to_dict()
+            moved.append(moved_item)
+
+        changed_card_count = self.changed_card_count
+
+        cycle_card_ids = self.cycle_card_ids
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "applied": applied,
+                "moved": moved,
+                "changed_card_count": changed_card_count,
+                "cycle_card_ids": cycle_card_ids,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.hierarchy_repair_move import HierarchyRepairMove
+
+        d = dict(src_dict)
+        applied = d.pop("applied")
+
+        moved = []
+        _moved = d.pop("moved")
+        for moved_item_data in _moved:
+            moved_item = HierarchyRepairMove.from_dict(moved_item_data)
+
+            moved.append(moved_item)
+
+        changed_card_count = d.pop("changed_card_count")
+
+        cycle_card_ids = cast(list[str], d.pop("cycle_card_ids"))
+
+        hierarchy_repair = cls(
+            applied=applied,
+            moved=moved,
+            changed_card_count=changed_card_count,
+            cycle_card_ids=cycle_card_ids,
+        )
+
+        hierarchy_repair.additional_properties = d
+        return hierarchy_repair
+
+    @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

holder/generated/models/hierarchy_repair_move.py

@@ -0,0 +1,76 @@
+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
+from typing_extensions import Self
+
+T = TypeVar("T", bound="HierarchyRepairMove")
+
+
+@_attrs_define
+class HierarchyRepairMove:
+    """
+    Attributes:
+        card_id (str): A hidden branch's top card. Its descendants stay attached and move with it.
+        parent_card_id (None | str): Where it goes, or null for the project's top level.
+    """
+
+    card_id: str
+    parent_card_id: None | str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        card_id = self.card_id
+
+        parent_card_id: None | str
+        parent_card_id = self.parent_card_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "card_id": card_id,
+                "parent_card_id": parent_card_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        card_id = d.pop("card_id")
+
+        def _parse_parent_card_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        parent_card_id = _parse_parent_card_id(d.pop("parent_card_id"))
+
+        hierarchy_repair_move = cls(
+            card_id=card_id,
+            parent_card_id=parent_card_id,
+        )
+
+        hierarchy_repair_move.additional_properties = d
+        return hierarchy_repair_move
+
+    @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

holder/generated/models/hierarchy_repair_request.py

@@ -0,0 +1,62 @@
+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
+from typing_extensions import Self
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="HierarchyRepairRequest")
+
+
+@_attrs_define
+class HierarchyRepairRequest:
+    """
+    Attributes:
+        apply (bool | Unset): Apply the repair. Without it, only report. Default: False.
+    """
+
+    apply: bool | Unset = False
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        apply = self.apply
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if apply is not UNSET:
+            field_dict["apply"] = apply
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        apply = d.pop("apply", UNSET)
+
+        hierarchy_repair_request = cls(
+            apply=apply,
+        )
+
+        hierarchy_repair_request.additional_properties = d
+        return hierarchy_repair_request
+
+    @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