Merge pull request #28 from ColibrITD-SAS/feat-capture-braket-hardprint

capture and handle hard print warnings from Braket

Author: Henri-ColibrITD

mpqp/execution/result.py

@@ -1,19 +1,3 @@
-######################################
-# Copyright(C) 2021 - 2023 ColibrITD
-#
-# Developers :
-#  - Hamza JAFFALI < hamza.jaffali@colibritd.com >
-#  - Karla BAUMANN < karla.baumann@colibritd.com >
-#  - Henri de BOUTRAY < henri.de.boutray@colibritd.com >
-#
-# Version : 0.1
-#
-# This file is part of QUICK.
-#
-# QUICK can not be copied and / or distributed without the express
-# permission of ColibrITD
-#
-######################################
 from __future__ import annotations
 
 import math

mpqp/qasm/qasm_to_braket.py

@@ -1,5 +1,9 @@
 """File regrouping all features for translating QASM code to Amazon Braket objects."""
 
+import io
+import warnings
+from logging import StreamHandler, getLogger
+
 from braket.ir.openqasm import Program
 from braket.circuits import Circuit
 from typeguard import typechecked
@@ -30,16 +34,14 @@ def qasm3_to_braket_Program(qasm3_str: str) -> Program:
 
 @typechecked
 def qasm3_to_braket_Circuit(qasm3_str: str) -> Circuit:
-    """
-    Converting a OpenQASM 3.0 code into a Braket Circuit
+    """Converting a OpenQASM 3.0 code into a Braket Circuit.
 
     Args:
         qasm3_str: A string representing the OpenQASM 3.0 code.
 
     Returns:
         A Circuit equivalent to the QASM code in parameter.
     """
-
     # PROBLEM: import and standard gates are not supported by Braket
     # NOTE: however custom OpenQASM 3 gates declaration is supported by Braket,
     # SOLUTION: the idea is then to hard import the standard lib and other files into the qasm string's header before
@@ -49,12 +51,30 @@ def qasm3_to_braket_Circuit(qasm3_str: str) -> Circuit:
     # SOLUTION: import a specific qasm file with U and gphase redefined with the supported Braket SDK gates, and by
     # removing from this import file the already handled gates
 
-    # we remove any include of stdgates.inc and replace it with custom include
     qasm3_str = qasm3_str.replace("stdgates.inc", "braket_custom_include.inc")
 
     after_stdgates_included = open_qasm_hard_includes(qasm3_str, set())
-    # NOTE : gphase is a already used in Braket and thus cannot be redefined as a native gate in OpenQASM.
-    # We used ggphase instead
+
+    braket_warning_message = (
+        "This program uses OpenQASM language features that may not be supported"
+        " on QPUs or on-demand simulators."
+    )
+
+    braket_logger = getLogger()
+    logger_output_stream = io.StringIO()
+    stream_handler = StreamHandler(logger_output_stream)
+    braket_logger.addHandler(stream_handler)
 
     circuit = Circuit.from_ir(after_stdgates_included)
+
+    braket_logger.removeHandler(stream_handler)
+    log_lines = logger_output_stream.getvalue().split("\n")
+    for message in log_lines:
+        if message == braket_warning_message:
+            warnings.warn(
+                "\n" + braket_warning_message, UnsupportedBraketFeaturesWarning
+            )
+        else:
+            braket_logger.warning(message)
+
     return circuit

pyproject.toml

@@ -5,4 +5,11 @@ build-backend = "setuptools.build_meta"
 
 [tool.setuptools_scm]
 version_scheme = "post-release"
-local_scheme = "no-local-version"
+local_scheme = "no-local-version"
+
+[tool.isort]
+multi_line_output = 3
+include_trailing_comma = true
+force_grid_wrap = 0
+line_length = 88
+profile = "black"

tests/example/test_demonstrations.py

@@ -1,13 +1,25 @@
+from typing import Any, Callable
+
+import numpy as np
 import pytest
+from braket.devices import LocalSimulator
+
 from mpqp import QCircuit
-from mpqp.core.instruction.measurement import Observable, ExpectationMeasure
-from mpqp.execution.devices import AWSDevice, ATOSDevice, IBMDevice
+from mpqp.core.instruction.measurement import ExpectationMeasure, Observable
+from mpqp.execution import run
+from mpqp.execution.devices import ATOSDevice, AvailableDevice, AWSDevice, IBMDevice
 from mpqp.gates import *
 from mpqp.measures import BasisMeasure
-from mpqp.execution import run
-from braket.devices import LocalSimulator
-import numpy as np
 from mpqp.qasm.qasm_to_braket import qasm3_to_braket_Circuit
+from mpqp.tools.errors import UnsupportedBraketFeaturesWarning
+
+
+def warn_guard(device: AvailableDevice, run: Callable[[], Any]):
+    if isinstance(device, AWSDevice):
+        with pytest.warns(UnsupportedBraketFeaturesWarning):
+            return run()
+    else:
+        return run()
 
 
 def test_sample_demo():
@@ -34,7 +46,7 @@ def test_sample_demo():
     circuit.add(BasisMeasure([0, 1, 2, 3], shots=2000))
 
     # Run the circuit on a selected device
-    run(
+    runner = lambda: run(
         circuit,
         [
             IBMDevice.AER_SIMULATOR,
@@ -44,6 +56,8 @@ def test_sample_demo():
         ],
     )
 
+    warn_guard(AWSDevice.BRAKET_LOCAL_SIMULATOR, runner)
+
     assert True
 
 
@@ -68,7 +82,7 @@ def test_statevector_demo():
     circuit.add(Rz(3.14, 0))
 
     # when no measure in the circuit, must run in statevector mode
-    run(
+    runner = lambda: run(
         circuit,
         [
             IBMDevice.AER_SIMULATOR_STATEVECTOR,
@@ -78,11 +92,13 @@ def test_statevector_demo():
         ],
     )
 
+    warn_guard(AWSDevice.BRAKET_LOCAL_SIMULATOR, runner)
+
     # same when we add a BasisMeasure with 0 shots
     circuit.add(BasisMeasure([0, 1, 2, 3], shots=0))
 
     # Run the circuit on a selected device
-    run(
+    runner = lambda: run(
         circuit,
         [
             IBMDevice.AER_SIMULATOR_STATEVECTOR,
@@ -92,6 +108,8 @@ def test_statevector_demo():
         ],
     )
 
+    warn_guard(AWSDevice.BRAKET_LOCAL_SIMULATOR, runner)
+
     assert True
 
 
@@ -121,7 +139,7 @@ def test_observable_demo():
     assert True
 
 
-def test_aws_executions():
+def test_aws_qasm_executions():
     device = LocalSimulator()
 
     qasm_str = """OPENQASM 3.0;
