stackit-certificates 1.2.0__tar.gz → 1.3.0__tar.gz

stackit_certificates-1.3.0/.gitignore

@@ -0,0 +1,267 @@
+### VisualStudioCode template
+.vscode/*
+!.vscode/settings.json
+!.vscode/tasks.json
+!.vscode/launch.json
+!.vscode/extensions.json
+!.vscode/*.code-snippets
+
+# Local History for Visual Studio Code
+.history/
+
+# Built Visual Studio Code Extensions
+*.vsix
+
+### JetBrains template
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### VirtualEnv template
+# Virtualenv
+# http://iamzed.com/2009/05/07/a-primer-on-virtualenv/
+.Python
+[Bb]in
+[Ii]nclude
+[Ll]ib
+[Ll]ib64
+[Ll]ocal
+[Ss]cripts
+pyvenv.cfg
+.venv
+pip-selfcheck.json
+
+### Python template
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+

{stackit_certificates-1.2.0 → stackit_certificates-1.3.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.4
 Name: stackit-certificates
-Version: 1.2.0
+Version: 1.3.0
 Summary: Load Balancer Certificates API
+Project-URL: Homepage, https://github.com/stackitcloud/stackit-sdk-python
+Project-URL: Issues, https://github.com/stackitcloud/stackit-sdk-python/issues
+Author-email: STACKIT Developer Tools <developer-tools@stackit.cloud>
 License-File: LICENSE.md
 License-File: NOTICE.txt
-Author: STACKIT Developer Tools
-Author-email: developer-tools@stackit.cloud
-Requires-Python: >=3.9,<4.0
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
@@ -16,12 +16,11 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
-Requires-Dist: pydantic (>=2.9.2)
-Requires-Dist: python-dateutil (>=2.9.0.post0)
-Requires-Dist: requests (>=2.32.3)
-Requires-Dist: stackit-core (>=0.0.1a)
-Project-URL: Homepage, https://github.com/stackitcloud/stackit-sdk-python
-Project-URL: Issues, https://github.com/stackitcloud/stackit-sdk-python/issues
+Requires-Python: <4.0,>=3.9
+Requires-Dist: pydantic>=2.9.2
+Requires-Dist: python-dateutil>=2.9.0.post0
+Requires-Dist: requests>=2.32.3
+Requires-Dist: stackit-core>=0.0.1a
 Description-Content-Type: text/markdown
 
 # stackit.certificates
@@ -45,4 +44,4 @@ import stackit.certificates
 
 ## Getting Started
 
-[Examples](https://github.com/stackitcloud/stackit-sdk-python/tree/main/examples) for the usage of the package can be found in the [GitHub repository](https://github.com/stackitcloud/stackit-sdk-python) of the SDK.
+[Examples](https://github.com/stackitcloud/stackit-sdk-python/tree/main/examples) for the usage of the package can be found in the [GitHub repository](https://github.com/stackitcloud/stackit-sdk-python) of the SDK.

{stackit_certificates-1.2.0 → stackit_certificates-1.3.0}/pyproject.toml

@@ -1,55 +1,67 @@
 [project]
 name = "stackit-certificates"
-
-[tool.poetry]
-name = "stackit-certificates"
-version = "v1.2.0"
-authors = [
-    "STACKIT Developer Tools <developer-tools@stackit.cloud>",
-]
+version = "v1.3.0"
 description = "Load Balancer Certificates API"
+authors = [{ name = "STACKIT Developer Tools", email = "developer-tools@stackit.cloud" }]
+requires-python = ">=3.9,<4.0"
 readme = "README.md"
-#license = "NoLicense"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: Apache Software License",
     "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
 ]
-packages = [
-  { include = "stackit", from="src" }
+dependencies = [
+    "stackit-core>=0.0.1a",
+    "requests>=2.32.3",
+    "pydantic>=2.9.2",
+    "python-dateutil>=2.9.0.post0",
 ]
 
-[tool.poetry.dependencies]
-python = ">=3.9,<4.0"
-stackit-core = ">=0.0.1a"
-requests = ">=2.32.3"
-pydantic = ">=2.9.2"
-python-dateutil = ">=2.9.0.post0"
-
-[tool.poetry.group.dev.dependencies]
-black = ">=24.8.0"
-pytest = ">=8.3.3"
-flake8 = [
-  { version= ">=5.0.3", python="<3.12"},
-  { version= ">=6.0.1", python=">=3.12"}
-]
-flake8-black = ">=0.3.6"
-flake8-pyproject = ">=1.2.3"
-autoimport = ">=1.6.1"
-flake8-eol = ">=0.0.8"
-flake8-eradicate = ">=1.5.0"
-flake8-bandit = ">=4.1.1"
-flake8-bugbear = ">=23.1.14"
-flake8-quotes = ">=3.4.0"
-isort = ">=5.13.2"
-
 [project.urls]
 Homepage = "https://github.com/stackitcloud/stackit-sdk-python"
 Issues = "https://github.com/stackitcloud/stackit-sdk-python/issues"
 
+[dependency-groups]
+dev = [
+    "black>=24.8.0",
+    "pytest>=8.3.3",
+    "flake8>=5.0.3 ; python_full_version < '3.12'",
+    "flake8>=6.0.1 ; python_full_version >= '3.12'",
+    "flake8-black>=0.3.6",
+    "flake8-pyproject>=1.2.3",
+    "autoimport>=1.6.1",
+    "flake8-eol>=0.0.8",
+    "flake8-eradicate>=1.5.0",
+    "flake8-bandit>=4.1.1",
+    "flake8-bugbear>=23.1.14",
+    "flake8-quotes>=3.4.0",
+    "isort>=5.13.2",
+]
+
+[tool.uv]
+default-groups = "all"
+
+[tool.uv.sources]
+stackit-core = { path = "../../core" }
+
+[tool.hatch.build.targets.sdist]
+include = ["src/stackit"]
+
+[tool.hatch.build.targets.wheel]
+include = ["src/stackit"]
+
+[tool.hatch.build.targets.wheel.sources]
+"src/stackit" = "stackit"
+
 [build-system]
-requires = ["setuptools", "poetry-core"]
-build-backend = "poetry.core.masonry.api"
+requires = ["hatchling"]
+build-backend = "hatchling.build"
 
 [tool.pytest.ini_options]
 pythonpath = [
@@ -105,4 +117,4 @@ per-file-ignores = """
     # E501: long descriptions/string values might lead to lines that are too long
     # B028: stacklevel for deprecation warning is irrelevant
   ./src/stackit/*/api/default_api.py: F841,B028,E501
