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

cirq/study/resolver_test.py

@@ -14,6 +14,8 @@
 
 """Tests for parameter resolvers."""
 
+from __future__ import annotations
+
 import fractions
 
 import numpy as np
@@ -39,7 +41,7 @@ import cirq
         fractions.Fraction(3, 2),
     ],
 )
-def test_value_of_pass_through_types(val):
+def test_value_of_pass_through_types(val) -> None:
     _assert_consistent_resolution(val, val)
 
 
@@ -47,12 +49,12 @@ def test_value_of_pass_through_types(val):
     'val,resolved',
     [(sympy.pi, np.pi), (sympy.S.NegativeOne, -1), (sympy.S.Half, 0.5), (sympy.S.One, 1)],
 )
-def test_value_of_transformed_types(val, resolved):
+def test_value_of_transformed_types(val, resolved) -> None:
     _assert_consistent_resolution(val, resolved)
 
 
 @pytest.mark.parametrize('val,resolved', [(sympy.I, 1j)])
-def test_value_of_substituted_types(val, resolved):
+def test_value_of_substituted_types(val, resolved) -> None:
     _assert_consistent_resolution(val, resolved)
 
 
@@ -112,11 +114,11 @@ def _assert_consistent_resolution(v, resolved):
     ), f"expected {type(resolved)} got {type(r.value_of(v))}"
 
 
-def test_value_of_strings():
+def test_value_of_strings() -> None:
     assert cirq.ParamResolver().value_of('x') == sympy.Symbol('x')
 
 
-def test_value_of_calculations():
+def test_value_of_calculations() -> None:
     assert not bool(cirq.ParamResolver())
 
     r = cirq.ParamResolver({'a': 0.5, 'b': 0.1, 'c': 1 + 1j})
@@ -129,34 +131,34 @@ def test_value_of_calculations():
     assert r.value_of(sympy.Symbol('b') / 0.1 - sympy.Symbol('a')) == 0.5
 
 
-def test_resolve_integer_division():
+def test_resolve_integer_division() -> None:
     r = cirq.ParamResolver({'a': 1, 'b': 2})
     resolved = r.value_of(sympy.Symbol('a') / sympy.Symbol('b'))
     assert resolved == 0.5
 
 
-def test_resolve_symbol_division():
+def test_resolve_symbol_division() -> None:
     B = sympy.Symbol('B')
     r = cirq.ParamResolver({'a': 1, 'b': B})
     resolved = r.value_of(sympy.Symbol('a') / sympy.Symbol('b'))
     assert resolved == sympy.core.power.Pow(B, -1)
 
 
-def test_param_dict():
+def test_param_dict() -> None:
     r = cirq.ParamResolver({'a': 0.5, 'b': 0.1})
     r2 = cirq.ParamResolver(r)
     assert r2 is r
     assert r.param_dict == {'a': 0.5, 'b': 0.1}
 
 
-def test_param_dict_iter():
+def test_param_dict_iter() -> None:
     r = cirq.ParamResolver({'a': 0.5, 'b': 0.1})
     assert [key for key in r] == ['a', 'b']
     assert [r.value_of(key) for key in r] == [0.5, 0.1]
     assert list(r) == ['a', 'b']
 
 
-def test_formulas_in_param_dict():
+def test_formulas_in_param_dict() -> None:
     """Tests that formula keys are rejected in a `param_dict`."""
     a = sympy.Symbol('a')
     b = sympy.Symbol('b')
@@ -166,7 +168,7 @@ def test_formulas_in_param_dict():
         _ = cirq.ParamResolver({a: b + 1, b: 2, b + c: 101, 'd': 2 * e})
 
 
-def test_recursive_evaluation():
+def test_recursive_evaluation() -> None:
     a = sympy.Symbol('a')
     b = sympy.Symbol('b')
     c = sympy.Symbol('c')
@@ -184,7 +186,7 @@ def test_recursive_evaluation():
     assert sympy.Eq(r.value_of(e), 0)
 
 
-def test_resolution_of_unknown_formulas():
+def test_resolution_of_unknown_formulas() -> None:
     a = sympy.Symbol('a')
     b = sympy.Symbol('b')
 
@@ -192,7 +194,7 @@ def test_resolution_of_unknown_formulas():
     assert r.value_of(sympy.sin(a), recursive=False) == sympy.sin(b - 2)
 
 
-def test_unbound_recursion_halted():
+def test_unbound_recursion_halted() -> None:
     a = sympy.Symbol('a')
     b = sympy.Symbol('b')
     c = sympy.Symbol('c')
@@ -223,14 +225,14 @@ def test_unbound_recursion_halted():
         _ = r.value_of(a)
 
 
-def test_resolve_unknown_type():
+def test_resolve_unknown_type() -> None:
     a = sympy.Symbol('a')
     b = sympy.Symbol('b')
     r = cirq.ParamResolver({a: b})
     assert r.value_of(cirq.X) == cirq.X
 
 
-def test_custom_resolved_value():
+def test_custom_resolved_value() -> None:
     class Foo:
         def _resolved_value_(self):
             return self
