Merge branch 'main' into generic

Author: AbeCoull

CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## v1.102.9 (2025-10-14)
+
+### Bug Fixes and Other Changes
+
+ * local job decorator integ test
+ * entry point module name for py312 and up
+
+## v1.102.8 (2025-10-13)
+
+### Bug Fixes and Other Changes
+
+ * Allow `Measure` instructions in `to_unitary`
+ * handle executable result with no input in its program
+
+## v1.102.7 (2025-10-13)
+
+### Bug Fixes and Other Changes
+
+ * Always include program inputs in from_ir
+
 ## v1.102.6 (2025-10-09)
 
 ### Bug Fixes and Other Changes

src/braket/_sdk/_version.py

@@ -15,4 +15,4 @@
 Version number (major.minor.patch[-label])
 """
 
-__version__ = "1.102.7.dev0"
+__version__ = "1.102.10.dev0"

src/braket/circuits/unitary_calculation.py

@@ -14,12 +14,13 @@
 from collections.abc import Iterable
 
 import numpy as np
-from braket.default_simulator.linalg_utils import multiply_matrix
+from braket.default_simulator.linalg_utils import controlled_matrix, multiply_matrix
 from scipy.linalg import fractional_matrix_power
 
 from braket.circuits.compiler_directive import CompilerDirective
 from braket.circuits.gate import Gate
 from braket.circuits.instruction import Instruction
+from braket.circuits.measure import Measure
 from braket.registers.qubit_set import QubitSet
 
 
@@ -56,25 +57,25 @@ def calculate_unitary_big_endian(
     unitary = np.eye(rank, dtype=complex).reshape([2] * 2 * qubit_count)
 
     for instruction in instructions:
-        if isinstance(instruction.operator, CompilerDirective):
+        if isinstance(instruction.operator, (CompilerDirective, Measure)):
             continue
         if not isinstance(instruction.operator, Gate):
             raise TypeError("Only Gate operators are supported to build the unitary")
 
         base_gate_matrix = instruction.operator.to_matrix()
-        if int(instruction.power) == instruction.power:
-            gate_matrix = np.linalg.matrix_power(base_gate_matrix, int(instruction.power))
-        else:
-            gate_matrix = fractional_matrix_power(base_gate_matrix, instruction.power)
 
-        gate_matrix = np.asarray(gate_matrix, dtype=complex)
+        gate_matrix = (
+            np.linalg.matrix_power(base_gate_matrix, int(instruction.power))
+            if int(instruction.power) == instruction.power
+            else fractional_matrix_power(base_gate_matrix, instruction.power)
+        )
+        target = tuple(index_substitutions[qubit] for qubit in instruction.target)
+        control = tuple(index_substitutions[qubit] for qubit in instruction.control)
 
         unitary = multiply_matrix(
             unitary,
-            gate_matrix,
-            tuple(index_substitutions[qubit] for qubit in instruction.target),
-            controls=instruction.control,
-            control_state=instruction.control_state,
+            controlled_matrix(np.asarray(gate_matrix, dtype=complex), instruction.control_state),
+            control + target,
         )
 
     return unitary.reshape(rank, rank)

src/braket/experimental_capabilities/experimental_capability_context.py

@@ -14,6 +14,7 @@
 from __future__ import annotations
 
 import types
+import warnings
 
 
 class ExperimentalCapabilityContextError(Exception):
@@ -83,6 +84,18 @@ def __enter__(self) -> None:
         """
         GLOBAL_EXPERIMENTAL_CAPABILITY_CONTEXT.enable()
 
