fujitsu-quantum 1.4.2__tar.gz

fujitsu_quantum-1.4.2/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.1
+Name: fujitsu-quantum
+Version: 1.4.2
+Summary: Fujitsu Quantum Cloud SDK
+Author: Fujitsu Limited
+Requires-Python: >=3.8,<4.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Provides-Extra: qiskit
+Requires-Dist: boto3 (>=1.34.58,<2.0.0)
+Requires-Dist: filelock (>=3.13.1,<4.0.0)
+Requires-Dist: pycognito (>=2024.2.0,<2025.0.0)
+Requires-Dist: pyjson5 (>=1.6.6,<2.0.0)
+Requires-Dist: qiskit (>=0.45,<0.46) ; extra == "qiskit"
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Requires-Dist: typing-extensions (>=4.8.0,<5.0.0) ; python_version < "3.11"
+Description-Content-Type: text/markdown
+
+An official SDK for Fujitsu Quantum Cloud.
+

fujitsu_quantum-1.4.2/README.md

@@ -0,0 +1 @@
+An official SDK for Fujitsu Quantum Cloud.

fujitsu_quantum-1.4.2/pyproject.toml

@@ -0,0 +1,69 @@
+[tool.poetry]
+name = "fujitsu-quantum"
+version = "1.4.2"
+description = "Fujitsu Quantum Cloud SDK"
+authors = ["Fujitsu Limited"]
+readme = "README.md"
+packages = [{include = "fujitsu_quantum", from = "src"}]
+
+[tool.poetry.scripts]
+fujitsu-quantum = 'fujitsu_quantum.cli.fujitsu_quantum_login:main'
+
+[tool.poetry.dependencies]
+python = "^3.8"
+requests = "^2.32.3"
+typing-extensions = { version = "^4.8.0", python = "<3.11" }
+qiskit = { version = "^0.45", optional = true }
+pyjson5 = "^1.6.6"
+boto3 = "^1.34.58"
+pycognito = "^2024.2.0"
+filelock = "^3.13.1"
+
+[tool.poetry.group.dev.dependencies]
+isort = "^5.12.0"
+flake8 = "^5.0.4"
+autoflake = "^1.7.8"
+autopep8 = "^2.0.0"
+mypy = "^1.4.1"
+types-requests = "^2.31.0.2"
+pytest = "^7.4.0"
+qiskit-qasm3-import = "^0.4.1"
+qulacs = "^0.6.4.1"
+openfermionpyscf = "^0.5"
+
+[tool.poetry.extras]
+qiskit = ["qiskit"]
+
+[tool.isort]
+line_length = 120
+
+[tool.autopep8]
+max_line_length = 120
+recursive = true
+ignore = ["E501"]
+
+[tool.mypy]
+exclude = [
+    ".venv",
+    ".git",
+]
+ignore_missing_imports = true
+
+[tool.pytest.ini_options]
+testpaths = [
+    "tests",
+]
+filterwarnings = [
+    "ignore::DeprecationWarning:qiskit.utils.algorithm_globals",
+    "ignore::PendingDeprecationWarning:qiskit.utils.deprecation",
+    "ignore::PendingDeprecationWarning:qiskit.visualization.circuit.matplotlib"
+]
+
+[tool.coverage.report]
+exclude_lines = [
+    "if TYPE_CHECKING:",
+]
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"

fujitsu_quantum-1.4.2/src/fujitsu_quantum/__init__.py

@@ -0,0 +1 @@
+# (C) 2024 Fujitsu Limited

fujitsu_quantum-1.4.2/src/fujitsu_quantum/auth.py

