cirq-core 1.4.0.dev20240529225110__py3-none-any.whl → 1.5.0__py3-none-any.whl

cirq/testing/consistent_qasm.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import warnings
-from typing import Any, List, Sequence, Optional
+from typing import Any, List, Optional, Sequence
 
 import numpy as np
 
@@ -47,7 +47,7 @@ def assert_qasm_is_consistent_with_unitary(val: Any):
         qid_shape = protocols.qid_shape(val)
         remaining_shape = list(qid_shape)
         controls = getattr(val, 'control_qubits', None)
-        if controls is not None:
+        if controls is not None:  # pragma: no cover
             for i, q in zip(reversed(range(len(controls))), reversed(controls)):
                 if q is not None:
                     remaining_shape.pop(i)
@@ -76,11 +76,9 @@ qreg q[{num_qubits}];
 
     qasm_unitary = None
     try:
-        result = qiskit.execute(
-            qiskit.QuantumCircuit.from_qasm_str(qasm),
-            backend=qiskit.Aer.get_backend('unitary_simulator'),
-        )
-        qasm_unitary = result.result().get_unitary()
+        qc = qiskit.QuantumCircuit.from_qasm_str(qasm)
+        qc.remove_final_measurements()
+        qasm_unitary = qiskit.quantum_info.Operator(qc).data
         qasm_unitary = _reorder_indices_of_matrix(qasm_unitary, list(reversed(range(num_qubits))))
 
         lin_alg_utils.assert_allclose_up_to_global_phase(
@@ -115,11 +113,9 @@ def assert_qiskit_parsed_qasm_consistent_with_unitary(qasm, unitary):  # pragma:
         return
 
     num_qubits = int(np.log2(len(unitary)))
-    result = qiskit.execute(
-        qiskit.QuantumCircuit.from_qasm_str(qasm),
-        backend=qiskit.Aer.get_backend('unitary_simulator'),
-    )
-    qiskit_unitary = result.result().get_unitary()
+    qc = qiskit.QuantumCircuit.from_qasm_str(qasm)
+    qc.remove_final_measurements()  # no measurements allowed
+    qiskit_unitary = qiskit.quantum_info.Operator(qc).data
     qiskit_unitary = _reorder_indices_of_matrix(qiskit_unitary, list(reversed(range(num_qubits))))
 
     lin_alg_utils.assert_allclose_up_to_global_phase(unitary, qiskit_unitary, rtol=1e-8, atol=1e-8)

cirq/testing/consistent_qasm_test.py

@@ -12,9 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+import warnings
 from typing import Tuple
 
-import warnings
 import numpy as np
 import pytest
 

cirq/testing/consistent_resolve_parameters.py

@@ -14,9 +14,10 @@
 
 from typing import Any
 
-import cirq
 import sympy
 
+import cirq
+
 
 def assert_consistent_resolve_parameters(val: Any):
     names = cirq.parameter_names(val)

cirq/testing/consistent_specified_has_unitary_test.py

@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import pytest
 import numpy as np
+import pytest
 
 import cirq
 

cirq/testing/consistent_unitary.py

@@ -14,9 +14,11 @@
 
 
 from typing import Any
-import cirq
+
 import numpy as np
 
+import cirq
+
 
 def assert_unitary_is_consistent(val: Any, ignoring_global_phase: bool = False):
     if not isinstance(val, (cirq.Operation, cirq.Gate)):

cirq/testing/consistent_unitary_test.py

@@ -12,10 +12,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import cirq
-
-import pytest
 import numpy as np
+import pytest
+
+import cirq
 
 
 class InconsistentGate(cirq.Gate):

cirq/testing/devices.py

@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Provides test devices that can validate circuits."""
-from typing import Tuple, AbstractSet, cast
+from typing import AbstractSet, cast, Tuple
 
 from cirq import devices, ops
 

cirq/testing/devices_test.py

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 import pytest
+
 import cirq
 from cirq.testing.devices import ValidatingTestDevice
 

cirq/testing/equals_tester.py

@@ -21,10 +21,8 @@ equal to each other. It will also check that a==b implies hash(a)==hash(b).
 """
 
 import collections
-
-from typing import Any, Callable, List, Tuple, Union
-
 import itertools
+from typing import Any, Callable, List, Tuple, Union
 
 
 class EqualsTester:
@@ -143,7 +141,7 @@ class _ClassUnknownToSubjects:
         return not self == other
 
     def __hash__(self):
-        return hash(_ClassUnknownToSubjects)
+        return hash(_ClassUnknownToSubjects)  # pragma: no cover
 
 
 class _TestsForNotImplemented:

cirq/testing/equals_tester_test.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 import fractions
+
 import pytest
 
 from cirq.testing.equals_tester import EqualsTester
@@ -117,7 +118,7 @@ def test_fails_when_forgot_type_check():
             return not self == other
 
         def __hash__(self):
-            return hash(self.x)
+            return hash(self.x)  # pragma: no cover
 
     with pytest.raises(AttributeError, match="has no attribute 'x'"):
         eq.add_equality_group(NoTypeCheckEqualImplementation())
@@ -193,14 +194,14 @@ def test_fails_when_ne_is_inconsistent_due_to_not_implemented():
 
         def __eq__(self, other):
             if not isinstance(other, type(self)):
-                return NotImplemented
+                return NotImplemented  # pragma: no cover
             return self.x == other.x
 
         def __ne__(self, other):
             return NotImplemented
 
         def __hash__(self):
-            return hash(self.x)
+            return hash(self.x)  # pragma: no cover
 
     with pytest.raises(AssertionError, match='inconsistent'):
         eq.make_equality_group(InconsistentNeImplementation)
@@ -215,7 +216,7 @@ def test_fails_when_not_reflexive():
 
         def __eq__(self, other):
             if other is not self:
-                return NotImplemented
+                return NotImplemented  # pragma: no cover
             return False
 
         def __ne__(self, other):
@@ -234,7 +235,7 @@ def test_fails_when_not_commutative():
 
         def __eq__(self, other):
             if not isinstance(other, type(self)):
-                return NotImplemented
+                return NotImplemented  # pragma: no cover
             return self.x <= other.x
 
         def __ne__(self, other):

cirq/testing/equivalent_basis_map.py

@@ -13,6 +13,7 @@
 # limitations under the License.
 
 from typing import Dict, Optional, Sequence
+
 import numpy as np
 
 import cirq

cirq/testing/equivalent_basis_map_test.py

@@ -14,7 +14,6 @@
 import pytest
 
 import cirq
-
 from cirq import circuits
 
 

cirq/testing/gate_features_test.py

@@ -78,3 +78,8 @@ def test_three_qubit_gate_validate():
         g.validate_args([a, b])
     with pytest.raises(ValueError):
         g.validate_args([a, b, c, d])
+
+
+def test_does_not_support_serialization_gate():
+    g = cirq.testing.DoesNotSupportSerializationGate(n_qubits=4)
+    assert g.num_qubits() == 4

cirq/testing/json.py

@@ -11,18 +11,20 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
 import dataclasses
 import inspect
 import io
 import pathlib
 from dataclasses import dataclass
-from typing import List, Type, Dict, Iterator, Tuple, Set
+from types import ModuleType
+from typing import Dict, Iterator, List, Set, Tuple, Type
 
 import numpy as np
 import pandas as pd
 
 import cirq
-from cirq._import import ModuleType
+from cirq.protocols.json_serialization import ObjectFactory
 
 # This is the testing framework for json serialization
 # The actual tests live in cirq.protocols.json_serialization_test.py.
@@ -36,8 +38,6 @@ from cirq._import import ModuleType
 #  - resolver cache: a resolver cache for the exposed types - see for example
 #       cirq/json_resolver_cache.py or cirq/google/json_resolver_cache.py
 
-from cirq.protocols.json_serialization import ObjectFactory
-
 
 @dataclass
 class ModuleJsonTestSpec:

cirq/testing/lin_alg_utils_test.py

@@ -15,6 +15,7 @@
 import numpy as np
 import pytest
 
+from cirq.linalg import is_orthogonal, is_special_orthogonal, is_special_unitary, is_unitary
 from cirq.testing import (
     assert_allclose_up_to_global_phase,
     random_density_matrix,
@@ -24,7 +25,6 @@ from cirq.testing import (
     random_superposition,
     random_unitary,
 )
-from cirq.linalg import is_unitary, is_orthogonal, is_special_unitary, is_special_orthogonal
 
 
 @pytest.mark.parametrize('dim', range(1, 10))

cirq/testing/order_tester.py

@@ -24,8 +24,8 @@ It will also check that a==b implies hash(a)==hash(b).
 """
 
 from typing import Any
-from cirq.testing.equals_tester import EqualsTester
 
+from cirq.testing.equals_tester import EqualsTester
 
 _NAMED_COMPARISON_OPERATORS = [
     ('<', lambda a, b: a < b),

cirq/testing/order_tester_test.py

@@ -13,11 +13,11 @@
 # limitations under the License.
 
 import fractions
+
 import pytest
 
 import cirq
 
-
 CMP_OPS = [
     lambda a, b: a == b,
     lambda a, b: a != b,

cirq/testing/pytest_utils.py

@@ -0,0 +1,57 @@
+# Copyright 2024 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Support one retry of tests that fail for a specific seed from pytest-randomly."""
+
+import functools
+import warnings
+from typing import Any, Callable
+
+
+def retry_once_after_timeout(testfunc: Callable) -> Callable:
+    """Marks a test function for one retry if it fails with TimeoutError.
+
+    This decorator is intended for test functions which occasionally fail
+    with TimeoutError.
+    """
+
+    @functools.wraps(testfunc)
+    def wrapped_func(*args, **kwargs) -> Any:
+        try:
+            return testfunc(*args, **kwargs)
+        except TimeoutError:
+            pass
+        warnings.warn("Retrying in case we have a transitive TimeoutError")
+        return testfunc(*args, **kwargs)
+
+    return wrapped_func
+
+
+def retry_once_with_later_random_values(testfunc: Callable) -> Callable:
+    """Marks a test function for one retry with later random values.
+
+    This decorator is intended for test functions which occasionally fail
+    for specific random seeds from pytest-randomly.
+    """
+
+    @functools.wraps(testfunc)
+    def wrapped_func(*args, **kwargs) -> Any:
+        try:
+            return testfunc(*args, **kwargs)
+        except AssertionError:
+            pass
+        warnings.warn("Retrying in case we got a failing seed from pytest-randomly.")
+        return testfunc(*args, **kwargs)
+
+    return wrapped_func

cirq/testing/pytest_utils_test.py

@@ -0,0 +1,35 @@
+# Copyright 2024 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from unittest.mock import Mock
+
+import pytest
+
+import cirq
+
+
+def test_retry_once_after_timeout():
+    testfunc = Mock(side_effect=[TimeoutError("first call fails"), None])
+    decoratedfunc = cirq.testing.retry_once_after_timeout(testfunc)
+    with pytest.warns(UserWarning, match="Retrying.*transitive TimeoutError"):
+        decoratedfunc()
+    assert testfunc.call_count == 2
+
+
+def test_retry_once_with_later_random_values():
+    testfunc = Mock(side_effect=[AssertionError("first call fails"), None])
+    decoratedfunc = cirq.testing.retry_once_with_later_random_values(testfunc)
+    with pytest.warns(UserWarning, match="Retrying.*failing seed.*pytest-randomly"):
+        decoratedfunc()
+    assert testfunc.call_count == 2

cirq/testing/random_circuit.py

@@ -12,11 +12,11 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import List, Union, Sequence, Dict, Optional, TYPE_CHECKING
+from typing import Dict, List, Optional, Sequence, TYPE_CHECKING, Union
 
 from cirq import circuits, ops, value
-from cirq.ops import Qid
 from cirq._doc import document
+from cirq.ops import Qid
 
 if TYPE_CHECKING:
     import cirq

cirq/testing/random_circuit_test.py

@@ -11,8 +11,8 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from typing import Optional, Dict, Sequence, Union, cast
 import random
+from typing import cast, Dict, Optional, Sequence, Union
 
 import numpy as np
 import pytest
@@ -57,7 +57,7 @@ def _cases_for_random_circuit():
                 )
             )
             # Sometimes we generate gate domains whose gates all act on a
