holder-python 0.2.5__py3-none-any.whl

holder/generated/models/resource_list_response.py

@@ -0,0 +1,134 @@
+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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.resource import Resource
+
+
+T = TypeVar("T", bound="ResourceListResponse")
+
+
+@_attrs_define
+class ResourceListResponse:
+    """
+    Attributes:
+        ok (bool):
+        data (list[Resource]):
+        card_id (str | Unset): Canonical live card ID, present only for card attachment lists.
+        limit (int | Unset):
+        offset (int | Unset):
+        next_offset (int | None | Unset): Present for card lists; null when exhausted, otherwise continue here (the next
+            page may be empty).
+    """
+
+    ok: bool
+    data: list[Resource]
+    card_id: str | Unset = UNSET
+    limit: int | Unset = UNSET
+    offset: int | Unset = UNSET
+    next_offset: int | None | Unset = UNSET
+    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)
+
+        card_id = self.card_id
+
+        limit = self.limit
+
+        offset = self.offset
+
+        next_offset: int | None | Unset
+        if isinstance(self.next_offset, Unset):
+            next_offset = UNSET
+        else:
+            next_offset = self.next_offset
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "ok": ok,
+                "data": data,
+            }
+        )
+        if card_id is not UNSET:
+            field_dict["card_id"] = card_id
+        if limit is not UNSET:
+            field_dict["limit"] = limit
+        if offset is not UNSET:
+            field_dict["offset"] = offset
+        if next_offset is not UNSET:
+            field_dict["next_offset"] = next_offset
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.resource import Resource
+
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = Resource.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        card_id = d.pop("card_id", UNSET)
+
+        limit = d.pop("limit", UNSET)
+
+        offset = d.pop("offset", UNSET)
+
+        def _parse_next_offset(data: object) -> int | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(int | None | Unset, data)
+
+        next_offset = _parse_next_offset(d.pop("next_offset", UNSET))
+
+        resource_list_response = cls(
+            ok=ok,
+            data=data,
+            card_id=card_id,
+            limit=limit,
+            offset=offset,
+            next_offset=next_offset,
+        )
+
+        resource_list_response.additional_properties = d
+        return resource_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/resource_metadata.py

@@ -0,0 +1,55 @@
+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="ResourceMetadata")
+
+
+@_attrs_define
+class ResourceMetadata:
+    """Permissive metadata map. Repeated and custom values are preserved in order."""
+
+    additional_properties: dict[str, list[str]] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        d = dict(src_dict)
+        resource_metadata = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = cast(list[str], prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        resource_metadata.additional_properties = additional_properties
+        return resource_metadata
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> list[str]:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: list[str]) -> 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/resource_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.resource import Resource
+
+
+T = TypeVar("T", bound="ResourceResponse")
+
+
+@_attrs_define
+class ResourceResponse:
+    """
+    Attributes:
+        ok (bool):
+        data (Resource):
+    """
+
+    ok: bool
+    data: Resource
+    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.resource import Resource
+
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        data = Resource.from_dict(d.pop("data"))
+
+        resource_response = cls(
+            ok=ok,
+            data=data,
+        )
+
+        resource_response.additional_properties = d
+        return resource_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/resource_update_request.py

@@ -0,0 +1,102 @@
+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
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.resource_metadata import ResourceMetadata
+
+
+T = TypeVar("T", bound="ResourceUpdateRequest")
+
+
+@_attrs_define
+class ResourceUpdateRequest:
+    """
+    Attributes:
+        type_ (str | Unset):
+        label (str | Unset):
+        metadata (ResourceMetadata | Unset): Permissive metadata map. Repeated and custom values are preserved in order.
+        updated_at (int | Unset):
+    """
+
+    type_: str | Unset = UNSET
+    label: str | Unset = UNSET
+    metadata: ResourceMetadata | Unset = UNSET
+    updated_at: int | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        type_ = self.type_
+
+        label = self.label
+
+        metadata: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.metadata, Unset):
+            metadata = self.metadata.to_dict()
+
+        updated_at = self.updated_at
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if type_ is not UNSET:
+            field_dict["type"] = type_
+        if label is not UNSET:
+            field_dict["label"] = label
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+        if updated_at is not UNSET:
+            field_dict["updated_at"] = updated_at
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.resource_metadata import ResourceMetadata
+
+        d = dict(src_dict)
+        type_ = d.pop("type", UNSET)
+
+        label = d.pop("label", UNSET)
+
+        _metadata = d.pop("metadata", UNSET)
+        metadata: ResourceMetadata | Unset
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = ResourceMetadata.from_dict(_metadata)
+
+        updated_at = d.pop("updated_at", UNSET)
+
+        resource_update_request = cls(
+            type_=type_,
+            label=label,
+            metadata=metadata,
+            updated_at=updated_at,
+        )
+
+        resource_update_request.additional_properties = d
+        return resource_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/runner_capabilities_data.py

