blaxel 0.64.0__py3-none-any.whl

blaxel/models/histogram_stats.py

@@ -0,0 +1,88 @@
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="HistogramStats")
+
+
+@_attrs_define
+class HistogramStats:
+    """Histogram stats
+
+    Attributes:
+        average (Union[Unset, float]): Average request duration
+        p50 (Union[Unset, float]): P50 request duration
+        p90 (Union[Unset, float]): P90 request duration
+        p99 (Union[Unset, float]): P99 request duration
+    """
+
+    average: Union[Unset, float] = UNSET
+    p50: Union[Unset, float] = UNSET
+    p90: Union[Unset, float] = UNSET
+    p99: Union[Unset, float] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        average = self.average
+
+        p50 = self.p50
+
+        p90 = self.p90
+
+        p99 = self.p99
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if average is not UNSET:
+            field_dict["average"] = average
+        if p50 is not UNSET:
+            field_dict["p50"] = p50
+        if p90 is not UNSET:
+            field_dict["p90"] = p90
+        if p99 is not UNSET:
+            field_dict["p99"] = p99
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        average = d.pop("average", UNSET)
+
+        p50 = d.pop("p50", UNSET)
+
+        p90 = d.pop("p90", UNSET)
+
+        p99 = d.pop("p99", UNSET)
+
+        histogram_stats = cls(
+            average=average,
+            p50=p50,
+            p90=p90,
+            p99=p99,
+        )
+
+        histogram_stats.additional_properties = d
+        return histogram_stats
+
+    @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

blaxel/models/integration_connection.py