@@ -0,0 +1,189 @@
+# (C) 2024 Fujitsu Limited
+
+import base64
+import hashlib
+import hmac
+import json
+import os
+from abc import ABC, abstractmethod
+from datetime import datetime, timedelta
+from pathlib import Path
+from typing import Dict, Optional
+
+import requests
+from botocore.exceptions import ClientError
+from filelock import BaseFileLock, FileLock
+from requests.auth import AuthBase
+
+from fujitsu_quantum import aws_utils
+
+
+class FjqAuthError(Exception):
+    @property
+    def msg(self) -> str:
+        return self.args[0]
+
+
+class FjqAuth(ABC, AuthBase):
+    CREDENTIALS_DIR: str = ".fujitsu-quantum/"
+    CREDENTIALS_FILE: str = "credentials.json"
+    CREDENTIALS_FILEPATH: Path = Path(Path.home() / CREDENTIALS_DIR / CREDENTIALS_FILE)
+    CREDENTIALS_FILE_LOCK_PATH: Path = CREDENTIALS_FILEPATH.with_suffix(CREDENTIALS_FILEPATH.suffix + ".lock")
+
+    def __init__(self) -> None:
+        self._load_credentials()
+
+    @staticmethod
+    def store_credentials(client_id: str,
+                          username: str,
+                          access_token: str,
+                          access_token_expiration_time: datetime,
+                          refresh_token: str,
+                          refresh_token_expiration_time: datetime,
+                          device_key: Optional[str]) -> None:
+
+        if not os.path.exists(Path.home() / FjqAuth.CREDENTIALS_DIR):
+            os.makedirs(Path.home() / FjqAuth.CREDENTIALS_DIR)
+
+        try:
+            lock = FileLock(FjqAuth.CREDENTIALS_FILE_LOCK_PATH)
+            with lock:
+                with os.fdopen(
+                    os.open(FjqAuth.CREDENTIALS_FILEPATH, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o600), "w"
+                ) as cred_json_file:
+                    cred_json = {
+                        "ClientId": client_id,
+                        "Username": username,
+                        "AccessToken": access_token,
+                        "AccessTokenExpirationTime": access_token_expiration_time.strftime("%Y-%m-%d %H:%M:%S"),
+                        "RefreshToken": refresh_token,
+                        "RefreshTokenExpirationTime": refresh_token_expiration_time.strftime("%Y-%m-%d %H:%M:%S"),
+                    }
+
+                    if device_key is not None:
+                        cred_json["DeviceKey"] = device_key
+
+                    cred_json_file.write(json.dumps(cred_json, indent=4))
+        except FileNotFoundError:
+            raise FjqAuthError(f"Unable to open credentials file lock: {FjqAuth.CREDENTIALS_FILE_LOCK_PATH}")
+
+    def update_access_token_in_credential_file(self, parent_lock: BaseFileLock = None) -> None:
+        cred_json = self._read_credential_file()
+        cred_json["AccessToken"] = self._access_token
+        try:
+            lock = parent_lock
+            if lock is None:
+                lock = FileLock(FjqAuth.CREDENTIALS_FILE_LOCK_PATH)
+
+            with lock:
+                with open(self.CREDENTIALS_FILEPATH, "w") as cred_json_file:
+                    cred_json_file.write(json.dumps(cred_json, indent=4))
+
+        except FileNotFoundError:
+            raise FjqAuthError(f"Unable to open credentials file lock: {FjqAuth.CREDENTIALS_FILE_LOCK_PATH}")
+
+    def _read_credential_file(self, parent_lock: BaseFileLock = None) -> Dict[str, str]:
+        try:
+            lock = parent_lock
+            if lock is None:
+                lock = FileLock(FjqAuth.CREDENTIALS_FILE_LOCK_PATH)
+
+            with lock:
+                try:
+                    with open(self.CREDENTIALS_FILEPATH, 'r') as cred_json_file:
+                        return json.load(cred_json_file)
+
+                except FileNotFoundError:
+                    raise FjqAuthError(
+                        "Credentials not found."
+                        " Please run `fujitsu-quantum login` to configure credentials.",
+                    )
+
+                except json.JSONDecodeError:
+                    raise FjqAuthError("The credential data is corrupted."
+                                       " Please run `fujitsu-quantum login` to configure credentials.")
+
+        except FileNotFoundError:
+            raise FjqAuthError(f"Unable to open credentials file lock: {FjqAuth.CREDENTIALS_FILE_LOCK_PATH}")
+
+    def _load_credentials(self, parent_lock: BaseFileLock = None) -> None:
+        cred_json = self._read_credential_file(parent_lock)
+        try:
+            self._client_id: str = cred_json["ClientId"]
+            self._username: str = cred_json["Username"]
+            self._access_token: str = cred_json["AccessToken"]
+            self._access_token_expiration_time: str = cred_json["AccessTokenExpirationTime"]
+            self._refresh_token: str = cred_json["RefreshToken"]
+            self.refresh_token_expiration_time: str = cred_json["RefreshTokenExpirationTime"]
+            self._device_key: Optional[str] = cred_json.get("DeviceKey", None)
+        except KeyError:
+            raise FjqAuthError("The credentials are outdated."
+                               " Please run `fujitsu-quantum login` to update the credentials.")
+
+    @abstractmethod
+    def refresh_auth(self, force: bool = False) -> None:
+        raise NotImplementedError()
+
+    def __call__(self, r: requests.PreparedRequest) -> requests.PreparedRequest:
+        r.headers["authorization"] = "Bearer " + self._access_token
+        return r
+
+    def update_authorization_header(self, r: requests.PreparedRequest):
+        r.headers["authorization"] = "Bearer " + self._access_token
+
+
+class FjqAuthBoto3(FjqAuth):
+    # TODO some error handling
+    def refresh_auth(self, force: bool = False) -> None:
+        """
+        Refreshes the access token.
+        If there is still time before the access token expires, this method does not refresh the access token to avoid
+        excessive token refresh requests.
+        """
+        try:
+            lock = FileLock(FjqAuth.CREDENTIALS_FILE_LOCK_PATH)
+            with lock:
+                if not force:
+                    # Because other threads or processes may have updated the credential file, it should reload the file.
+                    self._load_credentials(lock)
+                    expiration_time = datetime.strptime(self._access_token_expiration_time, "%Y-%m-%d %H:%M:%S")
+                    if expiration_time - datetime.now() > timedelta(minutes=10):
+                        return
+
+                client = aws_utils.get_client("cognito-idp", region_name="ap-northeast-1")
+
+                new_hmac = hmac.new(bytes(self._username + self._client_id, "utf-8"),
+                                    digestmod=hashlib.sha256).digest()
+                secret_hash = base64.b64encode(new_hmac).decode()
+
+                auth_params = {
+                    "USERNAME": self._username,
+                    "SECRET_HASH": secret_hash,
+                    "REFRESH_TOKEN": self._refresh_token,
+                }
+
+                if self._device_key is not None:
+                    auth_params["DEVICE_KEY"] = self._device_key
+
+                try:
+                    response = client.initiate_auth(
+                        ClientId=self._client_id,
+                        AuthFlow="REFRESH_TOKEN_AUTH",
+                        AuthParameters=auth_params,
+                    )
+                    self._access_token = response["AuthenticationResult"]["AccessToken"]
+                except ClientError as e:
+                    if e.response["Error"]["Code"] == 'NotAuthorizedException':
+                        raise FjqAuthError('The credentials have expired.'
+                                           ' Please run `fujitsu-quantum login` to update the credentials.')
+                    else:
+                        raise e
+
+                self.update_access_token_in_credential_file(lock)
+
+        except FileNotFoundError:
+            raise FjqAuthError(f"Unable to open credentials file lock: {FjqAuth.CREDENTIALS_FILE_LOCK_PATH}")
+
+    def logout(self) -> None:
+        client = aws_utils.get_client("cognito-idp", region_name="ap-northeast-1")
+        client.revoke_token(Token=self._refresh_token, ClientId=self._client_id)

