From 9fe162c8aed7c62bfee3ddf9b86e209b4e06588b Mon Sep 17 00:00:00 2001 From: qutech-machine Date: Fri, 20 Dec 2024 15:29:08 +0000 Subject: [PATCH] [QI2-1175] Auth Config --- .openapi-generator/FILES | 4 + README.md | 4 +- compute_api_client/__init__.py | 2 + compute_api_client/api/__init__.py | 1 + compute_api_client/api/auth_config_api.py | 286 ++++++++++++++++++ compute_api_client/docs/AuthConfig.md | 30 ++ compute_api_client/docs/AuthConfigApi.md | 70 +++++ compute_api_client/models/__init__.py | 1 + compute_api_client/models/auth_config.py | 91 ++++++ compute_api_client/test/test_auth_config.py | 57 ++++ .../test/test_auth_config_api.py | 38 +++ pyproject.toml | 2 +- 12 files changed, 584 insertions(+), 2 deletions(-) create mode 100644 compute_api_client/api/auth_config_api.py create mode 100644 compute_api_client/docs/AuthConfig.md create mode 100644 compute_api_client/docs/AuthConfigApi.md create mode 100644 compute_api_client/models/auth_config.py create mode 100644 compute_api_client/test/test_auth_config.py create mode 100644 compute_api_client/test/test_auth_config_api.py diff --git a/.openapi-generator/FILES b/.openapi-generator/FILES index 08f26de..a3eb7db 100644 --- a/.openapi-generator/FILES +++ b/.openapi-generator/FILES @@ -1,6 +1,7 @@ compute_api_client/__init__.py compute_api_client/api/__init__.py compute_api_client/api/algorithms_api.py +compute_api_client/api/auth_config_api.py compute_api_client/api/backend_api.py compute_api_client/api/backend_types_api.py compute_api_client/api/batch_jobs_api.py @@ -26,6 +27,8 @@ compute_api_client/docs/Algorithm.md compute_api_client/docs/AlgorithmIn.md compute_api_client/docs/AlgorithmType.md compute_api_client/docs/AlgorithmsApi.md +compute_api_client/docs/AuthConfig.md +compute_api_client/docs/AuthConfigApi.md compute_api_client/docs/Backend.md compute_api_client/docs/BackendApi.md compute_api_client/docs/BackendIn.md @@ -114,6 +117,7 @@ compute_api_client/models/__init__.py compute_api_client/models/algorithm.py compute_api_client/models/algorithm_in.py compute_api_client/models/algorithm_type.py +compute_api_client/models/auth_config.py compute_api_client/models/backend.py compute_api_client/models/backend_in.py compute_api_client/models/backend_patch.py diff --git a/README.md b/README.md index 9f2ba80..f762872 100644 --- a/README.md +++ b/README.md @@ -75,6 +75,7 @@ Class | Method | HTTP request | Description *AlgorithmsApi* | [**read_algorithm_algorithms_id_get**](compute_api_client/docs/AlgorithmsApi.md#read_algorithm_algorithms_id_get) | **GET** /algorithms/{id} | Retrieve algorithm *AlgorithmsApi* | [**read_algorithms_algorithms_get**](compute_api_client/docs/AlgorithmsApi.md#read_algorithms_algorithms_get) | **GET** /algorithms | List algorithms *AlgorithmsApi* | [**update_algorithm_algorithms_id_put**](compute_api_client/docs/AlgorithmsApi.md#update_algorithm_algorithms_id_put) | **PUT** /algorithms/{id} | Update algorithm +*AuthConfigApi* | [**auth_config_auth_config_get**](compute_api_client/docs/AuthConfigApi.md#auth_config_auth_config_get) | **GET** /auth_config | Get suggested authentication configuration *BackendApi* | [**create_backend_backends_post**](compute_api_client/docs/BackendApi.md#create_backend_backends_post) | **POST** /backends | Create backend *BackendApi* | [**read_backend_backends_id_get**](compute_api_client/docs/BackendApi.md#read_backend_backends_id_get) | **GET** /backends/{id} | Retrieve backend *BackendApi* | [**read_backend_self_backends_me_get**](compute_api_client/docs/BackendApi.md#read_backend_self_backends_me_get) | **GET** /backends/me | Retrieve backend @@ -150,6 +151,7 @@ Class | Method | HTTP request | Description - [Algorithm](compute_api_client/docs/Algorithm.md) - [AlgorithmIn](compute_api_client/docs/AlgorithmIn.md) - [AlgorithmType](compute_api_client/docs/AlgorithmType.md) + - [AuthConfig](compute_api_client/docs/AuthConfig.md) - [Backend](compute_api_client/docs/Backend.md) - [BackendIn](compute_api_client/docs/BackendIn.md) - [BackendPatch](compute_api_client/docs/BackendPatch.md) @@ -227,7 +229,7 @@ Authentication schemes defined for the API: - **Type**: OAuth - **Flow**: accessCode -- **Authorization URL**: https://auth.qi2.quantum-inspire.com/realms/oidc_staging/protocol/openid-connect/auth +- **Authorization URL**: https://auth.qi2.quantum-inspire.com/realms/oidc_development/protocol/openid-connect/auth - **Scopes**: N/A diff --git a/compute_api_client/__init__.py b/compute_api_client/__init__.py index fc58c9d..20f312c 100644 --- a/compute_api_client/__init__.py +++ b/compute_api_client/__init__.py @@ -18,6 +18,7 @@ # import apis into sdk package from compute_api_client.api.algorithms_api import AlgorithmsApi +from compute_api_client.api.auth_config_api import AuthConfigApi from compute_api_client.api.backend_api import BackendApi from compute_api_client.api.backend_types_api import BackendTypesApi from compute_api_client.api.batch_jobs_api import BatchJobsApi @@ -52,6 +53,7 @@ from compute_api_client.models.algorithm import Algorithm from compute_api_client.models.algorithm_in import AlgorithmIn from compute_api_client.models.algorithm_type import AlgorithmType +from compute_api_client.models.auth_config import AuthConfig from compute_api_client.models.backend import Backend from compute_api_client.models.backend_in import BackendIn from compute_api_client.models.backend_patch import BackendPatch diff --git a/compute_api_client/api/__init__.py b/compute_api_client/api/__init__.py index f949de5..6ff4575 100644 --- a/compute_api_client/api/__init__.py +++ b/compute_api_client/api/__init__.py @@ -2,6 +2,7 @@ # import apis into api package from compute_api_client.api.algorithms_api import AlgorithmsApi +from compute_api_client.api.auth_config_api import AuthConfigApi from compute_api_client.api.backend_api import BackendApi from compute_api_client.api.backend_types_api import BackendTypesApi from compute_api_client.api.batch_jobs_api import BatchJobsApi diff --git a/compute_api_client/api/auth_config_api.py b/compute_api_client/api/auth_config_api.py new file mode 100644 index 0000000..e382ffa --- /dev/null +++ b/compute_api_client/api/auth_config_api.py @@ -0,0 +1,286 @@ +# coding: utf-8 + +""" + Quantum Inspire 2 + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) + + The version of the OpenAPI document: 0.1.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import io +import warnings + +from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt +from typing import Dict, List, Optional, Tuple, Union, Any + +try: + from typing import Annotated +except ImportError: + from typing_extensions import Annotated + +from compute_api_client.models.auth_config import AuthConfig + +from compute_api_client.api_client import ApiClient +from compute_api_client.api_response import ApiResponse +from compute_api_client.rest import RESTResponseType + + +class AuthConfigApi: + """NOTE: This class is auto generated by OpenAPI Generator + Ref: https://openapi-generator.tech + + Do not edit the class manually. + """ + + def __init__(self, api_client=None) -> None: + if api_client is None: + api_client = ApiClient.get_default() + self.api_client = api_client + + + @validate_call + async def auth_config_auth_config_get( + self, + _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, + ) -> AuthConfig: + """Get suggested authentication configuration + + + :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._auth_config_auth_config_get_serialize( + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "AuthConfig" + + } + response_data = await self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + await response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ).data + + + @validate_call + async def auth_config_auth_config_get_with_http_info( + self, + _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[AuthConfig]: + """Get suggested authentication configuration + + + :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._auth_config_auth_config_get_serialize( + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "AuthConfig" + + } + response_data = await self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + await response_data.read() + return self.api_client.response_deserialize( + response_data=response_data, + response_types_map=_response_types_map, + ) + + + @validate_call + async def auth_config_auth_config_get_without_preload_content( + self, + _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 suggested authentication configuration + + + :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._auth_config_auth_config_get_serialize( + _request_auth=_request_auth, + _content_type=_content_type, + _headers=_headers, + _host_index=_host_index + ) + + _response_types_map: Dict[str, Optional[str]] = { + '200': "AuthConfig" + + } + response_data = await self.api_client.call_api( + *_param, + _request_timeout=_request_timeout + ) + return response_data.response + + + def _auth_config_auth_config_get_serialize( + self, + _request_auth, + _content_type, + _headers, + _host_index, + ) -> Tuple: + + _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, str] = {} + _body_params: Optional[bytes] = None + + # process the path parameters + # process the query parameters + # process the header parameters + # process the form parameters + # process the body parameter + + + # set the HTTP header `Accept` + _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='/auth_config', + 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 + ) + + diff --git a/compute_api_client/docs/AuthConfig.md b/compute_api_client/docs/AuthConfig.md new file mode 100644 index 0000000..85e071e --- /dev/null +++ b/compute_api_client/docs/AuthConfig.md @@ -0,0 +1,30 @@ +# AuthConfig + + +## Properties +Name | Type | Description | Notes +------------ | ------------- | ------------- | ------------- +**client_id** | **str** | | +**audience** | **str** | | +**well_known_endpoint** | **str** | | + +## Example + +```python +from compute_api_client.models.auth_config import AuthConfig + +# TODO update the JSON string below +json = "{}" +# create an instance of AuthConfig from a JSON string +auth_config_instance = AuthConfig.from_json(json) +# print the JSON string representation of the object +print AuthConfig.to_json() + +# convert the object into a dict +auth_config_dict = auth_config_instance.to_dict() +# create an instance of AuthConfig from a dict +auth_config_form_dict = auth_config.from_dict(auth_config_dict) +``` +[[Back to Model list]](../README.md#documentation-for-models) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to README]](../README.md) + + diff --git a/compute_api_client/docs/AuthConfigApi.md b/compute_api_client/docs/AuthConfigApi.md new file mode 100644 index 0000000..cb14fb1 --- /dev/null +++ b/compute_api_client/docs/AuthConfigApi.md @@ -0,0 +1,70 @@ +# compute_api_client.AuthConfigApi + +All URIs are relative to *http://localhost* + +Method | HTTP request | Description +------------- | ------------- | ------------- +[**auth_config_auth_config_get**](AuthConfigApi.md#auth_config_auth_config_get) | **GET** /auth_config | Get suggested authentication configuration + + +# **auth_config_auth_config_get** +> AuthConfig auth_config_auth_config_get() + +Get suggested authentication configuration + +### Example + +```python +import time +import os +import compute_api_client +from compute_api_client.models.auth_config import AuthConfig +from compute_api_client.rest import ApiException +from pprint import pprint + +# Defining the host is optional and defaults to http://localhost +# See configuration.py for a list of all supported configuration parameters. +configuration = compute_api_client.Configuration( + host = "http://localhost" +) + + +# Enter a context with an instance of the API client +async with compute_api_client.ApiClient(configuration) as api_client: + # Create an instance of the API class + api_instance = compute_api_client.AuthConfigApi(api_client) + + try: + # Get suggested authentication configuration + api_response = await api_instance.auth_config_auth_config_get() + print("The response of AuthConfigApi->auth_config_auth_config_get:\n") + pprint(api_response) + except Exception as e: + print("Exception when calling AuthConfigApi->auth_config_auth_config_get: %s\n" % e) +``` + + + +### Parameters +This endpoint does not need any parameter. + +### Return type + +[**AuthConfig**](AuthConfig.md) + +### Authorization + +No authorization required + +### HTTP request headers + + - **Content-Type**: Not defined + - **Accept**: application/json + +### HTTP response details +| Status code | Description | Response headers | +|-------------|-------------|------------------| +**200** | Successful Response | - | + +[[Back to top]](#) [[Back to API list]](../README.md#documentation-for-api-endpoints) [[Back to Model list]](../README.md#documentation-for-models) [[Back to README]](../README.md) + diff --git a/compute_api_client/models/__init__.py b/compute_api_client/models/__init__.py index c131381..8232c78 100644 --- a/compute_api_client/models/__init__.py +++ b/compute_api_client/models/__init__.py @@ -17,6 +17,7 @@ from compute_api_client.models.algorithm import Algorithm from compute_api_client.models.algorithm_in import AlgorithmIn from compute_api_client.models.algorithm_type import AlgorithmType +from compute_api_client.models.auth_config import AuthConfig from compute_api_client.models.backend import Backend from compute_api_client.models.backend_in import BackendIn from compute_api_client.models.backend_patch import BackendPatch diff --git a/compute_api_client/models/auth_config.py b/compute_api_client/models/auth_config.py new file mode 100644 index 0000000..80ad093 --- /dev/null +++ b/compute_api_client/models/auth_config.py @@ -0,0 +1,91 @@ +# coding: utf-8 + +""" + Quantum Inspire 2 + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) + + The version of the OpenAPI document: 0.1.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +from __future__ import annotations +import pprint +import re # noqa: F401 +import json + + +from typing import Any, ClassVar, Dict, List +from pydantic import BaseModel, StrictStr +try: + from typing import Self +except ImportError: + from typing_extensions import Self + +class AuthConfig(BaseModel): + """ + AuthConfig + """ # noqa: E501 + client_id: StrictStr + audience: StrictStr + well_known_endpoint: StrictStr + __properties: ClassVar[List[str]] = ["client_id", "audience", "well_known_endpoint"] + + model_config = { + "populate_by_name": True, + "validate_assignment": True + } + + + 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) -> Self: + """Create an instance of AuthConfig 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. + """ + _dict = self.model_dump( + by_alias=True, + exclude={ + }, + exclude_none=True, + ) + return _dict + + @classmethod + def from_dict(cls, obj: Dict) -> Self: + """Create an instance of AuthConfig from a dict""" + if obj is None: + return None + + if not isinstance(obj, dict): + return cls.model_validate(obj) + + _obj = cls.model_validate({ + "client_id": obj.get("client_id"), + "audience": obj.get("audience"), + "well_known_endpoint": obj.get("well_known_endpoint") + }) + return _obj + + diff --git a/compute_api_client/test/test_auth_config.py b/compute_api_client/test/test_auth_config.py new file mode 100644 index 0000000..b95135f --- /dev/null +++ b/compute_api_client/test/test_auth_config.py @@ -0,0 +1,57 @@ +# coding: utf-8 + +""" + Quantum Inspire 2 + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) + + The version of the OpenAPI document: 0.1.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest +import datetime + +from compute_api_client.models.auth_config import AuthConfig + +class TestAuthConfig(unittest.TestCase): + """AuthConfig unit test stubs""" + + def setUp(self): + pass + + def tearDown(self): + pass + + def make_instance(self, include_optional) -> AuthConfig: + """Test AuthConfig + include_option is a boolean, when False only required + params are included, when True both required and + optional params are included """ + # uncomment below to create an instance of `AuthConfig` + """ + model = AuthConfig() + if include_optional: + return AuthConfig( + client_id = '', + audience = '', + well_known_endpoint = '' + ) + else: + return AuthConfig( + client_id = '', + audience = '', + well_known_endpoint = '', + ) + """ + + def testAuthConfig(self): + """Test AuthConfig""" + # inst_req_only = self.make_instance(include_optional=False) + # inst_req_and_optional = self.make_instance(include_optional=True) + +if __name__ == '__main__': + unittest.main() diff --git a/compute_api_client/test/test_auth_config_api.py b/compute_api_client/test/test_auth_config_api.py new file mode 100644 index 0000000..a276965 --- /dev/null +++ b/compute_api_client/test/test_auth_config_api.py @@ -0,0 +1,38 @@ +# coding: utf-8 + +""" + Quantum Inspire 2 + + No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator) + + The version of the OpenAPI document: 0.1.0 + Generated by OpenAPI Generator (https://openapi-generator.tech) + + Do not edit the class manually. +""" # noqa: E501 + + +import unittest + +from compute_api_client.api.auth_config_api import AuthConfigApi + + +class TestAuthConfigApi(unittest.TestCase): + """AuthConfigApi unit test stubs""" + + def setUp(self) -> None: + self.api = AuthConfigApi() + + def tearDown(self) -> None: + pass + + def test_auth_config_auth_config_get(self) -> None: + """Test case for auth_config_auth_config_get + + Get suggested authentication configuration + """ + pass + + +if __name__ == '__main__': + unittest.main() diff --git a/pyproject.toml b/pyproject.toml index 52bacbf..e140aff 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "qi-compute-api-client" -version = "0.41.0" +version = "0.42.0" description = "An API client for the Compute Job Manager of Quantum Inspire." license = "Apache-2.0" authors = ["Quantum Inspire "]