blaxel 0.1.9rc36__py3-none-any.whl → 0.1.10__py3-none-any.whl

blaxel/client/models/integration.py

@@ -0,0 +1,197 @@
+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_additional_infos import IntegrationAdditionalInfos
+    from ..models.integration_endpoints import IntegrationEndpoints
+    from ..models.integration_headers import IntegrationHeaders
+    from ..models.integration_organization import IntegrationOrganization
+    from ..models.integration_query_params import IntegrationQueryParams
+    from ..models.integration_repository import IntegrationRepository
+
+
+T = TypeVar("T", bound="Integration")
+
+
+@_attrs_define
+class Integration:
+    """Integration
+
+    Attributes:
+        additional_infos (Union[Unset, IntegrationAdditionalInfos]): Integration additional infos
+        endpoints (Union[Unset, IntegrationEndpoints]): Integration endpoints
+        headers (Union[Unset, IntegrationHeaders]): Integration headers
+        name (Union[Unset, str]): Integration name
+        organizations (Union[Unset, list['IntegrationOrganization']]): Integration organizations
+        params (Union[Unset, IntegrationQueryParams]): Integration query params
+        repositories (Union[Unset, list['IntegrationRepository']]): Integration repositories
+    """
+
+    additional_infos: Union[Unset, "IntegrationAdditionalInfos"] = UNSET
+    endpoints: Union[Unset, "IntegrationEndpoints"] = UNSET
+    headers: Union[Unset, "IntegrationHeaders"] = UNSET
+    name: Union[Unset, str] = UNSET
+    organizations: Union[Unset, list["IntegrationOrganization"]] = UNSET
+    params: Union[Unset, "IntegrationQueryParams"] = UNSET
+    repositories: Union[Unset, list["IntegrationRepository"]] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        additional_infos: Union[Unset, dict[str, Any]] = UNSET
+        if (
+            self.additional_infos
+            and not isinstance(self.additional_infos, Unset)
+            and not isinstance(self.additional_infos, dict)
+        ):
+            additional_infos = self.additional_infos.to_dict()
+        elif self.additional_infos and isinstance(self.additional_infos, dict):
+            additional_infos = self.additional_infos
+
+        endpoints: Union[Unset, dict[str, Any]] = UNSET
+        if self.endpoints and not isinstance(self.endpoints, Unset) and not isinstance(self.endpoints, dict):
+            endpoints = self.endpoints.to_dict()
+        elif self.endpoints and isinstance(self.endpoints, dict):
+            endpoints = self.endpoints
+
+        headers: Union[Unset, dict[str, Any]] = UNSET
+        if self.headers and not isinstance(self.headers, Unset) and not isinstance(self.headers, dict):
+            headers = self.headers.to_dict()
+        elif self.headers and isinstance(self.headers, dict):
+            headers = self.headers
+
+        name = self.name
+
+        organizations: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.organizations, Unset):
+            organizations = []
+            for organizations_item_data in self.organizations:
+                if type(organizations_item_data) == dict:
+                    organizations_item = organizations_item_data
+                else:
+                    organizations_item = organizations_item_data.to_dict()
+                organizations.append(organizations_item)
+
+        params: Union[Unset, dict[str, Any]] = UNSET
+        if self.params and not isinstance(self.params, Unset) and not isinstance(self.params, dict):
+            params = self.params.to_dict()
+        elif self.params and isinstance(self.params, dict):
+            params = self.params
+
+        repositories: Union[Unset, list[dict[str, Any]]] = UNSET
+        if not isinstance(self.repositories, Unset):
+            repositories = []
+            for repositories_item_data in self.repositories:
+                if type(repositories_item_data) == dict:
+                    repositories_item = repositories_item_data
+                else:
+                    repositories_item = repositories_item_data.to_dict()
+                repositories.append(repositories_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if additional_infos is not UNSET:
+            field_dict["additionalInfos"] = additional_infos
+        if endpoints is not UNSET:
+            field_dict["endpoints"] = endpoints
+        if headers is not UNSET:
+            field_dict["headers"] = headers
+        if name is not UNSET:
+            field_dict["name"] = name
+        if organizations is not UNSET:
+            field_dict["organizations"] = organizations
+        if params is not UNSET:
+            field_dict["params"] = params
+        if repositories is not UNSET:
+            field_dict["repositories"] = repositories
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.integration_additional_infos import IntegrationAdditionalInfos
+        from ..models.integration_endpoints import IntegrationEndpoints
+        from ..models.integration_headers import IntegrationHeaders
+        from ..models.integration_organization import IntegrationOrganization
+        from ..models.integration_query_params import IntegrationQueryParams
+        from ..models.integration_repository import IntegrationRepository
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        _additional_infos = d.pop("additionalInfos", UNSET)
+        additional_infos: Union[Unset, IntegrationAdditionalInfos]
+        if isinstance(_additional_infos, Unset):
+            additional_infos = UNSET
+        else:
+            additional_infos = IntegrationAdditionalInfos.from_dict(_additional_infos)
+
+        _endpoints = d.pop("endpoints", UNSET)
+        endpoints: Union[Unset, IntegrationEndpoints]
+        if isinstance(_endpoints, Unset):
+            endpoints = UNSET
+        else:
+            endpoints = IntegrationEndpoints.from_dict(_endpoints)
+
+        _headers = d.pop("headers", UNSET)
+        headers: Union[Unset, IntegrationHeaders]
+        if isinstance(_headers, Unset):
+            headers = UNSET
+        else:
+            headers = IntegrationHeaders.from_dict(_headers)
+
+        name = d.pop("name", UNSET)
+
+        organizations = []
+        _organizations = d.pop("organizations", UNSET)
+        for organizations_item_data in _organizations or []:
+            organizations_item = IntegrationOrganization.from_dict(organizations_item_data)
+
+            organizations.append(organizations_item)
+
+        _params = d.pop("params", UNSET)
+        params: Union[Unset, IntegrationQueryParams]
+        if isinstance(_params, Unset):
+            params = UNSET
+        else:
+            params = IntegrationQueryParams.from_dict(_params)
+
+        repositories = []
+        _repositories = d.pop("repositories", UNSET)
+        for repositories_item_data in _repositories or []:
+            repositories_item = IntegrationRepository.from_dict(repositories_item_data)
+
+            repositories.append(repositories_item)
+
+        integration = cls(
+            additional_infos=additional_infos,
+            endpoints=endpoints,
+            headers=headers,
+            name=name,
+            organizations=organizations,
+            params=params,
+            repositories=repositories,
+        )
+
+        integration.additional_properties = d
+        return integration
+
+    @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/client/models/integration_additional_infos.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="IntegrationAdditionalInfos")
+
+
+@_attrs_define
+class IntegrationAdditionalInfos:
+    """Integration additional infos"""
+
+    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: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        integration_additional_infos = cls()
+
+        integration_additional_infos.additional_properties = d
+        return integration_additional_infos
+
+    @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