@@ -0,0 +1,96 @@
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.integration_connection_spec import IntegrationConnectionSpec
+    from ..models.metadata import Metadata
+
+
+T = TypeVar("T", bound="IntegrationConnection")
+
+
+@_attrs_define
+class IntegrationConnection:
+    """Integration Connection
+
+    Attributes:
+        metadata (Union[Unset, Metadata]): Metadata
+        spec (Union[Unset, IntegrationConnectionSpec]): Integration connection specification
+    """
+
+    metadata: Union[Unset, "Metadata"] = UNSET
+    spec: Union[Unset, "IntegrationConnectionSpec"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        metadata: Union[Unset, dict[str, Any]] = UNSET
+        if self.metadata and not isinstance(self.metadata, Unset) and not isinstance(self.metadata, dict):
+            metadata = self.metadata.to_dict()
+        elif self.metadata and isinstance(self.metadata, dict):
+            metadata = self.metadata
+
+        spec: Union[Unset, dict[str, Any]] = UNSET
+        if self.spec and not isinstance(self.spec, Unset) and not isinstance(self.spec, dict):
+            spec = self.spec.to_dict()
+        elif self.spec and isinstance(self.spec, dict):
+            spec = self.spec
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if metadata is not UNSET:
+            field_dict["metadata"] = metadata
+        if spec is not UNSET:
+            field_dict["spec"] = spec
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.integration_connection_spec import IntegrationConnectionSpec
+        from ..models.metadata import Metadata
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        _metadata = d.pop("metadata", UNSET)
+        metadata: Union[Unset, Metadata]
+        if isinstance(_metadata, Unset):
+            metadata = UNSET
+        else:
+            metadata = Metadata.from_dict(_metadata)
+
+        _spec = d.pop("spec", UNSET)
+        spec: Union[Unset, IntegrationConnectionSpec]
+        if isinstance(_spec, Unset):
+            spec = UNSET
+        else:
+            spec = IntegrationConnectionSpec.from_dict(_spec)
+
+        integration_connection = cls(
+            metadata=metadata,
+            spec=spec,
+        )
+
+        integration_connection.additional_properties = d
+        return integration_connection
+
+    @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

blaxel/models/integration_connection_spec.py

@@ -0,0 +1,114 @@
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.integration_connection_spec_config import IntegrationConnectionSpecConfig
+    from ..models.integration_connection_spec_secret import IntegrationConnectionSpecSecret
+
+
+T = TypeVar("T", bound="IntegrationConnectionSpec")
+
+
+@_attrs_define
+class IntegrationConnectionSpec:
+    """Integration connection specification
+
+    Attributes:
+        config (Union[Unset, IntegrationConnectionSpecConfig]): Additional configuration for the integration
+        integration (Union[Unset, str]): Integration type
+        sandbox (Union[Unset, bool]): Sandbox mode
+        secret (Union[Unset, IntegrationConnectionSpecSecret]): Integration secret
+    """
+
+    config: Union[Unset, "IntegrationConnectionSpecConfig"] = UNSET
+    integration: Union[Unset, str] = UNSET
+    sandbox: Union[Unset, bool] = UNSET
+    secret: Union[Unset, "IntegrationConnectionSpecSecret"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        config: Union[Unset, dict[str, Any]] = UNSET
+        if self.config and not isinstance(self.config, Unset) and not isinstance(self.config, dict):
+            config = self.config.to_dict()
+        elif self.config and isinstance(self.config, dict):
+            config = self.config
+
+        integration = self.integration
+
+        sandbox = self.sandbox
+
+        secret: Union[Unset, dict[str, Any]] = UNSET
+        if self.secret and not isinstance(self.secret, Unset) and not isinstance(self.secret, dict):
+            secret = self.secret.to_dict()
+        elif self.secret and isinstance(self.secret, dict):
+            secret = self.secret
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if config is not UNSET:
+            field_dict["config"] = config
+        if integration is not UNSET:
+            field_dict["integration"] = integration
+        if sandbox is not UNSET:
+            field_dict["sandbox"] = sandbox
+        if secret is not UNSET:
+            field_dict["secret"] = secret
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.integration_connection_spec_config import IntegrationConnectionSpecConfig
+        from ..models.integration_connection_spec_secret import IntegrationConnectionSpecSecret
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        _config = d.pop("config", UNSET)
+        config: Union[Unset, IntegrationConnectionSpecConfig]
+        if isinstance(_config, Unset):
+            config = UNSET
+        else:
+            config = IntegrationConnectionSpecConfig.from_dict(_config)
+
+        integration = d.pop("integration", UNSET)
+
+        sandbox = d.pop("sandbox", UNSET)
+
+        _secret = d.pop("secret", UNSET)
+        secret: Union[Unset, IntegrationConnectionSpecSecret]
+        if isinstance(_secret, Unset):
+            secret = UNSET
+        else:
+            secret = IntegrationConnectionSpecSecret.from_dict(_secret)
+
+        integration_connection_spec = cls(
+            config=config,
+            integration=integration,
+            sandbox=sandbox,
+            secret=secret,
+        )
+
+        integration_connection_spec.additional_properties = d
+        return integration_connection_spec
+
+    @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

blaxel/models/integration_connection_spec_config.py

@@ -0,0 +1,45 @@
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="IntegrationConnectionSpecConfig")
+
+
+@_attrs_define
+class IntegrationConnectionSpecConfig:
+    """Additional configuration for the integration"""
+
+    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: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        integration_connection_spec_config = cls()
+
+        integration_connection_spec_config.additional_properties = d
+        return integration_connection_spec_config
+
+    @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

blaxel/models/integration_connection_spec_secret.py

@@ -0,0 +1,45 @@
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="IntegrationConnectionSpecSecret")
+
+
+@_attrs_define
+class IntegrationConnectionSpecSecret:
+    """Integration secret"""
+
+    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: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        integration_connection_spec_secret = cls()
+
+        integration_connection_spec_secret.additional_properties = d
+        return integration_connection_spec_secret
+
+    @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

blaxel/models/integration_model.py

