cirq-core 1.5.0.dev20250409222543__py3-none-any.whl → 1.6.0__py3-none-any.whl

cirq/testing/deprecation.py

@@ -11,16 +11,19 @@
 # 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 __future__ import annotations
+
 import contextlib
 import logging
 import os
-from typing import Iterator, Optional
+from typing import Iterator
 
 from cirq._compat import ALLOW_DEPRECATION_IN_TEST
 
 
 @contextlib.contextmanager
-def assert_deprecated(*msgs: str, deadline: str, count: Optional[int] = 1) -> Iterator[None]:
+def assert_deprecated(*msgs: str, deadline: str, count: int | None = 1) -> Iterator[None]:
     """Allows deprecated functions, classes, decorators in tests.
 
     It acts as a contextmanager that can be used in with statements:

cirq/testing/deprecation_test.py

@@ -11,6 +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.
+
+from __future__ import annotations
+
 import warnings
 
 import pytest
@@ -18,14 +21,14 @@ import pytest
 from cirq.testing import assert_deprecated
 
 
-def test_nested_assert_deprecation():
+def test_nested_assert_deprecation() -> None:
     with assert_deprecated(deadline="v1.2", count=1):
         with assert_deprecated(deadline="v1.2", count=1):
             with assert_deprecated(deadline="v1.2", count=1):
                 warnings.warn("hello, this is deprecated in v1.2")
 
 
-def test_assert_deprecated_log_handling():
+def test_assert_deprecated_log_handling() -> None:
     # correct deprecation message
     with assert_deprecated("hello", deadline="v1.2"):
         warnings.warn("hello, this is deprecated in v1.2")

cirq/testing/devices.py

@@ -11,8 +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.
+
 """Provides test devices that can validate circuits."""
-from typing import AbstractSet, cast, Tuple
+from __future__ import annotations
+
+from typing import AbstractSet, cast
 
 from cirq import devices, ops
 
@@ -37,10 +40,10 @@ class ValidatingTestDevice(devices.Device):
         self,
         qubits: AbstractSet[ops.Qid],
         name: str = "ValidatingTestDevice",
-        allowed_gates: Tuple[type, ...] = (ops.Gate,),
-        allowed_qubit_types: Tuple[type, ...] = (devices.GridQubit,),
+        allowed_gates: tuple[type, ...] = (ops.Gate,),
+        allowed_qubit_types: tuple[type, ...] = (devices.GridQubit,),
         validate_locality: bool = False,
-        auto_decompose_gates: Tuple[type, ...] = tuple(),
+        auto_decompose_gates: tuple[type, ...] = tuple(),
     ):
         self.allowed_qubit_types = allowed_qubit_types
         self.allowed_gates = allowed_gates

cirq/testing/devices_test.py

@@ -11,13 +11,16 @@
 # 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 __future__ import annotations
+
 import pytest
 
 import cirq
 from cirq.testing.devices import ValidatingTestDevice
 
 
-def test_validating_types_and_qubits():
+def test_validating_types_and_qubits() -> None:
     dev = ValidatingTestDevice(
         allowed_qubit_types=(cirq.GridQubit,),
         allowed_gates=(cirq.XPowGate,),
@@ -37,7 +40,7 @@ def test_validating_types_and_qubits():
         dev.validate_operation(cirq.Y(cirq.GridQubit(0, 0)))
 
 
-def test_validating_locality():
+def test_validating_locality() -> None:
     dev = ValidatingTestDevice(
         allowed_qubit_types=(cirq.GridQubit,),
         allowed_gates=(cirq.CZPowGate, cirq.MeasurementGate),
@@ -62,7 +65,7 @@ def test_validating_locality():
         )
 
 
-def test_repr():
+def test_repr() -> None:
     dev = ValidatingTestDevice(
         allowed_qubit_types=(cirq.GridQubit,),
         allowed_gates=(cirq.CZPowGate, cirq.MeasurementGate),
@@ -73,7 +76,7 @@ def test_repr():
     assert repr(dev) == 'test'
 
 
-def test_defaults():
+def test_defaults() -> None:
     dev = ValidatingTestDevice(qubits={cirq.GridQubit(0, 0)})
     assert repr(dev) == 'ValidatingTestDevice'
     assert dev.allowed_qubit_types == (cirq.GridQubit,)

cirq/testing/equals_tester.py

@@ -20,16 +20,18 @@ group are all equal to each other, but that items between each group are never
 equal to each other. It will also check that a==b implies hash(a)==hash(b).
 """
 
