quantuminspire 3.0.0__py3-none-any.whl

quantuminspire/cli/command_list.py

@@ -0,0 +1,202 @@
+"""Module containing the commands for the Quantum Inspire CLI."""
+
+import asyncio
+import webbrowser
+from pathlib import Path
+from typing import Optional
+
+import typer
+from compute_api_client import JobStatus
+from rich import print
+from rich.console import Console
+from rich.table import Table
+from typer import Typer
+
+from quantuminspire.sdk.models.cqasm_algorithm import CqasmAlgorithm
+from quantuminspire.sdk.models.file_algorithm import FileAlgorithm
+from quantuminspire.sdk.models.hybrid_algorithm import HybridAlgorithm
+from quantuminspire.sdk.models.job_options import JobOptions
+from quantuminspire.util.api.local_backend import LocalBackend
+from quantuminspire.util.api.remote_backend import RemoteBackend
+from quantuminspire.util.authentication import OauthDeviceSession
+from quantuminspire.util.configuration import Settings, Url
+
+app = Typer(add_completion=False, no_args_is_help=True)
+backend_types_app = Typer(no_args_is_help=True)
+app.add_typer(backend_types_app, name="backends", help="Manage backends")
+files_app = Typer(no_args_is_help=True)
+app.add_typer(files_app, name="files", help="Manage files")
+results_app = Typer(no_args_is_help=True)
+app.add_typer(results_app, name="results", help="Manage results")
+final_results_app = Typer(no_args_is_help=True)
+app.add_typer(final_results_app, name="final_results", help="Manage final results")
+
+console = Console()
+
+
+@backend_types_app.command("list")
+def list_backend_types() -> None:
+    """List backends.
+
+    List all available backends and their configuration.
+    """
+    backend = RemoteBackend()
+    backend_types = backend.get_backend_types().items
+    table = Table("id", "name", "status", "is_hardware", "supports_raw_data", "number_of_qubits", "max_number_of_shots")
+    for backend_type in backend_types:
+        table.add_row(
+            str(backend_type.id),
+            backend_type.name,
+            str(backend_type.status.name),
+            str(backend_type.is_hardware),
+            str(backend_type.supports_raw_data),
+            str(backend_type.nqubits),
+            str(backend_type.max_number_of_shots),
+        )
+    console.print(table)
+
+
+def load_algorithm_from_file(file_path: Path) -> FileAlgorithm:
+    """Load an algorithm from a file."""
+    if file_path.suffix == ".py":
+        algorithm: FileAlgorithm = HybridAlgorithm("", str(file_path))
+    elif file_path.suffix == ".cq":
+        algorithm = CqasmAlgorithm("", str(file_path))
+    else:
+        raise ValueError(f"Unsupported file type: {file_path.suffix}. Supported types are .py and .cq")
+
+    algorithm.read_file(file_path)
+    return algorithm
+
+
+@files_app.command("upload")
+def upload_files(
+    name: str = typer.Argument(..., help="The name of the file to upload"),
+    backend_type_id: int = typer.Argument(
+        ..., help="The id of the backend type on which this algorithm should be executed"
+    ),
+    num_shots: int = typer.Option(
+        1024, help="The number of shots to run the algorithm (only for pure cQASM algorithms)"
+    ),
+    store_raw_data: bool = typer.Option(
+        False, help="Whether to enable shot memory for the algorithm (only for pure cQASM algorithms)"
+    ),
+) -> None:
+    """Upload a file to the QI API.
+
+    Upload a file containing either a Hybrid (.py) or a Quantum (.cq) algorithm, and run it on the QI platform.
+    """
+    backend = RemoteBackend()
+    program = load_algorithm_from_file(Path(name))
+    program.read_file(Path(name))
+    job_options = JobOptions(number_of_shots=num_shots, raw_data_enabled=store_raw_data)
+    job_id = backend.run(program, backend_type_id=backend_type_id, options=job_options)
+    typer.echo(f"Upload file with name: {name}")
+    typer.echo(f"job_id {job_id}")
+
+
+@files_app.command("run")
+def run_file(
+    name: str = typer.Argument(..., help="The full path of the file to run"),
+) -> None:
+    """Run a file locally.
+
+    Run a Hybrid Quantum/Classical Algorithm locally. The quantum part will be run with QXEmulator.
+    """
+    algorithm = HybridAlgorithm("test", "test")
+    algorithm.read_file(Path(name))
+
+    local_backend = LocalBackend()
+    job_id = local_backend.run(algorithm, 0)
+    results = local_backend.get_results(job_id)
+    typer.echo(f"{results}")
+
+
+def _has_job_failed(backend: RemoteBackend, job_id: int) -> None:
+    """Check if a job has failed and exit with error_code 1 if it has."""
+    job = backend.get_job(job_id)
+    if job.status == JobStatus.FAILED:
+        job.message = job.message or "Job failed."
+        typer.echo(job.message, err=True)
+        typer.echo(f"Trace id: {job.trace_id}", err=True)
+        raise typer.Exit(1)
+
+
+@results_app.command("get")
+def get_results(job_id: int = typer.Argument(..., help="The id of the run")) -> None:
+    """Retrieve the results for a run.
+
+    Takes the id as returned by upload_files and retrieves the results for that run, if it's finished.
+    """
+    backend = RemoteBackend()
+    _has_job_failed(backend, job_id)
+    results = backend.get_results(job_id)
+
+    if results is None:
+        typer.echo("No results.")
+        raise typer.Exit(1)
+
+    typer.echo("Raw results:")
+    print(results.model_dump())
+
+
+@final_results_app.command("get")
+def get_final_results(job_id: int = typer.Argument(..., help="The id of the run")) -> None:
+    """Retrieve the final results for a run.
+
+    Takes the id as returned by upload_files and retrieves the final results for that job, if it's finished.
+    """
+    backend = RemoteBackend()
+    _has_job_failed(backend, job_id)
+    results = backend.get_final_results(job_id)
+
+    if results is None:
+        typer.echo("No final results.")
+        raise typer.Exit(1)
+
+    typer.echo("Raw final results:")
+    print(results.model_dump())
+
+
+@app.command("login")
+def login(
+    host: Optional[str] = typer.Argument(None, help="The URL of the platform to which to connect"),
+    override_auth_config: bool = typer.Option(
+        False,
+        help="Will ignore authentication configuration suggested by the API and use stored configuration instead",
+    ),
+) -> None:
+    """Log in to Quantum Inspire.
+
+    Log in to the Quantum Inspire platform. The host can be overwritten, so that the user can connect to different
+    instances. If no host is specified, the production environment will be used.
+    """
+    settings = Settings()
+    host = host or settings.default_host
+    host_url = Url(host)
+    settings.default_host = host_url
+
+    if not override_auth_config:
+        asyncio.run(settings.fetch_auth_settings(host_url))
+
+    auth_session = OauthDeviceSession(settings.auths[host_url])
+
+    login_info = auth_session.initialize_authorization()
+    typer.echo(f"Please continue logging in by opening: {login_info['verification_uri_complete']} in your browser")
+    typer.echo(f"If promped to verify a code, please confirm it is as follows: {login_info['user_code']}")
+    webbrowser.open(login_info["verification_uri_complete"], new=2)
+    tokens = auth_session.poll_for_tokens()
+    settings.store_tokens(host_url, tokens)
+    typer.echo("Login successful!")
+    typer.echo(f"Using member ID {settings.auths[host].team_member_id}")
+
+
+@app.command("set-default-host")
+def set_default_host(
+    host: str = typer.Argument(help="The URL of the platform to which to connect"),
+) -> None:
+    """Set default_host for interacting with Quantum Inspire."""
+    settings = Settings()
+    settings.default_host = Url(host)
+    settings.write_settings_to_file()
+    typer.echo(f"Default host set to {host}")

