holder-python 0.2.5__py3-none-any.whl

holder/generated/models/card_tag_mutation_result.py

@@ -0,0 +1,88 @@
+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 ..models.card_tag_mutation_result_outcome import CardTagMutationResultOutcome
+
+T = TypeVar("T", bound="CardTagMutationResult")
+
+
+@_attrs_define
+class CardTagMutationResult:
+    """
+    Attributes:
+        card_id (str):
+        tag (str): Normalized tag without the leading
+        outcome (CardTagMutationResultOutcome):
+        changed (bool): True only when card content was changed.
+    """
+
+    card_id: str
+    tag: str
+    outcome: CardTagMutationResultOutcome
+    changed: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        card_id = self.card_id
+
+        tag = self.tag
+
+        outcome = self.outcome.value
+
+        changed = self.changed
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "card_id": card_id,
+                "tag": tag,
+                "outcome": outcome,
+                "changed": changed,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        card_id = d.pop("card_id")
+
+        tag = d.pop("tag")
+
+        outcome = CardTagMutationResultOutcome(d.pop("outcome"))
+
+        changed = d.pop("changed")
+
+        card_tag_mutation_result = cls(
+            card_id=card_id,
+            tag=tag,
+            outcome=outcome,
+            changed=changed,
+        )
+
+        card_tag_mutation_result.additional_properties = d
+        return card_tag_mutation_result
+
+    @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/card_tag_mutation_result_outcome.py

@@ -0,0 +1,12 @@
+from enum import StrEnum
+
+
+class CardTagMutationResultOutcome(StrEnum):
+    ADDED = "added"
+    ALREADY_PRESENT = "already_present"
+    NOT_PRESENT = "not_present"
+    PRESENT_OUTSIDE_EDITABLE_TAG_LINE = "present_outside_editable_tag_line"
+    REMOVED = "removed"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/card_update_request.py

