azure-quantum 2.1.2__py3-none-any.whl → 2.2.0__py3-none-any.whl

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.1.2"
+VERSION = "2.2.0"

azure/quantum/qiskit/backends/backend.py

@@ -21,14 +21,15 @@ from abc import abstractmethod
 from azure.quantum.job.session import SessionHost
 
 try:
-    from qiskit import QuantumCircuit, transpile
+    from qiskit import QuantumCircuit
     from qiskit.providers import BackendV1 as Backend
     from qiskit.providers import Options
     from qiskit.providers import Provider
     from qiskit.providers.models import BackendConfiguration
     from qiskit.qobj import QasmQobj, PulseQobj
-    from pyqir import Module
-    from qiskit_qir import to_qir_module
+    import pyqir as pyqir
+    from qsharp.interop.qiskit import QSharpBackend
+    from qsharp import TargetProfile
 
 except ImportError:
     raise ImportError(
@@ -36,23 +37,37 @@ except ImportError:
 To install run: pip install azure-quantum[qiskit]"
     )
 
+# barrier is handled by an extra flag which will transpile
+# them away if the backend doesn't support them. This has
+# to be done as a special pass as the transpiler will not
+# remove barriers by default.
 QIR_BASIS_GATES = [
-    "x",
-    "y",
-    "z",
+    "measure",
+    "reset",
+    "ccx",
+    "cx",
+    "cy",
+    "cz",
     "rx",
+    "rxx",
+    "crx",
     "ry",
+    "ryy",
+    "cry",
     "rz",
+    "rzz",
+    "crz",
     "h",
-    "swap",
-    "cx",
-    "cz",
-    "reset",
     "s",
     "sdg",
+    "swap",
     "t",
     "tdg",
-    "measure",
+    "x",
+    "y",
+    "z",
+    "id",
+    "ch",
 ]
 
 
@@ -391,98 +406,141 @@ class AzureQirBackend(AzureBackendBase):
         return {}
 
     def _generate_qir(
-        self, circuits, targetCapability, **to_qir_kwargs
-    ) -> Tuple[Module, List[str]]:
+        self, circuits: List[QuantumCircuit], target_profile: TargetProfile, **kwargs
+    ) -> pyqir.Module:
+
+        if len(circuits) == 0:
+            raise ValueError("No QuantumCircuits provided")
 
         config = self.configuration()
         # Barriers aren't removed by transpilation and must be explicitly removed in the Qiskit to QIR translation.
