azure-quantum 2.2.0.dev5__tar.gz → 2.3.0__tar.gz

{azure-quantum-2.2.0.dev5 → azure-quantum-2.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: azure-quantum
-Version: 2.2.0.dev5
+Version: 2.3.0
 Summary: Python client for Azure Quantum
 Home-page: https://github.com/microsoft/azure-quantum-python
 Author: Microsoft

{azure-quantum-2.2.0.dev5 → azure-quantum-2.3.0}/azure/quantum/_client/_version.py

@@ -6,4 +6,4 @@
 # Changes may cause incorrect behavior and will be lost if the code is regenerated.
 # --------------------------------------------------------------------------
 
-VERSION = "2.2.0.dev5"
+VERSION = "2.3.0"

{azure-quantum-2.2.0.dev5 → azure-quantum-2.3.0}/azure/quantum/argument_types/__init__.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License.
 ##
 
-"""Defines argument types for Microsoft Estimator"""
+"""Defines argument types for QIR"""
 
 from .types import EmptyArray, Pauli, Range, Result
 

{azure-quantum-2.2.0.dev5 → azure-quantum-2.3.0}/azure/quantum/cirq/service.py

@@ -160,36 +160,6 @@ see https://aka.ms/AQ/Docs/AddProvider")
             name=name
         )
 
