qi-compute-api-client 0.56.0__py3-none-any.whl

compute_api_client/rest.py

@@ -0,0 +1,213 @@
+# 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 json
+import re
+import ssl
+from typing import Optional, Union
+
+import aiohttp
+import aiohttp_retry
+
+from compute_api_client.exceptions import ApiException, ApiValueError
+
+RESTResponseType = aiohttp.ClientResponse
+
+ALLOW_RETRY_METHODS = frozenset({'DELETE', 'GET', 'HEAD', 'OPTIONS', 'PUT', 'TRACE'})
+
+class RESTResponse(io.IOBase):
+
+    def __init__(self, resp) -> None:
+        self.response = resp
+        self.status = resp.status
+        self.reason = resp.reason
+        self.data = None
+
+    async def read(self):
+        if self.data is None:
+            self.data = await self.response.read()
+        return self.data
+
+    def getheaders(self):
+        """Returns a CIMultiDictProxy of the response headers."""
+        return self.response.headers
+
+    def getheader(self, name, default=None):
+        """Returns a given response header."""
+        return self.response.headers.get(name, default)
+
+
+class RESTClientObject:
+
+    def __init__(self, configuration) -> None:
+
+        # maxsize is number of requests to host that are allowed in parallel
+        self.maxsize = configuration.connection_pool_maxsize
+
+        self.ssl_context = ssl.create_default_context(
+            cafile=configuration.ssl_ca_cert,
+            cadata=configuration.ca_cert_data,
+        )
+        if configuration.cert_file:
+            self.ssl_context.load_cert_chain(
+                configuration.cert_file, keyfile=configuration.key_file
+            )
+
+        if not configuration.verify_ssl:
+            self.ssl_context.check_hostname = False
+            self.ssl_context.verify_mode = ssl.CERT_NONE
+
+        self.proxy = configuration.proxy
+        self.proxy_headers = configuration.proxy_headers
+
+        self.retries = configuration.retries
+
+        self.pool_manager: Optional[aiohttp.ClientSession] = None
+        self.retry_client: Optional[aiohttp_retry.RetryClient] = None
+
+    async def close(self) -> None:
+        if self.pool_manager:
+            await self.pool_manager.close()
+        if self.retry_client is not None:
+            await self.retry_client.close()
+
+    async def request(
+        self,
+        method,
+        url,
+        headers=None,
+        body=None,
+        post_params=None,
+        _request_timeout=None
+    ):
+        """Execute request
+
+        :param method: http request method
+        :param url: http request url
+        :param headers: http request headers
+        :param body: request json body, for `application/json`
+        :param post_params: request post parameters,
+                            `application/x-www-form-urlencoded`
+                            and `multipart/form-data`
+        :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.
+        """
+        method = method.upper()
+        assert method in [
+            'GET',
+            'HEAD',
+            'DELETE',
+            'POST',
+            'PUT',
+            'PATCH',
+            'OPTIONS'
+        ]
+
+        if post_params and body:
+            raise ApiValueError(
+                "body parameter cannot be used with post_params parameter."
+            )
+
+        post_params = post_params or {}
+        headers = headers or {}
+        # url already contains the URL query string
+        timeout = _request_timeout or 5 * 60
+
+        if 'Content-Type' not in headers:
+            headers['Content-Type'] = 'application/json'
+
+        args = {
+            "method": method,
+            "url": url,
+            "timeout": timeout,
+            "headers": headers
+        }
+
+        if self.proxy:
+            args["proxy"] = self.proxy
+        if self.proxy_headers:
+            args["proxy_headers"] = self.proxy_headers
+
+        # For `POST`, `PUT`, `PATCH`, `OPTIONS`, `DELETE`
+        if method in ['POST', 'PUT', 'PATCH', 'OPTIONS', 'DELETE']:
+            if re.search('json', headers['Content-Type'], re.IGNORECASE):
+                if body is not None:
+                    body = json.dumps(body)
+                args["data"] = body
+            elif headers['Content-Type'] == 'application/x-www-form-urlencoded':
+                args["data"] = aiohttp.FormData(post_params)
+            elif headers['Content-Type'] == 'multipart/form-data':
+                # must del headers['Content-Type'], or the correct
+                # Content-Type which generated by aiohttp
+                del headers['Content-Type']
+                data = aiohttp.FormData()
+                for param in post_params:
+                    k, v = param
+                    if isinstance(v, tuple) and len(v) == 3:
+                        data.add_field(
+                            k,
+                            value=v[1],
+                            filename=v[0],
+                            content_type=v[2]
+                        )
+                    else:
+                        # Ensures that dict objects are serialized
+                        if isinstance(v, dict):
+                            v = json.dumps(v)
+                        elif isinstance(v, int):
+                            v = str(v)
+                        data.add_field(k, v)
+                args["data"] = data
+
+            # Pass a `bytes` or `str` parameter directly in the body to support
+            # other content types than Json when `body` argument is provided
+            # in serialized form
+            elif isinstance(body, str) or isinstance(body, bytes):
+                args["data"] = body
+            else:
+                # Cannot generate the request from given parameters
+                msg = """Cannot prepare a request message for provided
+                         arguments. Please check that your arguments match
+                         declared content type."""
+                raise ApiException(status=0, reason=msg)
+
+        pool_manager: Union[aiohttp.ClientSession, aiohttp_retry.RetryClient]
+
+        # https pool manager
+        if self.pool_manager is None:
+            self.pool_manager = aiohttp.ClientSession(
+                connector=aiohttp.TCPConnector(limit=self.maxsize, ssl=self.ssl_context),
+                trust_env=True,
+            )
+        pool_manager = self.pool_manager
+
+        if self.retries is not None and method in ALLOW_RETRY_METHODS:
+            if self.retry_client is None:
+                self.retry_client = aiohttp_retry.RetryClient(
+                    client_session=self.pool_manager,
+                    retry_options=aiohttp_retry.ExponentialRetry(
+                        attempts=self.retries,
+                        factor=2.0,
+                        start_timeout=0.1,
+                        max_timeout=120.0
+                    )
+                )
+            pool_manager = self.retry_client
+
+        r = await pool_manager.request(**args)
+
+        return RESTResponse(r)