-        emit_barrier_calls = "barrier" in config.basis_gates
-        return to_qir_module(
-            circuits,
-            targetCapability,
-            emit_barrier_calls=emit_barrier_calls,
-            **to_qir_kwargs,
+        supports_barrier = "barrier" in config.basis_gates
+        skip_transpilation = kwargs.pop("skip_transpilation", False)
+
+        backend = QSharpBackend(
+            qiskit_pass_options={"supports_barrier": supports_barrier},
+            target_profile=target_profile,
+            skip_transpilation=skip_transpilation,
+            **kwargs,
         )
 
-    def _get_qir_str(self, circuits, targetCapability, **to_qir_kwargs) -> str:
-        module, _ = self._generate_qir(circuits, targetCapability, **to_qir_kwargs)
+        name = "batch"
+        if len(circuits) == 1:
+            name = circuits[0].name
+
+        if isinstance(circuits, list):
+            for value in circuits:
+                if not isinstance(value, QuantumCircuit):
+                    raise ValueError("Input must be List[QuantumCircuit]")
+        else:
+            raise ValueError("Input must be List[QuantumCircuit]")
+
+        context = pyqir.Context()
+        llvm_module = pyqir.qir_module(context, name)
+        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:
+            raise Exception(err)
+
+        return llvm_module
+
+    def _get_qir_str(
+        self,
+        circuits: List[QuantumCircuit],
+        target_profile: TargetProfile,
+        **to_qir_kwargs,
+    ) -> str:
+        module = self._generate_qir(circuits, target_profile, **to_qir_kwargs)
         return str(module)
 
     def _translate_input(
-        self, circuits: List[QuantumCircuit], input_params: Dict[str, Any]
+        self, circuits: Union[QuantumCircuit, List[QuantumCircuit]], input_params: Dict[str, Any]
     ) -> bytes:
         """Translates the input values to the QIR expected by the Backend."""
         logger.info(f"Using QIR as the job's payload format.")
-        config = self.configuration()
+        if not (isinstance(circuits, list)):
+            circuits = [circuits]
 
-        # Override QIR translation parameters
-        # We will record the output by default, but allow the backend to override this, and allow the user to override the backend.
-        to_qir_kwargs = input_params.pop(
-            "to_qir_kwargs", config.azure.get("to_qir_kwargs", {"record_output": True})
-        )
-        targetCapability = input_params.pop(
-            "targetCapability",
-            self.options.get("targetCapability", "AdaptiveExecution"),
-        )
+        target_profile = self._get_target_profile(input_params)
 
         if logger.isEnabledFor(logging.DEBUG):
-            qir = self._get_qir_str(circuits, targetCapability, **to_qir_kwargs)
+            qir = self._get_qir_str(circuits, target_profile, skip_transpilation=True)
             logger.debug(f"QIR:\n{qir}")
 
         # We'll transpile automatically to the supported gates in QIR unless explicitly skipped.
-        if not input_params.pop("skipTranspile", False):
-            # Set of gates supported by QIR targets.
-            circuits = transpile(
-                circuits, basis_gates=config.basis_gates, optimization_level=0
-            )
+        skip_transpilation = input_params.pop("skipTranspile", False)
+
+        module = self._generate_qir(
+            circuits, target_profile, skip_transpilation=skip_transpilation
+        )
+
+        def get_func_name(func: pyqir.Function) -> str:
+            return func.name
+
+        entry_points = list(
+            map(get_func_name, filter(pyqir.is_entry_point, module.functions))
+        )
+
+        if not skip_transpilation:
             # We'll only log the QIR again if we performed a transpilation.
             if logger.isEnabledFor(logging.DEBUG):
-                qir = self._get_qir_str(circuits, targetCapability, **to_qir_kwargs)
+                qir = str(module)
                 logger.debug(f"QIR (Post-transpilation):\n{qir}")
 
-        (module, entry_points) = self._generate_qir(
-            circuits, targetCapability, **to_qir_kwargs
-        )
-
-        if not "items" in input_params:
+        if "items" not in input_params:
             arguments = input_params.pop("arguments", [])
             input_params["items"] = [
                 {"entryPoint": name, "arguments": arguments} for name in entry_points
             ]
 
-        return module.bitcode
+        return str(module).encode("utf-8")
 
-    def _estimate_cost_qir(self, circuits, shots, options={}):
+    def _estimate_cost_qir(
+        self, circuits: Union[QuantumCircuit, List[QuantumCircuit]], shots, options={}
+    ):
         """Estimate the cost for the given circuit."""
-        config = self.configuration()
         input_params = self._get_input_params(options, shots=shots)
 
         if not (isinstance(circuits, list)):
             circuits = [circuits]
-        
-        to_qir_kwargs = input_params.pop(
-            "to_qir_kwargs", config.azure.get("to_qir_kwargs", {"record_output": True})
-        )
-        targetCapability = input_params.pop(
-            "targetCapability",
-            self.options.get("targetCapability", "AdaptiveExecution"),
-        )
-
-        if not input_params.pop("skipTranspile", False):
-            # Set of gates supported by QIR targets.
-            circuits = transpile(
-                circuits, basis_gates=config.basis_gates, optimization_level=0
-            )
-        
 
-        (module, _) = self._generate_qir(
-            circuits, targetCapability, **to_qir_kwargs
+        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
+        default_profile = self.options.get("target_profile", TargetProfile.Adaptive_RI)
+
+        # If the user is using the old targetCapability parameter, we'll warn them
+        # and use that value for now. This will be removed in the future.
+        if "targetCapability" in input_params:
+            warnings.warn(
+                "The 'targetCapability' parameter is deprecated and will be ignored in the future. "
+                "Please, use 'target_profile' parameter instead.",
+                category=DeprecationWarning,
+            )
+            cap = input_params.pop("targetCapability")
+            if cap == "AdaptiveExecution":
+                default_profile = TargetProfile.Adaptive_RI
+            else:
+                default_profile = TargetProfile.Base
+        # If the user specifies a target profile, use that.
+        # Otherwise, use the profile we got from the backend/targetCapability.
+        return input_params.pop("target_profile", default_profile)
+
 
 class AzureBackend(AzureBackendBase):
     """Base class for interfacing with a backend in Azure Quantum"""

azure/quantum/qiskit/backends/ionq.py

@@ -7,7 +7,7 @@ from azure.quantum import __version__
 from azure.quantum.qiskit.job import AzureQuantumJob
 from azure.quantum.target.ionq import IonQ
 from abc import abstractmethod
-
+from qsharp import TargetProfile
 from qiskit import QuantumCircuit
 
 from .backend import (
@@ -65,7 +65,7 @@ class IonQQirBackendBase(AzureQirBackend):
             **{
                 cls._SHOTS_PARAM_NAME: _DEFAULT_SHOTS_COUNT,
             },
-            targetCapability="BasicExecution",
+            target_profile=TargetProfile.Base,
             )
 
     def _azure_config(self) -> Dict[str, str]:

azure/quantum/qiskit/backends/microsoft.py

@@ -3,36 +3,17 @@
 # Licensed under the MIT License.
 ##
 
-from typing import TYPE_CHECKING, Any, Dict, List
+from typing import TYPE_CHECKING, Any, Dict, List, Union
 from azure.quantum.version import __version__
 from qiskit import QuantumCircuit
 from abc import abstractmethod
-from .backend import AzureQirBackend
+from .backend import AzureQirBackend, QIR_BASIS_GATES
 
 from qiskit.providers.models import BackendConfiguration
 from qiskit.providers import Options, Provider
-
-QIR_BASIS_GATES = [
-    "measure",
-    "m",
-    "ccx",
-    "cx",
-    "cz",
-    "h",
-    "reset",
-    "rx",
-    "ry",
-    "rz",
-    "s",
-    "sdg",
-    "swap",
-    "t",
-    "tdg",
-    "x",
-    "y",
-    "z",
-    "id",
-]
+from qsharp import TargetProfile
+from qsharp.interop.qiskit import ResourceEstimatorBackend
+import pyqir as pyqir
 
 if TYPE_CHECKING:
     from azure.quantum.qiskit import AzureQuantumProvider
@@ -55,7 +36,7 @@ class MicrosoftBackend(AzureQirBackend):
 
     @classmethod
     def _default_options(cls):
-        return Options(targetCapability="AdaptiveExecution")
+        return Options(target_profile=TargetProfile.Adaptive_RI)
 
     def _azure_config(self) -> Dict[str, str]:
         config = super()._azure_config()
@@ -63,11 +44,65 @@ class MicrosoftBackend(AzureQirBackend):
             {
                 "provider_id": "microsoft-qc",
                 "output_data_format": "microsoft.resource-estimates.v1",
-                "to_qir_kwargs": {"record_output": False},
             }
         )
         return config
 
+    def _translate_input(
+        self,
+        circuits: Union[QuantumCircuit, List[QuantumCircuit]],
+        input_params: Dict[str, Any],
+    ) -> bytes:
+        """Translates the input values to the QIR expected by the Backend."""
+        # All the logic is in the base class, but we need to override
+        # this method to ensure that the bitcode QIR format is used for RE.
+
+        # normal translation is to QIR text format in utf-8 encoded bytes
+        ir_byte_str = super()._translate_input(circuits, input_params)
+        # decode the utf-8 encoded bytes to a string
+        ir_str = ir_byte_str.decode('utf-8')
+        # convert the QIR text format to QIR bitcode format
+        module = pyqir.Module.from_ir(pyqir.Context(), ir_str)
+        return module.bitcode
+
+    def _generate_qir(
+        self, circuits: List[QuantumCircuit], target_profile: TargetProfile, **kwargs
+    ) -> pyqir.Module:
+        if len(circuits) == 0:
+            raise ValueError("No QuantumCircuits provided")
+
+        name = "circuits"
+        if isinstance(circuits, QuantumCircuit):
+            name = circuits.name
+            circuits = [circuits]
+        elif isinstance(circuits, list):
+            for value in circuits:
+                if not isinstance(value, QuantumCircuit):
+                    raise ValueError(
+                        "Input must be Union[QuantumCircuit, List[QuantumCircuit]]"
+                    )
+        else:
+            raise ValueError(
+                "Input must be Union[QuantumCircuit, List[QuantumCircuit]]"
+            )
+
+        skip_transpilation = kwargs.pop("skip_transpilation", False)
+        backend = ResourceEstimatorBackend(
+            skip_transpilation=skip_transpilation, **kwargs
+        )
+        context = pyqir.Context()
+        llvm_module = pyqir.qir_module(context, name)
+        for circuit in circuits:
+            qir_str = backend.qir(circuit, target_profile=target_profile)
+            module = pyqir.Module.from_ir(context, qir_str)
+            llvm_module.link(module)
+
+        err = llvm_module.verify()
+        if err is not None:
+            raise Exception(err)
+
+        return llvm_module
+
 
 class MicrosoftResourceEstimationBackend(MicrosoftBackend):
     """Backend class for interfacing with the resource estimator target"""
@@ -77,7 +112,7 @@ class MicrosoftResourceEstimationBackend(MicrosoftBackend):
     @classmethod
     def _default_options(cls):
         return Options(
-            targetCapability="AdaptiveExecution",
+            target_profile=TargetProfile.Adaptive_RI,
             errorBudget=1e-3,
             qubitParams={"name": "qubit_gate_ns_e3"},
             qecScheme={"name": "surface_code"}

azure/quantum/qiskit/backends/qci.py

@@ -3,7 +3,7 @@
 # Licensed under the MIT License.
 ##
 
-from typing import TYPE_CHECKING, Dict
+from typing import TYPE_CHECKING, Dict, List
 from azure.quantum.version import __version__
 from azure.quantum.qiskit.job import AzureQuantumJob
 from abc import abstractmethod
@@ -14,6 +14,8 @@ from .backend import (
 
 from qiskit.providers.models import BackendConfiguration
 from qiskit.providers import Options, Provider
+from qsharp import TargetProfile
+
 
 if TYPE_CHECKING:
     from azure.quantum.qiskit import AzureQuantumProvider
@@ -43,7 +45,7 @@ class QCIBackend(AzureQirBackend):
             **{
                 cls._SHOTS_PARAM_NAME: _DEFAULT_SHOTS_COUNT, 
             },
-            targetCapability="AdaptiveExecution",
+            target_profile=TargetProfile.Adaptive_RI,
         )
 
     def _azure_config(self) -> Dict[str, str]:
@@ -54,9 +56,12 @@ class QCIBackend(AzureQirBackend):
             }
         )
         return config