+from __future__ import annotations
+
 import collections
 import itertools
-from typing import Any, Callable, List, Tuple, Union
+from typing import Any, Callable
 
 
 class EqualsTester:
     """Tests equality against user-provided disjoint equivalence groups."""
 
     def __init__(self) -> None:
-        self._groups: List[Tuple[Union[Any, _ClassUnknownToSubjects], ...]] = [
+        self._groups: list[tuple[Any | _ClassUnknownToSubjects, ...]] = [
             (_ClassUnknownToSubjects(),)
         ]
 

cirq/testing/equals_tester_test.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import fractions
 
 import pytest
@@ -19,7 +21,7 @@ import pytest
 from cirq.testing.equals_tester import EqualsTester
 
 
-def test_add_equality_group_correct():
+def test_add_equality_group_correct() -> None:
     eq = EqualsTester()
 
     eq.add_equality_group(fractions.Fraction(1, 1))
@@ -39,7 +41,7 @@ def test_add_equality_group_correct():
     eq.add_equality_group('unrelated')
 
 
-def test_assert_make_equality_group():
+def test_assert_make_equality_group() -> None:
     eq = EqualsTester()
 
     with pytest.raises(AssertionError, match="can't be in the same"):
@@ -57,20 +59,20 @@ def test_assert_make_equality_group():
         eq.make_equality_group(lambda: 3)
 
 
-def test_add_equality_group_not_equivalent():
+def test_add_equality_group_not_equivalent() -> None:
     eq = EqualsTester()
     with pytest.raises(AssertionError, match="can't be in the same"):
         eq.add_equality_group(1, 2)
 
 
-def test_add_equality_group_not_disjoint():
+def test_add_equality_group_not_disjoint() -> None:
     eq = EqualsTester()
     eq.add_equality_group(1)
     with pytest.raises(AssertionError, match="can't be in different"):
         eq.add_equality_group(1)
 
 
-def test_add_equality_group_bad_hash():
+def test_add_equality_group_bad_hash() -> None:
     class KeyHash:
         def __init__(self, k, h):
             self._k = k
@@ -94,7 +96,7 @@ def test_add_equality_group_bad_hash():
         eq.add_equality_group(KeyHash('c', 2), KeyHash('c', 3))
 
 
-def test_add_equality_group_exception_hash():
+def test_add_equality_group_exception_hash() -> None:
     class FailHash:
         def __hash__(self):
             raise ValueError('injected failure')
@@ -104,7 +106,7 @@ def test_add_equality_group_exception_hash():
         eq.add_equality_group(FailHash())
 
 
-def test_fails_when_forgot_type_check():
+def test_fails_when_forgot_type_check() -> None:
     eq = EqualsTester()
 
     class NoTypeCheckEqualImplementation:
@@ -124,11 +126,12 @@ def test_fails_when_forgot_type_check():
         eq.add_equality_group(NoTypeCheckEqualImplementation())
 
 
-def test_fails_when_equal_to_everything():
+def test_fails_when_equal_to_everything() -> None:
     eq = EqualsTester()
 
     class AllEqual:
-        __hash__ = None
+        def __hash__(self) -> int:
+            return 0
 
         def __eq__(self, other):
             return True
@@ -136,11 +139,12 @@ def test_fails_when_equal_to_everything():
         def __ne__(self, other):
             return False
 
+    assert hash(AllEqual()) == 0
     with pytest.raises(AssertionError, match="can't be in different"):
         eq.add_equality_group(AllEqual())
 
 
-def test_fails_hash_is_default_and_inconsistent():
+def test_fails_hash_is_default_and_inconsistent() -> None:
     eq = EqualsTester()
 
     class DefaultHashImplementation:
@@ -161,7 +165,7 @@ def test_fails_hash_is_default_and_inconsistent():
         eq.make_equality_group(DefaultHashImplementation)
 
 
-def test_fails_when_ne_is_inconsistent():
+def test_fails_when_ne_is_inconsistent() -> None:
     eq = EqualsTester()
 
     class InconsistentNeImplementation:
@@ -185,7 +189,7 @@ def test_fails_when_ne_is_inconsistent():
         eq.make_equality_group(InconsistentNeImplementation)
 
 
-def test_fails_when_ne_is_inconsistent_due_to_not_implemented():
+def test_fails_when_ne_is_inconsistent_due_to_not_implemented() -> None:
     eq = EqualsTester()
 
     class InconsistentNeImplementation:
@@ -207,7 +211,7 @@ def test_fails_when_ne_is_inconsistent_due_to_not_implemented():
         eq.make_equality_group(InconsistentNeImplementation)
 
 
-def test_fails_when_not_reflexive():
+def test_fails_when_not_reflexive() -> None:
     eq = EqualsTester()
 
     class NotReflexiveImplementation:
@@ -226,7 +230,7 @@ def test_fails_when_not_reflexive():
         eq.add_equality_group(NotReflexiveImplementation())
 
 
-def test_fails_when_not_commutative():
+def test_fails_when_not_commutative() -> None:
     eq = EqualsTester()
 
     class NotCommutativeImplementation:
@@ -248,14 +252,14 @@ def test_fails_when_not_commutative():
         eq.add_equality_group(NotCommutativeImplementation(1), NotCommutativeImplementation(0))
 
 
-def test_works_on_types():
+def test_works_on_types() -> None:
     eq = EqualsTester()
     eq.add_equality_group(object)
     eq.add_equality_group(int)
     eq.add_equality_group(object())
 
 
-def test_returns_not_implemented_for_other_types():
+def test_returns_not_implemented_for_other_types() -> None:
     # First we demonstrate an example of the problem.
 
     # FirstClass is the class that is broken.
@@ -323,7 +327,7 @@ def test_returns_not_implemented_for_other_types():
     eq.add_equality_group(ThirdClass("a"), ThirdClass("a"))
 
 
-def test_not_implemented_error():
+def test_not_implemented_error() -> None:
     # Common bug is to return NotImplementedError instead of NotImplemented.
     class NotImplementedErrorCase:
         def __init__(self, val):

cirq/testing/equivalent_basis_map.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Dict, Optional, Sequence
+from __future__ import annotations
+
+from typing import Sequence
 
 import numpy as np
 
@@ -20,7 +22,7 @@ import cirq
 from cirq import circuits
 
 
-def assert_equivalent_computational_basis_map(maps: Dict[int, int], circuit: circuits.Circuit):
+def assert_equivalent_computational_basis_map(maps: dict[int, int], circuit: circuits.Circuit):
     """Ensure equivalence of basis state mapping.
 
     Args:
@@ -47,7 +49,7 @@ def assert_equivalent_computational_basis_map(maps: Dict[int, int], circuit: cir
 
 def _sparse_computational_basis_map(
     inputs: Sequence[int], circuit: circuits.Circuit
-) -> Dict[int, int]:
+) -> dict[int, int]:
     # Pick a unique amplitude for each computational basis input state.
     amps = [np.exp(1j * i / len(inputs)) / len(inputs) ** 0.5 for i in range(len(inputs))]
 
@@ -67,7 +69,7 @@ def _sparse_computational_basis_map(
     return actual_map
 
 
-def _bin_dec(x: Optional[int], num_bits: int) -> str:
+def _bin_dec(x: int | None, num_bits: int) -> str:
     if x is None:
         return 'None'
     return f'0b{bin(x)[2:].zfill(num_bits)} ({x})'

cirq/testing/equivalent_basis_map_test.py

@@ -11,13 +11,16 @@
 # 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 __future__ import annotations
+
 import pytest
 
 import cirq
 from cirq import circuits
 
 
-def test_correct_mappings():
+def test_correct_mappings() -> None:
     a, b, c = cirq.LineQubit.range(3)
     cirq.testing.assert_equivalent_computational_basis_map(
         maps={0b01: 0b01, 0b10: 0b10},
@@ -30,11 +33,10 @@ def test_correct_mappings():
     )
 
 
-def test_incorrect_mappings():
+def test_incorrect_mappings() -> None:
     a, b, c = cirq.LineQubit.range(3)
     with pytest.raises(
-        AssertionError,
-        match=r"0b001 \(1\) was mapped to " r"0b100 \(4\) instead of " r"0b010 \(2\)",
+        AssertionError, match=r"0b001 \(1\) was mapped to 0b100 \(4\) instead of 0b010 \(2\)"
     ):
         cirq.testing.assert_equivalent_computational_basis_map(
             maps={0b001: 0b010, 0b010: 0b100, 0b100: 0b001},

cirq/testing/equivalent_repr_eval.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Any, Dict, Optional
+from __future__ import annotations
+
+from typing import Any
 
 
 def assert_equivalent_repr(
@@ -21,8 +23,8 @@ def assert_equivalent_repr(
     setup_code: str = (
         'import cirq\nimport numpy as np\nimport sympy\nimport pandas as pd\nimport datetime\n'
     ),
-    global_vals: Optional[Dict[str, Any]] = None,
-    local_vals: Optional[Dict[str, Any]] = None,
+    global_vals: dict[str, Any] | None = None,
+    local_vals: dict[str, Any] | None = None,
 ) -> None:
     """Checks that eval(repr(v)) == v.
 
@@ -39,7 +41,7 @@ def assert_equivalent_repr(
     Raises:
         AssertionError: If the assertion fails, or eval(repr(value)) raises an error.
     """
-    __tracebackhide__ = True  # pylint: disable=unused-variable
+    __tracebackhide__ = True
 
     global_vals = global_vals or {}
     local_vals = local_vals or {}

cirq/testing/equivalent_repr_eval_test.py

@@ -12,13 +12,15 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import numpy as np
 import pytest
 
 import cirq
 
 
-def test_external():
+def test_external() -> None:
     for t in ['a', 1j]:
         cirq.testing.assert_equivalent_repr(t)
         cirq.testing.assert_equivalent_repr(t, setup_code='')
@@ -29,7 +31,7 @@ def test_external():
         cirq.testing.assert_equivalent_repr(np.array([5]))
 
 
-def test_custom_class_repr():
+def test_custom_class_repr() -> None:
     class CustomRepr:  # pragma: no cover
         setup_code = """class CustomRepr:
             def __init__(self, eq_val):
@@ -81,5 +83,5 @@ def test_custom_class_repr():
         )
 
 
-def test_imports_cirq_by_default():
+def test_imports_cirq_by_default() -> None:
     cirq.testing.assert_equivalent_repr(cirq.NamedQubit('a'))

cirq/testing/gate_features.py

@@ -14,6 +14,8 @@
 
 """Simple gates used for testing purposes."""
 
+from __future__ import annotations
+
 from cirq.ops import raw_types
 
 

cirq/testing/gate_features_test.py

@@ -12,12 +12,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 import cirq
 
 
-def test_two_qubit_gate_is_abstract_can_implement():
+def test_two_qubit_gate_is_abstract_can_implement() -> None:
     class Included(cirq.testing.TwoQubitGate):
         def matrix(self):
             pass
@@ -25,7 +27,7 @@ def test_two_qubit_gate_is_abstract_can_implement():
     assert isinstance(Included(), cirq.testing.TwoQubitGate)
 
 
-def test_two_qubit_gate_validate_pass():
+def test_two_qubit_gate_validate_pass() -> None:
     class Example(cirq.testing.TwoQubitGate):
         def matrix(self):
             pass
@@ -41,7 +43,7 @@ def test_two_qubit_gate_validate_pass():
     g.validate_args([q3, q2])
 
 
-def test_two_qubit_gate_validate_wrong_number():
+def test_two_qubit_gate_validate_wrong_number() -> None:
     class Example(cirq.testing.TwoQubitGate):
         def matrix(self):
             pass
@@ -59,7 +61,7 @@ def test_two_qubit_gate_validate_wrong_number():
         g.validate_args([q1, q2, q3])
 
 
-def test_three_qubit_gate_validate():
+def test_three_qubit_gate_validate() -> None:
     class Example(cirq.testing.ThreeQubitGate):
         def matrix(self):
             pass
@@ -80,6 +82,6 @@ def test_three_qubit_gate_validate():
         g.validate_args([a, b, c, d])
 
 
-def test_does_not_support_serialization_gate():
+def test_does_not_support_serialization_gate() -> None:
     g = cirq.testing.DoesNotSupportSerializationGate(n_qubits=4)
     assert g.num_qubits() == 4

cirq/testing/json.py

@@ -12,19 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import dataclasses
 import inspect
 import io
 import pathlib
 from dataclasses import dataclass
 from types import ModuleType
-from typing import Dict, Iterator, List, Set, Tuple, Type
+from typing import Iterator, TYPE_CHECKING
 
 import numpy as np
 import pandas as pd
 
 import cirq
-from cirq.protocols.json_serialization import ObjectFactory
+
+if TYPE_CHECKING:
+    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.
@@ -44,28 +48,28 @@ class ModuleJsonTestSpec:
     # for test failures, a better representation
     name: str
     # the packages that have the public classes to be checked for serialization
-    packages: List[ModuleType]
+    packages: list[ModuleType]
     # the path for the folder containing the test files
     test_data_path: pathlib.Path
     # these public class names are planned to be serializable but not yet
-    not_yet_serializable: List[str]
+    not_yet_serializable: list[str]
     # these public class names do not need to be serialized ever
-    should_not_be_serialized: List[str]
+    should_not_be_serialized: list[str]
     # points to the resolver cache's dict for this module
-    resolver_cache: Dict[str, ObjectFactory]
+    resolver_cache: dict[str, ObjectFactory]
     # {DeprecatedClass: deprecation_deadline} pairs to avoid deprecation errors
     # in serialization tests.
-    deprecated: Dict[str, str]
+    deprecated: dict[str, str]
     # The unqualified public name is different from the cirq_type field of the json object,
     # usually due to namespacing.
-    custom_class_name_to_cirq_type: Dict[str, str] = dataclasses.field(default_factory=dict)
+    custom_class_name_to_cirq_type: dict[str, str] = dataclasses.field(default_factory=dict)
     # Special cases where classes cannot be tested using the normal infrastructure.
-    tested_elsewhere: List[str] = dataclasses.field(default_factory=list)
+    tested_elsewhere: list[str] = dataclasses.field(default_factory=list)
 
     def __repr__(self):
         return self.name
 
-    def _get_all_public_classes(self) -> Iterator[Tuple[str, Type]]:
+    def _get_all_public_classes(self) -> Iterator[tuple[str, type]]:
         for module in self.packages:
             for name, obj in inspect.getmembers(module):
                 if inspect.isfunction(obj) or inspect.ismodule(obj):
@@ -87,16 +91,16 @@ class ModuleJsonTestSpec:
                 name = self.custom_class_name_to_cirq_type.get(name, name)
                 yield name, obj
 
-    def find_classes_that_should_serialize(self) -> Set[Tuple[str, Type]]:
-        result: Set[Tuple[str, Type]] = set()
+    def find_classes_that_should_serialize(self) -> set[tuple[str, type]]:
+        result: set[tuple[str, type]] = set()
 
         result.update({(name, obj) for name, obj in self._get_all_public_classes()})
         result.update(self.get_resolver_cache_types())
 
         return result
 
-    def get_resolver_cache_types(self) -> Set[Tuple[str, Type]]:
-        result: Set[Tuple[str, Type]] = set()
+    def get_resolver_cache_types(self) -> set[tuple[str, type]]:
+        result: set[tuple[str, type]] = set()
         for k, v in self.resolver_cache.items():
             if isinstance(v, type):
                 result.add((k, v))
@@ -113,7 +117,7 @@ class ModuleJsonTestSpec:
         for name, _ in self.get_resolver_cache_types():
             yield name
 
-    def all_test_data_keys(self) -> List[str]:
+    def all_test_data_keys(self) -> list[str]:
         seen = set()
 
         for file in self.test_data_path.iterdir():

cirq/testing/json_test.py

@@ -12,21 +12,23 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 from cirq.testing.json import spec_for
 
 
-def test_module_missing_json_test_data():
+def test_module_missing_json_test_data() -> None:
     with pytest.raises(ValueError, match="json_test_data"):
         spec_for('cirq.testing.test_data.test_module_missing_json_test_data')
 
 
-def test_module_missing_testspec():
+def test_module_missing_testspec() -> None:
     with pytest.raises(ValueError, match="TestSpec"):
         spec_for('cirq.testing.test_data.test_module_missing_testspec')
 
 
-def test_missing_module():
+def test_missing_module() -> None:
     with pytest.raises(ModuleNotFoundError):
         spec_for('non_existent')