azure-quantum 0.29.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

azure/quantum/qiskit/backends/quantinuum.py

@@ -3,7 +3,8 @@
 # Licensed under the MIT License.
 ##
 
-from typing import Dict
+from typing import Dict, List, Union
+from azure.quantum.qiskit.job import AzureQuantumJob
 from azure.quantum.version import __version__
 import warnings
 
@@ -62,8 +63,13 @@ def _get_n_qubits(name):
         UserWarning(f"Number of qubits not known for target {name}. Defaulting to 20."))
     return 20
 
+_QUANTINUUM_COUNT_INPUT_PARAM_NAME = "count"
+_DEFAULT_SHOTS_COUNT = 500
 
 class QuantinuumQirBackendBase(AzureQirBackend):
+
+    _SHOTS_PARAM_NAME = _QUANTINUUM_COUNT_INPUT_PARAM_NAME
+
     @abstractmethod
     def __init__(
         self, configuration: BackendConfiguration, provider: Provider = None, **fields
@@ -72,7 +78,12 @@ class QuantinuumQirBackendBase(AzureQirBackend):
 
     @classmethod
     def _default_options(cls) -> Options:
-        return Options(shots=500, targetCapability="BasicExecution")
+        return Options(
+            **{
+                cls._SHOTS_PARAM_NAME: _DEFAULT_SHOTS_COUNT
+            },
+            targetCapability="BasicExecution",
+        )
 
     def _azure_config(self) -> Dict[str, str]:
         config = super()._azure_config()
@@ -204,6 +215,8 @@ class QuantinuumQPUQirBackend(QuantinuumQirBackendBase):
 class QuantinuumBackend(AzureBackend):
     """Base class for interfacing with a Quantinuum (formerly Honeywell) backend in Azure Quantum"""
 
+    _SHOTS_PARAM_NAME = _QUANTINUUM_COUNT_INPUT_PARAM_NAME
+
     @abstractmethod
     def __init__(
         self, configuration: BackendConfiguration, provider: Provider = None, **fields
@@ -212,7 +225,11 @@ class QuantinuumBackend(AzureBackend):
 
     @classmethod
     def _default_options(cls):
-        return Options(count=500)
+        return Options(
+            **{
+                cls._SHOTS_PARAM_NAME: _DEFAULT_SHOTS_COUNT,
+            },
+        )
 
     def _azure_config(self) -> Dict[str, str]:
         return {
@@ -241,6 +258,10 @@ class QuantinuumBackend(AzureBackend):
         :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:
@@ -249,7 +270,7 @@ class QuantinuumBackend(AzureBackend):
         input_data = circuit.qasm()
         workspace = self.provider().get_workspace()
         target = workspace.get_targets(self.name())
-        return target.estimate_cost(input_data, num_shots=shots)
+        return target.estimate_cost(input_data, shots=shots)
 
     def _get_n_qubits(self, name):
         return _get_n_qubits(name)

azure/quantum/qiskit/backends/rigetti.py

@@ -42,9 +42,13 @@ logger = logging.getLogger(__name__)
 __all__ = ["RigettiSimulatorBackend" "RigettiQPUBackend"]
 
 
+_DEFAULT_SHOTS_COUNT = 500
+
 class RigettiBackend(AzureQirBackend):
     """Base class for interfacing with a Rigetti backend in Azure Quantum"""
 
+    _SHOTS_PARAM_NAME = "count"
+
     @abstractmethod
     def __init__(
         self, configuration: BackendConfiguration, provider: Provider = None, **fields
@@ -53,7 +57,10 @@ class RigettiBackend(AzureQirBackend):
 
     @classmethod
     def _default_options(cls):
-        return Options(count=500, targetCapability="BasicExecution")
+        other_options = {
+            cls._SHOTS_PARAM_NAME: _DEFAULT_SHOTS_COUNT,
+        }
+        return Options(targetCapability="BasicExecution", **other_options)
 
     def _azure_config(self) -> Dict[str, str]:
         config = super()._azure_config()

azure/quantum/qiskit/job.py

@@ -229,26 +229,17 @@ class AzureQuantumJob(JobV1):
 
     def _format_microsoft_results(self, sampler_seed=None):
         """ Translate Microsoft's job results histogram into a format that can be consumed by qiskit libraries. """
-        az_result = self._azure_job.get_results()
+        histogram = self._azure_job.get_results()
         shots = self._shots_count()
 
-        if not 'Histogram' in az_result:
-            raise "Histogram missing from Job results"
-
-        histogram = az_result['Histogram']
         counts = {}
         probabilities = {}
-        # The Histogram serialization is odd entries are key and even entries values
-        # Make sure we have even entries
-        if (len(histogram) % 2) == 0:
-            items = range(0, len(histogram), 2)
-            for i in items:
-                bitstring = AzureQuantumJob._qir_to_qiskit_bitstring(histogram[i])
-
-                value = histogram[i + 1]
-                probabilities[bitstring] = value
-        else:
-            raise "Invalid number of items in Job results' histogram."
+
+        for key in histogram.keys():
+            bitstring = AzureQuantumJob._qir_to_qiskit_bitstring(key)
+
+            value = histogram[key]
+            probabilities[bitstring] = value
 
         if self.backend().configuration().simulator:
             counts = self._draw_random_sample(sampler_seed, probabilities, shots)

azure/quantum/qiskit/provider.py

@@ -31,7 +31,23 @@ QISKIT_USER_AGENT = "azure-quantum-qiskit"
 
 
 class AzureQuantumProvider(Provider):
-    def __init__(self, workspace=None, **kwargs):
+    """
+    Class for interfacing with the Azure Quantum service
+    using Qiskit quantum circuits
+    """
+    def __init__(self, workspace: Workspace=None, **kwargs):
+        """AzureQuantumService class
+
+        :param workspace: Azure Quantum workspace. If missing it will create a new Workspace passing `kwargs` to the constructor. Defaults to None. 
+        :type workspace: Workspace, optional
+        """
+        if kwargs is not None and len(kwargs) > 0:
+            from warnings import warn
+            warn(f"""Consider passing \"workspace\" argument explicitly. 
+                 The ability to initialize AzureQuantumProvider with arguments {', '.join(f'"{argName}"' for argName in kwargs)} is going to be deprecated in future versions.""", 
+                 DeprecationWarning, 
+                 stacklevel=2)
+
         if workspace is None:
             workspace = Workspace(**kwargs)
 
@@ -43,7 +59,7 @@ class AzureQuantumProvider(Provider):
     def get_workspace(self) -> Workspace:
         return self._workspace
 
-    def get_backend(self, name=None, **kwargs):
+    def get_backend(self, name=None, **kwargs) -> AzureBackendBase:
         """Return a single backend matching the specified filtering.
         Args:
             name (str): name of the backend.

azure/quantum/storage.py

@@ -14,6 +14,7 @@ from azure.storage.blob import (
     generate_blob_sas,
     generate_container_sas,
     BlobType,
+    BlobProperties
 )
 from datetime import datetime, timedelta
 from enum import Enum
@@ -196,7 +197,7 @@ def download_blob(blob_url: str) -> Any:
     return response
 
 
-def download_blob_properties(blob_url: str) -> Dict[str, str]:
+def download_blob_properties(blob_url: str) -> BlobProperties:
     """Downloads the blob properties from Azure for the given blob URI"""
     blob_client = BlobClient.from_blob_url(blob_url)
     logger.info(

azure/quantum/target/__init__.py

@@ -11,6 +11,7 @@ from .ionq import IonQ
 from .quantinuum import Quantinuum
 from .rigetti import Rigetti
 from .pasqal import Pasqal
+from .microsoft.elements.dft import MicrosoftElementsDft, MicrosoftElementsDftJob
 
 # Default targets to use when there is no target class
 # associated with a given target ID

azure/quantum/target/ionq.py

@@ -3,8 +3,12 @@
 # Licensed under the MIT License.
 ##
 from typing import Any, Dict, List
+from warnings import warn
 
-from azure.quantum.target.target import Target
+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
@@ -50,6 +54,8 @@ class IonQ(Target):
         "ionq.qpu.forte-1"
     )
 
+    _SHOTS_PARAM_NAME = "shots"
+
     def __init__(
         self,
         workspace: Workspace,
@@ -78,7 +84,7 @@ class IonQ(Target):
         self,
         circuit: Dict[str, Any] = None,
         name: str = "ionq-job",
-        num_shots: int = None,
+        shots: int = None,
         input_params: Dict[str, Any] = None,
         **kwargs
     ) -> Job:
@@ -89,8 +95,8 @@ class IonQ(Target):
         :type circuit: Dict[str, Any]
         :param name: Job name
         :type name: str
-        :param num_shots: Number of shots, defaults to None
-        :type num_shots: int
+        :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
@@ -103,13 +109,18 @@ class IonQ(Target):
             )
         if input_params is None:
             input_params = {}
-        if num_shots is not None:
-            input_params = input_params.copy()
-            input_params["shots"] = num_shots
 
+        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
         )
@@ -117,10 +128,11 @@ class IonQ(Target):
     def estimate_cost(
         self,
         circuit: Dict[str, Any],
-        num_shots: int,
+        num_shots: int = None,
         price_1q: float = None,
         price_2q: float = None,
-        min_price: float = None
+        min_price: float = None,
+        shots: int = None
     ) -> CostEstimate:
         """Estimate the cost of submitting a circuit to IonQ targets.
         Optionally, you can provide the number of gate and measurement operations
@@ -156,7 +168,20 @@ class IonQ(Target):
         :type price_2q: float, optional
         :param min_price: The minimum price for running a job.
         :type min_price: float, optional
+        :param shots: Number of shots, defaults to None
+        :type shots: int
         """
+
+        if num_shots is None and shots is None:
+             raise ValueError("The 'shots' parameter has to be specified")
+
+        if num_shots is not None:
+            warn(
+                "The 'num_shots' parameter will be deprecated. Please, use 'shots' parameter instead.",
+                category=DeprecationWarning,
+            )
+            shots = num_shots
+
         def is_1q_gate(gate: Dict[str, Any]):
             return "controls" not in gate and "control" not in gate
 
@@ -185,7 +210,7 @@ class IonQ(Target):
         N_1q = sum(map(is_1q_gate, gates))
         N_2q = sum(map(num_2q_gates, filter(is_multi_q_gate, gates)))
 
-        price = (price_1q * N_1q + price_2q * N_2q) * num_shots
+        price = (price_1q * N_1q + price_2q * N_2q) * shots
         price = max(price, min_price)
 
         return CostEstimate(
@@ -195,7 +220,7 @@ class IonQ(Target):
                     dimension_name="1Q Gate Shot",
                     measure_unit="1q gate shot",
                     amount_billed=0.0,
-                    amount_consumed=N_1q * num_shots,
+                    amount_consumed=N_1q * shots,
                     unit_price=0.0
                 ),
                 UsageEvent(
@@ -203,7 +228,7 @@ class IonQ(Target):
                     dimension_name="2Q Gate Shot",
                     measure_unit="2q gate shot",
                     amount_billed=0.0,
-                    amount_consumed=N_2q * num_shots,
+                    amount_consumed=N_2q * shots,
                     unit_price=0.0
                 )
             ],

azure/quantum/target/microsoft/elements/dft/__init__.py

@@ -0,0 +1,4 @@
+from .target import MicrosoftElementsDft
+from .job import MicrosoftElementsDftJob
+
+__all__ = ["MicrosoftElementsDft", "MicrosoftElementsDftJob"]

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

@@ -0,0 +1,46 @@
+import collections.abc
+from typing import Any, Dict, Union
+from azure.quantum.job import JobFailedWithResultsError
+from azure.quantum.job.job import Job, DEFAULT_TIMEOUT
+from azure.quantum._client.models import JobDetails
+
+class MicrosoftElementsDftJob(Job):
+    """
+    A dedicated job class for jobs from the microsoft.dft target.
+    """
+
+    def __init__(self, workspace, job_details: JobDetails, **kwargs):
+        super().__init__(workspace, job_details, **kwargs)
+
+
+    def get_results(self, timeout_secs: float = DEFAULT_TIMEOUT) -> Dict[str, Any]:
+        try:
+            job_results = super().get_results(timeout_secs)
+            return job_results["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"]

azure/quantum/target/microsoft/elements/dft/target.py

@@ -0,0 +1,66 @@
+import warnings
+
+from azure.quantum.job.base_job import ContentType
+from azure.quantum.job.job import Job
+from azure.quantum.target.target import Target
+from azure.quantum.workspace import Workspace
+from azure.quantum.target.params import InputParams
+from typing import Any, Dict, Type, Union
+from .job import MicrosoftElementsDftJob
+
+
+class MicrosoftElementsDft(Target):
+    """
+    Microsoft Elements Dft target from the microsoft-elements provider.
+    """
+
+    target_names = [
+        "microsoft.dft"
+    ]
+
+
+    def __init__(
+        self,
+        workspace: "Workspace",
+        name: str = "microsoft.dft",
+        **kwargs
+    ):
+        # There is only a single target name for this target
+        assert name == self.target_names[0]
+
+        # make sure to not pass argument twice
+        kwargs.pop("provider_id", None)
+
+        super().__init__(
+            workspace=workspace,
+            name=name,
+            input_data_format="microsoft.xyz.v1",
+            output_data_format="microsoft.dft-results.v1",
+            provider_id="microsoft-elements",
+            content_type=ContentType.text_plain,
+            **kwargs
+        )
+
+
+    def submit(self,
+               input_data: Any,
+               name: str = "azure-quantum-dft-job",
+               shots: int = None,
+               input_params: Union[Dict[str, Any], InputParams, None] = None,
+               **kwargs) -> MicrosoftElementsDftJob:
+
+        if shots is not None:
+            warnings.warn("The 'shots' parameter is ignored in Microsoft Elements Dft job.")
+        
+        return super().submit(
+            input_data=input_data,
+            name=name, 
+            shots=shots, 
+            input_params=input_params,
+            **kwargs
+        )
+
+
+    @classmethod
+    def _get_job_class(cls) -> Type[Job]:
+        return MicrosoftElementsDftJob

azure/quantum/target/microsoft/target.py

@@ -3,8 +3,10 @@
 # Licensed under the MIT License.
 ##
 import re
+import warnings
 from dataclasses import dataclass, field
-from typing import Any, Dict, Optional, Type, Union
+from typing import Any, Dict, Optional, Type, Union, List
+
 from ...job import Job
 from ...job.base_job import ContentType
 from ...workspace import Workspace
@@ -12,8 +14,6 @@ from ..params import InputParams, InputParamsItem, AutoValidatingParams, \
     validating_field
 from ..target import Target
 from . import MicrosoftEstimatorJob
-from typing import List
-
 
 class QubitParams:
     GATE_US_E3 = "qubit_gate_us_e3"
@@ -377,11 +377,32 @@ class MicrosoftEstimator(Target):
             **kwargs
         )
 
-    def submit(self,
-               input_data: Any,
-               name: str = "azure-quantum-job",
-               input_params: Union[Dict[str, Any], InputParams, None] = None,
-               **kwargs) -> Job:
+    def submit(
+        self,
+        input_data: Any,
+        name: str = "azure-quantum-job",
+        shots: int = None,
+        input_params: Union[Dict[str, Any], InputParams, None] = None,
+        **kwargs,
+    ) -> Job:
+        """
+        Submit an estimation job
+
+        :param input_data: Input data
+        :type input_data: Any
+        :param name: Job name
+        :type name: str
+        :param shots: Number of shots. Ignored in estimation. Defaults to None
+        :type shots: int
+        :param input_params: Input parameters
+        :type input_params: Dict[str, Any]
+        :return: Azure Quantum job
+        :rtype: Job
+        """
+
+        if shots is not None:
+            warnings.warn("The 'shots' parameter is ignored in resource estimation job.")
+
         try:
             from qiskit import QuantumCircuit, transpile
             from qiskit_qir import to_qir_module
@@ -393,7 +414,13 @@ class MicrosoftEstimator(Target):
                 (module, _) = to_qir_module(input_data, record_output=False)
                 input_data = module.bitcode
         finally:
-            return super().submit(input_data, name, input_params, **kwargs)
+            return super().submit(
+                input_data=input_data, 
+                name=name, 
+                shots=shots,
+                input_params=input_params, 
+                **kwargs
+            )
 
     @classmethod
     def _get_job_class(cls) -> Type[Job]:

azure/quantum/target/params.py

@@ -180,7 +180,7 @@ class InputParams(InputParamsItem):
     """
     Class to define input parameters.
 
-    This class allows to define inout parameters for non-batching and batching
+    This class allows to define input parameters for non-batching and batching
     jobs.  The instance represents a batching job, if and only if num_items is
     set to some positive number less or equal to MAX_NUM_ITEMS.
 

azure/quantum/target/pasqal/target.py

@@ -64,6 +64,8 @@ class Pasqal(Target):
 
     target_names = tuple(target.value for target in PasqalTarget)
 
+    _SHOTS_PARAM_NAME = "count"
+
     def __init__(
         self,
         workspace: Workspace,
@@ -91,6 +93,7 @@ class Pasqal(Target):
         self,
         input_data: Any,
         name: str = "azure-quantum-job",
+        shots: int = None,
         input_params: Union[InputParams, None, Dict[str, Any]] = None,
         **kwargs,
     ) -> Job:
@@ -103,15 +106,26 @@ class Pasqal(Target):
         :type input_data: Any
         :param name: Job name
         :type name: str
+        :param shots: Number of shots, defaults to None
+        :type shots: int
         :param input_params: Input parameters, see :class:`azure.quantum.target.pasqal.InputParams` for details.
         :type input_params: Union[InputParams, None, Dict[str, Any]]
         :return: Azure Quantum job
         :rtype: Job
         """
+
         if isinstance(input_params, InputParams):
             typed_input_params = input_params
             input_params = {
-                "runs": typed_input_params.runs,
+                self.__class__._SHOTS_PARAM_NAME: typed_input_params.runs,
             }
+        
+        input_params = input_params or {}
 
-        return super().submit(input_data, name, input_params, **kwargs)
+        return super().submit(
+            input_data=input_data, 
+            name=name,
+            shots=shots, 
+            input_params=input_params, 
+            **kwargs
+        )

azure/quantum/target/quantinuum.py

@@ -3,8 +3,12 @@
 # Licensed under the MIT License.
 ##
 from typing import Any, Dict
+from warnings import warn
 
-from azure.quantum.target.target import Target
+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
@@ -25,6 +29,8 @@ class Quantinuum(Target):
         "quantinuum.sim.h2-1e",
     )
 
+    _SHOTS_PARAM_NAME = "count"
+
     def __init__(
         self,
         workspace: Workspace,
@@ -53,7 +59,7 @@ class Quantinuum(Target):
         self,
         circuit: str = None,
         name: str = "quantinuum-job",
-        num_shots: int = None,
+        shots: int = None,
         input_params: Dict[str, Any] = None,
         **kwargs
     ) -> Job:
@@ -63,8 +69,8 @@ class Quantinuum(Target):
         :type circuit: str
         :param name: Job name
         :type name: str
-        :param num_shots: Number of shots, defaults to None
-        :type num_shots: int
+        :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
@@ -77,13 +83,18 @@ class Quantinuum(Target):
             )
         if input_params is None:
             input_params = {}
-        if num_shots is not None:
-            input_params = input_params.copy()
-            input_params["count"] = num_shots
+
+        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
         )
@@ -94,7 +105,8 @@ class Quantinuum(Target):
         num_shots: int = None,
         N_1q: int = None,
         N_2q: int = None,
-        N_m: int = None
+        N_m: int = None,
+        shots: int = None,
     ) -> CostEstimate:
         """Estimate the cost in HQC for a given circuit.
         Optionally, you can provide the number of gate and measurement operations
@@ -119,9 +131,22 @@ class Quantinuum(Target):
         :param N_m: Number of measurement operations, if not specified,
             this is estimated from the circuit
         :type N_m: int, optional
+        :param shots: Number of shots for which to estimate costs
+        :type shots: int, optional
         :raises ImportError: If N_1q, N_2q and N_m are not specified,
             this will require a qiskit installation.
         """
+
+        if num_shots is None and shots is None:
+             raise ValueError("The 'shots' parameter has to be specified")
+
+        if num_shots is not None:
+            warn(
+                "The 'num_shots' parameter will be deprecated. Please, use 'shots' parameter instead.",
+                category=DeprecationWarning,
+            )
+            shots = num_shots
+
         if circuit is not None and (N_1q is None or N_2q is None or N_m is None):
             try:
                 from qiskit.circuit.quantumcircuit import Qasm
@@ -160,7 +185,7 @@ class Quantinuum(Target):
         if is_syntax_checker_regex.match(self.name):
             HQC = 0.0
         else:
-            HQC = 5 + num_shots * (N_1q + 10 * N_2q + 5 * N_m) / 5000
+            HQC = 5 + shots * (N_1q + 10 * N_2q + 5 * N_m) / 5000
 
         return CostEstimate(
             events=[