From a8a3cba105b555ecbdc70bd8eb3db4e57c90c0dd Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Thu, 5 Mar 2026 10:41:56 +0000 Subject: [PATCH] Generate ske --- services/ske/oas_commit | 2 +- services/ske/src/stackit/ske/__init__.py | 4 + .../ske/src/stackit/ske/api/default_api.py | 266 ++++++++++++++++++ .../ske/src/stackit/ske/models/__init__.py | 2 + services/ske/src/stackit/ske/models/access.py | 86 ++++++ .../ske/src/stackit/ske/models/cluster.py | 7 + .../src/stackit/ske/models/cluster_error.py | 2 +- .../create_or_update_cluster_payload.py | 7 + .../src/stackit/ske/models/idp_kubeconfig.py | 81 ++++++ 9 files changed, 455 insertions(+), 2 deletions(-) create mode 100644 services/ske/src/stackit/ske/models/access.py create mode 100644 services/ske/src/stackit/ske/models/idp_kubeconfig.py diff --git a/services/ske/oas_commit b/services/ske/oas_commit index 85295bf53..bf3189995 100644 --- a/services/ske/oas_commit +++ b/services/ske/oas_commit @@ -1 +1 @@ -9ba4c1ad01406fe6d0399b971043a2f9f74ea510 +3e9c109388be83b40c16d8cb5ab146aa314eb6e8 diff --git a/services/ske/src/stackit/ske/__init__.py b/services/ske/src/stackit/ske/__init__.py index 9e61c70e9..1b2c7e0c8 100644 --- a/services/ske/src/stackit/ske/__init__.py +++ b/services/ske/src/stackit/ske/__init__.py @@ -29,6 +29,7 @@ "ApiAttributeError", "ApiException", "ACL", + "Access", "AccessScope", "AvailabilityZone", "CRI", @@ -45,6 +46,7 @@ "Hibernation", "HibernationSchedule", "IDP", + "IDPKubeconfig", "Image", "Kubeconfig", "Kubernetes", @@ -83,6 +85,7 @@ from stackit.ske.exceptions import ApiTypeError as ApiTypeError from stackit.ske.exceptions import ApiValueError as ApiValueError from stackit.ske.exceptions import OpenApiException as OpenApiException +from stackit.ske.models.access import Access as Access from stackit.ske.models.access_scope import AccessScope as AccessScope # import models into sdk package @@ -114,6 +117,7 @@ HibernationSchedule as HibernationSchedule, ) from stackit.ske.models.idp import IDP as IDP +from stackit.ske.models.idp_kubeconfig import IDPKubeconfig as IDPKubeconfig from stackit.ske.models.image import Image as Image from stackit.ske.models.kubeconfig import Kubeconfig as Kubeconfig from stackit.ske.models.kubernetes import Kubernetes as Kubernetes diff --git a/services/ske/src/stackit/ske/api/default_api.py b/services/ske/src/stackit/ske/api/default_api.py index 2ac00e743..50325e938 100644 --- a/services/ske/src/stackit/ske/api/default_api.py +++ b/services/ske/src/stackit/ske/api/default_api.py @@ -30,6 +30,7 @@ from stackit.ske.models.create_or_update_cluster_payload import ( CreateOrUpdateClusterPayload, ) +from stackit.ske.models.idp_kubeconfig import IDPKubeconfig from stackit.ske.models.kubeconfig import Kubeconfig from stackit.ske.models.list_clusters_response import ListClustersResponse from stackit.ske.models.login_kubeconfig import LoginKubeconfig @@ -1430,6 +1431,271 @@ def _get_cluster_serialize( _request_auth=_request_auth, ) + @validate_call + def get_idp_kubeconfig( + self, + project_id: StrictStr, + region: StrictStr, + cluster_name: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> IDPKubeconfig: + """Get a kubeconfig to authenticate via IDP for use with the STACKIT CLI + + A kubeconfig retrieved using this endpoint does not contain any credentials and instead obtains valid credentials via the STACKIT CLI. Permissions must be granted to the user beforehand using an admin kubeconfig. + + :param project_id: (required) + :type project_id: str + :param region: (required) + :type region: str + :param cluster_name: (required) + :type cluster_name: str + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._get_idp_kubeconfig_serialize( + project_id=project_id, + region=region, + cluster_name=cluster_name, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + _response_types_map: Dict[str, Optional[str]] = { + "200": "IDPKubeconfig", + "400": "object", + "401": "object", + "404": "object", + } + response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + @validate_call + def get_idp_kubeconfig_with_http_info( + self, + project_id: StrictStr, + region: StrictStr, + cluster_name: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> ApiResponse[IDPKubeconfig]: + """Get a kubeconfig to authenticate via IDP for use with the STACKIT CLI + + A kubeconfig retrieved using this endpoint does not contain any credentials and instead obtains valid credentials via the STACKIT CLI. Permissions must be granted to the user beforehand using an admin kubeconfig. + + :param project_id: (required) + :type project_id: str + :param region: (required) + :type region: str + :param cluster_name: (required) + :type cluster_name: str + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._get_idp_kubeconfig_serialize( + project_id=project_id, + region=region, + cluster_name=cluster_name, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + _response_types_map: Dict[str, Optional[str]] = { + "200": "IDPKubeconfig", + "400": "object", + "401": "object", + "404": "object", + } + response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout) + response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + @validate_call + def get_idp_kubeconfig_without_preload_content( + self, + project_id: StrictStr, + region: StrictStr, + cluster_name: StrictStr, + _request_timeout: Union[ + None, + Annotated[StrictFloat, Field(gt=0)], + Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]], + ] = None, + _request_auth: Optional[Dict[StrictStr, Any]] = None, + _content_type: Optional[StrictStr] = None, + _headers: Optional[Dict[StrictStr, Any]] = None, + _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0, + ) -> RESTResponseType: + """Get a kubeconfig to authenticate via IDP for use with the STACKIT CLI + + A kubeconfig retrieved using this endpoint does not contain any credentials and instead obtains valid credentials via the STACKIT CLI. Permissions must be granted to the user beforehand using an admin kubeconfig. + + :param project_id: (required) + :type project_id: str + :param region: (required) + :type region: str + :param cluster_name: (required) + :type cluster_name: str + :param _request_timeout: timeout setting for this request. If one + number provided, it will be total request + timeout. It can also be a pair (tuple) of + (connection, read) timeouts. + :type _request_timeout: int, tuple(int, int), optional + :param _request_auth: set to override the auth_settings for an a single + request; this effectively ignores the + authentication in the spec for a single request. + :type _request_auth: dict, optional + :param _content_type: force content-type for the request. + :type _content_type: str, Optional + :param _headers: set to override the headers for a single + request; this effectively ignores the headers + in the spec for a single request. + :type _headers: dict, optional + :param _host_index: set to override the host_index for a single + request; this effectively ignores the host_index + in the spec for a single request. + :type _host_index: int, optional + :return: Returns the result object. + """ # noqa: E501 + + _param = self._get_idp_kubeconfig_serialize( + project_id=project_id, + region=region, + cluster_name=cluster_name, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + _response_types_map: Dict[str, Optional[str]] = { + "200": "IDPKubeconfig", + "400": "object", + "401": "object", + "404": "object", + } + response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout) + return response_data.response + + def _get_idp_kubeconfig_serialize( + self, + project_id, + region, + cluster_name, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> RequestSerialized: + + _host = None + + _collection_formats: Dict[str, str] = {} + + _path_params: Dict[str, str] = {} + _query_params: List[Tuple[str, str]] = [] + _header_params: Dict[str, Optional[str]] = _headers or {} + _form_params: List[Tuple[str, str]] = [] + _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + if project_id is not None: + _path_params["projectId"] = project_id + if region is not None: + _path_params["region"] = region + if cluster_name is not None: + _path_params["clusterName"] = cluster_name + # process the query parameters + # process the header parameters + # process the form parameters + # process the body parameter + + # set the HTTP header `Accept` + if "Accept" not in _header_params: + _header_params["Accept"] = self.api_client.select_header_accept(["application/json"]) + + # authentication setting + _auth_settings: List[str] = [] + + return self.api_client.param_serialize( + method="GET", + resource_path="/v2/projects/{projectId}/regions/{region}/clusters/{clusterName}/kubeconfig/idp", + path_params=_path_params, + query_params=_query_params, + header_params=_header_params, + body=_body_params, + post_params=_form_params, + files=_files, + auth_settings=_auth_settings, + collection_formats=_collection_formats, + _host=_host, + _request_auth=_request_auth, + ) + @validate_call def get_login_kubeconfig( self, diff --git a/services/ske/src/stackit/ske/models/__init__.py b/services/ske/src/stackit/ske/models/__init__.py index 93fd8b4f0..85d93b39d 100644 --- a/services/ske/src/stackit/ske/models/__init__.py +++ b/services/ske/src/stackit/ske/models/__init__.py @@ -13,6 +13,7 @@ """ # noqa: E501 +from stackit.ske.models.access import Access from stackit.ske.models.access_scope import AccessScope # import models into model package @@ -36,6 +37,7 @@ from stackit.ske.models.hibernation import Hibernation from stackit.ske.models.hibernation_schedule import HibernationSchedule from stackit.ske.models.idp import IDP +from stackit.ske.models.idp_kubeconfig import IDPKubeconfig from stackit.ske.models.image import Image from stackit.ske.models.kubeconfig import Kubeconfig from stackit.ske.models.kubernetes import Kubernetes diff --git a/services/ske/src/stackit/ske/models/access.py b/services/ske/src/stackit/ske/models/access.py new file mode 100644 index 000000000..7e96d233f --- /dev/null +++ b/services/ske/src/stackit/ske/models/access.py @@ -0,0 +1,86 @@ +# coding: utf-8 + +""" + STACKIT Kubernetes Engine API + + The SKE API provides endpoints to create, update or delete clusters within STACKIT projects and to trigger further cluster management tasks. + + The version of the OpenAPI document: 2.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + +from __future__ import annotations + +import json +import pprint +from typing import Any, ClassVar, Dict, List, Optional, Set + +from pydantic import BaseModel, ConfigDict +from typing_extensions import Self + +from stackit.ske.models.idp import IDP + + +class Access(BaseModel): + """ + Access + """ # noqa: E501 + + idp: Optional[IDP] = None + __properties: ClassVar[List[str]] = ["idp"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of Access from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + # override the default output from pydantic by calling `to_dict()` of idp + if self.idp: + _dict["idp"] = self.idp.to_dict() + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of Access from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({"idp": IDP.from_dict(obj["idp"]) if obj.get("idp") is not None else None}) + return _obj diff --git a/services/ske/src/stackit/ske/models/cluster.py b/services/ske/src/stackit/ske/models/cluster.py index c77601048..db8860f64 100644 --- a/services/ske/src/stackit/ske/models/cluster.py +++ b/services/ske/src/stackit/ske/models/cluster.py @@ -20,6 +20,7 @@ from pydantic import BaseModel, ConfigDict, Field, StrictStr from typing_extensions import Annotated, Self +from stackit.ske.models.access import Access from stackit.ske.models.cluster_status import ClusterStatus from stackit.ske.models.extension import Extension from stackit.ske.models.hibernation import Hibernation @@ -34,6 +35,7 @@ class Cluster(BaseModel): Cluster """ # noqa: E501 + access: Optional[Access] = None extensions: Optional[Extension] = None hibernation: Optional[Hibernation] = None kubernetes: Kubernetes @@ -43,6 +45,7 @@ class Cluster(BaseModel): nodepools: Annotated[List[Nodepool], Field(min_length=1, max_length=50)] status: Optional[ClusterStatus] = None __properties: ClassVar[List[str]] = [ + "access", "extensions", "hibernation", "kubernetes", @@ -95,6 +98,9 @@ def to_dict(self) -> Dict[str, Any]: exclude=excluded_fields, exclude_none=True, ) + # override the default output from pydantic by calling `to_dict()` of access + if self.access: + _dict["access"] = self.access.to_dict() # override the default output from pydantic by calling `to_dict()` of extensions if self.extensions: _dict["extensions"] = self.extensions.to_dict() @@ -133,6 +139,7 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: _obj = cls.model_validate( { + "access": Access.from_dict(obj["access"]) if obj.get("access") is not None else None, "extensions": Extension.from_dict(obj["extensions"]) if obj.get("extensions") is not None else None, "hibernation": ( Hibernation.from_dict(obj["hibernation"]) if obj.get("hibernation") is not None else None diff --git a/services/ske/src/stackit/ske/models/cluster_error.py b/services/ske/src/stackit/ske/models/cluster_error.py index 4de3df059..c75d8ec84 100644 --- a/services/ske/src/stackit/ske/models/cluster_error.py +++ b/services/ske/src/stackit/ske/models/cluster_error.py @@ -28,7 +28,7 @@ class ClusterError(BaseModel): code: Optional[StrictStr] = Field( default=None, - description='Possible values: `"SKE_OBSERVABILITY_INSTANCE_NOT_FOUND"`, `"SKE_DNS_ZONE_NOT_FOUND"`, `"SKE_NODE_NO_VALID_HOST_FOUND"`, `"SKE_NODE_MISCONFIGURED_PDB"`, `"SKE_NODE_MACHINE_TYPE_NOT_FOUND"`, `"SKE_INFRA_SNA_NETWORK_NOT_FOUND"`, `"SKE_FETCHING_ERRORS_NOT_POSSIBLE"`', + description='Possible values: `"SKE_INFRA_SNA_NETWORK_NOT_FOUND"`, `"SKE_INFRA_SNA_NETWORK_NO_ROUTER"`, `"SKE_NODE_NO_VALID_HOST_FOUND"`, `"SKE_NODE_MISCONFIGURED_PDB"`, `"SKE_NODE_MACHINE_TYPE_NOT_FOUND"`, `"SKE_NETWORK_NO_DNS_CONFIGURED"`, `"SKE_NETWORK_NO_AVAILABLE_IPS"`, `"SKE_NODE_MEMORY_PRESSURE"`, `"SKE_NODE_DISK_PRESSURE"`, `"SKE_NODE_PID_PRESSURE"`, `"SKE_OBSERVABILITY_INSTANCE_NOT_FOUND"`, `"SKE_OBSERVABILITY_INSTANCE_NOT_READY"`, `"SKE_DNS_ZONE_NOT_FOUND"`, `"SKE_FETCHING_ERRORS_NOT_POSSIBLE"`', ) message: Optional[StrictStr] = None __properties: ClassVar[List[str]] = ["code", "message"] diff --git a/services/ske/src/stackit/ske/models/create_or_update_cluster_payload.py b/services/ske/src/stackit/ske/models/create_or_update_cluster_payload.py index 6b120c4bc..436748f19 100644 --- a/services/ske/src/stackit/ske/models/create_or_update_cluster_payload.py +++ b/services/ske/src/stackit/ske/models/create_or_update_cluster_payload.py @@ -20,6 +20,7 @@ from pydantic import BaseModel, ConfigDict, Field from typing_extensions import Annotated, Self +from stackit.ske.models.access import Access from stackit.ske.models.cluster_status import ClusterStatus from stackit.ske.models.extension import Extension from stackit.ske.models.hibernation import Hibernation @@ -34,6 +35,7 @@ class CreateOrUpdateClusterPayload(BaseModel): CreateOrUpdateClusterPayload """ # noqa: E501 + access: Optional[Access] = None extensions: Optional[Extension] = None hibernation: Optional[Hibernation] = None kubernetes: Kubernetes @@ -42,6 +44,7 @@ class CreateOrUpdateClusterPayload(BaseModel): nodepools: Annotated[List[Nodepool], Field(min_length=1, max_length=50)] status: Optional[ClusterStatus] = None __properties: ClassVar[List[str]] = [ + "access", "extensions", "hibernation", "kubernetes", @@ -88,6 +91,9 @@ def to_dict(self) -> Dict[str, Any]: exclude=excluded_fields, exclude_none=True, ) + # override the default output from pydantic by calling `to_dict()` of access + if self.access: + _dict["access"] = self.access.to_dict() # override the default output from pydantic by calling `to_dict()` of extensions if self.extensions: _dict["extensions"] = self.extensions.to_dict() @@ -126,6 +132,7 @@ def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: _obj = cls.model_validate( { + "access": Access.from_dict(obj["access"]) if obj.get("access") is not None else None, "extensions": Extension.from_dict(obj["extensions"]) if obj.get("extensions") is not None else None, "hibernation": ( Hibernation.from_dict(obj["hibernation"]) if obj.get("hibernation") is not None else None diff --git a/services/ske/src/stackit/ske/models/idp_kubeconfig.py b/services/ske/src/stackit/ske/models/idp_kubeconfig.py new file mode 100644 index 000000000..8714cfbda --- /dev/null +++ b/services/ske/src/stackit/ske/models/idp_kubeconfig.py @@ -0,0 +1,81 @@ +# coding: utf-8 + +""" + STACKIT Kubernetes Engine API + + The SKE API provides endpoints to create, update or delete clusters within STACKIT projects and to trigger further cluster management tasks. + + The version of the OpenAPI document: 2.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + +from __future__ import annotations + +import json +import pprint +from typing import Any, ClassVar, Dict, List, Optional, Set + +from pydantic import BaseModel, ConfigDict, StrictStr +from typing_extensions import Self + + +class IDPKubeconfig(BaseModel): + """ + IDPKubeconfig + """ # noqa: E501 + + kubeconfig: Optional[StrictStr] = None + __properties: ClassVar[List[str]] = ["kubeconfig"] + + model_config = ConfigDict( + populate_by_name=True, + validate_assignment=True, + protected_namespaces=(), + ) + + def to_str(self) -> str: + """Returns the string representation of the model using alias""" + return pprint.pformat(self.model_dump(by_alias=True)) + + def to_json(self) -> str: + """Returns the JSON representation of the model using alias""" + # TODO: pydantic v2: use .model_dump_json(by_alias=True, exclude_unset=True) instead + return json.dumps(self.to_dict()) + + @classmethod + def from_json(cls, json_str: str) -> Optional[Self]: + """Create an instance of IDPKubeconfig from a JSON string""" + return cls.from_dict(json.loads(json_str)) + + def to_dict(self) -> Dict[str, Any]: + """Return the dictionary representation of the model using alias. + + This has the following differences from calling pydantic's + `self.model_dump(by_alias=True)`: + + * `None` is only added to the output dict for nullable fields that + were set at model initialization. Other fields with value `None` + are ignored. + """ + excluded_fields: Set[str] = set([]) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of IDPKubeconfig from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({"kubeconfig": obj.get("kubeconfig")}) + return _obj