+        warnings.warn(
+            (
+                "You are enabling experimental capabilities. To view descriptions and "
+                "restrictions of experimental capabilities, please review Amazon Braket "
+                "Developer Guide ("
+                "https://docs.aws.amazon.com/braket/latest/developerguide/braket-experimental-capabilities.html"
+                ")."
+            ),
+            category=UserWarning,
+            stacklevel=1,
+        )
+
     def __exit__(
         self,
         exc_type: type[BaseException] | None,

src/braket/jobs/hybrid_job.py

@@ -218,7 +218,7 @@ def job_wrapper(*args: Any, **kwargs: Any) -> Callable:
                     "device": device or "local:none/none",
                     "source_module": temp_dir,
                     "entry_point": (
-                        f"{temp_dir}.{entry_point_file_path.stem}:{entry_point.__name__}"
+                        f"{temp_dir_path.name}.{entry_point_file_path.stem}:{entry_point.__name__}"
                     ),
                     "wait_until_complete": wait_until_complete,
                     "job_name": job_name or _generate_default_job_name(func=entry_point),

src/braket/tasks/program_set_quantum_task_result.py

@@ -299,7 +299,11 @@ def _dispatch_executable_result(
                 result,
                 program=program.source,
                 shots=shots_per_executable,
-                inputs={k: v[result.inputsIndex] for k, v in program.inputs.items()},
+                inputs=(
+                    {k: v[result.inputsIndex] for k, v in program.inputs.items()}
+                    if program.inputs is not None
+                    else None
+                ),
                 observable=(
                     observables[result.inputsIndex % len(observables)] if observables else None
                 ),

test/integ_tests/test_create_local_quantum_job.py

@@ -14,11 +14,13 @@
 import json
 import os
 import re
+import subprocess
 import tempfile
 from pathlib import Path
 
 import pytest
 
+from braket.jobs import hybrid_job
 from braket.jobs.local import LocalQuantumJob
 
 
@@ -152,3 +154,14 @@ def test_failed_local_job(aws_session, capsys):
                 assert data in log_data
         finally:
             os.chdir(current_dir)
+
+
+def test_decorator_local_job_invalid_image():
+    @hybrid_job(device=None, image_uri="fake", local=True)
+    def empty_decorator_job():
+        pass
+
+    with pytest.raises(ValueError, match="specify a valid ECR URL"):
+        # Should successfully get all the way to LocalQuantumJob.create,
+        # but image pull or docker call will fail due to invalid image URI.
+        empty_decorator_job()

test/integ_tests/test_reservation_arn.py

@@ -61,17 +61,18 @@ def test_create_task_via_reservation_arn_on_simulator(reservation_arn):
     reason="Python version mismatch",
 )
 def test_create_job_with_decorator_via_invalid_reservation_arn(reservation_arn):
-    with pytest.raises(ClientError, match="Reservation arn is invalid"):
-
-        @hybrid_job(
-            device=Devices.IQM.Garnet,
-            reservation_arn=reservation_arn,
-        )
-        def hello_job():
-            device = AwsDevice(get_job_device_arn())
-            bell = Circuit().h(0).cnot(0, 1)
-            task = device.run(bell, shots=10)
-            measurements = task.result().measurements
-            return measurements
-
-        hello_job()
+    if AwsDevice(Devices.IQM.Garnet).status == "ONLINE":
+        with pytest.raises(ClientError, match="Reservation arn is invalid"):
+
+            @hybrid_job(
+                device=Devices.IQM.Garnet,
+                reservation_arn=reservation_arn,
+            )
+            def hello_job():
+                device = AwsDevice(get_job_device_arn())
+                bell = Circuit().h(0).cnot(0, 1)
+                task = device.run(bell, shots=10)
+                measurements = task.result().measurements
+                return measurements
+
+            hello_job()

test/unit_tests/braket/circuits/test_circuit.py

@@ -2482,6 +2482,7 @@ def test_to_unitary_with_global_phase():
         (Circuit().h(0).add_result_type(ResultType.Probability(target=[0])), gates.H().to_matrix()),
         (Circuit().h(1), gates.H().to_matrix()),
         (Circuit().h(2), gates.H().to_matrix()),
+        (Circuit().h(2).measure(2), gates.H().to_matrix()),
         (Circuit().x(0), gates.X().to_matrix()),
         (Circuit().y(0), gates.Y().to_matrix()),
         (Circuit().z(0), gates.Z().to_matrix()),
@@ -2500,6 +2501,7 @@ def test_to_unitary_with_global_phase():
         (Circuit().cnot(0, 1), gates.CNot().to_matrix()),
         (Circuit().cnot(0, 1).add_result_type(ResultType.StateVector()), gates.CNot().to_matrix()),
         (Circuit().cnot(2, 4), gates.CNot().to_matrix()),
+        (Circuit().cnot(2, 4).measure([2, 4]), gates.CNot().to_matrix()),
         (Circuit().swap(0, 1), gates.Swap().to_matrix()),
         (Circuit().swap(1, 0), gates.Swap().to_matrix()),
         (Circuit().iswap(0, 1), gates.ISwap().to_matrix()),
@@ -2592,7 +2594,7 @@ def test_to_unitary_with_global_phase():
             ),
         ),
         (
-            Circuit().x(0, control=1),
+            Circuit().x(3, control=7),
             np.array(
                 [
                     [1.0, 0.0, 0.0, 0.0],
@@ -2628,7 +2630,7 @@ def test_to_unitary_with_global_phase():
             ),
         ),
         (
-            Circuit().ccnot(1, 2, 0),
+            Circuit().ccnot(3, 6, 1),
             np.array(
                 [
                     [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
@@ -2644,7 +2646,7 @@ def test_to_unitary_with_global_phase():
             ),
         ),
         (
-            Circuit().ccnot(2, 1, 0),
+            Circuit().ccnot(6, 3, 1),
             np.array(
                 [
                     [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
@@ -2660,7 +2662,7 @@ def test_to_unitary_with_global_phase():
             ),
         ),
         (
-            Circuit().ccnot(0, 2, 1),
+            Circuit().ccnot(1, 6, 3),
             np.array(
                 [
                     [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
@@ -2676,7 +2678,7 @@ def test_to_unitary_with_global_phase():
             ),
         ),
         (
-            Circuit().ccnot(2, 0, 1),
+            Circuit().ccnot(6, 1, 3),
             np.array(
                 [
                     [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
@@ -2691,6 +2693,102 @@ def test_to_unitary_with_global_phase():
                 dtype=complex,
             ),
         ),
+        (
+            Circuit().cnot([1, 6], 3),
+            np.array(
+                [
+                    [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
+                ],
+                dtype=complex,
+            ),
+        ),
+        (
+            Circuit().cnot([6, 1], 3),
+            np.array(
+                [
+                    [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
+                ],
+                dtype=complex,
+            ),
+        ),
+        (
+            Circuit().x(3, control=[6, 1]),
+            np.array(
+                [
+                    [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
+                ],
+                dtype=complex,
+            ),
+        ),
+        (
+            Circuit().x(3, control=[1, 6]),
+            np.array(
+                [
+                    [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
+                ],
+                dtype=complex,
+            ),
+        ),
+        (
+            Circuit().i(3).cnot(6, 1),
+            np.array(
+                [
+                    [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
+                    [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
+                    [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],
+                    [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
+                    [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
+                ],
+                dtype=complex,
+            ),
+        ),
+        (
+            Circuit().i(3).x(1, control=[6]),
+            np.array(
+                [
+                    [1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0],
+                    [0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0],
+                    [0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0],
+                    [0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+                    [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0],
+                    [0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0],
+                ],
+                dtype=complex,
+            ),
+        ),
         (
             Circuit().s(0).v(1).cnot(0, 1).cnot(2, 1),
             np.dot(

test/unit_tests/braket/tasks/test_program_set_quantum_task_result.py

@@ -423,3 +423,17 @@ def test_results_missing(metadata, execution_results_missing, program):
         ProgramSetQuantumTaskResult.from_object(
             BraketSchemaBase.parse_raw_schema(json.dumps(result))
         )
+
+
+def test_dispatch_executable_result_with_none_inputs(execution_measurement_probabilities):
+    mock_program = Mock()
+    mock_program.source = "OPENQASM 3.0;\nbit[2] b;\nqubit[2] q;\nh q[0];\ncnot q[0], q[1];\nb[0] = measure q[0];\nb[1] = measure q[1];"
+    mock_program.inputs = None
+    result = BraketSchemaBase.parse_raw_schema(json.dumps(execution_measurement_probabilities))
+
+    measured_entry = CompositeEntry._dispatch_executable_result(
+        result=result, program=mock_program, observables=None, shots_per_executable=40
+    )
+    assert isinstance(measured_entry, MeasuredEntry)
+    assert measured_entry.inputs is None
+    assert measured_entry.probabilities == {"00": 0.7, "11": 0.3}