fujitsu_quantum-1.4.2/src/fujitsu_quantum/aws_utils.py

@@ -0,0 +1,64 @@
+# (C) 2024 Fujitsu Limited
+
+import os
+from typing import Any, Dict
+
+import boto3
+from botocore.client import BaseClient
+from botocore.config import Config
+
+
+def add_aws_link_local_address_to_no_proxy():
+    # AWS SDK tries to connect http://169.254.169.254/** to retrieve metadata.
+    # 169.254.169.254 is a link-local address and must be accessed with no proxies.
+    # https://docs.aws.amazon.com/cli/v1/userguide/cli-configure-proxy.html#cli-configure-proxy-ec2
+    aws_link_local_address = '169.254.169.254'
+
+    original_no_proxy = None
+    env_name_is_lowercase = True
+    if 'no_proxy' in os.environ:
+        original_no_proxy = os.environ['no_proxy']
+    elif 'NO_PROXY' in os.environ:
+        original_no_proxy = os.environ['NO_PROXY']
+        env_name_is_lowercase = False
+
+    if original_no_proxy is None:
+        os.environ['no_proxy'] = aws_link_local_address
+    else:
+        no_proxies = [address.strip() for address in original_no_proxy.split(',')]
+        if aws_link_local_address not in no_proxies:
+            if env_name_is_lowercase:
+                os.environ['no_proxy'] = f'{original_no_proxy},{aws_link_local_address}'
+            else:
+                os.environ['NO_PROXY'] = f'{original_no_proxy},{aws_link_local_address}'
+
+    return {'original_no_proxy': original_no_proxy, 'env_name_is_lowercase': env_name_is_lowercase}
+
+
+def restore_no_proxy(original_no_proxy_config: Dict[str, Any]) -> None:
+    original_no_proxy = original_no_proxy_config['original_no_proxy']
+    env_name_is_lowercase = original_no_proxy_config['env_name_is_lowercase']
+    if original_no_proxy is None:
+        del os.environ['no_proxy']
+    else:
+        if env_name_is_lowercase:
+            os.environ['no_proxy'] = original_no_proxy
+        else:
+            os.environ['NO_PROXY'] = original_no_proxy
+
+
+def get_client(*args, **kwargs) -> BaseClient:
+    # AWS SDK requires a special setting of 'no_proxy'
+    add_aws_link_local_address_to_no_proxy()
+
+    if 'config' in kwargs:
+        raise ValueError('get_client(...) does not allow to specify the "config" parameter.')
+
+    config = Config(
+        retries={
+            'max_attempts': 10,
+            'mode': 'standard'
+        }
+    )
+    client = boto3.client(*args, **kwargs, config=config)
+    return client