@@ -0,0 +1,122 @@
+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 ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CardUpdateRequest")
+
+
+@_attrs_define
+class CardUpdateRequest:
+    """
+    Attributes:
+        updated_at (int):
+        content (str | Unset):
+        title (None | str | Unset):
+        parent_card_id (None | str | Unset):
+        sort_key (float | Unset):
+    """
+
+    updated_at: int
+    content: str | Unset = UNSET
+    title: None | str | Unset = UNSET
+    parent_card_id: None | str | Unset = UNSET
+    sort_key: float | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        updated_at = self.updated_at
+
+        content = self.content
+
+        title: None | str | Unset
+        if isinstance(self.title, Unset):
+            title = UNSET
+        else:
+            title = self.title
+
+        parent_card_id: None | str | Unset
+        if isinstance(self.parent_card_id, Unset):
+            parent_card_id = UNSET
+        else:
+            parent_card_id = self.parent_card_id
+
+        sort_key = self.sort_key
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "updated_at": updated_at,
+            }
+        )
+        if content is not UNSET:
+            field_dict["content"] = content
+        if title is not UNSET:
+            field_dict["title"] = title
+        if parent_card_id is not UNSET:
+            field_dict["parent_card_id"] = parent_card_id
+        if sort_key is not UNSET:
+            field_dict["sort_key"] = sort_key
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        updated_at = d.pop("updated_at")
+
+        content = d.pop("content", UNSET)
+
+        def _parse_title(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        title = _parse_title(d.pop("title", UNSET))
+
+        def _parse_parent_card_id(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        parent_card_id = _parse_parent_card_id(d.pop("parent_card_id", UNSET))
+
+        sort_key = d.pop("sort_key", UNSET)
+
+        card_update_request = cls(
+            updated_at=updated_at,
+            content=content,
+            title=title,
+            parent_card_id=parent_card_id,
+            sort_key=sort_key,
+        )
+
+        card_update_request.additional_properties = d
+        return card_update_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

holder/generated/models/caste_info.py

@@ -0,0 +1,85 @@
+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.caste_info_name import CasteInfoName
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CasteInfo")
+
+
+@_attrs_define
+class CasteInfo:
+    """
+    Attributes:
+        name (CasteInfoName):
+        reason (None | str | Unset):
+    """
+
+    name: CasteInfoName
+    reason: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name.value
+
+        reason: None | str | Unset
+        if isinstance(self.reason, Unset):
+            reason = UNSET
+        else:
+            reason = self.reason
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+            }
+        )
+        if reason is not UNSET:
+            field_dict["reason"] = reason
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        name = CasteInfoName(d.pop("name"))
+
+        def _parse_reason(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        reason = _parse_reason(d.pop("reason", UNSET))
+
+        caste_info = cls(
+            name=name,
+            reason=reason,
+        )
+
+        caste_info.additional_properties = d
+        return caste_info
+
+    @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/caste_info_name.py

@@ -0,0 +1,12 @@
+from enum import StrEnum
+
+
+class CasteInfoName(StrEnum):
+    DEVELOPER = "developer"
+    MINI = "mini"
+    RIG = "rig"
+    USER = "user"
+    WORKSTATION = "workstation"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/caste_recommended_model.py

@@ -0,0 +1,143 @@
+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.caste_recommended_model_required_caste import (
+    CasteRecommendedModelRequiredCaste,
+)
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="CasteRecommendedModel")
+
+
+@_attrs_define
+class CasteRecommendedModel:
+    """
+    Attributes:
+        tag (str):
+        required_caste (CasteRecommendedModelRequiredCaste):
+        installed (bool):
+        provider (None | str | Unset):
+        engine (None | str | Unset):
+        category (None | str | Unset):
+    """
+
+    tag: str
+    required_caste: CasteRecommendedModelRequiredCaste
+    installed: bool
+    provider: None | str | Unset = UNSET
+    engine: None | str | Unset = UNSET
+    category: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        tag = self.tag
+
+        required_caste = self.required_caste.value
+
+        installed = self.installed
+
+        provider: None | str | Unset
+        if isinstance(self.provider, Unset):
+            provider = UNSET
+        else:
+            provider = self.provider
+
+        engine: None | str | Unset
+        if isinstance(self.engine, Unset):
+            engine = UNSET
+        else:
+            engine = self.engine
+
+        category: None | str | Unset
+        if isinstance(self.category, Unset):
+            category = UNSET
+        else:
+            category = self.category
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "tag": tag,
+                "required_caste": required_caste,
+                "installed": installed,
+            }
+        )
+        if provider is not UNSET:
+            field_dict["provider"] = provider
+        if engine is not UNSET:
+            field_dict["engine"] = engine
+        if category is not UNSET:
+            field_dict["category"] = category
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        tag = d.pop("tag")
+
+        required_caste = CasteRecommendedModelRequiredCaste(d.pop("required_caste"))
+
+        installed = d.pop("installed")
+
+        def _parse_provider(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        provider = _parse_provider(d.pop("provider", UNSET))
+
+        def _parse_engine(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        engine = _parse_engine(d.pop("engine", UNSET))
+
+        def _parse_category(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        category = _parse_category(d.pop("category", UNSET))
+
+        caste_recommended_model = cls(
+            tag=tag,
+            required_caste=required_caste,
+            installed=installed,
+            provider=provider,
+            engine=engine,
+            category=category,
+        )
+
+        caste_recommended_model.additional_properties = d
+        return caste_recommended_model
+
+    @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/caste_recommended_model_required_caste.py

@@ -0,0 +1,12 @@
+from enum import StrEnum
+
+
+class CasteRecommendedModelRequiredCaste(StrEnum):
+    DEVELOPER = "developer"
+    MINI = "mini"
+    RIG = "rig"
+    USER = "user"
+    WORKSTATION = "workstation"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/change_event_data.py

@@ -0,0 +1,109 @@
+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.change_event_data_entity import ChangeEventDataEntity
+
+T = TypeVar("T", bound="ChangeEventData")
+
+
+@_attrs_define
+class ChangeEventData:
+    """
+    Attributes:
+        entity (ChangeEventDataEntity):
+        entity_id (str):
+        project_id (None | str):
+        deleted (bool): Entity disappeared from the observed database snapshot. Soft deletion remains an ordinary
+            invalidation.
+        git_revision (None | str): Observed Git HEAD for this project; live changes may not yet be committed to Git.
+    """
+
+    entity: ChangeEventDataEntity
+    entity_id: str
+    project_id: None | str
+    deleted: bool
+    git_revision: None | str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        entity = self.entity.value
+
+        entity_id = self.entity_id
+
+        project_id: None | str
+        project_id = self.project_id
+
+        deleted = self.deleted
+
+        git_revision: None | str
+        git_revision = self.git_revision
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "entity": entity,
+                "entity_id": entity_id,
+                "project_id": project_id,
+                "deleted": deleted,
+                "git_revision": git_revision,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        entity = ChangeEventDataEntity(d.pop("entity"))
+
+        entity_id = d.pop("entity_id")
+
+        def _parse_project_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        project_id = _parse_project_id(d.pop("project_id"))
+
+        deleted = d.pop("deleted")
+
+        def _parse_git_revision(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        git_revision = _parse_git_revision(d.pop("git_revision"))
+
+        change_event_data = cls(
+            entity=entity,
+            entity_id=entity_id,
+            project_id=project_id,
+            deleted=deleted,
+            git_revision=git_revision,
+        )
+
+        change_event_data.additional_properties = d
+        return change_event_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/change_event_data_entity.py

@@ -0,0 +1,14 @@
+from enum import StrEnum
+
+
+class ChangeEventDataEntity(StrEnum):
+    CARD = "card"
+    LOCATION = "location"
+    MESSAGE = "message"
+    PROJECT = "project"
+    RESOURCE = "resource"
+    RUN = "run"
+    THREAD = "thread"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/delete_cards_card_id_children.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+
+class DeleteCardsCardIdChildren(StrEnum):
+    PROMOTE = "promote"
+    TRASH_SUBTREE = "trash_subtree"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/delete_cards_card_id_resources_body.py

@@ -0,0 +1,70 @@
+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="DeleteCardsCardIdResourcesBody")
+
+
+@_attrs_define
+class DeleteCardsCardIdResourcesBody:
+    """
+    Attributes:
+        project_id (str):
+        resource_id (str): Complete exact project resource ID; no prefix or label lookup.
+    """
+
+    project_id: str
+    resource_id: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        project_id = self.project_id
+
+        resource_id = self.resource_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "project_id": project_id,
+                "resource_id": resource_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        project_id = d.pop("project_id")
+
+        resource_id = d.pop("resource_id")
+
+        delete_cards_card_id_resources_body = cls(
+            project_id=project_id,
+            resource_id=resource_id,
+        )
+
+        delete_cards_card_id_resources_body.additional_properties = d
+        return delete_cards_card_id_resources_body
+
+    @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