@@ -0,0 +1,220 @@
+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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.ai_local_model_config_data import AiLocalModelConfigData
+    from ..models.caste_info import CasteInfo
+    from ..models.caste_recommended_model import CasteRecommendedModel
+    from ..models.local_model import LocalModel
+
+
+T = TypeVar("T", bound="RunnerCapabilitiesData")
+
+
+@_attrs_define
+class RunnerCapabilitiesData:
+    """
+    Attributes:
+        runner_available (bool):
+        last_checked (int):
+        local_model_config (AiLocalModelConfigData):
+        models (list[LocalModel]):
+        recommended_models (list[CasteRecommendedModel]):
+        recommended_install (list[CasteRecommendedModel]):
+        spawn_attempted (bool | Unset):
+        version (str | Unset):
+        error (None | str | Unset):
+        caste (CasteInfo | None | Unset):
+    """
+
+    runner_available: bool
+    last_checked: int
+    local_model_config: AiLocalModelConfigData
+    models: list[LocalModel]
+    recommended_models: list[CasteRecommendedModel]
+    recommended_install: list[CasteRecommendedModel]
+    spawn_attempted: bool | Unset = UNSET
+    version: str | Unset = UNSET
+    error: None | str | Unset = UNSET
+    caste: CasteInfo | None | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        from ..models.caste_info import CasteInfo
+
+        runner_available = self.runner_available
+
+        last_checked = self.last_checked
+
+        local_model_config = self.local_model_config.to_dict()
+
+        models = []
+        for models_item_data in self.models:
+            models_item = models_item_data.to_dict()
+            models.append(models_item)
+
+        recommended_models = []
+        for recommended_models_item_data in self.recommended_models:
+            recommended_models_item = recommended_models_item_data.to_dict()
+            recommended_models.append(recommended_models_item)
+
+        recommended_install = []
+        for recommended_install_item_data in self.recommended_install:
+            recommended_install_item = recommended_install_item_data.to_dict()
+            recommended_install.append(recommended_install_item)
+
+        spawn_attempted = self.spawn_attempted
+
+        version = self.version
+
+        error: None | str | Unset
+        if isinstance(self.error, Unset):
+            error = UNSET
+        else:
+            error = self.error
+
+        caste: dict[str, Any] | None | Unset
+        if isinstance(self.caste, Unset):
+            caste = UNSET
+        elif isinstance(self.caste, CasteInfo):
+            caste = self.caste.to_dict()
+        else:
+            caste = self.caste
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "runner_available": runner_available,
+                "last_checked": last_checked,
+                "local_model_config": local_model_config,
+                "models": models,
+                "recommended_models": recommended_models,
+                "recommended_install": recommended_install,
+            }
+        )
+        if spawn_attempted is not UNSET:
+            field_dict["spawn_attempted"] = spawn_attempted
+        if version is not UNSET:
+            field_dict["version"] = version
+        if error is not UNSET:
+            field_dict["error"] = error
+        if caste is not UNSET:
+            field_dict["caste"] = caste
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.ai_local_model_config_data import (
+            AiLocalModelConfigData,
+        )
+        from ..models.caste_info import CasteInfo
+        from ..models.caste_recommended_model import (
+            CasteRecommendedModel,
+        )
+        from ..models.local_model import LocalModel
+
+        d = dict(src_dict)
+        runner_available = d.pop("runner_available")
+
+        last_checked = d.pop("last_checked")
+
+        local_model_config = AiLocalModelConfigData.from_dict(
+            d.pop("local_model_config")
+        )
+
+        models = []
+        _models = d.pop("models")
+        for models_item_data in _models:
+            models_item = LocalModel.from_dict(models_item_data)
+
+            models.append(models_item)
+
+        recommended_models = []
+        _recommended_models = d.pop("recommended_models")
+        for recommended_models_item_data in _recommended_models:
+            recommended_models_item = CasteRecommendedModel.from_dict(
+                recommended_models_item_data
+            )
+
+            recommended_models.append(recommended_models_item)
+
+        recommended_install = []
+        _recommended_install = d.pop("recommended_install")
+        for recommended_install_item_data in _recommended_install:
+            recommended_install_item = CasteRecommendedModel.from_dict(
+                recommended_install_item_data
+            )
+
+            recommended_install.append(recommended_install_item)
+
+        spawn_attempted = d.pop("spawn_attempted", UNSET)
+
+        version = d.pop("version", UNSET)
+
+        def _parse_error(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        error = _parse_error(d.pop("error", UNSET))
+
+        def _parse_caste(data: object) -> CasteInfo | None | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            try:
+                if not isinstance(data, dict):
+                    raise TypeError()
+                caste_type_1 = CasteInfo.from_dict(data)
+
+                return caste_type_1
+            except (TypeError, ValueError, AttributeError, KeyError):
+                pass
+            return cast(CasteInfo | None | Unset, data)
+
+        caste = _parse_caste(d.pop("caste", UNSET))
+
+        runner_capabilities_data = cls(
+            runner_available=runner_available,
+            last_checked=last_checked,
+            local_model_config=local_model_config,
+            models=models,
+            recommended_models=recommended_models,
+            recommended_install=recommended_install,
+            spawn_attempted=spawn_attempted,
+            version=version,
+            error=error,
+            caste=caste,
+        )
+
+        runner_capabilities_data.additional_properties = d
+        return runner_capabilities_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/runner_capabilities_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.runner_capabilities_data import RunnerCapabilitiesData
+
+
+T = TypeVar("T", bound="RunnerCapabilitiesResponse")
+
+
+@_attrs_define
+class RunnerCapabilitiesResponse:
+    """
+    Attributes:
+        ok (bool):
+        data (RunnerCapabilitiesData):
+    """
+
+    ok: bool
+    data: RunnerCapabilitiesData
+    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.runner_capabilities_data import (
+            RunnerCapabilitiesData,
+        )
+
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        data = RunnerCapabilitiesData.from_dict(d.pop("data"))
+
+        runner_capabilities_response = cls(
+            ok=ok,
+            data=data,
+        )
+
+        runner_capabilities_response.additional_properties = d
+        return runner_capabilities_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