quantuminspire/sdk/models/base_algorithm.py

@@ -0,0 +1,64 @@
+"""Module containing the Abstract Base Class for Algorithm classes."""
+
+from abc import ABC, abstractmethod
+
+
+class BaseAlgorithm(ABC):
+    """A container object, used to store content and metadata for the algorithm."""
+
+    def __init__(self, platform_name: str, program_name: str) -> None:
+        self._platform_name = platform_name
+        self._program_name = program_name
+
+    @property
+    def program_name(self) -> str:
+        """Return the name of the program.
+
+        Returns:
+            The string representation of the program name.
+        """
+        return self._program_name
+
+    @property
+    def platform_name(self) -> str:
+        """Return the name of the platform the algorithm is intended to run on.
+
+        Returns:
+            The string representation of the platform name.
+        """
+        return self._platform_name
+
+    @property
+    @abstractmethod
+    def content(self) -> str:
+        """Return the content.
+
+        Returns:
+            The string representation of the program.
+        """
+
+    @property
+    @abstractmethod
+    def content_type(self) -> str:
+        """Return the content type.
+
+        Returns:
+            The string representation of the `AlgorithmType`.
+        """
+
+    @property
+    @abstractmethod
+    def compile_stage(self) -> str:
+        """Return the compile stage.
+
+        Returns:
+            The string representation of the `CompileStage`.
+        """
+
+    @property
+    @abstractmethod
+    def language_name(self) -> str:
+        """The name of the language the algorithm in the file is written in.
+
+        Should match a language in the API.
+        """

