From 5262e475251c04f7997f55607fefed6e3ef12b20 Mon Sep 17 00:00:00 2001 From: SDK Generator Bot Date: Tue, 24 Mar 2026 13:04:09 +0000 Subject: [PATCH] Generate certificates --- services/certificates/oas_commit | 2 +- .../src/stackit/certificates/__init__.py | 10 + .../stackit/certificates/api/default_api.py | 254 ++++++++++++++++++ .../stackit/certificates/models/__init__.py | 3 + .../certificates/models/certificates_quota.py | 86 ++++++ .../certificates/models/get_quota_response.py | 125 +++++++++ .../src/stackit/certificates/models/quotas.py | 92 +++++++ 7 files changed, 571 insertions(+), 1 deletion(-) create mode 100644 services/certificates/src/stackit/certificates/models/certificates_quota.py create mode 100644 services/certificates/src/stackit/certificates/models/get_quota_response.py create mode 100644 services/certificates/src/stackit/certificates/models/quotas.py diff --git a/services/certificates/oas_commit b/services/certificates/oas_commit index e3713dde3..272dcd7b3 100644 --- a/services/certificates/oas_commit +++ b/services/certificates/oas_commit @@ -1 +1 @@ -0e64886dd0847341800d7191ed193b75413be998 +7387ad1600ca8bb2a3f15a5df04cd5831d75852f diff --git a/services/certificates/src/stackit/certificates/__init__.py b/services/certificates/src/stackit/certificates/__init__.py index 43feed9a1..f34fecf6e 100644 --- a/services/certificates/src/stackit/certificates/__init__.py +++ b/services/certificates/src/stackit/certificates/__init__.py @@ -28,10 +28,13 @@ "ApiKeyError", "ApiAttributeError", "ApiException", + "CertificatesQuota", "CreateCertificatePayload", "GetCertificateResponse", + "GetQuotaResponse", "GoogleProtobufAny", "ListCertificatesResponse", + "Quotas", "Status", ] @@ -50,16 +53,23 @@ from stackit.certificates.exceptions import OpenApiException as OpenApiException # import models into sdk package +from stackit.certificates.models.certificates_quota import ( + CertificatesQuota as CertificatesQuota, +) from stackit.certificates.models.create_certificate_payload import ( CreateCertificatePayload as CreateCertificatePayload, ) from stackit.certificates.models.get_certificate_response import ( GetCertificateResponse as GetCertificateResponse, ) +from stackit.certificates.models.get_quota_response import ( + GetQuotaResponse as GetQuotaResponse, +) from stackit.certificates.models.google_protobuf_any import ( GoogleProtobufAny as GoogleProtobufAny, ) from stackit.certificates.models.list_certificates_response import ( ListCertificatesResponse as ListCertificatesResponse, ) +from stackit.certificates.models.quotas import Quotas as Quotas from stackit.certificates.models.status import Status as Status diff --git a/services/certificates/src/stackit/certificates/api/default_api.py b/services/certificates/src/stackit/certificates/api/default_api.py index 7473fdff3..79ae3645f 100644 --- a/services/certificates/src/stackit/certificates/api/default_api.py +++ b/services/certificates/src/stackit/certificates/api/default_api.py @@ -23,6 +23,7 @@ CreateCertificatePayload, ) from stackit.certificates.models.get_certificate_response import GetCertificateResponse +from stackit.certificates.models.get_quota_response import GetQuotaResponse from stackit.certificates.models.list_certificates_response import ( ListCertificatesResponse, ) @@ -857,6 +858,259 @@ def _get_certificate_serialize( _request_auth=_request_auth, ) + @validate_call + def get_quota( + self, + project_id: StrictStr, + region: 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, + ) -> GetQuotaResponse: + """Get the quota for TLS certificates in a project. + + Retrieves the configured TLS certificate quota for the project. Limit can be changed via service request. + + :param project_id: (required) + :type project_id: str + :param region: (required) + :type region: 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_quota_serialize( + project_id=project_id, + region=region, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + _response_types_map: Dict[str, Optional[str]] = { + "200": "GetQuotaResponse", + "400": None, + "401": "str", + "403": None, + "500": None, + } + 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_quota_with_http_info( + self, + project_id: StrictStr, + region: 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[GetQuotaResponse]: + """Get the quota for TLS certificates in a project. + + Retrieves the configured TLS certificate quota for the project. Limit can be changed via service request. + + :param project_id: (required) + :type project_id: str + :param region: (required) + :type region: 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_quota_serialize( + project_id=project_id, + region=region, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + _response_types_map: Dict[str, Optional[str]] = { + "200": "GetQuotaResponse", + "400": None, + "401": "str", + "403": None, + "500": None, + } + 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_quota_without_preload_content( + self, + project_id: StrictStr, + region: 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 the quota for TLS certificates in a project. + + Retrieves the configured TLS certificate quota for the project. Limit can be changed via service request. + + :param project_id: (required) + :type project_id: str + :param region: (required) + :type region: 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_quota_serialize( + project_id=project_id, + region=region, + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index, + ) + + _response_types_map: Dict[str, Optional[str]] = { + "200": "GetQuotaResponse", + "400": None, + "401": "str", + "403": None, + "500": None, + } + response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout) + return response_data.response + + def _get_quota_serialize( + self, + project_id, + region, + _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 + # 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", "text/plain"]) + + # authentication setting + _auth_settings: List[str] = [] + + return self.api_client.param_serialize( + method="GET", + resource_path="/v2/projects/{projectId}/regions/{region}/quotas", + 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 list_certificates( self, diff --git a/services/certificates/src/stackit/certificates/models/__init__.py b/services/certificates/src/stackit/certificates/models/__init__.py index 803243b8e..40626de69 100644 --- a/services/certificates/src/stackit/certificates/models/__init__.py +++ b/services/certificates/src/stackit/certificates/models/__init__.py @@ -13,12 +13,15 @@ """ # noqa: E501 # import models into model package +from stackit.certificates.models.certificates_quota import CertificatesQuota from stackit.certificates.models.create_certificate_payload import ( CreateCertificatePayload, ) from stackit.certificates.models.get_certificate_response import GetCertificateResponse +from stackit.certificates.models.get_quota_response import GetQuotaResponse from stackit.certificates.models.google_protobuf_any import GoogleProtobufAny from stackit.certificates.models.list_certificates_response import ( ListCertificatesResponse, ) +from stackit.certificates.models.quotas import Quotas from stackit.certificates.models.status import Status diff --git a/services/certificates/src/stackit/certificates/models/certificates_quota.py b/services/certificates/src/stackit/certificates/models/certificates_quota.py new file mode 100644 index 000000000..debb5feb9 --- /dev/null +++ b/services/certificates/src/stackit/certificates/models/certificates_quota.py @@ -0,0 +1,86 @@ +# coding: utf-8 + +""" + STACKIT Application Load Balancer Certificates API + + This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server. + + The version of the OpenAPI document: 2.0.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, Field +from typing_extensions import Annotated, Self + + +class CertificatesQuota(BaseModel): + """ + Certificates quotas holds the limits and usage for certificates resources + """ # noqa: E501 + + limit: Optional[Annotated[int, Field(le=1000000, strict=True, ge=-1)]] = Field( + default=None, description="The maximum number of TLS certificates in this project." + ) + usage: Optional[Annotated[int, Field(le=1000000, strict=True, ge=-1)]] = Field( + default=None, description="The number of certificates that are currently existing in this project." + ) + __properties: ClassVar[List[str]] = ["limit", "usage"] + + 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 CertificatesQuota 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 CertificatesQuota from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({"limit": obj.get("limit"), "usage": obj.get("usage")}) + return _obj diff --git a/services/certificates/src/stackit/certificates/models/get_quota_response.py b/services/certificates/src/stackit/certificates/models/get_quota_response.py new file mode 100644 index 000000000..c317a483e --- /dev/null +++ b/services/certificates/src/stackit/certificates/models/get_quota_response.py @@ -0,0 +1,125 @@ +# coding: utf-8 + +""" + STACKIT Application Load Balancer Certificates API + + This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server. + + The version of the OpenAPI document: 2.0.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 +import re # noqa: F401 +from typing import Any, ClassVar, Dict, List, Optional, Set +from uuid import UUID + +from pydantic import BaseModel, ConfigDict, Field, field_validator +from typing_extensions import Annotated, Self + +from stackit.certificates.models.quotas import Quotas + + +class GetQuotaResponse(BaseModel): + """ + GetQuotaResponse + """ # noqa: E501 + + project_id: Optional[UUID] = Field(default=None, description="Project identifier", alias="projectId") + quotas: Optional[Quotas] = None + region: Optional[Annotated[str, Field(strict=True)]] = Field(default=None, description="Region") + __properties: ClassVar[List[str]] = ["projectId", "quotas", "region"] + + @field_validator("project_id") + def project_id_validate_regular_expression(cls, value): + """Validates the regular expression""" + if value is None: + return value + + if not re.match(r"^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$", value): + raise ValueError( + r"must validate the regular expression /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/" + ) + return value + + @field_validator("region") + def region_validate_regular_expression(cls, value): + """Validates the regular expression""" + if value is None: + return value + + if not re.match(r"^[a-z]{2,4}[0-9]{2}$", value): + raise ValueError(r"must validate the regular expression /^[a-z]{2,4}[0-9]{2}$/") + return value + + 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 GetQuotaResponse 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. + * OpenAPI `readOnly` fields are excluded. + * OpenAPI `readOnly` fields are excluded. + """ + excluded_fields: Set[str] = set( + [ + "project_id", + "region", + ] + ) + + _dict = self.model_dump( + by_alias=True, + exclude=excluded_fields, + exclude_none=True, + ) + # override the default output from pydantic by calling `to_dict()` of quotas + if self.quotas: + _dict["quotas"] = self.quotas.to_dict() + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of GetQuotaResponse from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate( + { + "projectId": obj.get("projectId"), + "quotas": Quotas.from_dict(obj["quotas"]) if obj.get("quotas") is not None else None, + "region": obj.get("region"), + } + ) + return _obj diff --git a/services/certificates/src/stackit/certificates/models/quotas.py b/services/certificates/src/stackit/certificates/models/quotas.py new file mode 100644 index 000000000..146fa63af --- /dev/null +++ b/services/certificates/src/stackit/certificates/models/quotas.py @@ -0,0 +1,92 @@ +# coding: utf-8 + +""" + STACKIT Application Load Balancer Certificates API + + This API offers the ability to store TLS certificates, which can be used by load balancing servers in STACKIT. They can be between consumer and load balancing server and/or between load balancing server and endpoint server. + + The version of the OpenAPI document: 2.0.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.certificates.models.certificates_quota import CertificatesQuota + + +class Quotas(BaseModel): + """ + Quotas holds the specific quota elements for different resources + """ # noqa: E501 + + certificates: Optional[CertificatesQuota] = None + __properties: ClassVar[List[str]] = ["certificates"] + + 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 Quotas 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 certificates + if self.certificates: + _dict["certificates"] = self.certificates.to_dict() + return _dict + + @classmethod + def from_dict(cls, obj: Optional[Dict[str, Any]]) -> Optional[Self]: + """Create an instance of Quotas from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate( + { + "certificates": ( + CertificatesQuota.from_dict(obj["certificates"]) if obj.get("certificates") is not None else None + ) + } + ) + return _obj