azure-quantum 2.2.0.dev6__py3-none-any.whl → 2.4.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.2.0.dev6"
+VERSION = "2.4.0"

azure/quantum/_client/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561.

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/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/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/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/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/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/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/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/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/target/ionq.py

@@ -126,114 +126,3 @@ class IonQ(Target):
             input_params=input_params,
             **kwargs
         )
-
-    def estimate_cost(
-        self,
-        circuit: Union[Dict[str, Any], Any],
-        num_shots: int = None,
-        price_1q: float = None,
-        price_2q: 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
-        manually.
-        The actual price charged by the provider may differ from this calculation.
-        
-        Specify pricing details for your area to get most accurate results.
-        By default, this function charges depending on the target:
-            ionq.qpu.aria-1:
-                price_1q = 0.00022 USD for a single-qubit gate.
-                price_2q = 0.00098 USD for a two-qubit gate.
-                min_price = 1 USD, total minimum price per circuit.
-
-        For the most current pricing details, see
-        https://docs.microsoft.com/azure/quantum/provider-ionq#pricing
-        or find your workspace and view pricing options in the "Provider" tab
-        of your workspace: https://aka.ms/aq/myworkspaces
-
-        :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 num_shots: Number of shots, defaults to None
-        :type num_shots: int
-        :param price_1q: The price of running a single-qubit gate
-            for one shot.
-        :type price_1q: float
-        :param price_2q: The price of running a double-qubit gate
-            for one shot.
-        :type price_2q: float
-        :param min_price: The minimum price for running a job.
-        :type min_price: float
-        :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
-
-        # Get the costs for the gates depending on the provider if not specified
-        if price_1q is None:
-            price_1q = COST_1QUBIT_GATE_MAP[self.name]
-
-        if price_2q is None:
-            price_2q = COST_2QUBIT_GATE_MAP[self.name]
-
-        if min_price is None:
-            min_price = MIN_PRICE_MAP[self.name]
-
-        if (isinstance(circuit, Dict)):
-            def is_1q_gate(gate: Dict[str, Any]):
-                return "controls" not in gate and "control" not in gate
-
-            def is_multi_q_gate(gate):
-                return "controls" in gate or "control" in gate
-
-            def num_2q_gates(gate):
-                controls = gate.get("controls")
-                if controls is None or len(controls) == 1:
-                    # Only one control qubit
-                    return 1
-                # Multiple control qubits
-                return 6 * (len(controls) - 2)
-            
-            gates = circuit.get("circuit", [])
-            N_1q = sum(map(is_1q_gate, gates))
-            N_2q = sum(map(num_2q_gates, filter(is_multi_q_gate, gates)))
-
-        else:
-            N_1q, N_2q, _ = Target._calculate_qir_module_gate_stats(circuit)
-            
-        price = (price_1q * N_1q + price_2q * N_2q) * shots
-        price = max(price, min_price)
-
-        return CostEstimate(
-            events = [
-                UsageEvent(
-                    dimension_id="gs1q",
-                    dimension_name="1Q Gate Shot",
-                    measure_unit="1q gate shot",
-                    amount_billed=0.0,
-                    amount_consumed=N_1q * shots,
-                    unit_price=0.0
-                ),
-                UsageEvent(
-                    dimension_id="gs2q",
-                    dimension_name="2Q Gate Shot",
-                    measure_unit="2q gate shot",
-                    amount_billed=0.0,
-                    amount_consumed=N_2q * shots,
-                    unit_price=0.0
-                )
-            ],
-            currency_code="USD",
-            estimated_total=price
-        )

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

@@ -1,8 +1,13 @@
 import collections.abc
-from typing import Any, Dict, Union
+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):
     """
@@ -62,4 +67,105 @@ class MicrosoftElementsDftJob(Job):
                     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"]
+                    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
+        )