holder-python 0.2.5__py3-none-any.whl

holder/generated/models/card_history_author.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="CardHistoryAuthor")
+
+
+@_attrs_define
+class CardHistoryAuthor:
+    """
+    Attributes:
+        name (str):
+        email (str):
+    """
+
+    name: str
+    email: str
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        name = self.name
+
+        email = self.email
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "name": name,
+                "email": email,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        name = d.pop("name")
+
+        email = d.pop("email")
+
+        card_history_author = cls(
+            name=name,
+            email=email,
+        )
+
+        card_history_author.additional_properties = d
+        return card_history_author
+
+    @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_history_comparison_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.card_history_diff_line import CardHistoryDiffLine
+    from ..models.card_history_version import CardHistoryVersion
+
+
+T = TypeVar("T", bound="CardHistoryComparisonData")
+
+
+@_attrs_define
+class CardHistoryComparisonData:
+    """
+    Attributes:
+        from_ (CardHistoryVersion):
+        to (CardHistoryVersion):
+        summary (str):
+        lines (list[CardHistoryDiffLine]):
+        truncated (bool):
+    """
+
+    from_: CardHistoryVersion
+    to: CardHistoryVersion
+    summary: str
+    lines: list[CardHistoryDiffLine]
+    truncated: bool
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from_ = self.from_.to_dict()
+
+        to = self.to.to_dict()
+
+        summary = self.summary
+
+        lines = []
+        for lines_item_data in self.lines:
+            lines_item = lines_item_data.to_dict()
+            lines.append(lines_item)
+
+        truncated = self.truncated
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "from": from_,
+                "to": to,
+                "summary": summary,
+                "lines": lines,
+                "truncated": truncated,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.card_history_diff_line import CardHistoryDiffLine
+        from ..models.card_history_version import CardHistoryVersion
+
+        d = dict(src_dict)
+        from_ = CardHistoryVersion.from_dict(d.pop("from"))
+
+        to = CardHistoryVersion.from_dict(d.pop("to"))
+
+        summary = d.pop("summary")
+
+        lines = []
+        _lines = d.pop("lines")
+        for lines_item_data in _lines:
+            lines_item = CardHistoryDiffLine.from_dict(lines_item_data)
+
+            lines.append(lines_item)
+
+        truncated = d.pop("truncated")
+
+        card_history_comparison_data = cls(
+            from_=from_,
+            to=to,
+            summary=summary,
+            lines=lines,
+            truncated=truncated,
+        )
+
+        card_history_comparison_data.additional_properties = d
+        return card_history_comparison_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/card_history_comparison_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.card_history_comparison_data import CardHistoryComparisonData
+
+
+T = TypeVar("T", bound="CardHistoryComparisonResponse")
+
+
+@_attrs_define
+class CardHistoryComparisonResponse:
+    """
+    Attributes:
+        ok (bool):
+        data (CardHistoryComparisonData):
+    """
+
+    ok: bool
+    data: CardHistoryComparisonData
+    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.card_history_comparison_data import (
+            CardHistoryComparisonData,
+        )
+
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        data = CardHistoryComparisonData.from_dict(d.pop("data"))
+
+        card_history_comparison_response = cls(
+            ok=ok,
+            data=data,
+        )
+
+        card_history_comparison_response.additional_properties = d
+        return card_history_comparison_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/card_history_diff_line.py