-    
+
+    def _basis_gates(self) -> List[str]:
+        return super()._basis_gates() + ["barrier"]
+
     def run(
-        self, 
+        self,
         run_input=None,
         shots: int = None,
         **options,

azure/quantum/qiskit/backends/quantinuum.py

@@ -15,7 +15,7 @@ from qiskit.providers.models import BackendConfiguration
 from qiskit.providers import Options
 from qiskit.providers import Provider
 from qiskit.qasm2 import dumps
-
+from qsharp import TargetProfile
 import logging
 
 logger = logging.getLogger(__name__)
@@ -50,23 +50,6 @@ QUANTINUUM_BASIS_GATES = [
     "reset",
 ]
 
-QUANTINUUM_QIR_BASIS_GATES = [
-    "x",
-    "y",
-    "z",
-    "rx",
-    "ry",
-    "rz",
-    "h",
-    "cx",
-    "cz",
-    "reset",
-    "s",
-    "sdg",
-    "t",
-    "tdg",
-    "measure",
-]
 
 QUANTINUUM_PROVIDER_ID = "quantinuum"
 QUANTINUUM_PROVIDER_NAME = "Quantinuum"
@@ -77,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
@@ -101,7 +84,7 @@ class QuantinuumQirBackendBase(AzureQirBackend):
             **{
                 cls._SHOTS_PARAM_NAME: _DEFAULT_SHOTS_COUNT
             },
-            targetCapability="BasicExecution",
+            target_profile=TargetProfile.Adaptive_RI,
         )
 
     def _azure_config(self) -> Dict[str, str]:
@@ -112,9 +95,6 @@ class QuantinuumQirBackendBase(AzureQirBackend):
             }
         )
         return config
-    
-    def _basis_gates(self) -> List[str]:
-        return QUANTINUUM_QIR_BASIS_GATES
 
     def _get_n_qubits(self, name):
         return _get_n_qubits(name)

azure/quantum/qiskit/backends/rigetti.py

@@ -11,6 +11,7 @@ from .backend import AzureQirBackend
 
 from qiskit.providers.models import BackendConfiguration
 from qiskit.providers import Options, Provider
+from qsharp import TargetProfile
 
 if TYPE_CHECKING:
     from azure.quantum.qiskit import AzureQuantumProvider
@@ -40,7 +41,7 @@ class RigettiBackend(AzureQirBackend):
         other_options = {
             cls._SHOTS_PARAM_NAME: _DEFAULT_SHOTS_COUNT,
         }
-        return Options(targetCapability="BasicExecution", **other_options)
+        return Options(target_profile=TargetProfile.Base, **other_options)
 
     def _azure_config(self) -> Dict[str, str]:
         config = super()._azure_config()

azure/quantum/qiskit/job.py

@@ -212,15 +212,19 @@ class AzureQuantumJob(JobV1):
 
     @staticmethod
     def _qir_to_qiskit_bitstring(obj):
-        """Convert the data structure from Azure into the "schema" used by Qiskit """
+        """Convert the data structure from Azure into the "schema" used by Qiskit"""
         if isinstance(obj, str) and not re.match(r"[\d\s]+$", obj):
             obj = ast.literal_eval(obj)
 
         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.
-            return " ".join([AzureQuantumJob._qir_to_qiskit_bitstring(term) for term in reversed(obj)])
+            # associated with a classical register.
+            return " ".join(
+                [
+                    AzureQuantumJob._qir_to_qiskit_bitstring(term)
+                    for term in obj
+                ]
+            )
         elif isinstance(obj, list):
             # a list is for an individual classical register
             return "".join([str(bit) for bit in obj])

azure/quantum/target/ionq.py

@@ -59,12 +59,16 @@ class IonQ(Target):
         name: str = "ionq.simulator",
         input_data_format: str = "ionq.circuit.v1",
         output_data_format: str = "ionq.quantum-results.v1",
-        capability: str = "BasicExecution",
+        capability: str = "",
         provider_id: str = "IonQ",
         content_type: str = "application/json",
         encoding: str = "",
-        **kwargs
+        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,
@@ -74,7 +78,8 @@ class IonQ(Target):
             provider_id=provider_id,
             content_type=content_type,
             encoding=encoding,
-            **kwargs
+            target_profile=target_profile,
+            **kwargs,
         )
 
     def submit(

azure/quantum/target/microsoft/target.py

@@ -392,6 +392,7 @@ class MicrosoftEstimator(Target):
             output_data_format="microsoft.resource-estimates.v1",
             provider_id="microsoft-qc",
             content_type=ContentType.json,
+            target_profile="Adaptive_RI",
             **kwargs
         )
 
@@ -422,14 +423,21 @@ class MicrosoftEstimator(Target):
             warnings.warn("The 'shots' parameter is ignored in resource estimation job.")
 
         try:
-            from qiskit import QuantumCircuit, transpile
-            from qiskit_qir import to_qir_module
-            from qiskit_qir.visitor import SUPPORTED_INSTRUCTIONS
+            from qiskit import QuantumCircuit
+            from qsharp import TargetProfile
+            from qsharp.interop.qiskit import ResourceEstimatorBackend
+            from pyqir import Context, Module
+
             if isinstance(input_data, QuantumCircuit):