quantuminspire/sdk/models/circuit.py

@@ -0,0 +1,79 @@
+"""Module containing the Quantum Circuit class."""
+
+from types import TracebackType
+from typing import Optional, Type
+
+from compute_api_client import AlgorithmType, CompileStage
+from opensquirrel import CircuitBuilder
+
+from quantuminspire.sdk.models.base_algorithm import BaseAlgorithm
+
+
+class Circuit(BaseAlgorithm):
+    """A container object, interacting with OpenSquirrel and storing cQASM internally.
+
+    A circuit wraps OpenSquirrel to handle the boilerplate code for the CircuitBuilder.
+    """
+
+    def __init__(
+        self, platform_name: str, program_name: str, number_of_qubits: int, bit_registers: Optional[int] = None
+    ) -> None:
+        super().__init__(platform_name, program_name)
+        self._number_of_qubits = number_of_qubits
+        if bit_registers is None:
+            bit_registers = number_of_qubits
+        self._number_of_bit_registers = bit_registers
+        self.ir = CircuitBuilder(qubit_register_size=number_of_qubits, bit_register_size=bit_registers)
+        self._cqasm: str = ""
+
+    @property
+    def content(self) -> str:
+        return self._cqasm
+
+    @property
+    def content_type(self) -> AlgorithmType:
+        return AlgorithmType.QUANTUM
+
+    @property
+    def compile_stage(self) -> CompileStage:
+        return CompileStage.NONE
+
+    def __enter__(self) -> "Circuit":
+        self.initialize()
+        return self
+
+    def __exit__(
+        self, exc_type: Optional[Type[BaseException]], exc_val: Optional[BaseException], exc_tb: Optional[TracebackType]
+    ) -> bool:
+        self.finalize()
+        return exc_type is None
+
+    @property
+    def language_name(self) -> str:
+        return "cQASM"
+
+    def initialize(self) -> None:
+        """Initialize the quantum circuit."""
+
+    def finalize(self) -> None:
+        """Finalize the quantum circuit.
+
+        After finishing writing the quantum circuit various actions are performed to generate the actual cQASM circuit.
+        The circuit is converted to cQASM. Due to some differences between OpenSquirrel and QX, the casing of the gates
+        need to be tweaked.
+        """
+        self._cqasm = str(self.ir.to_circuit())
+        self._cqasm = (
+            self._cqasm.replace("h", "H")
+            .replace("cnot", "CNOT")
+            .replace("x", "X")
+            .replace("y", "Y")
+            .replace("z", "Z")
+            .replace("x90", "X90")
+            .replace("mx90", "mX90")
+            .replace("y90", "Y90")
+            .replace("my90", "mY90")
+            .replace("RZ", "Rz")
+            .replace("RX", "Rx")
+            .replace("cz", "CZ")
+        )

quantuminspire/sdk/models/cqasm_algorithm.py

@@ -0,0 +1,20 @@
+"""Module containing the Quantum Algorithm class."""
+
+from compute_api_client import AlgorithmType
+
+from quantuminspire.sdk.models.file_algorithm import FileAlgorithm
+
+
+class CqasmAlgorithm(FileAlgorithm):
+    """A container object, reading the python algorithm and keeping metadata.
+
+    The CqasmAlgorithm reads the python file describing the algorithm and stores it in `.content`.
+    """
+
+    @property
+    def content_type(self) -> AlgorithmType:
+        return AlgorithmType.QUANTUM
+
+    @property
+    def language_name(self) -> str:
+        return "cQASM"

quantuminspire/sdk/models/file_algorithm.py