-"""
+"""

{stackit_certificates-1.2.0 → stackit_certificates-1.3.0}/src/stackit/certificates/__init__.py

@@ -28,10 +28,13 @@ __all__ = [
     "ApiKeyError",
     "ApiAttributeError",
     "ApiException",
+    "CertificatesQuota",
     "CreateCertificatePayload",
     "GetCertificateResponse",
+    "GetQuotaResponse",
     "GoogleProtobufAny",
     "ListCertificatesResponse",
+    "Quotas",
     "Status",
 ]
 
@@ -50,16 +53,23 @@ from stackit.certificates.exceptions import ApiValueError as ApiValueError
 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

{stackit_certificates-1.2.0 → stackit_certificates-1.3.0}/src/stackit/certificates/api/default_api.py

@@ -23,6 +23,7 @@ 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.list_certificates_response import (
     ListCertificatesResponse,
 )
@@ -857,6 +858,259 @@ class DefaultApi:
             _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,

{stackit_certificates-1.2.0 → stackit_certificates-1.3.0}/src/stackit/certificates/api_client.py

@@ -12,11 +12,13 @@
 """  # noqa: E501
 
 import datetime
+import decimal
 import json
 import mimetypes
 import os
 import re
 import tempfile
+import uuid
 from enum import Enum
 from typing import Dict, List, Optional, Tuple, Union
 from urllib.parse import quote
@@ -63,8 +65,10 @@ class ApiClient:
         "bool": bool,
         "date": datetime.date,
         "datetime": datetime.datetime,
+        "decimal": decimal.Decimal,
         "object": object,
     }
+    _pool = None
 
     def __init__(self, configuration, header_name=None, header_value=None, cookie=None) -> None:
         self.config: Configuration = configuration
@@ -267,7 +271,7 @@ class ApiClient:
                 return_data = self.__deserialize_file(response_data)
             elif response_type is not None:
                 match = None
-                content_type = response_data.getheader("content-type")
+                content_type = response_data.headers.get("content-type")
                 if content_type is not None:
                     match = re.search(r"charset=([a-zA-Z\-\d]+)[\s;]?", content_type)
                 encoding = match.group(1) if match else "utf-8"
@@ -284,7 +288,7 @@ class ApiClient:
         return ApiResponse(
             status_code=response_data.status,
             data=return_data,
-            headers=response_data.getheaders(),
+            headers=response_data.headers,
             raw_data=response_data.data,
         )
 
@@ -296,6 +300,7 @@ class ApiClient:
         If obj is str, int, long, float, bool, return directly.
         If obj is datetime.datetime, datetime.date
             convert to string in iso8601 format.
+        If obj is decimal.Decimal return string representation.
         If obj is list, sanitize each element in the list.
         If obj is dict, return the dict.
         If obj is OpenAPI model, return the properties dict.
@@ -311,12 +316,16 @@ class ApiClient:
             return obj.get_secret_value()
         elif isinstance(obj, self.PRIMITIVE_TYPES):
             return obj
+        elif isinstance(obj, uuid.UUID):
+            return str(obj)
         elif isinstance(obj, list):
             return [self.sanitize_for_serialization(sub_obj) for sub_obj in obj]
         elif isinstance(obj, tuple):
             return tuple(self.sanitize_for_serialization(sub_obj) for sub_obj in obj)
         elif isinstance(obj, (datetime.datetime, datetime.date)):
             return obj.isoformat()
+        elif isinstance(obj, decimal.Decimal):
+            return str(obj)
 
         elif isinstance(obj, dict):
             obj_dict = obj
@@ -326,7 +335,7 @@ class ApiClient:
             # and attributes which value is not None.
             # Convert attribute name to json key in
             # model definition for request.
-            if hasattr(obj, "to_dict") and callable(obj.to_dict):
+            if hasattr(obj, "to_dict") and callable(getattr(obj, "to_dict")):  # noqa: B009
                 obj_dict = obj.to_dict()
             else:
                 obj_dict = obj.__dict__
@@ -354,7 +363,7 @@ class ApiClient:
                 data = json.loads(response_text)
             except ValueError:
                 data = response_text
-        elif re.match(r"^application/(json|[\w!#$&.+-^_]+\+json)\s*(;|$)", content_type, re.IGNORECASE):
+        elif re.match(r"^application/(json|[\w!#$&.+\-^_]+\+json)\s*(;|$)", content_type, re.IGNORECASE):
             if response_text == "":
                 data = ""
             else:
@@ -400,12 +409,14 @@ class ApiClient:
 
         if klass in self.PRIMITIVE_TYPES:
             return self.__deserialize_primitive(data, klass)
-        elif klass == object:
+        elif klass is object:
             return self.__deserialize_object(data)
-        elif klass == datetime.date:
+        elif klass is datetime.date:
             return self.__deserialize_date(data)
-        elif klass == datetime.datetime:
+        elif klass is datetime.datetime:
             return self.__deserialize_datetime(data)
+        elif klass is decimal.Decimal:
+            return decimal.Decimal(data)
         elif issubclass(klass, Enum):
             return self.__deserialize_enum(data, klass)
         else:
@@ -553,12 +564,14 @@ class ApiClient:
         os.close(fd)
         os.remove(path)
 
-        content_disposition = response.getheader("Content-Disposition")
+        content_disposition = response.headers.get("Content-Disposition")
         if content_disposition:
             m = re.search(r'filename=[\'"]?([^\'"\s]+)[\'"]?', content_disposition)
             if m is None:
                 raise ValueError("Unexpected 'content-disposition' header value")
-            filename = m.group(1)
+            filename = os.path.basename(m.group(1))  # Strip any directory traversal
+            if filename in ("", ".", ".."):  # fall back to tmp filename
+                filename = os.path.basename(path)
             path = os.path.join(os.path.dirname(path), filename)
 
         with open(path, "wb") as f:

{stackit_certificates-1.2.0 → stackit_certificates-1.3.0}/src/stackit/certificates/exceptions.py

@@ -129,7 +129,7 @@ class ApiException(OpenApiException):
                     self.body = http_resp.data.decode("utf-8")
                 except Exception:  # noqa: S110
                     pass
-            self.headers = http_resp.getheaders()
+            self.headers = http_resp.headers
 
     @classmethod
     def from_response(

{stackit_certificates-1.2.0 → stackit_certificates-1.3.0}/src/stackit/certificates/models/__init__.py

@@ -12,14 +12,16 @@
     Do not edit the class manually.
 """  # 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