fujitsu_quantum-1.4.2/src/fujitsu_quantum/cli/fujitsu_quantum_login.py

@@ -0,0 +1,150 @@
+# (C) 2024 Fujitsu Limited
+
+import argparse
+import getpass
+import logging
+import sys
+import traceback
+from datetime import datetime, timedelta
+
+from botocore.exceptions import ClientError
+from pycognito.aws_srp import AWSSRP
+from pycognito.exceptions import ForceChangePasswordException, SoftwareTokenMFAChallengeException
+
+from fujitsu_quantum import aws_utils
+from fujitsu_quantum.auth import FjqAuthBoto3, FjqAuthError
+from fujitsu_quantum.config import Config
+
+# Used to make debugging faster. Input your testing user credentials,
+# and when the CLI asks for a username and password, just click Enter.
+Username = ""
+Password = ""
+
+
+def main() -> None:
+    try:
+        parser = argparse.ArgumentParser(description="Fujitsu Quantum CLI")
+        parser.add_argument("command", choices=["login", "refresh", "logout", "auth-status"],
+                            help="Command to run")
+        parser.add_argument("-d", "--debug", action="store_true", help="Enable debug mode")
+        options = parser.parse_args()
+
+        if options.debug:
+            logging.basicConfig(format="%(levelname)s: %(message)s", level=logging.DEBUG)
+            logging.debug("Set log level to DEBUG")
+        else:
+            logging.basicConfig(format="%(levelname)s: %(message)s", level=logging.INFO)
+
+        if options.command == "login":
+            user = input("Enter username: ") or Username
+            while len(user) == 0:
+                user = input("Enter username: ") or Username
+            password = getpass.getpass("Enter password: ") or Password
+
+            client = aws_utils.get_client("cognito-idp", region_name="ap-northeast-1")
+            aws = AWSSRP(
+                client=client,
+                pool_id=Config.auth_pool_id,
+                client_id=Config.auth_sdk_client_id,
+                username=user,
+                password=password,
+            )
+
+            try:
+                logging.debug("AWSSRP.authenticate")
+                aws.authenticate_user()
+
+            except ForceChangePasswordException:
+                print("Your account is in an invalid state. Please contact the support team.", file=sys.stderr)
+                raise RuntimeError("Invalid account state.")
+
+            except SoftwareTokenMFAChallengeException as exc:
+                logging.debug("pycognito.SoftwareTokenMFAChallengeException")
+
+                device_name = exc.get_tokens()["ChallengeParameters"].get("FRIENDLY_DEVICE_NAME", None)
+                if device_name is not None:
+                    code_prompt = "Enter the 6-digit code generated by your TOTP device ({0}): ".format(device_name)
+                else:
+                    code_prompt = "Enter the 6-digit code generated by your TOTP device): "
+
+                code = input(code_prompt)
+                while len(code) == 0:
+                    code = input(code_prompt)
+
+                current_time = datetime.now()
+                tokens = client.respond_to_auth_challenge(
+                    ClientId=Config.auth_sdk_client_id,
+                    Session=exc.get_tokens()["Session"],
+                    ChallengeName=exc.get_tokens()["ChallengeName"],
+                    ChallengeResponses={
+                        "USERNAME": user,
+                        "SOFTWARE_TOKEN_MFA_CODE": code,
+                    },
+                )
+
+                access_token = tokens["AuthenticationResult"]["AccessToken"]
+                refresh_token = tokens["AuthenticationResult"]["RefreshToken"]
+                access_token_expires_in = tokens["AuthenticationResult"]["ExpiresIn"]
+                access_token_expiration_time = current_time + timedelta(seconds=access_token_expires_in)
+                refresh_token_expiration_time = current_time + timedelta(days=180)
+
+                if "NewDeviceMetadata" in tokens["AuthenticationResult"]:
+                    logging.debug("Confirming device...")
+                    _, _ = aws.confirm_device(tokens=tokens)
+                    device_key = tokens["AuthenticationResult"]["NewDeviceMetadata"]["DeviceKey"]
+                else:
+                    device_key = None
+
+                print("Authentication succeeded.")
+
+                FjqAuthBoto3.store_credentials(
+                    client_id=Config.auth_sdk_client_id,
+                    username=user,
+                    access_token=access_token,
+                    access_token_expiration_time=access_token_expiration_time,
+                    refresh_token=refresh_token,
+                    refresh_token_expiration_time=refresh_token_expiration_time,
+                    device_key=device_key,
+                )
+
+                print("Successfully logged in.")
+
+        elif options.command == "refresh":
+            FjqAuthBoto3().refresh_auth(force=True)
+            print("The credential file has been successfully updated.")
+
+        elif options.command == "logout":
+            FjqAuthBoto3().logout()
+            print("Successfully logged out.")
+
+        elif options.command == 'auth-status':
+            try:
+                auth = FjqAuthBoto3()
+                expr_time = datetime.strptime(auth.refresh_token_expiration_time, '%Y-%m-%d %H:%M:%S')
+                if expr_time < datetime.now():
+                    print('Credentials are outdated.\nPlease run `fujitsu-quantum login` to update the credentials.')
+                else:
+                    print(f'You have valid credentials.\nThe credentials will expire at {expr_time}.')
+            except FjqAuthError as e:
+                print(e.args[0])
+
+        else:
+            print(f"Invalid command: {options.command}")
+
+    except ClientError as exc:
+        boto3_error_code = exc.response["Error"]["Code"]
+        boto3_error_message = exc.response["Error"]["Message"]
+        if boto3_error_code == 'NotAuthorizedException':
+            error_message = f'Failed to {options.command}.\n{boto3_error_message}.'
+        elif boto3_error_code == 'CodeMismatchException':
+            error_message = 'Failed to login.\nThe TOTP code is invalid.'
+        else:
+            error_message = f'Failed to login.\n{boto3_error_message}. ({boto3_error_code})'
+
+        print(error_message)
+    except Exception as exc:
+        print(''.join(traceback.format_exception(type(exc), exc, exc.__traceback__)))
+
+
+if __name__ == "__main__":
+    main()