@@ -0,0 +1,34 @@
+"""Module containing the Hybrid Quantum/Classical Algorithm class."""
+
+from pathlib import Path
+
+from compute_api_client import CompileStage
+
+from quantuminspire.sdk.models.base_algorithm import BaseAlgorithm
+
+
+class FileAlgorithm(BaseAlgorithm):
+    """A container object, reading the python algorithm and keeping metadata.
+
+    The FileAlgorithm reads the python file describing the algorithm and stores it in `.content`.
+    """
+
+    def __init__(self, platform_name: str, program_name: str) -> None:
+        super().__init__(platform_name, program_name)
+        self._content = ""
+
+    @property
+    def content(self) -> str:
+        return self._content
+
+    @property
+    def compile_stage(self) -> CompileStage:
+        return CompileStage.NONE
+
+    def read_file(self, file_pointer: Path) -> None:
+        """Read the python file to the wrapper.
+
+        Args:
+            file_pointer: the file path to the file to read.
+        """
+        self._content = file_pointer.read_text()

quantuminspire/sdk/models/hybrid_algorithm.py

@@ -0,0 +1,20 @@
+"""Module containing the Hybrid Quantum/Classical Algorithm class."""
+
+from compute_api_client import AlgorithmType
+
+from quantuminspire.sdk.models.file_algorithm import FileAlgorithm
+
+
+class HybridAlgorithm(FileAlgorithm):
+    """A container object, reading the python algorithm and keeping metadata.
+
+    The HybridAlgorithm reads the python file describing the algorithm and stores it in `.content`.
+    """
+
+    @property
+    def content_type(self) -> AlgorithmType:
+        return AlgorithmType.HYBRID
+
+    @property
+    def language_name(self) -> str:
+        return "Python"

quantuminspire/sdk/models/job_options.py

@@ -0,0 +1,15 @@
+from pydantic import BaseModel, Field
+
+
+class JobOptions(BaseModel):
+    """Options for running a job.
+
+    Subset of fields in the JobIn schema.
+    """
+
+    number_of_shots: int = Field(
+        1024, ge=1, description="Number of shots for the job (only pure cQASM algorithms supported)."
+    )
+    raw_data_enabled: bool = Field(
+        False, description="Whether to enable shot memory for the job (only pure cQASM algorithms supported)."
+    )

quantuminspire/sdk/quantum_interface.py