@@ -133,11 +151,12 @@ def test_aws_executions():
     c[0] = measure q[0];
     c[1] = measure q[1];"""
 
-    circuit = qasm3_to_braket_Circuit(qasm_str)
-
+    runner = lambda: qasm3_to_braket_Circuit(qasm_str)
+    circuit = warn_guard(AWSDevice.BRAKET_LOCAL_SIMULATOR, runner)
     device.run(circuit, shots=100).result()
 
-    #####################################################
+
+def test_aws_mpqp_executions():
 
     # Declaration of the circuit with the right size
     circuit = QCircuit(4)
@@ -161,7 +180,9 @@ def test_aws_executions():
     # Add measurement
     circuit.add(BasisMeasure([0, 1, 2, 3], shots=2000))
 
-    run(circuit, AWSDevice.BRAKET_LOCAL_SIMULATOR)
+    runner = lambda: run(circuit, AWSDevice.BRAKET_LOCAL_SIMULATOR)
+
+    warn_guard(AWSDevice.BRAKET_LOCAL_SIMULATOR, runner)
 
     #####################################################
 
@@ -185,7 +206,10 @@ def test_aws_executions():
     circuit.add(ExpectationMeasure([0, 1], observable=obs, shots=0))
 
     # Running the computation on myQLM and on Braket simulator, then retrieving the results
-    run(circuit, [AWSDevice.BRAKET_LOCAL_SIMULATOR, ATOSDevice.MYQLM_PYLINALG])
+    runner = lambda: run(
+        circuit, [AWSDevice.BRAKET_LOCAL_SIMULATOR, ATOSDevice.MYQLM_PYLINALG]
+    )
+    warn_guard(AWSDevice.BRAKET_LOCAL_SIMULATOR, runner)
 
     #####################################################
 
@@ -195,7 +219,10 @@ def test_aws_executions():
     )
 
     # Running the computation on myQLM and on Aer simulator, then retrieving the results
-    run(circuit, [AWSDevice.BRAKET_LOCAL_SIMULATOR, ATOSDevice.MYQLM_PYLINALG])
+    runner = lambda: run(
+        circuit, [AWSDevice.BRAKET_LOCAL_SIMULATOR, ATOSDevice.MYQLM_PYLINALG]
+    )
+    warn_guard(AWSDevice.BRAKET_LOCAL_SIMULATOR, runner)
 
 
 def test_all_native_gates():

tests/execution/test_vqa.py

@@ -1,4 +1,5 @@
 from typing import Any
+
 import numpy as np
 import pytest
 from sympy import Expr
@@ -8,11 +9,12 @@
     ExpectationMeasure,
     Observable,
 )
-from mpqp.gates import *
-from mpqp.execution.devices import AWSDevice, AvailableDevice, IBMDevice, ATOSDevice
-from mpqp.execution.vqa import minimize, Optimizer
-from mpqp.execution.vqa.vqa import OptimizableFunc
+from mpqp.execution.devices import ATOSDevice, AvailableDevice, AWSDevice, IBMDevice
 from mpqp.execution.runner import _run_single  # pyright: ignore[reportPrivateUsage]
+from mpqp.execution.vqa import Optimizer, minimize
+from mpqp.execution.vqa.vqa import OptimizableFunc
+from mpqp.gates import *
+from mpqp.tools.errors import UnsupportedBraketFeaturesWarning
 
 # the symbols function is a bit wacky, so some manual type definition is needed here
 theta: Expr = symbols("θ")  # type: ignore
@@ -41,8 +43,15 @@ def with_local_devices(args: tuple[Any, ...]):
     ),
 )
 def test_optimizer_circuit(circ: QCircuit, minimum: float, device: AvailableDevice):
-    try:
+    def run():
         assert minimize(circ, Optimizer.BFGS, device)[0] - minimum < 0.05
+
+    try:
+        if isinstance(device, AWSDevice):
+            with pytest.warns(UnsupportedBraketFeaturesWarning):
+                run()
+        else:
+            run()
     except (ValueError, NotImplementedError) as err:
         if "not handled" not in str(err):
             raise

tests/qasm/test_qasm_to_braket.py

@@ -1,8 +1,9 @@
-from braket.circuits import Operator, Circuit
-from braket.circuits.gates import H, CNot
 import pytest
+from braket.circuits import Circuit, Operator
+from braket.circuits.gates import CNot, H
 
 from mpqp.qasm.qasm_to_braket import qasm3_to_braket_Circuit
+from mpqp.tools.errors import UnsupportedBraketFeaturesWarning
 
 
 @pytest.mark.parametrize(
@@ -12,6 +13,19 @@
             """OPENQASM 3.0;""",
             [],
         ),
+    ],
+)
+def test_qasm3_to_braket_Circuit(qasm_code: str, braket_operators: list[Operator]):
+    circ = qasm3_to_braket_Circuit(qasm_code)
+
+    assert isinstance(circ, Circuit)
+    for circ_instr, expected_operator in zip(circ.instructions, braket_operators):
+        assert circ_instr.operator == expected_operator
+
+
+@pytest.mark.parametrize(
+    "qasm_code, braket_operators",
+    [
         (
             """OPENQASM 3.0;
             include 'stdgates.inc';
@@ -27,8 +41,16 @@
         ),
     ],
 )
-def test_qasm3_to_braket_Circuit(qasm_code: str, braket_operators: list[Operator]):
-    circ = qasm3_to_braket_Circuit(qasm_code)
+def test_qasm3_to_braket_Circuit_warning(
+    qasm_code: str, braket_operators: list[Operator]
+):
+    warning = (
+        "This program uses OpenQASM language features that may not be supported"
+        " on QPUs or on-demand simulators."
+    )
+    with pytest.warns(UnsupportedBraketFeaturesWarning, match=warning):
+        circ = qasm3_to_braket_Circuit(qasm_code)
+
     assert isinstance(circ, Circuit)
     for circ_instr, expected_operator in zip(circ.instructions, braket_operators):
         assert circ_instr.operator == expected_operator