-                input_data = transpile(input_data,
-                                       basis_gates=SUPPORTED_INSTRUCTIONS,
-                                       optimization_level=0)
-                (module, _) = to_qir_module(input_data, record_output=False)
+                backend = ResourceEstimatorBackend()
+                target_profile = TargetProfile.from_str(self.target_profile)
+                qir_str = backend.qir(input_data, target_profile=target_profile)
+                context = Context()
+                module = Module.from_ir(context, qir_str)
+
+                err = module.verify()
+                if err is not None:
+                    raise Exception(err)
                 input_data = module.bitcode
         finally:
             return super().submit(

azure/quantum/target/pasqal/target.py

@@ -80,9 +80,10 @@ class Pasqal(Target):
         name: Union[PasqalTarget, str] = PasqalTarget.SIM_EMU_TN,
         input_data_format: str = "pasqal.pulser.v1",
         output_data_format: str = "pasqal.pulser-results.v1",
-        capability: str = "BasicExecution",
+        capability: str = "",
         provider_id: str = "pasqal",
         encoding: str = "",
+        target_profile: Union[str, "TargetProfile"] = "Base",
         **kwargs,
     ):
         """
@@ -102,7 +103,12 @@ class Pasqal(Target):
         :type provider_id: str
         :param encoding: "Content-Encoding" attribute value to set on input blob (ex. "gzip")
         :type encoding: str
+        :param target_profile: Target QIR profile.
+        :type target_profile: str | TargetProfile
         """
