holder-python 0.2.5__py3-none-any.whl

holder/generated/models/project_git_test_remote_response_data.py

@@ -0,0 +1,151 @@
+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
+
+from ..models.project_git_test_remote_response_data_status import (
+    ProjectGitTestRemoteResponseDataStatus,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="ProjectGitTestRemoteResponseData")
+
+
+@_attrs_define
+class ProjectGitTestRemoteResponseData:
+    """
+    Attributes:
+        project_id (str):
+        branch (str):
+        status (ProjectGitTestRemoteResponseDataStatus):
+        remote_has_head (bool):
+        remote_url (None | str | Unset):
+        error_code (None | str | Unset):
+        error_message (None | str | Unset):
+    """
+
+    project_id: str
+    branch: str
+    status: ProjectGitTestRemoteResponseDataStatus
+    remote_has_head: bool
+    remote_url: None | str | Unset = UNSET
+    error_code: None | str | Unset = UNSET
+    error_message: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        project_id = self.project_id
+
+        branch = self.branch
+
+        status = self.status.value
+
+        remote_has_head = self.remote_has_head
+
+        remote_url: None | str | Unset
+        if isinstance(self.remote_url, Unset):
+            remote_url = UNSET
+        else:
+            remote_url = self.remote_url
+
+        error_code: None | str | Unset
+        if isinstance(self.error_code, Unset):
+            error_code = UNSET
+        else:
+            error_code = self.error_code
+
+        error_message: None | str | Unset
+        if isinstance(self.error_message, Unset):
+            error_message = UNSET
+        else:
+            error_message = self.error_message
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "project_id": project_id,
+                "branch": branch,
+                "status": status,
+                "remote_has_head": remote_has_head,
+            }
+        )
+        if remote_url is not UNSET:
+            field_dict["remote_url"] = remote_url
+        if error_code is not UNSET:
+            field_dict["error_code"] = error_code
+        if error_message is not UNSET:
+            field_dict["error_message"] = error_message
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        project_id = d.pop("project_id")
+
+        branch = d.pop("branch")
+
+        status = ProjectGitTestRemoteResponseDataStatus(d.pop("status"))
+
+        remote_has_head = d.pop("remote_has_head")
+
+        def _parse_remote_url(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        remote_url = _parse_remote_url(d.pop("remote_url", UNSET))
+
+        def _parse_error_code(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        error_code = _parse_error_code(d.pop("error_code", UNSET))
+
+        def _parse_error_message(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        error_message = _parse_error_message(d.pop("error_message", UNSET))
+
+        project_git_test_remote_response_data = cls(
+            project_id=project_id,
+            branch=branch,
+            status=status,
+            remote_has_head=remote_has_head,
+            remote_url=remote_url,
+            error_code=error_code,
+            error_message=error_message,
+        )
+
+        project_git_test_remote_response_data.additional_properties = d
+        return project_git_test_remote_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

holder/generated/models/project_git_test_remote_response_data_status.py

@@ -0,0 +1,14 @@
+from enum import StrEnum
+
+
+class ProjectGitTestRemoteResponseDataStatus(StrEnum):
+    AUTH_FAILED = "auth_failed"
+    INVALID_REMOTE_URL = "invalid_remote_url"
+    NETWORK_ERROR = "network_error"
+    NOT_FOUND = "not_found"
+    REACHABLE = "reachable"
+    REMOTE_UNSET = "remote_unset"
+    UNKNOWN_ERROR = "unknown_error"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/project_history_activity.py

@@ -0,0 +1,138 @@
+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.card_history_author import CardHistoryAuthor
+    from ..models.project_history_affected_object import ProjectHistoryAffectedObject
+
+
+T = TypeVar("T", bound="ProjectHistoryActivity")
+
+
+@_attrs_define
+class ProjectHistoryActivity:
+    """
+    Attributes:
+        oid (str):
+        parent_oids (list[str]):
+        author (CardHistoryAuthor):
+        authored_at (int):
+        committed_at (int):
+        message (str):
+        affected_objects (list[ProjectHistoryAffectedObject]):
+        is_merge (bool):
+    """
+
+    oid: str
+    parent_oids: list[str]
+    author: CardHistoryAuthor
+    authored_at: int
+    committed_at: int
+    message: str
+    affected_objects: list[ProjectHistoryAffectedObject]
+    is_merge: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        oid = self.oid
+
+        parent_oids = self.parent_oids
+
+        author = self.author.to_dict()
+
+        authored_at = self.authored_at
+
+        committed_at = self.committed_at
+
+        message = self.message
+
+        affected_objects = []
+        for affected_objects_item_data in self.affected_objects:
+            affected_objects_item = affected_objects_item_data.to_dict()
+            affected_objects.append(affected_objects_item)
+
+        is_merge = self.is_merge
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "oid": oid,
+                "parent_oids": parent_oids,
+                "author": author,
+                "authored_at": authored_at,
+                "committed_at": committed_at,
+                "message": message,
+                "affected_objects": affected_objects,
+                "is_merge": is_merge,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.card_history_author import CardHistoryAuthor
+        from ..models.project_history_affected_object import (
+            ProjectHistoryAffectedObject,
+        )
+
+        d = dict(src_dict)
+        oid = d.pop("oid")
+
+        parent_oids = cast(list[str], d.pop("parent_oids"))
+
+        author = CardHistoryAuthor.from_dict(d.pop("author"))
+
+        authored_at = d.pop("authored_at")
+
+        committed_at = d.pop("committed_at")
+
+        message = d.pop("message")
+
+        affected_objects = []
+        _affected_objects = d.pop("affected_objects")
+        for affected_objects_item_data in _affected_objects:
+            affected_objects_item = ProjectHistoryAffectedObject.from_dict(
+                affected_objects_item_data
+            )
+
+            affected_objects.append(affected_objects_item)
+
+        is_merge = d.pop("is_merge")
+
+        project_history_activity = cls(
+            oid=oid,
+            parent_oids=parent_oids,
+            author=author,
+            authored_at=authored_at,
+            committed_at=committed_at,
+            message=message,
+            affected_objects=affected_objects,
+            is_merge=is_merge,
+        )
+
+        project_history_activity.additional_properties = d
+        return project_history_activity
+
+    @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/project_history_affected_object.py

@@ -0,0 +1,74 @@
+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
+
+from ..models.project_history_affected_object_kind import (
+    ProjectHistoryAffectedObjectKind,
+)
+
+T = TypeVar("T", bound="ProjectHistoryAffectedObject")
+
+
+@_attrs_define
+class ProjectHistoryAffectedObject:
+    """
+    Attributes:
+        kind (ProjectHistoryAffectedObjectKind):
+        paths (list[str]):
+    """
+
+    kind: ProjectHistoryAffectedObjectKind
+    paths: list[str]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        kind = self.kind.value
+
+        paths = self.paths
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "kind": kind,
+                "paths": paths,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        kind = ProjectHistoryAffectedObjectKind(d.pop("kind"))
+
+        paths = cast(list[str], d.pop("paths"))
+
+        project_history_affected_object = cls(
+            kind=kind,
+            paths=paths,
+        )
+
+        project_history_affected_object.additional_properties = d
+        return project_history_affected_object
+
+    @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/project_history_affected_object_kind.py

@@ -0,0 +1,13 @@
+from enum import StrEnum
+
+
+class ProjectHistoryAffectedObjectKind(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/project_history_page_data.py

@@ -0,0 +1,115 @@
+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.project_history_activity import ProjectHistoryActivity
+
+
+T = TypeVar("T", bound="ProjectHistoryPageData")
+
+
+@_attrs_define
+class ProjectHistoryPageData:
+    """
+    Attributes:
+        head_oid (None | str):
+        activities (list[ProjectHistoryActivity]):
+        next_cursor (None | str):
+        scan_limited (bool):
+    """
+
+    head_oid: None | str
+    activities: list[ProjectHistoryActivity]
+    next_cursor: None | str
+    scan_limited: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        head_oid: None | str
+        head_oid = self.head_oid
+
+        activities = []
+        for activities_item_data in self.activities:
+            activities_item = activities_item_data.to_dict()
+            activities.append(activities_item)
+
+        next_cursor: None | str
+        next_cursor = self.next_cursor
+
+        scan_limited = self.scan_limited
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "head_oid": head_oid,
+                "activities": activities,
+                "next_cursor": next_cursor,
+                "scan_limited": scan_limited,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.project_history_activity import (
+            ProjectHistoryActivity,
+        )
+
+        d = dict(src_dict)
+
+        def _parse_head_oid(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        head_oid = _parse_head_oid(d.pop("head_oid"))
+
+        activities = []
+        _activities = d.pop("activities")
+        for activities_item_data in _activities:
+            activities_item = ProjectHistoryActivity.from_dict(activities_item_data)
+
+            activities.append(activities_item)
+
+        def _parse_next_cursor(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        next_cursor = _parse_next_cursor(d.pop("next_cursor"))
+
+        scan_limited = d.pop("scan_limited")
+
+        project_history_page_data = cls(
+            head_oid=head_oid,
+            activities=activities,
+            next_cursor=next_cursor,
+            scan_limited=scan_limited,
+        )
+
+        project_history_page_data.additional_properties = d
+        return project_history_page_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/project_history_page_response.py

@@ -0,0 +1,78 @@
+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.project_history_page_data import ProjectHistoryPageData
+
+
+T = TypeVar("T", bound="ProjectHistoryPageResponse")
+
+
+@_attrs_define
+class ProjectHistoryPageResponse:
+    """
+    Attributes:
+        ok (bool):
+        data (ProjectHistoryPageData):
+    """
+
+    ok: bool
+    data: ProjectHistoryPageData
+    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.project_history_page_data import (
+            ProjectHistoryPageData,
+        )
+
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        data = ProjectHistoryPageData.from_dict(d.pop("data"))
+
+        project_history_page_response = cls(
+            ok=ok,
+            data=data,
+        )
+
+        project_history_page_response.additional_properties = d
+        return project_history_page_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/project_list_response.py

@@ -0,0 +1,84 @@
+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.project import Project
+
+
+T = TypeVar("T", bound="ProjectListResponse")
+
+
+@_attrs_define
+class ProjectListResponse:
+    """
+    Attributes:
+        ok (bool):
+        data (list[Project]):
+    """
+
+    ok: bool
+    data: list[Project]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        ok = self.ok
+
+        data = []
+        for data_item_data in self.data:
+            data_item = data_item_data.to_dict()
+            data.append(data_item)
+
+        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.project import Project
+
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = Project.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        project_list_response = cls(
+            ok=ok,
+            data=data,
+        )
+
+        project_list_response.additional_properties = d
+        return project_list_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/project_privacy_mode.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+
+class ProjectPrivacyMode(StrEnum):
+    ENCRYPTED_GIT = "encrypted_git"
+    PLAIN = "plain"
+
+    def __str__(self) -> str:
+        return str(self.value)