@@ -0,0 +1,100 @@
+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.card_history_diff_line_origin import CardHistoryDiffLineOrigin
+
+T = TypeVar("T", bound="CardHistoryDiffLine")
+
+
+@_attrs_define
+class CardHistoryDiffLine:
+    """
+    Attributes:
+        origin (CardHistoryDiffLineOrigin):
+        text (str):
+        old_line (int | None):
+        new_line (int | None):
+    """
+
+    origin: CardHistoryDiffLineOrigin
+    text: str
+    old_line: int | None
+    new_line: int | None
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        origin = self.origin.value
+
+        text = self.text
+
+        old_line: int | None
+        old_line = self.old_line
+
+        new_line: int | None
+        new_line = self.new_line
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "origin": origin,
+                "text": text,
+                "old_line": old_line,
+                "new_line": new_line,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        origin = CardHistoryDiffLineOrigin(d.pop("origin"))
+
+        text = d.pop("text")
+
+        def _parse_old_line(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        old_line = _parse_old_line(d.pop("old_line"))
+
+        def _parse_new_line(data: object) -> int | None:
+            if data is None:
+                return data
+            return cast(int | None, data)
+
+        new_line = _parse_new_line(d.pop("new_line"))
+
+        card_history_diff_line = cls(
+            origin=origin,
+            text=text,
+            old_line=old_line,
+            new_line=new_line,
+        )
+
+        card_history_diff_line.additional_properties = d
+        return card_history_diff_line
+
+    @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_history_diff_line_origin.py

@@ -0,0 +1,10 @@
+from enum import StrEnum
+
+
+class CardHistoryDiffLineOrigin(StrEnum):
+    VALUE_0 = " "
+    VALUE_1 = "+"
+    VALUE_2 = "-"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/card_history_entry.py

@@ -0,0 +1,172 @@
+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
+
+from ..models.card_history_entry_kind import CardHistoryEntryKind
+
+if TYPE_CHECKING:
+    from ..models.card_history_author import CardHistoryAuthor
+    from ..models.card_history_entry_saves_item import CardHistoryEntrySavesItem
+
+
+T = TypeVar("T", bound="CardHistoryEntry")
+
+
+@_attrs_define
+class CardHistoryEntry:
+    """
+    Attributes:
+        first_oid (str):
+        last_oid (str):
+        parent_oids (list[str]):
+        visible_parent_oids (list[str]): Direct parent entries visible on this history page; omitted connections must
+            not be inferred across filtered commits or page boundaries.
+        author (CardHistoryAuthor):
+        started_at (int):
+        ended_at (int):
+        kind (CardHistoryEntryKind):
+        summary (str):
+        commit_count (int):
+        is_merge (bool):
+        saves (list[CardHistoryEntrySavesItem]): Exact saved commits in chronological order; one item for an ungrouped
+            entry.
+    """
+
+    first_oid: str
+    last_oid: str
+    parent_oids: list[str]
+    visible_parent_oids: list[str]
+    author: CardHistoryAuthor
+    started_at: int
+    ended_at: int
+    kind: CardHistoryEntryKind
+    summary: str
+    commit_count: int
+    is_merge: bool
+    saves: list[CardHistoryEntrySavesItem]
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        first_oid = self.first_oid
+
+        last_oid = self.last_oid
+
+        parent_oids = self.parent_oids
+
+        visible_parent_oids = self.visible_parent_oids
+
+        author = self.author.to_dict()
+
+        started_at = self.started_at
+
+        ended_at = self.ended_at
+
+        kind = self.kind.value
+
+        summary = self.summary
+
+        commit_count = self.commit_count
+
+        is_merge = self.is_merge
+
+        saves = []
+        for saves_item_data in self.saves:
+            saves_item = saves_item_data.to_dict()
+            saves.append(saves_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "first_oid": first_oid,
+                "last_oid": last_oid,
+                "parent_oids": parent_oids,
+                "visible_parent_oids": visible_parent_oids,
+                "author": author,
+                "started_at": started_at,
+                "ended_at": ended_at,
+                "kind": kind,
+                "summary": summary,
+                "commit_count": commit_count,
+                "is_merge": is_merge,
+                "saves": saves,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.card_history_author import CardHistoryAuthor
+        from ..models.card_history_entry_saves_item import (
+            CardHistoryEntrySavesItem,
+        )
+
+        d = dict(src_dict)
+        first_oid = d.pop("first_oid")
+
+        last_oid = d.pop("last_oid")
+
+        parent_oids = cast(list[str], d.pop("parent_oids"))
+
+        visible_parent_oids = cast(list[str], d.pop("visible_parent_oids"))
+
+        author = CardHistoryAuthor.from_dict(d.pop("author"))
+
+        started_at = d.pop("started_at")
+
+        ended_at = d.pop("ended_at")
+
+        kind = CardHistoryEntryKind(d.pop("kind"))
+
+        summary = d.pop("summary")
+
+        commit_count = d.pop("commit_count")
+
+        is_merge = d.pop("is_merge")
+
+        saves = []
+        _saves = d.pop("saves")
+        for saves_item_data in _saves:
+            saves_item = CardHistoryEntrySavesItem.from_dict(saves_item_data)
+
+            saves.append(saves_item)
+
+        card_history_entry = cls(
+            first_oid=first_oid,
+            last_oid=last_oid,
+            parent_oids=parent_oids,
+            visible_parent_oids=visible_parent_oids,
+            author=author,
+            started_at=started_at,
+            ended_at=ended_at,
+            kind=kind,
+            summary=summary,
+            commit_count=commit_count,
+            is_merge=is_merge,
+            saves=saves,
+        )
+
+        card_history_entry.additional_properties = d
+        return card_history_entry
+
+    @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_history_entry_kind.py

@@ -0,0 +1,16 @@
+from enum import StrEnum
+
+
+class CardHistoryEntryKind(StrEnum):
+    CREATED = "created"
+    DELETED = "deleted"
+    LINKS = "links"
+    MERGED = "merged"
+    MILESTONES = "milestones"
+    MOVED = "moved"
+    PERMANENTLY_DELETED = "permanently_deleted"
+    RESTORED = "restored"
+    UPDATED = "updated"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/card_history_entry_saves_item.py

@@ -0,0 +1,94 @@
+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="CardHistoryEntrySavesItem")
+
+
+@_attrs_define
+class CardHistoryEntrySavesItem:
+    """
+    Attributes:
+        oid (str):
+        parent_oids (list[str]):
+        authored_at (int):
+        committed_at (int):
+        message (str):
+    """
+
+    oid: str
+    parent_oids: list[str]
+    authored_at: int
+    committed_at: int
+    message: str
+    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
+
+        authored_at = self.authored_at
+
+        committed_at = self.committed_at
+
+        message = self.message
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "oid": oid,
+                "parent_oids": parent_oids,
+                "authored_at": authored_at,
+                "committed_at": committed_at,
+                "message": message,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        oid = d.pop("oid")
+
+        parent_oids = cast(list[str], d.pop("parent_oids"))
+
+        authored_at = d.pop("authored_at")
+
+        committed_at = d.pop("committed_at")
+
+        message = d.pop("message")
+
+        card_history_entry_saves_item = cls(
+            oid=oid,
+            parent_oids=parent_oids,
+            authored_at=authored_at,
+            committed_at=committed_at,
+            message=message,
+        )
+
+        card_history_entry_saves_item.additional_properties = d
+        return card_history_entry_saves_item
+
+    @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