@@ -0,0 +1,37 @@
+"""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 typing import TYPE_CHECKING, Any, List
+
+from quantuminspire.util.api.quantum_interface import ExecuteCircuitResult, QuantumInterface as QuantumInterfaceProtocol
+
+if TYPE_CHECKING:  # pragma: no cover
+    from quantuminspire.util.api.local_backend import LocalBackend
+
+
+class QuantumInterface(QuantumInterfaceProtocol):
+    """Quantum Interface implementation for running quantum circuits from hybrid algorithms."""
+
+    # pylint: disable = R0903
+    # R0903: Too few public methods (1/2) (too-few-public-methods)
+
+    def __init__(self, backend: "LocalBackend"):
+        self.backend = backend
+        self.results: List[Any] = []
+
+    def execute_circuit(self, circuit: str, number_of_shots: int) -> ExecuteCircuitResult:
+        """Execute a quantum circuit."""
+        results = self.backend.run_quantum(circuit, number_of_shots)
+        self.results.append(results.results)
+        return results

quantuminspire/util/api/base_backend.py

@@ -0,0 +1,35 @@
+"""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
+
+from quantuminspire.sdk.models.base_algorithm import BaseAlgorithm
+
+
+class BaseBackend(ABC):
+    """Base interface for backends.
+
+    A backend will execute the hybrid algorithm, or quantum circuit provided.
+    """
+
+    @abstractmethod
+    def run(self, program: BaseAlgorithm, backend_type_id: int) -> int:
+        """Execute provided algorithm/circuit."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def get_results(self, job_id: int) -> Any:
+        """Get results for algorithm/circuit."""
+        raise NotImplementedError

quantuminspire/util/api/local_backend.py

@@ -0,0 +1,110 @@
+"""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.
+"""
+
+import importlib
+import sys
+import types
+from enum import IntEnum
+from typing import Any, Union
+
+from quantuminspire.sdk.models.base_algorithm import BaseAlgorithm
+from quantuminspire.sdk.models.circuit import Circuit
+from quantuminspire.sdk.models.hybrid_algorithm import HybridAlgorithm
+from quantuminspire.sdk.quantum_interface import QuantumInterface
+from quantuminspire.util.api.base_backend import BaseBackend
+from quantuminspire.util.api.quantum_interface import ExecuteCircuitResult, QuantumInterface as QuantumInterfaceProtocol
+
+
+def import_qxelarator() -> types.ModuleType:  # pragma: no cover
+    """Helper function for importing optional dependency qxelarator."""
+
+    try:
+        return importlib.import_module("qxelarator")
+    except ModuleNotFoundError as exc:
+        print(
+            "Error: Dependencies for local execution not installed, install with 'pip install quantuminspire[local]'",
+            file=sys.stderr,
+        )
+        raise SystemExit from exc
+
+
+class LocalBackend(BaseBackend):
+    """Connection to remote backend.
+
+    Create a connection with the remote backend for Quantum Inspire. This connection creates the appropriate projects,
+    algorithms, files etc. The algorithm/circuit will also be run.
+    """
+
+    class JobFakeID(IntEnum):
+        """Helper to conform to BaseBackend interface of returning job IDs."""
+
+        QUANTUM = -1
+        HYBRID = -2
+
+    def __init__(self, qxelarator: Union[types.ModuleType, None] = None) -> None:
+        super().__init__()
+        self._quantum_results: Union[ExecuteCircuitResult, None] = None
+        self._hybrid_results: Union[Any, None] = None
+        self._qxelarator = qxelarator if qxelarator else import_qxelarator()
+
+    def run(self, program: BaseAlgorithm, backend_type_id: int) -> int:
+        """Execute provided algorithm/circuit."""
+        if isinstance(program, HybridAlgorithm):
+            quantum_interface = QuantumInterface(self)
+            self._hybrid_results = self.run_hybrid(program, quantum_interface)
+            return self.JobFakeID.HYBRID
+        if isinstance(program, Circuit):
+            self._quantum_results = self.run_quantum(program.content)
+            return self.JobFakeID.QUANTUM
+        raise AssertionError("Unknown algorithm type")
+
+    def run_hybrid(self, algorithm: HybridAlgorithm, quantum_interface: QuantumInterfaceProtocol) -> Any:
+        """Execute provided algorithm."""
+
+        # pylint: disable = E1101, W0122
+        # E1101: Instance of 'module' has no 'execute' member (no-member)
+        # W0122: Use of exec (exec-used)
+
+        program = types.ModuleType("mod")
+
+        exec(algorithm.content, program.__dict__)
+
+        if not hasattr(program, "execute") or not callable(program.execute):
+            raise AssertionError("'execute' hook not found or not callable.")
+        program.execute(quantum_interface)
+
+        if not hasattr(program, "finalize") or not callable(program.finalize):
+            raise AssertionError("'finalize' hook not found or not callable.")
+        result = program.finalize(quantum_interface.results)
+        if not isinstance(result, dict):
+            raise AssertionError("'finalize' hook returned invalid type, must be dict.")
+        return result
+
+    def run_quantum(self, circuit: str, number_of_shots: int = 1) -> ExecuteCircuitResult:
+        """Execute provided circuit."""
+        result = self._qxelarator.execute_string(circuit, iterations=number_of_shots)
+        return ExecuteCircuitResult(
+            results=result.results,
+            shots_done=result.shots_done,
+            shots_requested=result.shots_requested,
+        )
+
+    def get_results(self, job_id: int) -> Any:
+        """Get results for algorithm/circuit."""
+        if job_id == self.JobFakeID.QUANTUM:
+            return self._quantum_results
+        if job_id == self.JobFakeID.HYBRID:
+            return self._hybrid_results
+
+        raise AssertionError("Unknown job id")

quantuminspire/util/api/quantum_interface.py

@@ -0,0 +1,40 @@
+"""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
+
+from pydantic import BaseModel
+
+
+class ExecuteCircuitResult(BaseModel):
+    """Result of executing a quantum circuit."""
+
+    results: Dict[str, float]
+    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[Any]
+
+    @abstractmethod
+    def execute_circuit(self, circuit: str, number_of_shots: int) -> ExecuteCircuitResult:
+        """Execute a quantum circuit."""
+        raise NotImplementedError