@@ -249,7 +251,7 @@ def test_custom_resolved_value():
     assert r.value_of(b) == 'Baz'
 
 
-def test_custom_value_not_implemented():
+def test_custom_value_not_implemented() -> None:
     class BarImplicit:
         pass
 
@@ -264,7 +266,7 @@ def test_custom_value_not_implemented():
         assert r.value_of(b) == b
 
 
-def test_compose():
+def test_compose() -> None:
     """Tests that cirq.resolve_parameters on a ParamResolver composes."""
     a = sympy.Symbol('a')
     b = sympy.Symbol('b')
@@ -301,7 +303,7 @@ def test_compose():
     ],
 )
 @pytest.mark.parametrize('resolve_fn', [cirq.resolve_parameters, cirq.resolve_parameters_once])
-def test_compose_associative(p1, p2, p3, resolve_fn):
+def test_compose_associative(p1, p2, p3, resolve_fn) -> None:
     r1, r2, r3 = [
         cirq.ParamResolver(
             {sympy.Symbol(k): (sympy.Symbol(v) if isinstance(v, str) else v) for k, v in pd.items()}
@@ -313,7 +315,7 @@ def test_compose_associative(p1, p2, p3, resolve_fn):
     )
 
 
-def test_equals():
+def test_equals() -> None:
     et = cirq.testing.EqualsTester()
     et.add_equality_group(
         cirq.ParamResolver(),
@@ -329,7 +331,7 @@ def test_equals():
     et.add_equality_group(cirq.ParamResolver({'c': 0.1}))
 
 
-def test_repr():
+def test_repr() -> None:
     cirq.testing.assert_equivalent_repr(cirq.ParamResolver())
     cirq.testing.assert_equivalent_repr(cirq.ParamResolver({'a': 2.0}))
     cirq.testing.assert_equivalent_repr(cirq.ParamResolver({'a': sympy.Symbol('a')}))

cirq/study/result.py

@@ -11,25 +11,15 @@
 # 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.
+
 """Defines trial results."""
 
+from __future__ import annotations
+
 import abc
 import collections
 import io
-from typing import (
-    Any,
-    Callable,
-    cast,
-    Dict,
-    Iterable,
-    Mapping,
-    Optional,
-    Sequence,
-    Tuple,
-    TYPE_CHECKING,
-    TypeVar,
-    Union,
-)
+from typing import Any, Callable, cast, Iterable, Mapping, Sequence, TYPE_CHECKING, TypeVar, Union
 
 import numpy as np
 import pandas as pd
@@ -45,7 +35,7 @@ T = TypeVar('T')
 TMeasurementKey = Union[str, 'cirq.Qid', Iterable['cirq.Qid']]
 
 
-def _tuple_of_big_endian_int(bit_groups: Iterable[Any]) -> Tuple[int, ...]:
+def _tuple_of_big_endian_int(bit_groups: Iterable[Any]) -> tuple[int, ...]:
     """Returns the big-endian integers specified by groups of bits.
 
     Args:
@@ -99,7 +89,7 @@ class Result(abc.ABC):
 
     @property
     @abc.abstractmethod
-    def params(self) -> 'cirq.ParamResolver':
+    def params(self) -> cirq.ParamResolver:
         """A ParamResolver of settings used for this result."""
 
     @property
@@ -167,7 +157,7 @@ class Result(abc.ABC):
         self,
         *,  # Forces keyword args.
         keys: Iterable[TMeasurementKey],
-        fold_func: Callable[[Tuple], T] = cast(Callable[[Tuple], T], _tuple_of_big_endian_int),
+        fold_func: Callable[[tuple], T] = cast(Callable[[tuple], T], _tuple_of_big_endian_int),
     ) -> collections.Counter:
         """Counts the number of times combined measurement results occurred.
 
@@ -226,7 +216,7 @@ class Result(abc.ABC):
         self,
         *,  # Forces keyword args.
         key: TMeasurementKey,
-        fold_func: Callable[[Tuple], T] = cast(Callable[[Tuple], T], value.big_endian_bits_to_int),
+        fold_func: Callable[[tuple], T] = cast(Callable[[tuple], T], value.big_endian_bits_to_int),
     ) -> collections.Counter:
         """Counts the number of times a measurement result occurred.
 
@@ -275,7 +265,7 @@ class Result(abc.ABC):
             and self.params == other.params
         )
 
-    def __add__(self, other: 'cirq.Result') -> 'cirq.Result':
+    def __add__(self, other: cirq.Result) -> cirq.Result:
         if not isinstance(other, Result):
             return NotImplemented
         if self.params != other.params:
@@ -288,7 +278,7 @@ class Result(abc.ABC):
             raise ValueError(
                 f'Cannot add results with different measurement shapes: {shape} != {other_shape}'
             )
-        all_records: Dict[str, np.ndarray] = {}
+        all_records: dict[str, np.ndarray] = {}
         for key in other.records:
             all_records[key] = np.append(self.records[key], other.records[key], axis=0)
         return ResultDict(params=self.params, records=all_records)
@@ -309,9 +299,9 @@ class ResultDict(Result):
     def __init__(
         self,
         *,  # Forces keyword args.
-        params: Optional[resolver.ParamResolver] = None,
-        measurements: Optional[Mapping[str, np.ndarray]] = None,
-        records: Optional[Mapping[str, np.ndarray]] = None,
+        params: resolver.ParamResolver | None = None,
+        measurements: Mapping[str, np.ndarray] | None = None,
+        records: Mapping[str, np.ndarray] | None = None,
     ) -> None:
         """Inits Result.
 
@@ -338,10 +328,10 @@ class ResultDict(Result):
         self._params = params
         self._measurements = measurements
         self._records = records
-        self._data: Optional[pd.DataFrame] = None
+        self._data: pd.DataFrame | None = None
 
     @property
-    def params(self) -> 'cirq.ParamResolver':
+    def params(self) -> cirq.ParamResolver:
         return self._params
 
     @property
@@ -432,7 +422,7 @@ class ResultDict(Result):
         return cls._from_packed_records(params=params, records=kwargs['records'])
 
 
-def _pack_digits(digits: np.ndarray, pack_bits: str = 'auto') -> Tuple[str, bool]:
+def _pack_digits(digits: np.ndarray, pack_bits: str = 'auto') -> tuple[str, bool]:
     """Returns a string of packed digits and a boolean indicating whether the
     digits were packed as binary values.
 
@@ -471,7 +461,7 @@ def _pack_bits(bits: np.ndarray) -> str:
 
 
 def _unpack_digits(
-    packed_digits: str, binary: bool, dtype: Union[None, str], shape: Union[None, Sequence[int]]
+    packed_digits: str, binary: bool, dtype: None | str, shape: None | Sequence[int]
 ) -> np.ndarray:
     """The opposite of `_pack_digits`.
 

cirq/study/result_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 collections
 
 import numpy as np

cirq/study/sweepable.py

@@ -14,8 +14,10 @@
 
 """Defines which types are Sweepable."""
 
+from __future__ import annotations
+
 import warnings
-from typing import cast, Iterable, Iterator, List, Optional, Sequence, Union
+from typing import cast, Iterable, Iterator, Sequence
 
 from typing_extensions import Protocol
 
@@ -23,7 +25,7 @@ from cirq._doc import document
 from cirq.study.resolver import ParamResolver, ParamResolverOrSimilarType
 from cirq.study.sweeps import dict_to_product_sweep, ListSweep, Points, Sweep, UnitSweep, Zip
 
-SweepLike = Union[ParamResolverOrSimilarType, Sweep]
+SweepLike = ParamResolverOrSimilarType | Sweep
 document(SweepLike, """An object similar to an iterable of parameter resolvers.""")
 
 
@@ -31,11 +33,11 @@ class _Sweepable(Protocol):
     """An intermediate class allowing for recursive definition of Sweepable,
     since recursive union definitions are not yet supported in mypy."""
 
-    def __iter__(self) -> Iterator[Union[SweepLike, '_Sweepable']]:
+    def __iter__(self) -> Iterator[SweepLike | _Sweepable]:
         pass
 
 
-Sweepable = Union[SweepLike, _Sweepable]
+Sweepable = SweepLike | _Sweepable
 document(Sweepable, """An object or collection of objects representing a parameter sweep.""")
 
 
@@ -45,7 +47,7 @@ def to_resolvers(sweepable: Sweepable) -> Iterator[ParamResolver]:
         yield from sweep
 
 
-def to_sweeps(sweepable: Sweepable, metadata: Optional[dict] = None) -> List[Sweep]:
+def to_sweeps(sweepable: Sweepable, metadata: dict | None = None) -> list[Sweep]:
     """Converts a Sweepable to a list of Sweeps."""
     if sweepable is None:
         return [UnitSweep]
@@ -71,10 +73,10 @@ def to_sweeps(sweepable: Sweepable, metadata: Optional[dict] = None) -> List[Swe
 
 
 def to_sweep(
-    sweep_or_resolver_list: Union[
-        'Sweep', ParamResolverOrSimilarType, Iterable[ParamResolverOrSimilarType]
-    ],
-) -> 'Sweep':
+    sweep_or_resolver_list: (
+        Sweep | ParamResolverOrSimilarType | Iterable[ParamResolverOrSimilarType]
+    ),
+) -> Sweep:
     """Converts the argument into a ``cirq.Sweep``.
 
     Args:
@@ -99,7 +101,7 @@ def to_sweep(
     raise TypeError(f'Unexpected sweep-like value: {sweep_or_resolver_list}')
 
 
-def _resolver_to_sweep(resolver: ParamResolver, metadata: Optional[dict]) -> Sweep:
+def _resolver_to_sweep(resolver: ParamResolver, metadata: dict | None) -> Sweep:
     params = resolver.param_dict
     if not params:
         return UnitSweep

cirq/study/sweepable_test.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.
+
 """Tests for sweepable.py."""
 
+from __future__ import annotations
+
 import itertools
 
 import pytest