fujitsu_quantum-1.4.2/src/fujitsu_quantum/concurrent/__init__.py

@@ -0,0 +1 @@
+# (C) 2024 Fujitsu Limited

fujitsu_quantum-1.4.2/src/fujitsu_quantum/concurrent/futures.py

@@ -0,0 +1,65 @@
+# (C) 2024 Fujitsu Limited
+
+import sys
+from concurrent.futures import ProcessPoolExecutor
+from typing import List, Union
+
+if sys.version_info >= (3, 9):
+    from collections.abc import Sequence
+else:
+    # collections.abc.Sequence is not subscriptable in Python 3.8 or older.
+    # collections.abc.Sequence is deprecated since Python 3.9
+    from typing import Sequence
+
+from fujitsu_quantum.devices import QPU, Simulator
+from fujitsu_quantum.results import EstimationResult, SamplingResult
+from fujitsu_quantum.tasks import EstimationTask, SamplingTask
+
+
+class Executor:
+    """This class enables users to simultaneously submit multiple quantum tasks and retrieve results."""
+
+    def __init__(self, max_workers: int):
+        self.executor = ProcessPoolExecutor(max_workers=max_workers)
+
+    def submit_sampling_tasks(self, device: Union[QPU, Simulator], code_list, *args, **kwargs) -> List[SamplingTask]:
+        task_futures = []
+        for code in code_list:
+            if kwargs is None:
+                kwargs = {'code': code}
+            else:
+                kwargs['code'] = code
+
+            task_futures.append(self.executor.submit(device.submit_sampling_task, *args, **kwargs))
+
+        tasks = [tf.result() for tf in task_futures]
+        return tasks
+
+    def submit_estimation_tasks(self, device: Union[QPU, Simulator], code_list, *args, **kwargs)\
+            -> List[EstimationTask]:
+
+        task_futures = []
+        for code in code_list:
+            if kwargs is None:
+                kwargs = {'code': code}
+            else:
+                kwargs['code'] = code
+
+            task_futures.append(self.executor.submit(device.submit_estimation_task, *args, **kwargs))
+
+        tasks = [tf.result() for tf in task_futures]
+        return tasks
+
+    def get_results(self, tasks: Sequence[Union[EstimationTask, SamplingTask]])\
+            -> List[Union[EstimationResult, SamplingResult]]:
+
+        result_futures = []
+        for task in tasks:
+            result_futures.append(self.executor.submit(Executor._get_task_result, task))
+
+        results = [rf.result() for rf in result_futures]
+        return results
+
+    @staticmethod
+    def _get_task_result(task: Union[EstimationTask, SamplingTask]) -> Union[EstimationResult, SamplingResult]:
+        return task.result()