@@ -0,0 +1,162 @@
+from typing import Any, TypeVar, Union, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="IntegrationModel")
+
+
+@_attrs_define
+class IntegrationModel:
+    """Model obtained from an external authentication provider, such as HuggingFace, OpenAI, etc...
+
+    Attributes:
+        author (Union[Unset, str]): Provider model author
+        created_at (Union[Unset, str]): Provider model created at
+        downloads (Union[Unset, int]): Provider model downloads
+        endpoint (Union[Unset, str]): Model endpoint URL
+        id (Union[Unset, str]): Provider model ID
+        library_name (Union[Unset, str]): Provider model library name
+        likes (Union[Unset, int]): Provider model likes
+        model_private (Union[Unset, str]): Is the model private
+        name (Union[Unset, str]): Provider model name
+        pipeline_tag (Union[Unset, str]): Provider model pipeline tag
+        tags (Union[Unset, list[str]]): Provider model tags
+        trending_score (Union[Unset, int]): Provider model trending score
+    """
+
+    author: Union[Unset, str] = UNSET
+    created_at: Union[Unset, str] = UNSET
+    downloads: Union[Unset, int] = UNSET
+    endpoint: Union[Unset, str] = UNSET
+    id: Union[Unset, str] = UNSET
+    library_name: Union[Unset, str] = UNSET
+    likes: Union[Unset, int] = UNSET
+    model_private: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    pipeline_tag: Union[Unset, str] = UNSET
+    tags: Union[Unset, list[str]] = UNSET
+    trending_score: Union[Unset, int] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        author = self.author
+
+        created_at = self.created_at
+
+        downloads = self.downloads
+
+        endpoint = self.endpoint
+
+        id = self.id
+
+        library_name = self.library_name
+
+        likes = self.likes
+
+        model_private = self.model_private
+
+        name = self.name
+
+        pipeline_tag = self.pipeline_tag
+
+        tags: Union[Unset, list[str]] = UNSET
+        if not isinstance(self.tags, Unset):
+            tags = self.tags
+
+        trending_score = self.trending_score
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if author is not UNSET:
+            field_dict["author"] = author
+        if created_at is not UNSET:
+            field_dict["created_at"] = created_at
+        if downloads is not UNSET:
+            field_dict["downloads"] = downloads
+        if endpoint is not UNSET:
+            field_dict["endpoint"] = endpoint
+        if id is not UNSET:
+            field_dict["id"] = id
+        if library_name is not UNSET:
+            field_dict["library_name"] = library_name
+        if likes is not UNSET:
+            field_dict["likes"] = likes
+        if model_private is not UNSET:
+            field_dict["model_private"] = model_private
+        if name is not UNSET:
+            field_dict["name"] = name
+        if pipeline_tag is not UNSET:
+            field_dict["pipeline_tag"] = pipeline_tag
+        if tags is not UNSET:
+            field_dict["tags"] = tags
+        if trending_score is not UNSET:
+            field_dict["trending_score"] = trending_score
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        author = d.pop("author", UNSET)
+
+        created_at = d.pop("created_at", UNSET)
+
+        downloads = d.pop("downloads", UNSET)
+
+        endpoint = d.pop("endpoint", UNSET)
+
+        id = d.pop("id", UNSET)
+
+        library_name = d.pop("library_name", UNSET)
+
+        likes = d.pop("likes", UNSET)
+
+        model_private = d.pop("model_private", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        pipeline_tag = d.pop("pipeline_tag", UNSET)
+
+        tags = cast(list[str], d.pop("tags", UNSET))
+
+        trending_score = d.pop("trending_score", UNSET)
+
+        integration_model = cls(
+            author=author,
+            created_at=created_at,
+            downloads=downloads,
+            endpoint=endpoint,
+            id=id,
+            library_name=library_name,
+            likes=likes,
+            model_private=model_private,
+            name=name,
+            pipeline_tag=pipeline_tag,
+            tags=tags,
+            trending_score=trending_score,
+        )
+
+        integration_model.additional_properties = d
+        return integration_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

blaxel/models/integration_repository.py

@@ -0,0 +1,88 @@
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="IntegrationRepository")
+
+
+@_attrs_define
+class IntegrationRepository:
+    """Integration repository
+
+    Attributes:
+        id (Union[Unset, str]): Repository ID
+        name (Union[Unset, str]): Repository name
+        organization (Union[Unset, str]): Repository owner
+        url (Union[Unset, str]): Repository URL
+    """
+
+    id: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    organization: Union[Unset, str] = UNSET
+    url: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        id = self.id
+
+        name = self.name
+
+        organization = self.organization
+
+        url = self.url
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if id is not UNSET:
+            field_dict["id"] = id
+        if name is not UNSET:
+            field_dict["name"] = name
+        if organization is not UNSET:
+            field_dict["organization"] = organization
+        if url is not UNSET:
+            field_dict["url"] = url
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        id = d.pop("id", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        organization = d.pop("organization", UNSET)
+
+        url = d.pop("url", UNSET)
+
+        integration_repository = cls(
+            id=id,
+            name=name,
+            organization=organization,
+            url=url,
+        )
+
+        integration_repository.additional_properties = d
+        return integration_repository
+
+    @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

blaxel/models/invite_workspace_user_body.py

@@ -0,0 +1,60 @@
+from typing import Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="InviteWorkspaceUserBody")
+
+
+@_attrs_define
+class InviteWorkspaceUserBody:
+    """
+    Attributes:
+        email (Union[Unset, str]):
+    """
+
+    email: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        email = self.email
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if email is not UNSET:
+            field_dict["email"] = email
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        email = d.pop("email", UNSET)
+
+        invite_workspace_user_body = cls(
+            email=email,
+        )
+
+        invite_workspace_user_body.additional_properties = d
+        return invite_workspace_user_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