blaxel/client/models/integration_endpoint.py

@@ -0,0 +1,143 @@
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
+
+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_endpoint_token import IntegrationEndpointToken
+
+
+T = TypeVar("T", bound="IntegrationEndpoint")
+
+
+@_attrs_define
+class IntegrationEndpoint:
+    """Integration endpoint
+
+    Attributes:
+        body (Union[Unset, str]): Integration endpoint body
+        ignore_models (Union[Unset, list[Any]]): Integration endpoint ignore models
+        method (Union[Unset, str]): Integration endpoint method
+        models (Union[Unset, list[Any]]): Integration endpoint models
+        stream_key (Union[Unset, str]): Integration endpoint stream key
+        stream_token (Union[Unset, IntegrationEndpointToken]): Integration endpoint token
+        token (Union[Unset, IntegrationEndpointToken]): Integration endpoint token
+    """
+
+    body: Union[Unset, str] = UNSET
+    ignore_models: Union[Unset, list[Any]] = UNSET
+    method: Union[Unset, str] = UNSET
+    models: Union[Unset, list[Any]] = UNSET
+    stream_key: Union[Unset, str] = UNSET
+    stream_token: Union[Unset, "IntegrationEndpointToken"] = UNSET
+    token: Union[Unset, "IntegrationEndpointToken"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        body = self.body
+
+        ignore_models: Union[Unset, list[Any]] = UNSET
+        if not isinstance(self.ignore_models, Unset):
+            ignore_models = self.ignore_models
+
+        method = self.method
+
+        models: Union[Unset, list[Any]] = UNSET
+        if not isinstance(self.models, Unset):
+            models = self.models
+
+        stream_key = self.stream_key
+
+        stream_token: Union[Unset, dict[str, Any]] = UNSET
+        if self.stream_token and not isinstance(self.stream_token, Unset) and not isinstance(self.stream_token, dict):
+            stream_token = self.stream_token.to_dict()
+        elif self.stream_token and isinstance(self.stream_token, dict):
+            stream_token = self.stream_token
+
+        token: Union[Unset, dict[str, Any]] = UNSET
+        if self.token and not isinstance(self.token, Unset) and not isinstance(self.token, dict):
+            token = self.token.to_dict()
+        elif self.token and isinstance(self.token, dict):
+            token = self.token
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if body is not UNSET:
+            field_dict["body"] = body
+        if ignore_models is not UNSET:
+            field_dict["ignoreModels"] = ignore_models
+        if method is not UNSET:
+            field_dict["method"] = method
+        if models is not UNSET:
+            field_dict["models"] = models
+        if stream_key is not UNSET:
+            field_dict["streamKey"] = stream_key
+        if stream_token is not UNSET:
+            field_dict["streamToken"] = stream_token
+        if token is not UNSET:
+            field_dict["token"] = token
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.integration_endpoint_token import IntegrationEndpointToken
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        body = d.pop("body", UNSET)
+
+        ignore_models = cast(list[Any], d.pop("ignoreModels", UNSET))
+
+        method = d.pop("method", UNSET)
+
+        models = cast(list[Any], d.pop("models", UNSET))
+
+        stream_key = d.pop("streamKey", UNSET)
+
+        _stream_token = d.pop("streamToken", UNSET)
+        stream_token: Union[Unset, IntegrationEndpointToken]
+        if isinstance(_stream_token, Unset):
+            stream_token = UNSET
+        else:
+            stream_token = IntegrationEndpointToken.from_dict(_stream_token)
+
+        _token = d.pop("token", UNSET)
+        token: Union[Unset, IntegrationEndpointToken]
+        if isinstance(_token, Unset):
+            token = UNSET
+        else:
+            token = IntegrationEndpointToken.from_dict(_token)
+
+        integration_endpoint = cls(
+            body=body,
+            ignore_models=ignore_models,
+            method=method,
+            models=models,
+            stream_key=stream_key,
+            stream_token=stream_token,
+            token=token,
+        )
+
+        integration_endpoint.additional_properties = d
+        return integration_endpoint
+
+    @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/client/models/integration_endpoint_token.py

@@ -0,0 +1,79 @@
+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="IntegrationEndpointToken")
+
+
+@_attrs_define
+class IntegrationEndpointToken:
+    """Integration endpoint token
+
+    Attributes:
+        received (Union[Unset, str]): Integration endpoint token received
+        sent (Union[Unset, str]): Integration endpoint token sent
+        total (Union[Unset, str]): Integration endpoint token total
+    """
+
+    received: Union[Unset, str] = UNSET
+    sent: Union[Unset, str] = UNSET
+    total: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        received = self.received
+
+        sent = self.sent
+
+        total = self.total
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if received is not UNSET:
+            field_dict["received"] = received
+        if sent is not UNSET:
+            field_dict["sent"] = sent
+        if total is not UNSET:
+            field_dict["total"] = total
+
+        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()
+        received = d.pop("received", UNSET)
+
+        sent = d.pop("sent", UNSET)
+
+        total = d.pop("total", UNSET)
+
+        integration_endpoint_token = cls(
+            received=received,
+            sent=sent,
+            total=total,
+        )
+
+        integration_endpoint_token.additional_properties = d
+        return integration_endpoint_token
+
+    @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/client/models/integration_endpoints.py