qi2_shared/authentication.py

@@ -0,0 +1,66 @@
+import time
+from typing import Any, Tuple, cast
+
+import requests
+
+from qi2_shared.settings import ApiSettings, TokenInfo, Url
+
+
+class AuthorisationError(Exception):
+    """Indicates that the authorisation permanently went wrong."""
+
+    pass
+
+
+class IdentityProvider:
+    """Class for interfacing with the IdentityProvider."""
+
+    def __init__(self, well_known_endpoint: str):
+        self._well_known_endpoint = well_known_endpoint
+        self._token_endpoint, self._device_endpoint = self._get_endpoints()
+        self._headers = {"Content-Type": "application/x-www-form-urlencoded"}
+
+    def _get_endpoints(self) -> Tuple[str, str]:
+        response = requests.get(self._well_known_endpoint)
+        response.raise_for_status()
+        config = response.json()
+        return config["token_endpoint"], config["device_authorization_endpoint"]
+
+    def refresh_access_token(self, client_id: str, refresh_token: str) -> dict[str, Any]:
+        data = {
+            "grant_type": "refresh_token",
+            "client_id": client_id,
+            "refresh_token": refresh_token,
+        }
+        response = requests.post(self._token_endpoint, headers=self._headers, data=data)
+        response.raise_for_status()
+        return cast(dict[str, Any], response.json())
+
+
+class OauthDeviceSession:
+    """Class for storing OAuth session information and refreshing tokens when needed."""
+
+    def __init__(self, host: Url, settings: ApiSettings, identity_provider: IdentityProvider):
+        self._api_settings = settings
+        _auth_settings = settings.auths[host]
+        self._host = host
+        self._client_id = _auth_settings.client_id
+        self._token_info = _auth_settings.tokens
+        self._refresh_time_reduction = 5  # the number of seconds to refresh the expiration time
+        self._identity_provider = identity_provider
+
+    def refresh(self) -> TokenInfo:
+        if self._token_info is None:
+            raise AuthorisationError("You should authenticate first before you can refresh")
+
+        if self._token_info.access_expires_at > time.time() + self._refresh_time_reduction:
+            return self._token_info
+
+        try:
+            self._token_info = TokenInfo(
+                **self._identity_provider.refresh_access_token(self._client_id, self._token_info.refresh_token)
+            )
+            self._api_settings.store_tokens(self._host, self._token_info)
+            return self._token_info
+        except requests.HTTPError as e:
+            raise AuthorisationError(f"An error occurred during token refresh: {e}")

