cirq-aqt 1.4.0.dev20240415214855__py3-none-any.whl → 1.4.0.dev20240419073809__py3-none-any.whl

cirq_aqt/_version.py

@@ -1 +1 @@
-__version__ = "1.4.0.dev20240415214855"
+__version__ = "1.4.0.dev20240419073809"

cirq_aqt/aqt_device.py

@@ -25,6 +25,7 @@ The native gate set consists of the local gates: X, Y, and XX entangling gates
 """
 
 import json
+from enum import Enum
 from typing import Any, cast, Dict, Iterable, List, Optional, Sequence, Set, Tuple, Union
 
 import networkx as nx
@@ -36,11 +37,27 @@ from cirq_aqt import aqt_device_metadata
 gate_dict = {'X': cirq.X, 'Y': cirq.Y, 'Z': cirq.Z, 'MS': cirq.XX, 'R': cirq.PhasedXPowGate}
 
 
+class OperationString(Enum):
+    """String representations of operations supported by AQT resources."""
+
+    MS = "MS"
+    """Cirq: XXPowGate, AQT: RXX gate."""
+
+    Z = "Z"
+    """Cirq: ZPowGate, AQT: RZ gate."""
+
+    R = "R"
+    """Cirq: PhasedXPowGate, AQT: R gate."""
+
+    MEASURE = "Meas"
+    """Measurement gate."""
+
+
 def get_op_string(op_obj: cirq.Operation) -> str:
     """Find the string representation for a given gate or operation.
 
     Args:
-        op_obj: Gate or operation object. Gate must be one of: XXPowGate, XPowGate, YPowGate,
+        op_obj: Gate or operation object. Gate must be one of: XXPowGate,
             ZPowGate, PhasedXPowGate, or MeasurementGate.
 
     Returns:
@@ -50,20 +67,16 @@ def get_op_string(op_obj: cirq.Operation) -> str:
         ValueError: If the gate is not one of the supported gates.
     """
     if isinstance(op_obj.gate, cirq.XXPowGate):
-        op_str = 'MS'
-    elif isinstance(op_obj.gate, cirq.XPowGate):
-        op_str = 'X'
-    elif isinstance(op_obj.gate, cirq.YPowGate):
-        op_str = 'Y'
+        op_str = OperationString.MS.value
     elif isinstance(op_obj.gate, cirq.ZPowGate):
-        op_str = 'Z'
+        op_str = OperationString.Z.value
     elif isinstance(op_obj.gate, cirq.PhasedXPowGate):
-        op_str = 'R'
+        op_str = OperationString.R.value
     elif isinstance(op_obj.gate, cirq.MeasurementGate):
-        op_str = 'Meas'
+        op_str = OperationString.MEASURE.value
     else:
         raise ValueError(f'Got unknown gate on operation: {op_obj}.')
-    return op_str
+    return str(op_str)
 
 
 class AQTNoiseModel(cirq.NoiseModel):
@@ -97,6 +110,7 @@ class AQTNoiseModel(cirq.NoiseModel):
             for qubit in op.qubits:
                 noise_list.append(noise_op.on(qubit))
             noise_list += self.get_crosstalk_operation(op, system_qubits)
+
         return list(moment) + noise_list
 
     def get_crosstalk_operation(
@@ -122,16 +136,18 @@ class AQTNoiseModel(cirq.NoiseModel):
             for neigh_idx in neighbors:
                 if neigh_idx >= 0 and neigh_idx < num_qubits:
                     xtlk_arr[neigh_idx] = self.noise_op_dict['crosstalk']
+
         for idx in idx_list:
             xtlk_arr[idx] = 0
         xtlk_op_list = []
         op_str = get_op_string(operation)
         gate = cast(cirq.EigenGate, gate_dict[op_str])
+
         if len(operation.qubits) == 1:
             for idx in xtlk_arr.nonzero()[0]:
                 exponent = operation.gate.exponent  # type:ignore
                 exponent = exponent * xtlk_arr[idx]
-                xtlk_op = gate.on(system_qubits[idx]) ** exponent
+                xtlk_op = operation.gate.on(system_qubits[idx]) ** exponent  # type:ignore
                 xtlk_op_list.append(xtlk_op)
         elif len(operation.qubits) == 2:
             for op_qubit in operation.qubits:
@@ -216,10 +232,14 @@ class AQTSimulator:
             noise_model = cirq.NO_NOISE
         else:
             noise_model = AQTNoiseModel()
+
         if self.circuit == cirq.Circuit():
             raise RuntimeError('Simulate called without a valid circuit.')
+
         sim = cirq.DensityMatrixSimulator(noise=noise_model)
+
         result = sim.run(self.circuit, repetitions=repetitions)
+
         return result
 
 
@@ -342,10 +362,9 @@ def get_aqt_device(num_qubits: int) -> Tuple[AQTDevice, List[cirq.LineQubit]]:
 def get_default_noise_dict() -> Dict[str, Any]:
     """Returns the current noise parameters"""
     default_noise_dict = {
-        'X': cirq.depolarize(1e-3),
-        'Y': cirq.depolarize(1e-3),
-        'Z': cirq.depolarize(1e-3),
-        'MS': cirq.depolarize(1e-2),
+        OperationString.R.value: cirq.depolarize(1e-3),
+        OperationString.Z.value: cirq.depolarize(0),
+        OperationString.MS.value: cirq.depolarize(1e-2),
         'crosstalk': 0.03,
     }
     return default_noise_dict

cirq_aqt/aqt_device_metadata.py

@@ -53,8 +53,6 @@ class AQTDeviceMetadata(cirq.DeviceMetadata):
         self._gate_durations = {
             cirq.GateFamily(cirq.MeasurementGate): self._measurement_duration,
             cirq.GateFamily(cirq.XXPowGate): self._twoq_gates_duration,
-            cirq.GateFamily(cirq.XPowGate): self._oneq_gates_duration,
-            cirq.GateFamily(cirq.YPowGate): self._oneq_gates_duration,
             cirq.GateFamily(cirq.ZPowGate): self._oneq_gates_duration,
             cirq.GateFamily(cirq.PhasedXPowGate): self._oneq_gates_duration,
         }

cirq_aqt/aqt_device_metadata_test.py

@@ -45,7 +45,7 @@ def test_aqtdevice_metadata(metadata, qubits):
     assert len(edges) == 10
     assert all(q0 != q1 for q0, q1 in edges)
     assert AQTTargetGateset() == metadata.gateset
-    assert len(metadata.gate_durations) == 6
+    assert len(metadata.gate_durations) == 4
 
 
 def test_aqtdevice_duration_of(metadata, qubits):

cirq_aqt/aqt_sampler.py

@@ -25,13 +25,75 @@ API keys for classical simulators and quantum devices can be obtained at:
 import json
 import time
 import uuid
-from typing import cast, Dict, List, Sequence, Tuple, Union
+from typing import Callable, cast, Dict, List, Sequence, Tuple, Union, Literal, TypedDict
+from urllib.parse import urljoin
 
 import numpy as np
-from requests import put
+from requests import post, get
 
 import cirq
-from cirq_aqt.aqt_device import AQTSimulator, get_op_string
+from cirq_aqt.aqt_device import AQTSimulator, get_op_string, OperationString
+
+
+_DEFAULT_HOST = "https://arnica.aqt.eu/api/v1/"
+
+
+class SingleQubitGate(TypedDict):
+    """Abstract single qubit rotation."""
+
+    qubit: int
+
+
+class GateRZ(SingleQubitGate):
+    """A single-qubit rotation rotation around the Bloch sphere's z-axis."""
+
+    operation: Literal["RZ"]
+    phi: float
+
+
+class GateR(SingleQubitGate):
+    """A single-qubit rotation around an arbitrary axis on the Bloch sphere's equatorial plane."""
+
+    operation: Literal["R"]
+    phi: float
+    theta: float
+
+
+class GateRXX(TypedDict):
+    """A two-qubit entangling gate of Mølmer-Sørenson-type."""
+
+    operation: Literal["RXX"]
+    qubits: list[int]
+    theta: float
+
+
+class Measure(TypedDict):
+    """Measurement operation.
+
+    The MEASURE operation instructs the resource
+    to perform a projective measurement of all qubits.
+    """
+
+    operation: Literal["MEASURE"]
+
+
+Gate = GateRZ | GateR | GateRXX
+Operation = Gate | Measure
+
+
+class Resource(TypedDict):
+    """A quantum computing device."""
+
+    id: str
+    name: str
+    type: Literal["device", "simulator"]
+
+
+class Workspace(TypedDict):
+    """A user workspace."""
+
+    id: str
+    resources: list[Resource]
 
 
 class AQTSampler(cirq.Sampler):