@@ -0,0 +1,61 @@
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.integration_endpoint import IntegrationEndpoint
+
+
+T = TypeVar("T", bound="IntegrationEndpoints")
+
+
+@_attrs_define
+class IntegrationEndpoints:
+    """Integration endpoints"""
+
+    additional_properties: dict[str, "IntegrationEndpoint"] = _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():
+            if type(prop) == dict:
+                field_dict[prop_name] = prop
+            else:
+                field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: dict[str, Any]) -> T:
+        from ..models.integration_endpoint import IntegrationEndpoint
+
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        integration_endpoints = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = IntegrationEndpoint.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        integration_endpoints.additional_properties = additional_properties
+        return integration_endpoints
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> "IntegrationEndpoint":
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: "IntegrationEndpoint") -> 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/client/models/integration_headers.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="IntegrationHeaders")
+
+
+@_attrs_define
+class IntegrationHeaders:
+    """Integration headers"""
+
+    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: type[T], src_dict: dict[str, Any]) -> T:
+        if not src_dict:
+            return None
+        d = src_dict.copy()
+        integration_headers = cls()
+
+        integration_headers.additional_properties = d
+        return integration_headers
+
+    @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

blaxel/client/models/integration_organization.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="IntegrationOrganization")
+
+
+@_attrs_define
+class IntegrationOrganization:
+    """Integration organization
+
+    Attributes:
+        avatar_url (Union[Unset, str]): Provider organization avatar URL
+        display_name (Union[Unset, str]): Provider organization display name
+        id (Union[Unset, str]): Provider organization ID
+        name (Union[Unset, str]): Provider organization name
+    """
+
+    avatar_url: Union[Unset, str] = UNSET
+    display_name: Union[Unset, str] = UNSET
+    id: Union[Unset, str] = UNSET
+    name: Union[Unset, str] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        avatar_url = self.avatar_url
+
+        display_name = self.display_name
+
+        id = self.id
+
+        name = self.name
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if avatar_url is not UNSET:
+            field_dict["avatar_url"] = avatar_url
+        if display_name is not UNSET:
+            field_dict["displayName"] = display_name
+        if id is not UNSET:
+            field_dict["id"] = id
+        if name is not UNSET:
+            field_dict["name"] = name
+
+        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()
+        avatar_url = d.pop("avatar_url", UNSET)
+
+        display_name = d.pop("displayName", UNSET)
+
+        id = d.pop("id", UNSET)
+
+        name = d.pop("name", UNSET)
+
+        integration_organization = cls(
+            avatar_url=avatar_url,
+            display_name=display_name,
+            id=id,
+            name=name,
+        )
+
+        integration_organization.additional_properties = d
+        return integration_organization
+
+    @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