qi2_shared/client.py

@@ -0,0 +1,52 @@
+from typing import Any, Optional
+
+import compute_api_client
+
+from qi2_shared.authentication import IdentityProvider, OauthDeviceSession
+from qi2_shared.settings import ApiSettings
+
+
+class Configuration(compute_api_client.Configuration):  # type: ignore[misc]
+    """Original Configuration class in compute_api_client does not handle refreshing bearer tokens, so we need to add
+    some functionality."""
+
+    def __init__(self, host: str, oauth_session: OauthDeviceSession, **kwargs: Any):
+        self._oauth_session = oauth_session
+        super().__init__(host=host, **kwargs)
+
+    def auth_settings(self) -> Any:
+        token_info = self._oauth_session.refresh()
+        self.access_token = token_info.access_token
+        return super().auth_settings()
+
+
+_config: Optional[Configuration] = None
+
+
+def connect() -> None:
+    """Set connection configuration for the Quantum Inspire API.
+
+    Call after logging in with the CLI. Will remove old configuration.
+    """
+    global _config
+    settings = ApiSettings.from_config_file()
+
+    tokens = settings.auths[settings.default_host].tokens
+
+    if tokens is None:
+        raise ValueError("No access token found for the default host. Please connect to Quantum Inspire using the CLI.")
+
+    host = settings.default_host
+    _config = Configuration(
+        host=host,
+        oauth_session=OauthDeviceSession(host, settings, IdentityProvider(settings.auths[host].well_known_endpoint)),
+    )
+
+
+def config() -> Configuration:
+    global _config
+    if _config is None:
+        connect()
+
+    assert _config is not None
+    return _config

qi2_shared/hybrid/quantum_interface.py