@@ -40,16 +102,127 @@ class AQTSampler(cirq.Sampler):
     runs a single circuit or an entire sweep remotely
     """
 
-    def __init__(self, remote_host: str, access_token: str):
+    def __init__(
+        self, workspace: str, resource: str, access_token: str, remote_host: str = _DEFAULT_HOST
+    ):
         """Inits AQTSampler.
 
         Args:
-            remote_host: Address of the remote device.
-            access_token: Access token for the remote api.
+            workspace: the ID of the workspace you have access to.
+            resource: the ID of the resource to run the circuit on.
+            access_token: Access token for the AQT API.
+            remote_host: Address of the AQT API.
         """
+        self.workspace = workspace
+        self.resource = resource
         self.remote_host = remote_host
         self.access_token = access_token
 
+    @staticmethod
+    def fetch_resources(access_token: str, remote_host: str = _DEFAULT_HOST) -> list[Workspace]:
+        """Lists the workspaces and resources that are accessible with access_token.
+
+        Returns a list containing the workspaces and resources that the passed
+        access_token gives access to. The workspace and resource IDs in this list can be
+        used to submit jobs using the run and run_sweep methods.
+
+        The printed table contains four columns:
+            - WORKSPACE ID: the ID of the workspace. Use this value to submit circuits.
+            - RESOURCE NAME: the human-readable name of the resource.
+            - RESOURCE ID: the ID of the resource. Use this value to submit circuits.
+            - D/S: whether the resource is a (D)evice or (S)imulator.
+
+        Args:
+            access_token: Access token for the AQT API.
+            remote_host: Address of the AQT API. Defaults to "https://arnica.aqt.eu/api/v1/".
+
+        Raises:
+            RuntimeError: If there was an unexpected response from the server.
+        """
+        headers = {"Authorization": f"Bearer {access_token}", "SDK": "cirq"}
+        url = urljoin(remote_host if remote_host[-1] == "/" else remote_host + "/", "workspaces")
+
+        response = get(url, headers=headers)
+        if response.status_code != 200:
+            raise RuntimeError('Got unexpected return data from server: \n' + str(response.json()))
+
+        workspaces = [
+            Workspace(
+                id=w['id'],
+                resources=[
+                    Resource(id=r['id'], name=r['name'], type=r['type']) for r in w['resources']
+                ],
+            )
+            for w in response.json()
+        ]
+
+        return workspaces
+
+    @staticmethod
+    def print_resources(
+        access_token: str, emit: Callable = print, remote_host: str = _DEFAULT_HOST
+    ) -> None:
+        """Displays the workspaces and resources that are accessible with access_token.
+
+        Prints a table using the function passed as 'emit' containing the workspaces and
+        resources that the passed access_token gives access to. The IDs in this table
+        can be used to submit jobs using the run and run_sweep methods.
+
+        The printed table contains four columns:
+            - WORKSPACE ID: the ID of the workspace. Use this value to submit circuits.
+            - RESOURCE NAME: the human-readable name of the resource.
+            - RESOURCE ID: the ID of the resource. Use this value to submit circuits.
+            - D/S: whether the resource is a (D)evice or (S)imulator.
+
+        Args:
+            access_token: Access token for the AQT API.
+            emit (optional): A Callable which will be called once with a single string argument,
+                containing the table. Defaults to print from the standard library.
+            remote_host (optional): Address of the AQT API. Defaults to
+                "https://arnica.aqt.eu/api/v1/".
+
+        Raises:
+            RuntimeError: If there was an unexpected response from the server.
+        """
+        table_lines = []
+        workspaces = AQTSampler.fetch_resources(access_token, remote_host)
+
+        if len(workspaces) == 0:
+            return emit("No workspaces are accessible with this access token.")
+        if any(len(w['resources']) == 0 for w in workspaces):
+            return emit("No workspaces accessible with this access token contain resources.")
+
+        col_widths = [
+            max([len(w['id']) for w in workspaces]),
+            max([len(d['name']) for w in workspaces for d in w['resources']]),
+            max([len(d['id']) for w in workspaces for d in w['resources']]),
+            3,
+        ]
+        SEPARATOR = "+-" + "-+-".join(col_width * "-" for col_width in col_widths) + "-+"
+
+        table_lines.append(SEPARATOR)
+        table_lines.append(
+            f"| {'WORKSPACE ID'.ljust(col_widths[0])} |"
+            f" {'RESOURCE NAME'.ljust(col_widths[1])} |"
+            f" {'RESOURCE ID'.ljust(col_widths[2])} |"
+            f" {'D/S'.ljust(col_widths[3])} |"
+        )
+        table_lines.append(SEPARATOR)
+
+        for workspace in workspaces:
+            next_workspace = workspace['id']
+            for resource in workspace["resources"]:
+                table_lines.append(
+                    f"| {next_workspace.ljust(col_widths[0])} |"
+                    f" {resource['name'].ljust(col_widths[1])} |"
+                    f" {resource['id'].ljust(col_widths[2])} |"
+                    f" {resource['type'][0].upper().ljust(col_widths[3])} |"
+                )
+                next_workspace = ""
+            table_lines.append(SEPARATOR)
+
+        emit("\n".join(table_lines))
+
     def _generate_json(
         self, circuit: cirq.AbstractCircuit, param_resolver: cirq.ParamResolverOrSimilarType
     ) -> str:
@@ -62,7 +235,7 @@ class AQTSampler(cirq.Sampler):
         which is a list of sequential quantum operations,
         each operation defined by:
 
-        op_string: str that specifies the operation type: "X","Y","Z","MS"
+        op_string: str that specifies the operation type: "Z","MS","R","Meas"
         gate_exponent: float that specifies the gate_exponent of the operation
         qubits: list of qubits where the operation acts on.
 
@@ -100,27 +273,72 @@ class AQTSampler(cirq.Sampler):
         json_str = json.dumps(seq_list)
         return json_str
 
+    def _parse_legacy_circuit_json(self, json_str: str) -> list[Operation]:
+        """Converts a legacy JSON circuit representation.
+
+        Converts a JSON created for the legacy API into one that will work
+        with the Arnica v1 API.
+
+        Raises:
+            ValueError:
+                * if there is not exactly one measurement operation at the end
+                    of the circuit.
+
+                * if an operation is found in json_str that is not in
+                    OperationString.
+
+        Args:
+            json_str: A JSON-formatted string that could be used as the
+                data parameter in the body of a request to the old AQT API.
+        """
+        circuit = []
+        number_of_measurements = 0
+        instruction: Operation
+
+        for legacy_op in json.loads(json_str):
+            if number_of_measurements > 0:
+                raise ValueError("Need exactly one `MEASURE` operation at the end of the circuit.")
+
+            if legacy_op[0] == OperationString.Z.value:
+                instruction = GateRZ(operation="RZ", qubit=legacy_op[2][0], phi=legacy_op[1])
+
+            elif legacy_op[0] == OperationString.R.value:
+                instruction = GateR(
+                    operation="R", qubit=legacy_op[3][0], theta=legacy_op[1], phi=legacy_op[2]
+                )
+
+            elif legacy_op[0] == OperationString.MS.value:
+                instruction = GateRXX(operation="RXX", qubits=legacy_op[2], theta=legacy_op[1])
+
+            elif legacy_op[0] == OperationString.MEASURE.value:
+                instruction = Measure(operation="MEASURE")
+                number_of_measurements += 1
+
+            else:
+                raise ValueError(f'Got unknown gate on operation: {legacy_op}.')
+
+            circuit.append(instruction)
+
+        if circuit[-1]["operation"] != "MEASURE":
+            circuit.append({"operation": "MEASURE"})
+
+        return circuit
+
     def _send_json(
-        self,
-        *,
-        json_str: str,
-        id_str: Union[str, uuid.UUID],
-        repetitions: int = 1,
-        num_qubits: int = 1,
+        self, *, json_str: str, id_str: str, repetitions: int = 1, num_qubits: int = 1
     ) -> np.ndarray:
-        """Sends the json string to the remote AQT device
+        """Sends the json string to the remote AQT device.
 
-        The interface is given by PUT requests to a single endpoint URL.
-        The first PUT will insert the circuit into the remote queue,
-        given a valid access key.
-        Every subsequent PUT will return a dictionary, where the key "status"
-        is either 'queued', if the circuit has not been processed yet or
-        'finished' if the circuit has been processed.
-        The experimental data is returned via the key 'data'
+        Submits a pre-prepared JSON string representing a circuit to the AQT
+        API, then polls for the result, which is parsed and returned when
+        available.
+
+        Please consider that due to the potential for long wait-times, there is
+        no timeout in the result polling.
 
         Args:
             json_str: Json representation of the circuit.
-            id_str: Unique id of the datapoint.
+            id_str: A label to help identify a circuit.
             repetitions: Number of repetitions.
             num_qubits: Number of qubits present in the device.
 
@@ -130,49 +348,60 @@ class AQTSampler(cirq.Sampler):
         Raises:
             RuntimeError: If there was an unexpected response from the server.
         """