fujitsu_quantum-1.4.2/src/fujitsu_quantum/config.py

@@ -0,0 +1,55 @@
+# (C) 2024 Fujitsu Limited
+
+import dataclasses
+from pathlib import Path
+
+import pyjson5
+
+
+@dataclasses.dataclass(frozen=True)
+class _Config:
+    config_dir: str
+    auth_pool_id: str
+    auth_sdk_client_id: str
+    api_base: str
+    result_polling_interval: int
+
+
+def load_config() -> _Config:
+    config_dir = Path.home() / '.fujitsu-quantum'
+    config_file_path = config_dir / 'config.json'
+
+    if config_file_path.exists():
+        with open(config_file_path, "r", encoding='utf-8') as f:
+            conf_data = pyjson5.decode_io(f)
+
+        if not isinstance(conf_data, dict):
+            raise ValueError(f"Invalid config file: {config_file_path}")
+
+        conf = conf_data
+    else:
+        conf = {}
+
+    available_keys = {'authPoolId', 'authSdkClientId', 'apiBase', 'resultPollingInterval'}
+    invalid_keys = conf.keys() - available_keys
+    if invalid_keys:
+        raise ValueError(f'Invalid parameter names in config.json: {invalid_keys}\n'
+                         f'config.json path: {config_file_path}')
+
+    # validate the config values
+    result_polling_interval = conf.get('resultPollingInterval', 5)
+    if result_polling_interval < 1:
+        raise ValueError('Invalid value in config.json: resultPollingInterval must be >= 1.\n'
+                         f'config.json path: {config_file_path}')
+
+    # Note: some config values can be overridden via the config file for development purpose
+    return _Config(
+        config_dir=str(config_dir),
+        auth_pool_id=conf.get('authPoolId', 'ap-northeast-1_oUVGkT61e'),
+        auth_sdk_client_id=conf.get('authSdkClientId', '66l8iadggtteljctngjepi8du0'),
+        api_base=conf.get('apiBase', 'https://api.quantum.global.fujitsu.com'),
+        result_polling_interval=result_polling_interval,
+    )
+
+
+Config = load_config()