stackit_certificates-1.3.0/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

{stackit_certificates-1.2.0 → stackit_certificates-1.3.0}/src/stackit/certificates/models/create_certificate_payload.py

@@ -17,6 +17,7 @@ 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, StrictStr, field_validator
 from typing_extensions import Annotated, Self
@@ -31,9 +32,7 @@ class CreateCertificatePayload(BaseModel):
     private_key: Optional[StrictStr] = Field(
         default=None, description="The PEM encoded private key part", alias="privateKey"
     )
-    project_id: Optional[Annotated[str, Field(strict=True)]] = Field(
-        default=None, description="Project identifier", alias="projectId"
-    )
+    project_id: Optional[UUID] = Field(default=None, description="Project identifier", alias="projectId")
     public_key: Optional[StrictStr] = Field(
         default=None, description="The PEM encoded public key part", alias="publicKey"
     )

stackit_certificates-1.3.0/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

{stackit_certificates-1.2.0 → stackit_certificates-1.3.0}/src/stackit/certificates/models/list_certificates_response.py

@@ -87,9 +87,9 @@ class ListCertificatesResponse(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in items (list)
         _items = []
         if self.items:
-            for _item in self.items:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_items in self.items:
+                if _item_items:
+                    _items.append(_item_items.to_dict())
             _dict["items"] = _items
         return _dict
 

stackit_certificates-1.3.0/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

{stackit_certificates-1.2.0 → stackit_certificates-1.3.0}/src/stackit/certificates/models/status.py

@@ -82,9 +82,9 @@ class Status(BaseModel):
         # override the default output from pydantic by calling `to_dict()` of each item in details (list)
         _items = []
         if self.details:
-            for _item in self.details:
-                if _item:
-                    _items.append(_item.to_dict())
+            for _item_details in self.details:
+                if _item_details:
+                    _items.append(_item_details.to_dict())
             _dict["details"] = _items
         return _dict
 

{stackit_certificates-1.2.0 → stackit_certificates-1.3.0}/src/stackit/certificates/rest.py

@@ -38,12 +38,17 @@ class RESTResponse(io.IOBase):
             self.data = self.response.content
         return self.data
 
+    @property
+    def headers(self):
+        """Returns a dictionary of response headers."""
+        return self.response.headers
+
     def getheaders(self):
-        """Returns a dictionary of the response headers."""
+        """Returns a dictionary of the response headers; use ``headers`` instead."""
         return self.response.headers
 
     def getheader(self, name, default=None):
-        """Returns a given response header."""
+        """Returns a given response header; use ``headers.get()`` instead."""
         return self.response.headers.get(name, default)
 
 
@@ -93,6 +98,7 @@ class RESTClientObject:
                         url,
                         data=request_body,
                         headers=headers,
+                        timeout=_request_timeout,
                     )
                 elif content_type == "application/x-www-form-urlencoded":
                     r = self.session.request(
@@ -100,6 +106,7 @@ class RESTClientObject:
                         url,
                         params=post_params,
                         headers=headers,
+                        timeout=_request_timeout,
                     )
                 elif content_type == "multipart/form-data":
                     # must del headers['Content-Type'], or the correct
@@ -113,6 +120,7 @@ class RESTClientObject:
                         url,
                         files=post_params,
                         headers=headers,
+                        timeout=_request_timeout,
                     )
                 # Pass a `string` parameter directly in the body to support
                 # other content types than JSON when `body` argument is
@@ -123,10 +131,17 @@ class RESTClientObject:
                         url,
                         data=body,
                         headers=headers,
+                        timeout=_request_timeout,
                     )
                 elif headers["Content-Type"].startswith("text/") and isinstance(body, bool):
                     request_body = "true" if body else "false"
-                    r = self.session.request(method, url, data=request_body, headers=headers)
+                    r = self.session.request(
+                        method,
+                        url,
+                        data=request_body,
+                        headers=headers,
+                        timeout=_request_timeout,
+                    )
                 else:
                     # Cannot generate the request from given parameters
                     msg = """Cannot prepare a request message for provided
@@ -140,6 +155,7 @@ class RESTClientObject:
                     url,
                     params={},
                     headers=headers,
+                    timeout=_request_timeout,
                 )
         except requests.exceptions.SSLError as e:
             msg = "\n".join([type(e).__name__, str(e)])