-        header = {"Ocp-Apim-Subscription-Key": self.access_token, "SDK": "cirq"}
-        response = put(
-            self.remote_host,
-            data={
-                'data': json_str,
-                'access_token': self.access_token,
-                'repetitions': repetitions,
-                'no_qubits': num_qubits,
+        headers = {"Authorization": f"Bearer {self.access_token}", "SDK": "cirq"}
+        quantum_circuit = self._parse_legacy_circuit_json(json_str)
+        submission_data = {
+            "job_type": "quantum_circuit",
+            "label": id_str,
+            "payload": {
+                "circuits": [
+                    {
+                        "repetitions": repetitions,
+                        "quantum_circuit": quantum_circuit,
+                        "number_of_qubits": num_qubits,
+                    }
+                ]
             },
-            headers=header,
-        )
+        }
+
+        submission_url = urljoin(self.remote_host, f"submit/{self.workspace}/{self.resource}")
+
+        response = post(submission_url, json=submission_data, headers=headers)
         response = response.json()
         data = cast(Dict, response)
-        if 'status' not in data.keys():
+
+        if 'response' not in data.keys() or 'status' not in data['response'].keys():
             raise RuntimeError('Got unexpected return data from server: \n' + str(data))
-        if data['status'] == 'error':
+        if data['response']['status'] == 'error':
             raise RuntimeError('AQT server reported error: \n' + str(data))
 
-        if 'id' not in data.keys():
+        if 'job' not in data.keys() or 'job_id' not in data['job'].keys():
             raise RuntimeError('Got unexpected return data from AQT server: \n' + str(data))
-        id_str = data['id']
+        job_id = data['job']['job_id']
 
+        result_url = urljoin(self.remote_host, f"result/{job_id}")
         while True:
-            response = put(
-                self.remote_host,
-                data={'id': id_str, 'access_token': self.access_token},
-                headers=header,
-            )
+            response = get(result_url, headers=headers)
             response = response.json()
             data = cast(Dict, response)
-            if 'status' not in data.keys():
+
+            if 'response' not in data.keys() or 'status' not in data['response'].keys():
                 raise RuntimeError('Got unexpected return data from AQT server: \n' + str(data))
-            if data['status'] == 'finished':
+            if data['response']['status'] == 'finished':
                 break
-            elif data['status'] == 'error':
+            elif data['response']['status'] == 'error':
                 raise RuntimeError('Got unexpected return data from AQT server: \n' + str(data))
             time.sleep(1.0)
-        measurements_int = data['samples']
-        measurements = np.zeros((len(measurements_int), num_qubits))
-        for i, result_int in enumerate(measurements_int):
-            measurement_int_bin = format(result_int, f'0{num_qubits}b')
+
+        if 'result' not in data['response'].keys():
+            raise RuntimeError('Got unexpected return data from AQT server: \n' + str(data))
+
+        measurement_int = data['response']['result']['0']
+        measurements = np.zeros((repetitions, num_qubits), dtype=int)
+        for i, repetition in enumerate(measurement_int):
             for j in range(num_qubits):
-                measurements[i, j] = int(measurement_int_bin[j])
+                measurements[i, j] = repetition[j]
+
         return measurements
 
     def run_sweep(
@@ -198,7 +427,7 @@ class AQTSampler(cirq.Sampler):
         meas_name = 'm'
         trial_results: List[cirq.Result] = []
         for param_resolver in cirq.to_resolvers(params):
-            id_str = uuid.uuid1()
+            id_str = str(uuid.uuid1())
             num_qubits = len(program.all_qubits())
             json_str = self._generate_json(circuit=program, param_resolver=param_resolver)
             results = self._send_json(
@@ -223,10 +452,19 @@ class AQTSamplerLocalSimulator(AQTSampler):
     sampler.simulate_ideal=True
     """
 
-    def __init__(self, remote_host: str = '', access_token: str = '', simulate_ideal: bool = False):
+    def __init__(
+        self,
+        workspace: str = "",
+        resource: str = "",
+        access_token: str = "",
+        remote_host: str = "",
+        simulate_ideal: bool = False,
+    ):
         """Args:
-        remote_host: Remote host is not used by the local simulator.
+        workspace: Workspace is not used by the local simulator.
+        resource: Resource is not used by the local simulator.
         access_token: Access token is not used by the local simulator.
+        remote_host: Remote host is not used by the local simulator.
         simulate_ideal: Boolean that determines whether a noisy or
                         an ideal simulation is performed.
         """
@@ -235,18 +473,13 @@ class AQTSamplerLocalSimulator(AQTSampler):
         self.simulate_ideal = simulate_ideal
 
     def _send_json(
-        self,
-        *,
-        json_str: str,
-        id_str: Union[str, uuid.UUID],
-        repetitions: int = 1,
-        num_qubits: int = 1,
+        self, *, json_str: str, id_str: str, repetitions: int = 1, num_qubits: int = 1
     ) -> np.ndarray:
         """Replaces the remote host with a local simulator
 
         Args:
             json_str: Json representation of the circuit.
-            id_str: Unique id of the datapoint.
+            id_str: A label to help identify a datapoint.
             repetitions: Number of repetitions.
             num_qubits: Number of qubits present in the device.
 

cirq_aqt/aqt_sampler_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 from unittest import mock
+import json
 import numpy as np
 import pytest
 import sympy
@@ -22,15 +23,11 @@ from cirq_aqt import AQTSampler, AQTSamplerLocalSimulator
 from cirq_aqt.aqt_device import get_aqt_device, get_op_string
 
 
-class EngineReturn:
+class GetResultReturn:
     """A put mock class for testing the REST interface"""
 
     def __init__(self):
-        self.test_dict = {
-            'status': 'queued',
-            'id': '2131da',
-            'samples': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
-        }
+        self.test_dict = {'job': {'job_id': '2131da'}, 'response': {'status': 'queued'}}
         self.counter = 0
 
     def json(self):
@@ -38,75 +35,104 @@ class EngineReturn:
         return self.test_dict
 
     def update(self, *args, **kwargs):
-        if self.counter >= 2:
-            self.test_dict['status'] = 'finished'
         return self
 
 
-class EngineError(EngineReturn):
+class GetResultError(GetResultReturn):
     """A put mock class for testing error responses"""
 
     def __init__(self):
-        self.test_dict = {'status': 'error', 'id': '2131da', 'samples': "Error message"}
+        self.test_dict = {'response': {}}
+        self.test_dict['response']['status'] = 'error'
+        self.test_dict['response']['message'] = "Error message"
         self.counter = 0
 
 
-class EngineNoid(EngineReturn):
-    """A put mock class for testing error responses
-    This will not return an id at the first call"""
-
-    def __init__(self):
-        self.test_dict = {'status': 'queued'}
-        self.counter = 0
-
-
-class EngineNoStatus(EngineReturn):
+class GetResultNoStatus(GetResultReturn):
     """A put mock class for testing error responses
     This will not return a status in the second call"""
 
     def update(self, *args, **kwargs):
-        del self.test_dict['status']
+        del self.test_dict['response']['status']
         return self
 
 
-class EngineNoStatus2(EngineReturn):
+class GetResultErrorSecond(GetResultReturn):
     """A put mock class for testing error responses
-    This will not return a status in the second call"""
+    This will return an error on the second put call"""
 
     def update(self, *args, **kwargs):
         if self.counter >= 1:
-            del self.test_dict['status']
+            self.test_dict['response']['status'] = 'error'
         return self
 
 
-class EngineErrorSecond(EngineReturn):
+class SubmitGoodResponse:
+    def json(self):
+        return {"job": {"job_id": "test_job"}, "response": {"status": "queued"}}
+
+
+class SubmitResultNoID:
     """A put mock class for testing error responses
-    This will return an error on the second put call"""
+    This will not return an id at the first call"""
+
+    def json(self):
+        return {"job": {}, "response": {"status": "queued"}}
+
+
+class SubmitResultNoStatus:
+    """A put mock class for testing error responses
+    This will not return an id at the first call"""
+
+    def json(self):
+        return {"job": {"job_id": "test_job"}, "response": {}}
 
-    def update(self, *args, **kwargs):
-        if self.counter >= 1:
-            self.test_dict['status'] = 'error'
-        return self
 
+class SubmitResultWithError:
+    """A put mock class for testing error responses
+    This will not return an id at the first call"""
+
+    def json(self):
+        return {"job": {"job_id": "test_job"}, "response": {"status": "error"}}
 
-def test_aqt_sampler_error_handling():
-    for e_return in [
-        EngineError(),
-        EngineErrorSecond(),
-        EngineNoStatus(),
-        EngineNoStatus2(),
-        EngineNoid(),
-    ]:
-        with mock.patch(
-            'cirq_aqt.aqt_sampler.put', return_value=e_return, side_effect=e_return.update
-        ) as _mock_method:
+
+def test_aqt_sampler_submit_job_error_handling():
+    for e_return in [SubmitResultNoID(), SubmitResultNoStatus(), SubmitResultWithError()]:
+        with (
+            mock.patch('cirq_aqt.aqt_sampler.post', return_value=e_return),
+            mock.patch('cirq_aqt.aqt_sampler.get', return_value=GetResultReturn()),
+        ):
             theta = sympy.Symbol('theta')
             num_points = 1
             max_angle = np.pi
             repetitions = 10
-            sampler = AQTSampler(remote_host="http://localhost:5000", access_token='testkey')
+            sampler = AQTSampler(access_token='testkey', workspace="default", resource="test")
             _, qubits = get_aqt_device(1)
-            circuit = cirq.Circuit(cirq.X(qubits[0]) ** theta)
+            circuit = cirq.Circuit(
+                cirq.PhasedXPowGate(exponent=theta, phase_exponent=0.0).on(qubits[0])
+            )
+            sweep = cirq.Linspace(key='theta', start=0.1, stop=max_angle / np.pi, length=num_points)
+            with pytest.raises(RuntimeError):
+                _results = sampler.run_sweep(circuit, params=sweep, repetitions=repetitions)
+
+
+def test_aqt_sampler_get_result_error_handling():
+    for e_return in [GetResultError(), GetResultErrorSecond(), GetResultNoStatus()]:
+        with (
+            mock.patch('cirq_aqt.aqt_sampler.post', return_value=SubmitGoodResponse()),
+            mock.patch(
+                'cirq_aqt.aqt_sampler.get', return_value=e_return, side_effect=e_return.update
+            ),
+        ):
+            theta = sympy.Symbol('theta')
+            num_points = 1
+            max_angle = np.pi
+            repetitions = 10
+            sampler = AQTSampler(access_token='testkey', workspace="default", resource="test")
+            _, qubits = get_aqt_device(1)
+            circuit = cirq.Circuit(
+                cirq.PhasedXPowGate(exponent=theta, phase_exponent=0.0).on(qubits[0])
+            )
             sweep = cirq.Linspace(key='theta', start=0.1, stop=max_angle / np.pi, length=num_points)
             with pytest.raises(RuntimeError):
                 _results = sampler.run_sweep(circuit, params=sweep, repetitions=repetitions)
@@ -127,28 +153,48 @@ def test_aqt_sampler_empty_circuit():
 
 
 def test_aqt_sampler():
-    put_call_args0 = {'access_token': 'testkey', 'id': '2131da'}
-
-    e_return = EngineReturn()
-    with mock.patch(
-        'cirq_aqt.aqt_sampler.put', return_value=e_return, side_effect=e_return.update
-    ) as mock_method:
+    class ResultReturn:
+        def __init__(self):
+            self.request_counter = 0
+            self.status = "queued"
+
+        def json(self):
+            return {"response": {"status": self.status, "result": {"0": [[1, 1], [0, 0]]}}}
+
+        def on_request(self, *args, **kwargs):
+            self.request_counter += 1
+            if self.request_counter >= 3:
+                self.status = "finished"
+            return self
+
+    result_return = ResultReturn()
+
+    with (
+        mock.patch('cirq_aqt.aqt_sampler.post', return_value=SubmitGoodResponse()) as submit_method,
+        mock.patch(
+            'cirq_aqt.aqt_sampler.get',
+            return_value=result_return,
+            side_effect=result_return.on_request,
+        ) as result_method,
+    ):
         theta = sympy.Symbol('theta')
         num_points = 1
         max_angle = np.pi
         repetitions = 10
-        sampler = AQTSampler(remote_host="http://localhost:5000", access_token='testkey')
+        sampler = AQTSampler(access_token='testkey', workspace="default", resource="test")
         _, qubits = get_aqt_device(1)
-        circuit = cirq.Circuit(cirq.X(qubits[0]) ** theta)
+        circuit = cirq.Circuit(
+            cirq.PhasedXPowGate(exponent=theta, phase_exponent=0.0).on(qubits[0])
+        )
         sweep = cirq.Linspace(key='theta', start=0.1, stop=max_angle / np.pi, length=num_points)
         results = sampler.run_sweep(circuit, params=sweep, repetitions=repetitions)
         excited_state_probs = np.zeros(num_points)
+
         for i in range(num_points):
             excited_state_probs[i] = np.mean(results[i].measurements['m'])
-    callargs = mock_method.call_args[1]['data']
-    for keys in put_call_args0:
-        assert callargs[keys] == put_call_args0[keys]
-    assert mock_method.call_count == 3
+
+    assert submit_method.call_count == 1
+    assert result_method.call_count == 3
 
 
 def test_aqt_sampler_sim():
@@ -161,13 +207,13 @@ def test_aqt_sampler_sim():
     sampler = AQTSamplerLocalSimulator()
     sampler.simulate_ideal = True
     circuit = cirq.Circuit(
-        cirq.X(qubits[3]) ** theta,
-        cirq.X(qubits[0]),
-        cirq.X(qubits[0]),
-        cirq.X(qubits[1]),
-        cirq.X(qubits[1]),
-        cirq.X(qubits[2]),
-        cirq.X(qubits[2]),
+        cirq.PhasedXPowGate(phase_exponent=0.0, exponent=theta).on(qubits[3]),
+        cirq.PhasedXPowGate(phase_exponent=0.0, exponent=1.0).on(qubits[0]),
+        cirq.PhasedXPowGate(phase_exponent=0.0, exponent=1.0).on(qubits[0]),
+        cirq.PhasedXPowGate(phase_exponent=0.0, exponent=1.0).on(qubits[1]),
+        cirq.PhasedXPowGate(phase_exponent=0.0, exponent=1.0).on(qubits[1]),
+        cirq.PhasedXPowGate(phase_exponent=0.0, exponent=1.0).on(qubits[2]),
+        cirq.PhasedXPowGate(phase_exponent=0.0, exponent=1.0).on(qubits[2]),
     )
     circuit.append(cirq.PhasedXPowGate(phase_exponent=0.5, exponent=-0.5).on(qubits[0]))
     circuit.append(cirq.PhasedXPowGate(phase_exponent=0.5, exponent=0.5).on(qubits[0]))
@@ -188,11 +234,13 @@ def test_aqt_sampler_sim_xtalk():
     sampler = AQTSamplerLocalSimulator()
     sampler.simulate_ideal = False
     circuit = cirq.Circuit(
-        cirq.X(qubits[0]),
-        cirq.X(qubits[1]),
-        cirq.X(qubits[1]),
-        cirq.X(qubits[3]),
-        cirq.X(qubits[2]),
+        cirq.PhasedXPowGate(phase_exponent=0.0, exponent=1.0).on(qubits[0]),
+        cirq.PhasedXPowGate(phase_exponent=0.0, exponent=1.0).on(qubits[1]),
+        cirq.PhasedXPowGate(phase_exponent=0.0, exponent=1.0).on(qubits[1]),
+        cirq.PhasedXPowGate(phase_exponent=0.0, exponent=1.0).on(qubits[3]),
+        cirq.PhasedXPowGate(phase_exponent=0.0, exponent=1.0).on(qubits[2]),
+        cirq.XX(qubits[0], qubits[1]) ** 0.5,
+        cirq.Z.on_each(*qubits),
     )
     sweep = cirq.Linspace(key='theta', start=0.1, stop=max_angle / np.pi, length=num_points)
     _results = sampler.run_sweep(circuit, params=sweep, repetitions=repetitions)
@@ -220,3 +268,190 @@ def test_aqt_device_wrong_op_str():
     for op in circuit.all_operations():
         with pytest.raises(ValueError):
             _result = get_op_string(op)
+
+
+def test_aqt_sampler_parses_legacy_json_correctly() -> None:
+    legacy_json = json.dumps(
+        [
+            ["R", 1.0, 0.0, [0]],
+            ["MS", 0.5, [0, 1]],
+            ["Z", -0.5, [0]],
+            ["R", 0.5, 1.0, [0]],
+            ["R", 0.5, 1.0, [1]],
+        ]
+    )
+
+    sampler = AQTSampler("default", "test", "testkey")
+    quantum_circuit = sampler._parse_legacy_circuit_json(legacy_json)
+
+    assert quantum_circuit == [
+        {"operation": "R", "phi": 0.0, "theta": 1.0, "qubit": 0},
+        {"operation": "RXX", "qubits": [0, 1], "theta": 0.5},
+        {"operation": "RZ", "qubit": 0, "phi": -0.5},
+        {"operation": "R", "qubit": 0, "theta": 0.5, "phi": 1.0},
+        {"operation": "R", "qubit": 1, "theta": 0.5, "phi": 1.0},
+        {"operation": "MEASURE"},
+    ]
+
+
+def test_aqt_sampler_submits_jobs_correctly() -> None:
+    legacy_json = json.dumps(
+        [
+            ["R", 1.0, 0.0, [0]],
+            ["MS", 0.5, [0, 1]],
+            ["Z", -0.5, [0]],
+            ["R", 0.5, 1.0, [0]],
+            ["R", 0.5, 1.0, [1]],
+        ]
+    )
+
+    result = [[1, 1], [0, 0]]
+
+    class ResultReturn:
+        def json(self):
+            return {"response": {"status": "finished", "result": {"0": result}}}
+
+    sampler = AQTSampler("default", "test", "testkey", "http://localhost:7777/api/v1/")
+
+    with (
+        mock.patch('cirq_aqt.aqt_sampler.post', return_value=SubmitGoodResponse()) as submit_method,
+        mock.patch('cirq_aqt.aqt_sampler.get', return_value=ResultReturn()) as result_method,
+    ):
+        measurements = sampler._send_json(
+            json_str=legacy_json, id_str="test", repetitions=2, num_qubits=2
+        )
+
+        assert submit_method.call_count == 1
+        assert submit_method.call_args[0][0] == "http://localhost:7777/api/v1/submit/default/test"
+
+        assert result_method.call_count == 1
+        assert result_method.call_args[0][0] == "http://localhost:7777/api/v1/result/test_job"
+
+        for i, rep in enumerate(measurements):
+            for j, sample in enumerate(rep):
+                assert sample == result[i][j]
+
+
+def test_measurement_not_at_end_is_not_allowed() -> None:
+    legacy_json = json.dumps([["R", 1.0, 0.0, [0]], ["Meas"], ["MS", 0.5, [0, 1]]])
+
+    sampler = AQTSampler("default", "dummy_resource", "test")
+    with pytest.raises(ValueError):
+        sampler._send_json(json_str=legacy_json, id_str="test")
+
+
+def test_multiple_measurements_are_not_allowed() -> None:
+    legacy_json = json.dumps([["R", 1.0, 0.0, [0]], ["Meas"], ["Meas"]])
+
+    sampler = AQTSampler("default", "dummy_resource", "test")
+    with pytest.raises(ValueError):
+        sampler._send_json(json_str=legacy_json, id_str="test")
+
+
+def test_unknown_gate_in_json() -> None:
+    legacy_json = json.dumps([["A", 1.0, 0.0, [0]], ["Meas"]])
+
+    sampler = AQTSampler("default", "dummy_resource", "test")
+    with pytest.raises(
+        ValueError, match=r"Got unknown gate on operation: \['A', 1\.0, 0\.0, \[0\]\]\."
+    ):
+        sampler._send_json(json_str=legacy_json, id_str="test")
+
+
+def test_aqt_sampler_raises_exception_on_bad_result_response() -> None:
+    legacy_json = json.dumps([["R", 1.0, 0.0, [0]]])
+
+    class ResultReturn:
+        def json(self):
+            return {"response": {"status": "finished"}}
+
+    sampler = AQTSampler("default", "test", "testkey", "http://localhost:7777/api/v1/")
+
+    with (
+        mock.patch('cirq_aqt.aqt_sampler.post', return_value=SubmitGoodResponse()),
+        mock.patch('cirq_aqt.aqt_sampler.get', return_value=ResultReturn()),
+        pytest.raises(RuntimeError),
+    ):
+        sampler._send_json(json_str=legacy_json, id_str="test", repetitions=2, num_qubits=2)
+
+
+def test_aqt_sampler_print_resources_shows_hint_if_no_workspaces() -> None:
+    output = []
+
+    def intercept(values):
+        output.append(str(values))
+
+    with mock.patch('cirq_aqt.aqt_sampler.AQTSampler.fetch_resources', return_value=[]):
+        AQTSampler.print_resources(access_token="test", emit=intercept)
+
+    assert output[0] == "No workspaces are accessible with this access token."
+
+
+def test_aqt_sampler_print_resources_shows_hint_if_no_resources() -> None:
+    output = []
+
+    def intercept(values):
+        output.append(str(values))
+
+    empty_workspace_list = [{"id": "test_ws", "resources": []}]
+
+    with mock.patch(
+        'cirq_aqt.aqt_sampler.AQTSampler.fetch_resources', return_value=empty_workspace_list
+    ):
+        AQTSampler.print_resources("test", emit=intercept)
+
+    assert output[0] == "No workspaces accessible with this access token contain resources."
+
+
+def test_aqt_sampler_print_resources_includes_received_resources_in_table() -> None:
+    output = []
+
+    def intercept(values):
+        output.append(str(values))
+
+    workspace_list = [
+        {"id": "test_ws", "resources": [{"id": "resource", "name": "Resource", "type": "device"}]}
+    ]
+
+    with mock.patch('cirq_aqt.aqt_sampler.AQTSampler.fetch_resources', return_value=workspace_list):
+        AQTSampler.print_resources("test", emit=intercept)
+
+    assert any("test_ws" in o and "resource" in o and "Resource" in o and "D" in o for o in output)
+
+
+def test_aqt_sampler_fetch_resources_raises_exception_if_non_200_status_code() -> None:
+    class ResourceResponse:
+        def __init__(self):
+            self.status_code = 403
+
+        def json(self):
+            return "error"
+
+    sampler = AQTSampler("default", "test", "testkey", "http://localhost:7777/api/v1/")
+
+    with (
+        mock.patch('cirq_aqt.aqt_sampler.get', return_value=ResourceResponse()),
+        pytest.raises(RuntimeError),
+    ):
+        sampler.fetch_resources("token")
+
+
+def test_aqt_sampler_fetch_resources_returns_retrieved_resources() -> None:
+    class ResourceResponse:
+        def __init__(self):
+            self.status_code = 200
+
+        def json(self):
+            return [
+                {"id": "wid", "resources": [{"id": "rid", "name": "Resource", "type": "device"}]}
+            ]
+
+    sampler = AQTSampler("default", "test", "testkey", "http://localhost:7777/api/v1/")
+
+    with mock.patch('cirq_aqt.aqt_sampler.get', return_value=ResourceResponse()):
+        workspaces = sampler.fetch_resources("token")
+
+    assert workspaces[0]["id"] == "wid"
+    assert workspaces[0]["resources"][0]["id"] == "rid"
+    assert workspaces[0]["resources"][0]["name"] == "Resource"
+    assert workspaces[0]["resources"][0]["type"] == "device"

cirq_aqt/aqt_simulator_test.py

@@ -44,21 +44,3 @@ def test_ms_crosstalk_n_noise():
         (cirq.XX**0.015).on(cirq.LineQubit(2), cirq.LineQubit(0)),
         (cirq.XX**0.015).on(cirq.LineQubit(2), cirq.LineQubit(3)),
     ]
-
-
-def test_x_crosstalk_n_noise():
-    num_qubits = 4
-    noise_mod = AQTNoiseModel()
-    _, qubits = get_aqt_device(num_qubits)
-    circuit = cirq.Circuit()
-    circuit.append(cirq.Y(qubits[1]) ** 0.5)
-    circuit.append(cirq.Z(qubits[1]) ** 0.5)
-    circuit.append(cirq.X(qubits[1]) ** 0.5)
-    for moment in circuit.moments:
-        noisy_moment = noise_mod.noisy_moment(moment, qubits)
-    assert noisy_moment == [
-        (cirq.X**0.5).on(cirq.LineQubit(1)),
-        cirq.depolarize(p=0.001).on(cirq.LineQubit(1)),
-        (cirq.X**0.015).on(cirq.LineQubit(0)),
-        (cirq.X**0.015).on(cirq.LineQubit(2)),
-    ]

cirq_aqt/aqt_target_gateset.py

@@ -30,8 +30,7 @@ class AQTTargetGateset(cirq.TwoQubitCompilationTargetGateset):
     gates to the following universal target gateset:
 
     - `cirq.XXPowGate`: The two qubit entangling gate.
-    - `cirq.XPowGate`, `cirq.YPowGate`, `cirq.ZPowGate`,
-      `cirq.PhasedXPowGate`: Single qubit rotations.
+    - `cirq.ZPowGate`, `cirq.PhasedXPowGate`: Single qubit rotations.
     - `cirq.MeasurementGate`: Measurements.
     """
 
@@ -39,8 +38,6 @@ class AQTTargetGateset(cirq.TwoQubitCompilationTargetGateset):
         super().__init__(
             cirq.XXPowGate,
             cirq.MeasurementGate,
-            cirq.XPowGate,
-            cirq.YPowGate,
             cirq.ZPowGate,
             cirq.PhasedXPowGate,
             unroll_circuit_op=False,

cirq_aqt/aqt_target_gateset_test.py

@@ -31,8 +31,8 @@ Q, Q2, Q3, Q4 = cirq.LineQubit.range(4)
         (cirq.HPowGate(exponent=0.5)(Q), False),
         (cirq.XX(Q, Q2), True),
         (cirq.measure(Q), True),
-        (cirq.XPowGate(exponent=0.5)(Q), True),
-        (cirq.YPowGate(exponent=0.25)(Q), True),
+        (cirq.XPowGate(exponent=0.5)(Q), False),
+        (cirq.YPowGate(exponent=0.25)(Q), False),
         (cirq.ZPowGate(exponent=0.125)(Q), True),
         (cirq.PhasedXPowGate(exponent=0.25, phase_exponent=0.125)(Q), True),
         (cirq.CZPowGate(exponent=0.5)(Q, Q2), False),

{cirq_aqt-1.4.0.dev20240415214855.dist-info → cirq_aqt-1.4.0.dev20240419073809.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cirq-aqt
-Version: 1.4.0.dev20240415214855
+Version: 1.4.0.dev20240419073809
 Summary: A Cirq package to simulate and connect to Alpine Quantum Technologies quantum computers
 Home-page: http://github.com/quantumlib/cirq
 Author: The Cirq Developers
@@ -9,7 +9,7 @@ License: Apache 2
 Requires-Python: >=3.9.0
 License-File: LICENSE
 Requires-Dist: requests ~=2.18
-Requires-Dist: cirq-core ==1.4.0.dev20240415214855
+Requires-Dist: cirq-core ==1.4.0.dev20240419073809
 
 **This is a development version of Cirq-AQT and may be unstable.**
 

cirq_aqt-1.4.0.dev20240419073809.dist-info/RECORD

@@ -0,0 +1,21 @@
+cirq_aqt/__init__.py,sha256=2uufR12R3crUqeeDqMrA3rvsPqZuSNYysVLVvdpQzFk,803
+cirq_aqt/_version.py,sha256=VLMyoKgtktjsOU359gwigM2OxEruVVvbeMGm1irygRs,40
+cirq_aqt/_version_test.py,sha256=b1Lhv0twYyu-3pKzJygENb3Uy57KwZXQoctswTiRJSg,141
+cirq_aqt/aqt_device.py,sha256=48OblqJDD0R7xuwRHxHMcP3yxeTbGc5gSfWHZM9LE0Y,13654
+cirq_aqt/aqt_device_metadata.py,sha256=vdYGf3gdZNJEIttlYNutdXGh9qz-93vNzLrail6ujYc,4779
+cirq_aqt/aqt_device_metadata_test.py,sha256=naTXEU4VCCdR__gBlzbWjR0-DzViZ1xgVrH_GAyjskY,2111
+cirq_aqt/aqt_device_test.py,sha256=eYHT1DIt3EI_4e-rSROiUw5_E4A9Bjt8tIchvUrKnxs,5210
+cirq_aqt/aqt_sampler.py,sha256=GKkbF1iEuseDui9fDR6stJSrwQcssX4DTTeUhzFdezg,18379
+cirq_aqt/aqt_sampler_test.py,sha256=EspGPtmOs6WJUEOZEjCGcbUANawPyOWAFL3ozsFiu7Y,16402
+cirq_aqt/aqt_simulator_test.py,sha256=LSRyNSnme3A1l5eyDC79MzJLKZNoKa3LdsN_NoKMPTE,1673
+cirq_aqt/aqt_target_gateset.py,sha256=1hvaHH5zSz292qgMxE7MQJxngytpUAH2nEj5Ob9e8CI,2779
+cirq_aqt/aqt_target_gateset_test.py,sha256=wILzfJ3uWTzs-9R93I_qReZoWER-TaBhVr1lG3zl1WU,3336
+cirq_aqt/conftest.py,sha256=2-K0ZniZ28adwVNB-f5IqvYjavKEBwC4jes_WQ17Xzg,667
+cirq_aqt/json_resolver_cache.py,sha256=oZUTckLvATBDSrn-Y6kEAjHjiGXtKc-Bz_i23WsxFj8,788
+cirq_aqt/json_test_data/__init__.py,sha256=K0c9IduIrV7xvSXoc0yJVz5T-ITed3VKlssTN8XYq9w,892
+cirq_aqt/json_test_data/spec.py,sha256=RMp340PqpXN2iFQClZzTcXrKDVMKa_OLcXQ8qn2mPsw,1051
+cirq_aqt-1.4.0.dev20240419073809.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
+cirq_aqt-1.4.0.dev20240419073809.dist-info/METADATA,sha256=waZ2q8mAIG3NIYIIoifxfHyLzhBLyerAL0qg_S_krJs,1789
+cirq_aqt-1.4.0.dev20240419073809.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+cirq_aqt-1.4.0.dev20240419073809.dist-info/top_level.txt,sha256=culYyFTEtuC3Z7wT3wZ6kGVspH3hYFZUEKooByfe9h0,9
+cirq_aqt-1.4.0.dev20240419073809.dist-info/RECORD,,

cirq_aqt-1.4.0.dev20240415214855.dist-info/RECORD

@@ -1,21 +0,0 @@
-cirq_aqt/__init__.py,sha256=2uufR12R3crUqeeDqMrA3rvsPqZuSNYysVLVvdpQzFk,803
-cirq_aqt/_version.py,sha256=iiKeRvFg2OmKbbnJRlID0KjT_MhK9l6wa0R7fi7oTtY,40
-cirq_aqt/_version_test.py,sha256=b1Lhv0twYyu-3pKzJygENb3Uy57KwZXQoctswTiRJSg,141
-cirq_aqt/aqt_device.py,sha256=RIjNlZzB4cZkNKHytKRe-HHT2y85Fwtbr51fiD5AguY,13327
-cirq_aqt/aqt_device_metadata.py,sha256=l8TtJtbxe1g99lygxVg5Njrn_mvnhxlvi0eZaptuuQI,4921
-cirq_aqt/aqt_device_metadata_test.py,sha256=CJ7XAvvogUSJPfduq5GDZp9t-nZaIZGaRqRexeUmHlg,2111
-cirq_aqt/aqt_device_test.py,sha256=eYHT1DIt3EI_4e-rSROiUw5_E4A9Bjt8tIchvUrKnxs,5210
-cirq_aqt/aqt_sampler.py,sha256=9Iuam2RXcWW0uHha0eZETotJdiIrnC1gx9oNwUEPzfw,9738
-cirq_aqt/aqt_sampler_test.py,sha256=0pYnqZikTySM1Yjr1IWoryGlIa_H54Dhq1e19poaaOg,7446
-cirq_aqt/aqt_simulator_test.py,sha256=ZRW04CtQduqYfoEsxEKNa04CdTAr987xMhck-KGUIm0,2292
-cirq_aqt/aqt_target_gateset.py,sha256=2HjfnCgJ2MaKITjvXqpej7Y2DVQEm7n7RAklanUKDWo,2873
-cirq_aqt/aqt_target_gateset_test.py,sha256=dnwyv74JmnU3G0OX9-RS-KuEyxTmx9JQ9SbHS1pBmRE,3334
-cirq_aqt/conftest.py,sha256=2-K0ZniZ28adwVNB-f5IqvYjavKEBwC4jes_WQ17Xzg,667
-cirq_aqt/json_resolver_cache.py,sha256=oZUTckLvATBDSrn-Y6kEAjHjiGXtKc-Bz_i23WsxFj8,788
-cirq_aqt/json_test_data/__init__.py,sha256=K0c9IduIrV7xvSXoc0yJVz5T-ITed3VKlssTN8XYq9w,892
-cirq_aqt/json_test_data/spec.py,sha256=RMp340PqpXN2iFQClZzTcXrKDVMKa_OLcXQ8qn2mPsw,1051
-cirq_aqt-1.4.0.dev20240415214855.dist-info/LICENSE,sha256=tAkwu8-AdEyGxGoSvJ2gVmQdcicWw3j1ZZueVV74M-E,11357
-cirq_aqt-1.4.0.dev20240415214855.dist-info/METADATA,sha256=mTLxM84c2q1OcYhipAHKnl_E6IaaE1B78fPJE53QfIE,1789
-cirq_aqt-1.4.0.dev20240415214855.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-cirq_aqt-1.4.0.dev20240415214855.dist-info/top_level.txt,sha256=culYyFTEtuC3Z7wT3wZ6kGVspH3hYFZUEKooByfe9h0,9
-cirq_aqt-1.4.0.dev20240415214855.dist-info/RECORD,,