holder-python 0.2.5__py3-none-any.whl

holder/generated/models/search_messages_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.search_message_item import SearchMessageItem
+
+
+T = TypeVar("T", bound="SearchMessagesResponse")
+
+
+@_attrs_define
+class SearchMessagesResponse:
+    """
+    Attributes:
+        ok (bool):
+        data (list[SearchMessageItem]):
+    """
+
+    ok: bool
+    data: list[SearchMessageItem]
+    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.search_message_item import SearchMessageItem
+
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = SearchMessageItem.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        search_messages_response = cls(
+            ok=ok,
+            data=data,
+        )
+
+        search_messages_response.additional_properties = d
+        return search_messages_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/storage_location.py

@@ -0,0 +1,149 @@
+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.storage_location_provider import StorageLocationProvider
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.storage_location_configuration import StorageLocationConfiguration
+
+
+T = TypeVar("T", bound="StorageLocation")
+
+
+@_attrs_define
+class StorageLocation:
+    """
+    Attributes:
+        location_id (str):
+        project_id (str):
+        name (str):
+        provider (StorageLocationProvider):
+        configuration (StorageLocationConfiguration): Portable non-secret provider configuration.
+        bound (bool):
+        created_at (int):
+        updated_at (int):
+        binding_preview (None | str | Unset): Safe display text; credentials are never returned.
+    """
+
+    location_id: str
+    project_id: str
+    name: str
+    provider: StorageLocationProvider
+    configuration: StorageLocationConfiguration
+    bound: bool
+    created_at: int
+    updated_at: int
+    binding_preview: None | str | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        location_id = self.location_id
+
+        project_id = self.project_id
+
+        name = self.name
+
+        provider = self.provider.value
+
+        configuration = self.configuration.to_dict()
+
+        bound = self.bound
+
+        created_at = self.created_at
+
+        updated_at = self.updated_at
+
+        binding_preview: None | str | Unset
+        if isinstance(self.binding_preview, Unset):
+            binding_preview = UNSET
+        else:
+            binding_preview = self.binding_preview
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "location_id": location_id,
+                "project_id": project_id,
+                "name": name,
+                "provider": provider,
+                "configuration": configuration,
+                "bound": bound,
+                "created_at": created_at,
+                "updated_at": updated_at,
+            }
+        )
+        if binding_preview is not UNSET:
+            field_dict["binding_preview"] = binding_preview
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.storage_location_configuration import (
+            StorageLocationConfiguration,
+        )
+
+        d = dict(src_dict)
+        location_id = d.pop("location_id")
+
+        project_id = d.pop("project_id")
+
+        name = d.pop("name")
+
+        provider = StorageLocationProvider(d.pop("provider"))
+
+        configuration = StorageLocationConfiguration.from_dict(d.pop("configuration"))
+
+        bound = d.pop("bound")
+
+        created_at = d.pop("created_at")
+
+        updated_at = d.pop("updated_at")
+
+        def _parse_binding_preview(data: object) -> None | str | Unset:
+            if data is None:
+                return data
+            if isinstance(data, Unset):
+                return data
+            return cast(None | str | Unset, data)
+
+        binding_preview = _parse_binding_preview(d.pop("binding_preview", UNSET))
+
+        storage_location = cls(
+            location_id=location_id,
+            project_id=project_id,
+            name=name,
+            provider=provider,
+            configuration=configuration,
+            bound=bound,
+            created_at=created_at,
+            updated_at=updated_at,
+            binding_preview=binding_preview,
+        )
+
+        storage_location.additional_properties = d
+        return storage_location
+
+    @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/storage_location_configuration.py

@@ -0,0 +1,48 @@
+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="StorageLocationConfiguration")
+
+
+@_attrs_define
+class StorageLocationConfiguration:
+    """Portable non-secret provider configuration."""
+
+    additional_properties: dict[str, str] = _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)
+        storage_location_configuration = cls()
+
+        storage_location_configuration.additional_properties = d
+        return storage_location_configuration
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: 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/storage_location_list_response.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.storage_location import StorageLocation
+
+
+T = TypeVar("T", bound="StorageLocationListResponse")
+
+
+@_attrs_define
+class StorageLocationListResponse:
+    """
+    Attributes:
+        ok (bool):
+        data (list[StorageLocation]):
+        preferred_location_id (None | str):
+    """
+
+    ok: bool
+    data: list[StorageLocation]
+    preferred_location_id: None | str
+    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)
+
+        preferred_location_id: None | str
+        preferred_location_id = self.preferred_location_id
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "ok": ok,
+                "data": data,
+                "preferred_location_id": preferred_location_id,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.storage_location import StorageLocation
+
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        data = []
+        _data = d.pop("data")
+        for data_item_data in _data:
+            data_item = StorageLocation.from_dict(data_item_data)
+
+            data.append(data_item)
+
+        def _parse_preferred_location_id(data: object) -> None | str:
+            if data is None:
+                return data
+            return cast(None | str, data)
+
+        preferred_location_id = _parse_preferred_location_id(
+            d.pop("preferred_location_id")
+        )
+
+        storage_location_list_response = cls(
+            ok=ok,
+            data=data,
+            preferred_location_id=preferred_location_id,
+        )
+
+        storage_location_list_response.additional_properties = d
+        return storage_location_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/storage_location_provider.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+
+class StorageLocationProvider(StrEnum):
+    LOCAL_DIRECTORY = "local_directory"
+    S3_COMPATIBLE = "s3_compatible"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/storage_location_request.py