-    def estimate_cost(
-        self,
-        program: cirq.Circuit,
-        repetitions: int,
-        target: str = None,
-        param_resolver: cirq.ParamResolverOrSimilarType = cirq.ParamResolver({}),
-        **kwargs
-    ):
-        """
-        Estimate the cost for a given circuit.
-
-        :param program: Cirq program or circuit
-        :type program: cirq.Circuit
-        :param repetitions: Number of measurement repetitions
-        :type repetitions: int
-        :param target: Target name, defaults to default_target
-        :type target: str
-        :param param_resolver: Cirq parameters, defaults to `cirq.ParamResolver({})`
-        :type param_resolver: cirq.ParamResolverOrSimilarType
-        """
-        
-        # Resolve parameters
-        resolved_circuit = cirq.resolve_parameters(program, param_resolver)
-        target = self.get_target(name=target)
-        return target.estimate_cost(
-            program=resolved_circuit,
-            repetitions=repetitions,
-            **kwargs
-        )
-
     def run(
         self,
         program: cirq.Circuit,

{azure-quantum-2.2.0.dev5 → azure-quantum-2.3.0}/azure/quantum/cirq/targets/ionq.py

@@ -119,37 +119,6 @@ are not installed, throw error with installation instructions."""
         job_dict = self._client._create_job_dict(azure_job)
         return CirqIonqJob(client=self._client, job_dict=job_dict)
 
-    def estimate_cost(
-        self,
-        program: "cirq.Circuit",
-        repetitions: int,
-        price_1q: float = None,
-        price_2q: float = None,
-        min_price: float = None) -> float:
-        """Estimate cost for running this program
-
-        :param program: Cirq quantum program
-        :type program: cirq.Circuit
-        :param repetitions: Number of repetitions
-        :type repetitions: int
-        :param price_1q: The price of running a single-qubit gate.
-        :type price_1q: float, optional
-        :param price_2q: The price of running a double-qubit gate.
-        :type price_2q: float, optional
-        :param min_price: The minimum price for running a job.
-        :type min_price: float, optional
-        :return: Price estimate
-        :rtype: float
-        """
-        serialized_program = self._translate_cirq_circuit(program)
-        return super().estimate_cost(
-            serialized_program.body,
-            repetitions,
-            price_1q=price_1q,
-            price_2q=price_2q,
-            min_price=min_price
-        )
-
     def submit(
         self,
         program: "cirq.Circuit",

{azure-quantum-2.2.0.dev5 → azure-quantum-2.3.0}/azure/quantum/cirq/targets/quantinuum.py

@@ -74,26 +74,6 @@ class QuantinuumTarget(Quantinuum, CirqTarget):
             meas.gate.key: [q.x for q in meas.qubits] for meas in measurements
         }
 
-    def estimate_cost(
-        self,
-        program: str,
-        repetitions: int
-    ) -> float:
-        """Estimate cost for running this program
-
-        :param program: Cirq quantum program
-        :type program: str, optional
-        :param repetitions: Number of repetitions
-        :type repetitions: int, optional
-        :return: Price estimate in HQC
-        :rtype: float
-        """
-        serialized_program = self._translate_circuit(program)
-        return super().estimate_cost(
-            circuit=serialized_program,
-            shots=repetitions
-        )
-
     def submit(
         self,
         program: "cirq.Circuit",

{azure-quantum-2.2.0.dev5 → azure-quantum-2.3.0}/azure/quantum/qiskit/backends/__init__.py

@@ -37,11 +37,6 @@ from azure.quantum.qiskit.backends.qci import (
     QCIQPUBackend,
 )
 
-from azure.quantum.qiskit.backends.microsoft import (
-    MicrosoftBackend,
-    MicrosoftResourceEstimationBackend,
-)
-
 from .backend import AzureBackendBase
 
 __all__ = [

{azure-quantum-2.2.0.dev5 → azure-quantum-2.3.0}/azure/quantum/qiskit/backends/backend.py

@@ -440,6 +440,8 @@ class AzureQirBackend(AzureBackendBase):
         for circuit in circuits:
             qir_str = backend.qir(circuit)
             module = pyqir.Module.from_ir(context, qir_str)
+            entry_point = next(filter(pyqir.is_entry_point, module.functions))
+            entry_point.name = circuit.name
             llvm_module.link(module)
         err = llvm_module.verify()
         if err is not None:
@@ -498,25 +500,6 @@ class AzureQirBackend(AzureBackendBase):
 
         return str(module).encode("utf-8")
 
-    def _estimate_cost_qir(
-        self, circuits: Union[QuantumCircuit, List[QuantumCircuit]], shots, options={}
-    ):
-        """Estimate the cost for the given circuit."""
-        input_params = self._get_input_params(options, shots=shots)
-
-        if not (isinstance(circuits, list)):
-            circuits = [circuits]
-
-        skip_transpilation = input_params.pop("skipTranspile", False)
-        target_profile = self._get_target_profile(input_params)
-        module = self._generate_qir(
-            circuits, target_profile, skip_transpilation=skip_transpilation
-        )
-
-        workspace = self.provider().get_workspace()
-        target = workspace.get_targets(self.name())
-        return target.estimate_cost(module, shots=shots)
-
     def _get_target_profile(self, input_params) -> TargetProfile:
         # Default to Adaptive_RI if not specified on the backend
         # this is really just a safeguard in case the backend doesn't have a default

{azure-quantum-2.2.0.dev5 → azure-quantum-2.3.0}/azure/quantum/qiskit/backends/ionq.py

@@ -77,10 +77,6 @@ class IonQQirBackendBase(AzureQirBackend):
         )
         return config
 
-    def estimate_cost(self, circuits, shots, options={}):
-        """Estimate the cost for the given circuit."""
-        return self._estimate_cost_qir(circuits, shots, options)
-    
     def run(
         self, 
         run_input: Union[QuantumCircuit, List[QuantumCircuit]] = [],
@@ -265,17 +261,6 @@ class IonQBackend(AzureBackend):
     def gateset(self):
         return self.configuration().gateset
 
-    def estimate_cost(self, circuit, shots):
-        """Estimate the cost for the given circuit."""
-        ionq_circ, _, _ = qiskit_circ_to_ionq_circ(circuit, gateset=self.gateset())
-        input_data = {
-            "qubits": circuit.num_qubits,
-            "circuit": ionq_circ,
-        }
-        workspace = self.provider().get_workspace()
-        target = workspace.get_targets(self.name())
-        return target.estimate_cost(input_data, shots=shots)
-
 
 class IonQSimulatorBackend(IonQBackend):
     backend_names = ("ionq.simulator",)

{azure-quantum-2.2.0.dev5 → azure-quantum-2.3.0}/azure/quantum/qiskit/backends/quantinuum.py

@@ -60,7 +60,7 @@ def _get_n_qubits(name):
     if ".h1-" in name or "hqs-lt" in name:
         return 20
     if ".h2-" in name:
-        return 32
+        return 56
     warnings.warn(
         UserWarning(f"Number of qubits not known for target {name}. Defaulting to 20."))
     return 20
@@ -99,10 +99,6 @@ class QuantinuumQirBackendBase(AzureQirBackend):
     def _get_n_qubits(self, name):
         return _get_n_qubits(name)
     
-    def estimate_cost(self, circuits, shots, options={}):
-        """Estimate the cost for the given circuit."""
-        return self._estimate_cost_qir(circuits, shots, options)
-
 
 class QuantinuumSyntaxCheckerQirBackend(QuantinuumQirBackendBase):
     backend_names = (
@@ -248,33 +244,6 @@ class QuantinuumBackend(AzureBackend):
         """Translates the input values to the format expected by the AzureBackend."""
         return dumps(circuit)
 
-    def estimate_cost(
-        self, circuit: QuantumCircuit, shots: int = None, count: int = None
-    ):
-        """Estimate cost for running this circuit
-
-        :param circuit: Qiskit quantum circuit
-        :type circuit: QuantumCircuit
-        :param shots: Shot count
-        :type shots: int
-        :param count: Shot count (alternative to 'shots')
-        :type count: int
-        """
-        if count is not None:
-            warnings.warn(
-                "The 'count' parameter will be deprecated. Please, use 'shots' parameter instead.",
-                category=DeprecationWarning,
-            )
-            shots = count
-
-        if shots is None:
-            raise ValueError("Missing input argument 'shots'.")
-
-        input_data = dumps(circuit)
-        workspace = self.provider().get_workspace()
-        target = workspace.get_targets(self.name())
-        return target.estimate_cost(input_data, shots=shots)
-
     def _get_n_qubits(self, name):
         return _get_n_qubits(name)
 

{azure-quantum-2.2.0.dev5 → azure-quantum-2.3.0}/azure/quantum/qiskit/job.py

@@ -19,7 +19,6 @@ import ast
 import json
 import re
 from azure.quantum import Job
-from azure.quantum.qiskit.results.resource_estimator import make_estimator_result
 
 import logging
 logger = logging.getLogger(__name__)
@@ -38,7 +37,6 @@ MICROSOFT_OUTPUT_DATA_FORMAT = "microsoft.quantum-results.v1"
 MICROSOFT_OUTPUT_DATA_FORMAT_V2 = "microsoft.quantum-results.v2"
 IONQ_OUTPUT_DATA_FORMAT = "ionq.quantum-results.v1"
 QUANTINUUM_OUTPUT_DATA_FORMAT = "honeywell.quantum-results.v1"
-RESOURCE_ESTIMATOR_OUTPUT_DATA_FORMAT = "microsoft.resource-estimates.v1"
 
 class AzureQuantumJob(JobV1):
     def __init__(
@@ -96,10 +94,7 @@ class AzureQuantumJob(JobV1):
             "error_data" : None if self._azure_job.details.error_data is None else self._azure_job.details.error_data.as_dict()
         }
 
-        if self._azure_job.details.output_data_format == RESOURCE_ESTIMATOR_OUTPUT_DATA_FORMAT:
-            return make_estimator_result(result_dict)
-        else:
-            return Result.from_dict(result_dict)
+        return Result.from_dict(result_dict)
 
     def cancel(self):
         """Attempt to cancel the job."""
@@ -218,8 +213,7 @@ class AzureQuantumJob(JobV1):
 
         if isinstance(obj, tuple):
             # the outermost implied container is a tuple, and each item is
-            # associated with a classical register. Azure and Qiskit order the
-            # registers in opposite directions, so reverse here to match.
+            # associated with a classical register.
             return " ".join(
                 [
                     AzureQuantumJob._qir_to_qiskit_bitstring(term)

azure-quantum-2.3.0/azure/quantum/target/ionq.py

@@ -0,0 +1,128 @@
+##
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+##
+from typing import Any, Dict, List
+from warnings import warn
+
+from azure.quantum.target.target import (
+    Target,
+    _determine_shots_or_deprecated_num_shots,
+)
+from azure.quantum.job.job import Job
+from azure.quantum.workspace import Workspace
+from azure.quantum._client.models import CostEstimate, UsageEvent
+from typing import Union
+
+COST_1QUBIT_GATE_MAP = {
+    "ionq.simulator" : 0.0,
+    "ionq.qpu.aria-1" : 0.0002205,
+    "ionq.qpu.aria-2" : 0.0002205,
+    "ionq.qpu.forte-1" : 0.0002205
+}
+
+COST_2QUBIT_GATE_MAP = {
+    "ionq.simulator" : 0.0,
+    "ionq.qpu.aria-1" : 0.00098,
+    "ionq.qpu.aria-2" : 0.00098,
+    "ionq.qpu.forte-1" : 0.00098
+}
+
+MIN_PRICE_MAP = {
+    "ionq.simulator" : 0.0,
+    "ionq.qpu.aria-1" : 97.5,
+    "ionq.qpu.aria-2" : 97.5,
+    "ionq.qpu.forte-1" : 97.5
+}
+
+def int_to_bitstring(k: int, num_qubits: int, measured_qubit_ids: List[int]):
+    # flip bitstring to convert to little Endian
+    bitstring = format(int(k), f"0{num_qubits}b")[::-1]
+    # flip bitstring to convert back to big Endian
+    return "".join([bitstring[n] for n in measured_qubit_ids])[::-1]
+
+
+class IonQ(Target):
+    """IonQ target."""
+    target_names = (
+        "ionq.simulator",
+        "ionq.qpu.aria-1",
+        "ionq.qpu.aria-2",
+        "ionq.qpu.forte-1"
+    )
+
+    _SHOTS_PARAM_NAME = "shots"
+
+    def __init__(
+        self,
+        workspace: Workspace,
+        name: str = "ionq.simulator",
+        input_data_format: str = "ionq.circuit.v1",
+        output_data_format: str = "ionq.quantum-results.v1",
+        capability: str = "",
+        provider_id: str = "IonQ",
+        content_type: str = "application/json",
+        encoding: str = "",
+        target_profile: Union[str, "TargetProfile"] = "Base",
+        **kwargs,
+    ):
+        if capability:
+            msg = "The 'capability' parameter is not used for the Quantinuum target."
+            warn(msg, DeprecationWarning)
+        super().__init__(
+            workspace=workspace,
+            name=name,
+            input_data_format=input_data_format,
+            output_data_format=output_data_format,
+            capability=capability,
+            provider_id=provider_id,
+            content_type=content_type,
+            encoding=encoding,
+            target_profile=target_profile,
+            **kwargs,
+        )
+
+    def submit(
+        self,
+        circuit: Dict[str, Any] = None,
+        name: str = "ionq-job",
+        shots: int = None,
+        input_params: Dict[str, Any] = None,
+        **kwargs
+    ) -> Job:
+        """Submit an IonQ circuit (JSON format)
+
+        :param circuit: Quantum circuit in IonQ JSON format (for examples,
+            see: https://docs.ionq.com/#section/Sample-JSON-Circuits)
+        :type circuit: Dict[str, Any]
+        :param name: Job name
+        :type name: str
+        :param shots: Number of shots, defaults to None
+        :type shots: int
+        :param input_params: Optional input params dict
+        :type input_params: Dict[str, Any]
+        :return: Azure Quantum job
+        :rtype: Job
+        """
+        input_data = kwargs.pop("input_data", circuit)
+        if input_data is None:
+            raise ValueError(
+                "Either the `circuit` parameter or the `input_data` parameter must have a value."
+            )
+        if input_params is None:
+            input_params = {}
+
+        num_shots = kwargs.pop("num_shots", None)
+
+        shots = _determine_shots_or_deprecated_num_shots(
+            shots=shots,
+            num_shots=num_shots,
+        )
+        
+        return super().submit(
+            input_data=input_data,
+            name=name,
+            shots=shots,
+            input_params=input_params,
+            **kwargs
+        )

azure-quantum-2.3.0/azure/quantum/target/microsoft/elements/dft/job.py

@@ -0,0 +1,171 @@
+import collections.abc
+import logging
+from typing import Any, Dict, Union, Optional
+from azure.quantum.job import JobFailedWithResultsError
+from azure.quantum.job.base_job import BaseJob, ContentType
+from azure.quantum.job.job import Job, DEFAULT_TIMEOUT
+from azure.quantum._client.models import JobDetails
+from azure.quantum.workspace import Workspace
+
+logger = logging.getLogger(__name__)
+
+class MicrosoftElementsDftJob(Job):
+    """
+    A dedicated job class for jobs from the microsoft.dft target.
+    """
+
+    def __init__(self, workspace, job_details: JobDetails, **kwargs):
+        """Azure Quantum Job that is submitted to a given Workspace.
+
+        :param workspace: Workspace instance to submit job to
+        :type workspace: Workspace
+        :param job_details: Job details model,
+                contains Job ID, name and other details
+        :type job_details: JobDetails
+        """
+        super().__init__(workspace, job_details, **kwargs)
+
+
+    def get_results(self, timeout_secs: float = DEFAULT_TIMEOUT) -> Dict[str, Any]:
+        """Get job results by downloading the results blob from the
+        storage container linked via the workspace.
+
+        :param timeout_secs: Timeout in seconds, defaults to 300
+        :type timeout_secs: float
+        :raises: :class:`RuntimeError` if job execution failed.
+        :raises: :class:`azure.quantum.job.JobFailedWithResultsError` if job execution failed,
+                but failure results could still be retrieved.
+        :return: Results dictionary.
+        """
+
+        try:
+            job_results = super().get_results(timeout_secs)
+            return job_results
+        except JobFailedWithResultsError as e:
+                failure_results = e.get_failure_results()
+                if MicrosoftElementsDftJob._is_dft_failure_results(failure_results):
+                    error = failure_results["results"][0]["error"]
+                    message = f'{e.get_message()} Error type: {error["error_type"]}. Message: {error["error_message"]}'
+                    raise JobFailedWithResultsError(message, failure_results) from None
+
+
+    @classmethod
+    def _allow_failure_results(cls) -> bool: 
+        """
+        Allow to download job results even if the Job status is "Failed".
+        """
+        return True
+
+
+    @staticmethod
+    def _is_dft_failure_results(failure_results: Union[Dict[str, Any], str]) -> bool:
+         return isinstance(failure_results, dict) \
+                    and "results" in failure_results \
+                    and isinstance(failure_results["results"], collections.abc.Sequence) \
+                    and len(failure_results["results"]) > 0 \
+                    and isinstance(failure_results["results"][0], dict) \
+                    and "error" in failure_results["results"][0] \
+                    and isinstance(failure_results["results"][0]["error"], dict) \
+                    and "error_type" in failure_results["results"][0]["error"] \
+                    and "error_message" in failure_results["results"][0]["error"]
+
+    @classmethod
+    def from_input_data_container(
+        cls,
+        workspace: "Workspace",
+        name: str,
+        target: str,
+        input_data: bytes,
+        batch_input_blobs: Dict[str, bytes],
+        content_type: ContentType = ContentType.json,
+        blob_name: str = "inputData",
+        encoding: str = "",
+        job_id: str = None,
+        container_name: str = None,
+        provider_id: str = None,
+        input_data_format: str = None,
+        output_data_format: str = None,
+        input_params: Dict[str, Any] = None,
+        session_id: Optional[str] = None,
+        **kwargs
+    ) -> "BaseJob":
+        """Create a new Azure Quantum job based on a list of input_data.
+
+        :param workspace: Azure Quantum workspace to submit the input_data to
+        :type workspace: Workspace
+        :param name: Name of the job
+        :type name: str
+        :param target: Azure Quantum target
+        :type target: str
+        :param input_data: Raw input data to submit
+        :type input_data: Dict
+        :param blob_name: Dict of Input data json to gives a table of contents
+        :type batch_input_blobs: Dict
+        :param blob_name: Dict of QcSchema Data where the key is the blob name to store it in the container
+        :type blob_name: str
+        :param content_type: Content type, e.g. "application/json"
+        :type content_type: ContentType
+        :param encoding: input_data encoding, e.g. "gzip", defaults to empty string
+        :type encoding: str
+        :param job_id: Job ID, defaults to None
+        :type job_id: str
+        :param container_name: Container name, defaults to None
+        :type container_name: str
+        :param provider_id: Provider ID, defaults to None
+        :type provider_id: str
+        :param input_data_format: Input data format, defaults to None
+        :type input_data_format: str
+        :param output_data_format: Output data format, defaults to None
+        :type output_data_format: str
+        :param input_params: Input parameters, defaults to None
+        :type input_params: Dict[str, Any]
+        :param input_params: Input params for job
+        :type input_params: Dict[str, Any]
+        :return: Azure Quantum Job
+        :rtype: Job
+        """
+        # Generate job ID if not specified
+        if job_id is None:
+            job_id = cls.create_job_id()
+
+        # Create container if it does not yet exist
+        container_uri = workspace.get_container_uri(
+            job_id=job_id,
+            container_name=container_name
+        )
+        logger.debug(f"Container URI: {container_uri}")
+
+        # Upload Input Data
+        input_data_uri = cls.upload_input_data(
+            container_uri=container_uri,
+            input_data=input_data,
+            content_type=content_type,
+            blob_name=blob_name,
+            encoding=encoding,
+        )
+
+        # Upload data to container
+        for blob_name, input_data_item in batch_input_blobs.items():
+            cls.upload_input_data(
+                container_uri=container_uri,
+                input_data=input_data_item,
+                content_type=content_type,
+                blob_name=blob_name,
+                encoding=encoding,
+            )
+
+        # Create and submit job
+        return cls.from_storage_uri(
+            workspace=workspace,
+            job_id=job_id,
+            target=target,
+            input_data_uri=input_data_uri,
+            container_uri=container_uri,
+            name=name,
+            input_data_format=input_data_format,
+            output_data_format=output_data_format,
+            provider_id=provider_id,
+            input_params=input_params,
+            session_id=session_id,
+            **kwargs
+        )