@@ -0,0 +1,45 @@
+"""Quantum Inspire SDK.
+
+Copyright 2022 QuTech Delft
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the
+License. You may obtain a copy of the License at
+
+https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific
+language governing permissions and limitations under the License.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional
+
+from compute_api_client.models.backend_type import BackendType
+from pydantic import BaseModel
+
+
+class ExecuteCircuitResult(BaseModel):
+    """Result of executing a quantum circuit."""
+
+    results: Dict[str, int]
+    raw_data: Optional[List[str]]
+    shots_requested: int
+    shots_done: int
+
+
+class QuantumInterface(ABC):
+    """Interface for running quantum circuits from hybrid algorithms."""
+
+    # pylint: disable = R0903
+    # Too few public methods (1/2) (too-few-public-methods)
+
+    results: List[Dict[str, Any]]
+    backend_type: BackendType
+
+    @abstractmethod
+    def execute_circuit(
+        self, circuit: str, number_of_shots: int, raw_data_enabled: bool = False
+    ) -> ExecuteCircuitResult:
+        """Execute a quantum circuit."""
+        raise NotImplementedError

qi2_shared/pagination.py

@@ -0,0 +1,44 @@
+from typing import Any, Awaitable, Callable, Generic, List, Optional, TypeVar, Union, cast
+
+from pydantic import BaseModel, Field
+from typing_extensions import Annotated
+
+PageType = TypeVar("PageType")
+ItemType = TypeVar("ItemType")
+
+
+class PageInterface(BaseModel, Generic[ItemType]):
+    """The page models in the generated API client don't inherit from a common base class, so we have to trick the
+    typing system a bit with this fake base class."""
+
+    items: List[ItemType]
+    total: Optional[Annotated[int, Field(strict=True, ge=0)]]
+    page: Optional[Annotated[int, Field(strict=True, ge=1)]]
+    size: Optional[Annotated[int, Field(strict=True, ge=1)]]
+    pages: Optional[Annotated[int, Field(strict=True, ge=0)]] = None
+
+
+class PageReader(Generic[PageType, ItemType]):
+    """Helper class for reading fastapi-pagination style pages returned by the compute_api_client."""
+
+    async def get_all(self, api_call: Callable[..., Awaitable[PageType]], **kwargs: Any) -> List[ItemType]:
+        """Get all items from an API call that supports paging."""
+        items: List[ItemType] = []
+        page = 1
+
+        while True:
+            response = cast(PageInterface[ItemType], await api_call(page=page, **kwargs))
+
+            items.extend(response.items)
+            page += 1
+            if response.pages is None or page > response.pages:
+                break
+        return items
+
+    async def get_single(self, api_call: Callable[..., Awaitable[PageType]], **kwargs: Any) -> Union[ItemType, None]:
+        """Get a single item from an API call that supports paging."""
+        response = cast(PageInterface[ItemType], await api_call(**kwargs))
+        if len(response.items) > 1:
+            raise RuntimeError(f"Response contains more than one item -> {kwargs}.")
+
+        return response.items[0] if response.items else None

qi2_shared/settings.py

@@ -0,0 +1,68 @@
+"""Module containing the handler for the Quantum Inspire persistent configuration."""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+from typing import Dict, Optional
+
+from pydantic import BaseModel, BeforeValidator, Field, HttpUrl
+from typing_extensions import Annotated
+
+Url = Annotated[str, BeforeValidator(lambda value: str(HttpUrl(value)).rstrip("/"))]
+API_SETTINGS_FILE = Path.joinpath(Path.home(), ".quantuminspire", "config.json")
+
+
+class TokenInfo(BaseModel):
+    """A pydantic model for storing all information regarding oauth access and refresh tokens."""
+
+    access_token: str
+    expires_in: int  # [s]
+    refresh_token: str
+    refresh_expires_in: Optional[int] = None  # [s]
+    generated_at: float = Field(default_factory=time.time)
+
+    @property
+    def access_expires_at(self) -> float:
+        """Unix timestamp containing the time when the access token will expire."""
+        return self.generated_at + self.expires_in
+
+
+class AuthSettings(BaseModel):
+    """Pydantic model for storing all auth related settings for a given host."""
+
+    client_id: str
+    code_challenge_method: str
+    code_verifyer_length: int
+    well_known_endpoint: Url
+    tokens: Optional[TokenInfo]
+    team_member_id: Optional[int]
+
+
+class ApiSettings(BaseModel):
+    """The settings class for the Quantum Inspire persistent configuration."""
+
+    auths: Dict[Url, AuthSettings]
+    default_host: Url
+
+    def store_tokens(self, host: Url, tokens: TokenInfo, path: Path = API_SETTINGS_FILE) -> None:
+        """Stores the team_member_id, access and refresh tokens in the config.json file.
+
+        Args:
+            host: The hostname of the API for which the tokens are intended.
+            tokens: OAuth access and refresh tokens.
+            path: The path to the config.json file. Defaults to API_SETTINGS_FILE.
+        Returns:
+            None
+        """
+        self.auths[host].tokens = tokens
+        path.write_text(self.model_dump_json(indent=2))
+
+    @classmethod
+    def from_config_file(cls, path: Path = API_SETTINGS_FILE) -> ApiSettings:
+        """Load the configuration from a file."""
+        if not path.is_file():
+            raise FileNotFoundError("No configuration file found. Please connect to Quantum Inspire using the CLI.")
+
+        api_settings = path.read_text()
+        return ApiSettings.model_validate_json(api_settings)

qi2_shared/utils.py

@@ -0,0 +1,13 @@
+import asyncio
+import concurrent
+from typing import Any, Coroutine
+
+
+def run_async(async_function: Coroutine[Any, Any, Any]) -> Any:
+    try:
+        _ = asyncio.get_running_loop()
+    except RuntimeError:
+        return asyncio.run(async_function)
+
+    with concurrent.futures.ThreadPoolExecutor() as executor:
+        return executor.submit(asyncio.run, async_function).result()