@@ -0,0 +1,118 @@
+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 ..models.storage_location_request_provider import StorageLocationRequestProvider
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.storage_location_request_configuration import (
+        StorageLocationRequestConfiguration,
+    )
+
+
+T = TypeVar("T", bound="StorageLocationRequest")
+
+
+@_attrs_define
+class StorageLocationRequest:
+    """
+    Attributes:
+        project_id (str):
+        name (str):
+        provider (StorageLocationRequestProvider):
+        location_id (str | Unset):
+        configuration (StorageLocationRequestConfiguration | Unset):
+    """
+
+    project_id: str
+    name: str
+    provider: StorageLocationRequestProvider
+    location_id: str | Unset = UNSET
+    configuration: StorageLocationRequestConfiguration | 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
+
+        name = self.name
+
+        provider = self.provider.value
+
+        location_id = self.location_id
+
+        configuration: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.configuration, Unset):
+            configuration = self.configuration.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "project_id": project_id,
+                "name": name,
+                "provider": provider,
+            }
+        )
+        if location_id is not UNSET:
+            field_dict["location_id"] = location_id
+        if configuration is not UNSET:
+            field_dict["configuration"] = configuration
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls, src_dict: Mapping[str, Any]) -> Self:
+        from ..models.storage_location_request_configuration import (
+            StorageLocationRequestConfiguration,
+        )
+
+        d = dict(src_dict)
+        project_id = d.pop("project_id")
+
+        name = d.pop("name")
+
+        provider = StorageLocationRequestProvider(d.pop("provider"))
+
+        location_id = d.pop("location_id", UNSET)
+
+        _configuration = d.pop("configuration", UNSET)
+        configuration: StorageLocationRequestConfiguration | Unset
+        if isinstance(_configuration, Unset):
+            configuration = UNSET
+        else:
+            configuration = StorageLocationRequestConfiguration.from_dict(
+                _configuration
+            )
+
+        storage_location_request = cls(
+            project_id=project_id,
+            name=name,
+            provider=provider,
+            location_id=location_id,
+            configuration=configuration,
+        )
+
+        storage_location_request.additional_properties = d
+        return storage_location_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/storage_location_request_configuration.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="StorageLocationRequestConfiguration")
+
+
+@_attrs_define
+class StorageLocationRequestConfiguration:
+    additional_properties: dict[str, str] = _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)
+        storage_location_request_configuration = cls()
+
+        storage_location_request_configuration.additional_properties = d
+        return storage_location_request_configuration
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> str:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: 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/storage_location_request_provider.py

@@ -0,0 +1,9 @@
+from enum import StrEnum
+
+
+class StorageLocationRequestProvider(StrEnum):
+    LOCAL_DIRECTORY = "local_directory"
+    S3_COMPATIBLE = "s3_compatible"
+
+    def __str__(self) -> str:
+        return str(self.value)

holder/generated/models/trash_delete_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.trash_delete_response_data import TrashDeleteResponseData
+
+
+T = TypeVar("T", bound="TrashDeleteResponse")
+
+
+@_attrs_define
+class TrashDeleteResponse:
+    """
+    Attributes:
+        ok (bool):
+        data (TrashDeleteResponseData):
+    """
+
+    ok: bool
+    data: TrashDeleteResponseData
+    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.trash_delete_response_data import (
+            TrashDeleteResponseData,
+        )
+
+        d = dict(src_dict)
+        ok = d.pop("ok")
+
+        data = TrashDeleteResponseData.from_dict(d.pop("data"))
+
+        trash_delete_response = cls(
+            ok=ok,
+            data=data,
+        )
+
+        trash_delete_response.additional_properties = d
+        return trash_delete_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/trash_delete_response_data.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="TrashDeleteResponseData")
+
+
+@_attrs_define
+class TrashDeleteResponseData:
+    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)
+        trash_delete_response_data = cls()
+
+        trash_delete_response_data.additional_properties = d
+        return trash_delete_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