+        if capability:
+            msg = "The 'capability' parameter is not used for the Quantinuum target."
+            warn(msg, DeprecationWarning)
 
         super().__init__(
             workspace=workspace,

azure/quantum/target/quantinuum.py

@@ -2,7 +2,7 @@
 # Copyright (c) Microsoft Corporation.
 # Licensed under the MIT License.
 ##
-from typing import Any, Dict
+from typing import Any, Dict, Union
 from warnings import warn
 
 from azure.quantum.target.target import (
@@ -12,7 +12,6 @@ from azure.quantum.target.target import (
 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
 
 
 class Quantinuum(Target):
@@ -35,12 +34,16 @@ class Quantinuum(Target):
         name: str = "quantinuum.sim.h1-1sc",
         input_data_format: str = "honeywell.openqasm.v1",
         output_data_format: str = "honeywell.quantum-results.v1",
-        capability: str = "AdaptiveExecution",
+        capability: str = "",
         provider_id: str = "quantinuum",
         content_type: str = "application/qasm",
         encoding: str = "",
+        target_profile: Union[str, "TargetProfile"] = "Adaptive_RI",
         **kwargs
     ):
+        if capability:
+            msg = "The 'capability' parameter is not used for the Quantinuum target."
+            warn(msg, DeprecationWarning)
         super().__init__(
             workspace=workspace,
             name=name,
@@ -50,6 +53,7 @@ class Quantinuum(Target):
             provider_id=provider_id,
             content_type=content_type,
             encoding=encoding,
+            target_profile=target_profile,
             **kwargs
         )
 

azure/quantum/target/rigetti/target.py

@@ -14,6 +14,7 @@ __all__ = [
 from dataclasses import dataclass
 from enum import Enum
 from typing import Union, Any, Dict, List, Optional
+from warnings import warn
 
 from ..target import Target
 from ... import Job
@@ -137,9 +138,10 @@ class Rigetti(Target):
         name: Union[RigettiTarget, str] = RigettiTarget.QVM,
         input_data_format: str = "rigetti.quil.v1",
         output_data_format: str = "rigetti.quil-results.v1",
-        capability: str = "BasicExecution",
+        capability: str = "",
         provider_id: str = "rigetti",
         encoding: str = "",
+        target_profile: Union[str, "TargetProfile"] = "Base",
         **kwargs,
     ):
         """
@@ -159,8 +161,12 @@ class Rigetti(Target):
         :type provider_id: str
         :param encoding: "Content-Encoding" attribute value to set on input blob (ex. "gzip")
         :type encoding: str
+        :param target_profile: Target QIR profile.
+        :type target_profile: str | TargetProfile
         """
-                
+        if capability:
+            msg = "The 'capability' parameter is not used for the Quantinuum target."
+            warn(msg, DeprecationWarning)
         super().__init__(
             workspace=workspace,
             name=name,
@@ -170,6 +176,7 @@ class Rigetti(Target):
             provider_id=provider_id,
             content_type="text/plain",
             encoding=encoding,
+            target_profile=target_profile,
             **kwargs,
         )
 

azure/quantum/target/target.py

@@ -68,7 +68,8 @@ class Target(abc.ABC, SessionHost):
         content_type: ContentType = ContentType.json,
         encoding: str = "",
         average_queue_time: Union[float, None] = None,
-        current_availability: str = ""
+        current_availability: str = "",
+        target_profile: Union[str, "TargetProfile"] = "Base",
     ):
         """
         Initializes a new target.
@@ -81,7 +82,7 @@ class Target(abc.ABC, SessionHost):
         :type input_data_format: str
         :param output_data_format: Format of output data (ex. "microsoft.resource-estimates.v1")
         :type output_data_format: str
-        :param capability: QIR capability
+        :param capability: QIR capability. Deprecated, use `target_profile`
         :type capability: str
         :param provider_id: Id of provider (ex. "microsoft-qc")
         :type provider_id: str
@@ -93,6 +94,8 @@ class Target(abc.ABC, SessionHost):
         :type average_queue_time: float
         :param current_availability: Set current availability (for internal use)
         :type current_availability: str
+        :param target_profile: Target QIR profile.
+        :type target_profile: str | TargetProfile
         """
         if not provider_id and "." in name:
             provider_id = name.split(".")[0]
@@ -106,6 +109,7 @@ class Target(abc.ABC, SessionHost):
         self.encoding = encoding
         self._average_queue_time = average_queue_time
         self._current_availability = current_availability
+        self.target_profile = target_profile
 
     def __repr__(self):
         return f"<Target name=\"{self.name}\", \
@@ -255,8 +259,17 @@ target '{self.name}' of provider '{self.provider_id}' not found."
             input_params["arguments"] = input_params.get("arguments", [])
             targetCapability = input_params.get("targetCapability", kwargs.pop("target_capability", self.capability))
             if targetCapability:
+                warnings.warn(
+                    "The 'targetCapability' parameter is deprecated and will be ignored in the future. "
+                    "Please, use 'target_profile' parameter instead.",
+                    category=DeprecationWarning,
+                )
                 input_params["targetCapability"] = targetCapability
-            input_data = input_data._repr_qir_(target=self.name, target_capability=targetCapability)
+            if target_profile := input_params.get(
+                "target_profile", kwargs.pop("target_profile", self.target_profile)
+            ):
+                input_params["target_profile"] = target_profile
+            input_data = input_data._repr_qir_(target=self.name)
         else:
             input_data_format = kwargs.pop("input_data_format", self.input_data_format)
             output_data_format = kwargs.pop("output_data_format", self.output_data_format)

azure/quantum/version.py

@@ -5,4 +5,4 @@
 # Copyright (c) Microsoft Corporation. All rights reserved.
 # Licensed under the MIT License.
 ##
-__version__ = "2.1.2"
+__version__ = "2.2.0"

{azure_quantum-2.1.2.dist-info → azure_quantum-2.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: azure-quantum
-Version: 2.1.2
+Version: 2.2.0
 Summary: Python client for Azure Quantum
 Home-page: https://github.com/microsoft/azure-quantum-python
 Author: Microsoft
@@ -26,8 +26,8 @@ Requires-Dist: azure-devtools<2.0,>=1.2.0; extra == "all"
 Requires-Dist: graphviz>=0.20.1; extra == "all"
 Requires-Dist: pulser<0.19,>=0.18; extra == "all"
 Requires-Dist: qiskit-ionq<0.6,>=0.5; extra == "all"
-Requires-Dist: qiskit-qir<0.6,>=0.5; extra == "all"
-Requires-Dist: qiskit<2.0,>=1.0; extra == "all"
+Requires-Dist: qsharp[qiskit]<2.0,>=1.9.0; extra == "all"
+Requires-Dist: pyqir<0.11,>=0.10.6; extra == "all"
 Requires-Dist: Markdown<4.0,>=3.4.1; extra == "all"
 Requires-Dist: python-markdown-math<1.0,>=0.8.0; extra == "all"
 Requires-Dist: qsharp<2.0,>=1.0.33; extra == "all"
@@ -43,8 +43,8 @@ Provides-Extra: pulser
 Requires-Dist: pulser<0.19,>=0.18; extra == "pulser"
 Provides-Extra: qiskit
 Requires-Dist: qiskit-ionq<0.6,>=0.5; extra == "qiskit"
-Requires-Dist: qiskit-qir<0.6,>=0.5; extra == "qiskit"
-Requires-Dist: qiskit<2.0,>=1.0; extra == "qiskit"
+Requires-Dist: qsharp[qiskit]<2.0,>=1.9.0; extra == "qiskit"
+Requires-Dist: pyqir<0.11,>=0.10.6; extra == "qiskit"
 Requires-Dist: Markdown<4.0,>=3.4.1; extra == "qiskit"
 Requires-Dist: python-markdown-math<1.0,>=0.8.0; extra == "qiskit"
 Provides-Extra: qsharp

{azure_quantum-2.1.2.dist-info → azure_quantum-2.2.0.dist-info}/RECORD

@@ -2,7 +2,7 @@ azure/quantum/__init__.py,sha256=Za8xZY4lzFkW8m4ero-bqrfN437D2NRukM77ukb4GPM,508
 azure/quantum/_constants.py,sha256=nDL_QrGdI_Zz_cvTB9nVgfE7J6A_Boo1ollMYqsiEBs,3499
 azure/quantum/_workspace_connection_params.py,sha256=KoT90U89Dj6pVwAKp_ENJL1hyTF0oQe7w0QioOGvjXg,21685
 azure/quantum/storage.py,sha256=_4bMniDk9LrB_K5CQwuCivJFZXdmhRvU2b6Z3xxXw9I,12556
-azure/quantum/version.py,sha256=UKyDm7olfca_jl4kfZ2YJWPOicc_dGHFVc4HIlN0Fxo,235
+azure/quantum/version.py,sha256=TnDCYSdtFyry__XYbh4tqN_uFRjxSp9rlHSAEAQYfY0,235
 azure/quantum/workspace.py,sha256=1__iZTe59ozAsAGJ4nECxmk_211Dm8ALJi-MFIdrg4o,23438
 azure/quantum/_authentication/__init__.py,sha256=bniNZlS0hMIjO_y7DevGBAS6MixyA5pbPHcdGipUWM4,236
 azure/quantum/_authentication/_chained.py,sha256=0rdohB_fVGFHUhlly9sGxqQTBTZGpGxtlBqNHDFbAqE,4848
@@ -14,7 +14,7 @@ azure/quantum/_client/_configuration.py,sha256=5uktKtZxoVVAoSyeL0VNGS9AfPERp-9rU
 azure/quantum/_client/_patch.py,sha256=YTV6yZ9bRfBBaw2z7v4MdzR-zeHkdtKkGb4SU8C25mE,694
 azure/quantum/_client/_serialization.py,sha256=KJSS6KWgnKcz-cENQCmWZ9Ziv303lnBbLwFIpYZeKFU,81097
 azure/quantum/_client/_vendor.py,sha256=h8ByiyZ4cCQyFxqnuhTQdv1Rms3dVjKsrgZDzwMcSJ0,996
-azure/quantum/_client/_version.py,sha256=qvePw7MpAjzl2NlBoHDo0GGUX4XuuZjihqAuUURVLNc,495
+azure/quantum/_client/_version.py,sha256=Ugb4E4_TnbHI-G9DlVpP7Ury0IKbr0EDFsfNmY4GwJg,495
 azure/quantum/_client/models/__init__.py,sha256=c1PRpzNsQTcDk4GkrFMMIlwNQQa2c0p5N0Lzd-23YBA,2100
 azure/quantum/_client/models/_enums.py,sha256=omj_B8_E8ONzTHg5hLgDlFYibRRbdr9sEN298im_otA,2977
 azure/quantum/_client/models/_models.py,sha256=wktCM5oBVfwQetNoHobL1wNsC3knXV-HmqBq_Q77Kw4,41810
@@ -41,38 +41,38 @@ azure/quantum/job/session.py,sha256=EEJVKEEB5g0yyH963aaR0GY0Cd0axrX-49gwDWxBcfE,
 azure/quantum/job/workspace_item.py,sha256=lyBIJCtUfIZMGJYJkX7Se8IDnXhXe4JU0RnqzSuhhI4,1380
 azure/quantum/job/workspace_item_factory.py,sha256=QRWyrtgcKZqUucJOFi9V_SYMV3lj6S74tGRrPtk3NE0,1200
 azure/quantum/qiskit/__init__.py,sha256=gjKsmRwtVNcbbsuOvy2wT0ASELh5NXGmuwaEwjZcVQo,314
-azure/quantum/qiskit/job.py,sha256=zrm1HHW_9A9DG8XFO-y7xDZtsbuS64C8etFaF8XWotE,14888
+azure/quantum/qiskit/job.py,sha256=_pKIwMuEOXNzXhl7X79Uzq1EbOtxmNI7u_r3ybzGn34,14868
 azure/quantum/qiskit/provider.py,sha256=kbZJgDX-hI-AD5rQfik4JHNnNd74oyfrKYauosqBRxw,10966
 azure/quantum/qiskit/backends/__init__.py,sha256=DBC6GgYa5Y0p5xu5ADqlOXs7zp8_RDTJ86qKhuzXfG0,1118
-azure/quantum/qiskit/backends/backend.py,sha256=nj4gYDPxp91uA_JfStnpJFU7hSw15Nsz8--9wmHFMXc,22024
-azure/quantum/qiskit/backends/ionq.py,sha256=bDL7Oy85nK1iMbOlbhxOc8izBOqFGpZ593jCQ6PoMjg,14406
-azure/quantum/qiskit/backends/microsoft.py,sha256=7Nw-z8KoIBOBXbP8aqhmhAeW9TENrwwkZk6LD31M9F0,3478
-azure/quantum/qiskit/backends/qci.py,sha256=_t6IVUGe4LXzXSLLADwpvic2JTNxOSCsRl0s4zx3K7c,4656
-azure/quantum/qiskit/backends/quantinuum.py,sha256=bwmhcZEnj71LMWT31six-WnZJ_b-YqP0VxzCZwnsa9g,13910
-azure/quantum/qiskit/backends/rigetti.py,sha256=3XYr5C37MhGH6fm7LHX3UQ6BGYlSN9-q61Xd8WHEX5U,4112
+azure/quantum/qiskit/backends/backend.py,sha256=qE0mt03sI2DsSZ7WWPshkeg8CqIYotIobMiLaRcVVn8,24126
+azure/quantum/qiskit/backends/ionq.py,sha256=YYR6ELJ7VMw2kUSMQ0VTART0ykJvGgYTQDbfAFdx8Do,14438
+azure/quantum/qiskit/backends/microsoft.py,sha256=okn5J1Ddcmg2_8pSjrn1uykp6p7tLw1sQCkoeo0HTXw,5540
+azure/quantum/qiskit/backends/qci.py,sha256=c0YK-znG8TSAnFmeszo7mpKhM624QHszTQoapOqOvHg,4794
+azure/quantum/qiskit/backends/quantinuum.py,sha256=wR0oxE9UmZyy73hnhWnG8XvPIaPAA3h77brhqUXBsfk,13654
+azure/quantum/qiskit/backends/rigetti.py,sha256=lTsa0UjPdsAZUvvfnBge7H22TvA7c-_3fU09ZTA4ARs,4146
 azure/quantum/qiskit/results/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 azure/quantum/qiskit/results/resource_estimator.py,sha256=pAP5ZpVxdzNekQ_qXfSdSKYWWuqL_Vq7WK6pWU4wbEQ,814
 azure/quantum/target/__init__.py,sha256=F0nIEJdlbczmxAdtvPDWf8J1Y33_XjPzloliHeWpJos,689
-azure/quantum/target/ionq.py,sha256=cJ7jZHN8HSLvlxCSY6hNHf1dFog40PmVLfJ_PT5eVo4,8068
+azure/quantum/target/ionq.py,sha256=saPRhYlwyx0tLEtJHWR0K5tE7CUjwnXu_ay17sCKM_Y,8317
 azure/quantum/target/params.py,sha256=oI-35HUEMCskNjpxCJU3tjL664K-TxqAg5LA5xU0nso,9130
-azure/quantum/target/quantinuum.py,sha256=Fe84Mf927Bd4UrebOa0qx4qOH7SqOAlFE6zR42ioYec,7937
-azure/quantum/target/target.py,sha256=GChB4kzTlETgLHlH8zIMPJX5W5m1GoOkrNqiCHw3R70,16281
+azure/quantum/target/quantinuum.py,sha256=dogWB2u6XUOhg0VZVoI9GbvDeHa-EQtl05N_iJExEUg,8169
+azure/quantum/target/target.py,sha256=jmrFY_CqYAQCMWEfs05MxHq_mUOSyqUGmBwl2cg0XUo,16989
 azure/quantum/target/target_factory.py,sha256=jjZ9zxWaNDkcvslKV02GSP8rtXwStJ7EmVXQSOFh_j8,5266
 azure/quantum/target/microsoft/__init__.py,sha256=36kM2YlWv69AzAfUA5wMdWyYRSaCMwX2Ajhffpzx67g,570
 azure/quantum/target/microsoft/job.py,sha256=GM4OA-rxFUqQzsH8V59pVc4BmBaPYvd99E26pyPwxto,1249
 azure/quantum/target/microsoft/result.py,sha256=AntJptXKHNRdRR6oxhTlKKPOJVSU7u9fIfH2GXJqfx0,18784
-azure/quantum/target/microsoft/target.py,sha256=D7KS3AH-sjD1MVXL-J0SG61aGdWlrTZNT9JicjJzWeE,17879
+azure/quantum/target/microsoft/target.py,sha256=UoWZzD6sLrWKUQnFKfeYHvUdXWvIsMPv0YtsmubCDL0,18123
 azure/quantum/target/microsoft/elements/__init__.py,sha256=gVVpaN5086iuBnajtvTjSd7MLExtnsR6RDCmcgz6xpE,70
 azure/quantum/target/microsoft/elements/dft/__init__.py,sha256=kCXOA9HT-gb23An-A0eyktlB66VoH6EwNO4gPM97l3U,224
 azure/quantum/target/microsoft/elements/dft/job.py,sha256=REDLDF6-HBwB4OxUMrgKfZWCE6W7RWj7HKhiYeH1a-E,2936
 azure/quantum/target/microsoft/elements/dft/target.py,sha256=IeFDVh3SqDsQOZmd9UKhl1Qu0ChkOEIHHb5fC5x4YGE,2556
 azure/quantum/target/pasqal/__init__.py,sha256=qbe6oWTQTsnTYwY3xZr32z4AWaYIchx71bYlqC2rQqw,348
 azure/quantum/target/pasqal/result.py,sha256=SUvpnrtgvCGiepmNpyifW8b4p14-SZZ1ToCC0NAdIwg,1463
-azure/quantum/target/pasqal/target.py,sha256=DMt2uYeCeaUFh7vlnf687VOoRStXCWL-6Mk_Dub8anI,4833
+azure/quantum/target/pasqal/target.py,sha256=K_vqavov6gvS84voRKeBx9pO8g4LrtWrlZ5-RMLWozw,5139
 azure/quantum/target/rigetti/__init__.py,sha256=I1vyzZBYGI540pauTqJd0RSSyTShGqkEL7Yjo25_RNY,378
 azure/quantum/target/rigetti/result.py,sha256=65mtAZxfdNrTWNjWPqgfwt2BZN6Nllo4g_bls7-Nm68,2334
-azure/quantum/target/rigetti/target.py,sha256=ymfJX6khTfe6H26pxvbNgIVbd9cldP1OQ5CsF2PQHp0,7059
-azure_quantum-2.1.2.dist-info/METADATA,sha256=v0yXxkGbBzJagpju4FMPhwjV1gKXhA4X86YvAOenDgw,7339
-azure_quantum-2.1.2.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-azure_quantum-2.1.2.dist-info/top_level.txt,sha256=S7DhWV9m80TBzAhOFjxDUiNbKszzoThbnrSz5MpbHSQ,6
-azure_quantum-2.1.2.dist-info/RECORD,,
+azure/quantum/target/rigetti/target.py,sha256=75yGp8RYXGX9NWOkqoY_9L7FtUcAlD5KPj92wTn1zYg,7418
+azure_quantum-2.2.0.dist-info/METADATA,sha256=BXXM2KPKaIzZNP-6KONkBkciorjonJNe-IWWsL9mRLY,7357
+azure_quantum-2.2.0.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
+azure_quantum-2.2.0.dist-info/top_level.txt,sha256=S7DhWV9m80TBzAhOFjxDUiNbKszzoThbnrSz5MpbHSQ,6
+azure_quantum-2.2.0.dist-info/RECORD,,