-            # number of qubits greater that the number of qubits for the
+            # number of qubits greater than the number of qubits for the
             # circuit. In this case, try again.
             if all(n > n_qubits for n in gate_domain.values()):
                 continue  # pragma: no cover

cirq/testing/routing_devices_test.py

@@ -11,8 +11,9 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-import pytest
 import networkx as nx
+import pytest
+
 import cirq
 
 

cirq/testing/sample_circuits.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 from typing import TYPE_CHECKING
 
-from cirq import ops, circuits
+from cirq import circuits, ops
 
 if TYPE_CHECKING:
     import cirq

cirq/testing/sample_gates.py

@@ -13,9 +13,10 @@
 # limitations under the License.
 import dataclasses
 
-import cirq
 import numpy as np
-from cirq import ops, qis, protocols
+
+import cirq
+from cirq import ops, protocols, qis
 
 
 def _matrix_for_phasing_state(num_qubits, phase_state, phase):
@@ -29,7 +30,7 @@ def _matrix_for_phasing_state(num_qubits, phase_state, phase):
 
 @dataclasses.dataclass(frozen=True)
 class PhaseUsingCleanAncilla(ops.Gate):
-    r"""Phases the state $|phase_state>$ by $\exp(1j * \pi * \theta)$ using one clean ancilla."""
+    r"""Phases the state $|phase\_state>$ by $\exp(1j * \pi * \theta)$ using one clean ancilla."""
 
     theta: float
     phase_state: int = 1
@@ -56,7 +57,7 @@ class PhaseUsingCleanAncilla(ops.Gate):
 
 @dataclasses.dataclass(frozen=True)
 class PhaseUsingDirtyAncilla(ops.Gate):
-    r"""Phases the state $|phase_state>$ by -1 using one dirty ancilla."""
+    r"""Phases the state $|phase\_state>$ by -1 using one dirty ancilla."""
 
     phase_state: int = 1
     target_bitsize: int = 1

cirq/testing/sample_gates_test.py

@@ -11,11 +11,11 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+import numpy as np
 import pytest
 
-import numpy as np
-from cirq.testing import sample_gates
 import cirq
+from cirq.testing import sample_gates
 
 
 @pytest.mark.parametrize('theta', np.linspace(0, 2 * np.pi, 20))