cirq-core 1.7.0.dev20250825174419__py3-none-any.whl → 1.7.0.dev20251203004401__py3-none-any.whl

cirq/study/result_test.py

@@ -25,12 +25,12 @@ import cirq.testing
 from cirq.study.result import _pack_digits
 
 
-def test_result_init():
+def test_result_init() -> None:
     assert cirq.ResultDict(params=cirq.ParamResolver({}), measurements=None).repetitions == 0
     assert cirq.ResultDict(params=cirq.ParamResolver({}), measurements={}).repetitions == 0
 
 
-def test_default_repetitions():
+def test_default_repetitions() -> None:
     class MyResult(cirq.Result):
         def __init__(self, records):
             self._records = records
@@ -55,7 +55,7 @@ def test_default_repetitions():
     assert MyResult({'a': np.zeros((5, 2, 3))}).repetitions == 5
 
 
-def test_repr():
+def test_repr() -> None:
     v = cirq.ResultDict(
         params=cirq.ParamResolver({'a': 2}), measurements={'xy': np.array([[1, 0], [0, 1]])}
     )
@@ -68,7 +68,7 @@ def test_repr():
     cirq.testing.assert_equivalent_repr(v)
 
 
-def test_construct_from_measurements():
+def test_construct_from_measurements() -> None:
     r = cirq.ResultDict(
         params=None,
         measurements={'a': np.array([[0, 0], [1, 1]]), 'b': np.array([[0, 0, 0], [1, 1, 1]])},
@@ -79,7 +79,7 @@ def test_construct_from_measurements():
     assert np.all(r.records['b'] == np.array([[[0, 0, 0]], [[1, 1, 1]]]))
 
 
-def test_construct_from_repeated_measurements():
+def test_construct_from_repeated_measurements() -> None:
     r = cirq.ResultDict(
         params=None,
         records={
@@ -104,13 +104,13 @@ def test_construct_from_repeated_measurements():
     assert r2.repetitions == 2
 
 
-def test_empty_measurements():
+def test_empty_measurements() -> None:
     assert cirq.ResultDict(params=None).repetitions == 0
     assert cirq.ResultDict(params=None, measurements={}).repetitions == 0
     assert cirq.ResultDict(params=None, records={}).repetitions == 0
 
 
-def test_str():
+def test_str() -> None:
     result = cirq.ResultDict(
         params=cirq.ParamResolver({}),
         measurements={
@@ -136,7 +136,7 @@ def test_str():
     assert str(result) == 'c=1, 0\nc=0, 1'
 
 
-def test_df():
+def test_df() -> None:
     result = cirq.ResultDict(
         params=cirq.ParamResolver({}),
         measurements={
@@ -156,7 +156,7 @@ def test_df():
     assert df.c.value_counts().to_dict() == {0: 3, 1: 2}
 
 
-def test_df_large():
+def test_df_large() -> None:
     result = cirq.ResultDict(
         params=cirq.ParamResolver({}),
         measurements={
@@ -171,7 +171,7 @@ def test_df_large():
     assert result.data['d'].dtype == object
 
 
-def test_histogram():
+def test_histogram() -> None:
     result = cirq.ResultDict(
         params=cirq.ParamResolver({}),
         measurements={
@@ -188,7 +188,7 @@ def test_histogram():
     assert result.histogram(key='c') == collections.Counter({0: 3, 1: 2})
 
 
-def test_multi_measurement_histogram():
+def test_multi_measurement_histogram() -> None:
     result = cirq.ResultDict(
         params=cirq.ParamResolver({}),
         measurements={
@@ -222,7 +222,7 @@ def test_multi_measurement_histogram():
     )
 
 
-def test_result_equality():
+def test_result_equality() -> None:
     et = cirq.testing.EqualsTester()
     et.add_equality_group(
         cirq.ResultDict(params=cirq.ParamResolver({}), measurements={'a': np.array([[0]] * 5)}),
@@ -239,7 +239,7 @@ def test_result_equality():
     )
 
 
-def test_result_addition_valid():
+def test_result_addition_valid() -> None:
     a = cirq.ResultDict(
         params=cirq.ParamResolver({'ax': 1}),
         measurements={
@@ -278,7 +278,7 @@ def test_result_addition_valid():
     )
 
 
-def test_result_addition_invalid():
+def test_result_addition_invalid() -> None:
     a = cirq.ResultDict(
         params=cirq.ParamResolver({'ax': 1}),
         measurements={
@@ -324,10 +324,10 @@ def test_result_addition_invalid():
     with pytest.raises(ValueError, match='different measurement shapes'):
         _ = a + e
     with pytest.raises(TypeError):
-        _ = a + 'junk'
+        _ = a + 'junk'  # type: ignore[operator]
 
 
-def test_qubit_keys_for_histogram():
+def test_qubit_keys_for_histogram() -> None:
     a, b, c = cirq.LineQubit.range(3)
     circuit = cirq.Circuit(cirq.measure(a, b), cirq.X(c), cirq.measure(c))
     results = cirq.Simulator().run(program=circuit, repetitions=100)
@@ -339,7 +339,7 @@ def test_qubit_keys_for_histogram():
     assert results.histogram(key=[c]) == collections.Counter({1: 100})
 
 
-def test_text_diagram_jupyter():
+def test_text_diagram_jupyter() -> None:
     result = cirq.ResultDict(
         params=cirq.ParamResolver({}),
         measurements={
@@ -397,12 +397,12 @@ def test_json_bit_packing_and_dtype(use_records: bool) -> None:
     np.testing.assert_allclose(len(bits_json), len(digits_json) / 8, rtol=0.02)
 
 
-def test_json_bit_packing_error():
+def test_json_bit_packing_error() -> None:
     with pytest.raises(ValueError):
         _pack_digits(np.ones(10), pack_bits='hi mom')
 
 
-def test_json_bit_packing_force():
+def test_json_bit_packing_force() -> None:
     assert _pack_digits(np.ones(10, dtype=int), pack_bits='force') == _pack_digits(
         np.ones(10), pack_bits='auto'
     )
@@ -418,7 +418,7 @@ def test_json_bit_packing_force():
     )
 
 
-def test_json_unpack_compat():
+def test_json_unpack_compat() -> None:
     """Test reading old json with serialized measurements array."""
     old_json = """
         {

cirq/study/sweepable.py

@@ -17,7 +17,8 @@
 from __future__ import annotations
 
 import warnings
-from typing import cast, Iterable, Iterator, Protocol, Sequence
+from collections.abc import Iterable, Iterator, Sequence
+from typing import cast, Protocol
 
 from cirq._doc import document
 from cirq.study.resolver import ParamResolver, ParamResolverOrSimilarType

cirq/study/sweepable_test.py

@@ -24,66 +24,66 @@ import sympy
 import cirq
 
 
-def test_to_resolvers_none():
+def test_to_resolvers_none() -> None:
     assert list(cirq.to_resolvers(None)) == [cirq.ParamResolver({})]
 
 
-def test_to_resolvers_single():
+def test_to_resolvers_single() -> None:
     resolver = cirq.ParamResolver({})
     assert list(cirq.to_resolvers(resolver)) == [resolver]
     assert list(cirq.to_resolvers({})) == [resolver]
 
 
-def test_to_resolvers_sweep():
+def test_to_resolvers_sweep() -> None:
     sweep = cirq.Linspace('a', 0, 1, 10)
     assert list(cirq.to_resolvers(sweep)) == list(sweep)
 
 
-def test_to_resolvers_iterable():
+def test_to_resolvers_iterable() -> None:
     resolvers = [cirq.ParamResolver({'a': 2}), cirq.ParamResolver({'a': 1})]
     assert list(cirq.to_resolvers(resolvers)) == resolvers
     assert list(cirq.to_resolvers([{'a': 2}, {'a': 1}])) == resolvers
 
 
-def test_to_resolvers_iterable_sweeps():
+def test_to_resolvers_iterable_sweeps() -> None:
     sweeps = [cirq.Linspace('a', 0, 1, 10), cirq.Linspace('b', 0, 1, 10)]
     assert list(cirq.to_resolvers(sweeps)) == list(itertools.chain(*sweeps))
 
 
-def test_to_resolvers_bad():
+def test_to_resolvers_bad() -> None:
     with pytest.raises(TypeError, match='Unrecognized sweepable'):
         for _ in cirq.study.to_resolvers('nope'):
             pass
 
 
-def test_to_sweeps_none():
+def test_to_sweeps_none() -> None:
     assert cirq.study.to_sweeps(None) == [cirq.UnitSweep]
 
 
-def test_to_sweeps_single():
+def test_to_sweeps_single() -> None:
     resolver = cirq.ParamResolver({})
     assert cirq.study.to_sweeps(resolver) == [cirq.UnitSweep]
     assert cirq.study.to_sweeps({}) == [cirq.UnitSweep]
 
 
-def test_to_sweeps_sweep():
+def test_to_sweeps_sweep() -> None:
     sweep = cirq.Linspace('a', 0, 1, 10)
     assert cirq.study.to_sweeps(sweep) == [sweep]
 
 
-def test_to_sweeps_iterable():
+def test_to_sweeps_iterable() -> None:
     resolvers = [cirq.ParamResolver({'a': 2}), cirq.ParamResolver({'a': 1})]
     sweeps = [cirq.study.Zip(cirq.Points('a', [2])), cirq.study.Zip(cirq.Points('a', [1]))]
     assert cirq.study.to_sweeps(resolvers) == sweeps
     assert cirq.study.to_sweeps([{'a': 2}, {'a': 1}]) == sweeps
 
 
-def test_to_sweeps_iterable_sweeps():
+def test_to_sweeps_iterable_sweeps() -> None:
     sweeps = [cirq.Linspace('a', 0, 1, 10), cirq.Linspace('b', 0, 1, 10)]
     assert cirq.study.to_sweeps(sweeps) == sweeps
 
 
-def test_to_sweeps_dictionary_of_list():
+def test_to_sweeps_dictionary_of_list() -> None:
     with pytest.warns(DeprecationWarning, match='dict_to_product_sweep'):
         assert cirq.study.to_sweeps({'t': [0, 2, 3]}) == cirq.study.to_sweeps(
             [{'t': 0}, {'t': 2}, {'t': 3}]
@@ -98,12 +98,12 @@ def test_to_sweeps_dictionary_of_list():
         )
 
 
-def test_to_sweeps_invalid():
+def test_to_sweeps_invalid() -> None:
     with pytest.raises(TypeError, match='Unrecognized sweepable'):
         cirq.study.to_sweeps('nope')
 
 
-def test_to_sweep_sweep():
+def test_to_sweep_sweep() -> None:
     sweep = cirq.Linspace('a', 0, 1, 10)
     assert cirq.to_sweep(sweep) is sweep
 
@@ -117,7 +117,7 @@ def test_to_sweep_sweep():
         lambda: cirq.ParamResolver({sympy.Symbol('a'): 1}),
     ],
 )
-def test_to_sweep_single_resolver(r_gen):
+def test_to_sweep_single_resolver(r_gen) -> None:
     sweep = cirq.to_sweep(r_gen())
     assert isinstance(sweep, cirq.Sweep)
     assert list(sweep) == [cirq.ParamResolver({'a': 1})]
@@ -141,18 +141,18 @@ def test_to_sweep_single_resolver(r_gen):
         lambda: {object(): r for r in [{'a': 1}, {'a': 1.5}]}.values(),
     ],
 )
-def test_to_sweep_resolver_list(r_list_gen):
+def test_to_sweep_resolver_list(r_list_gen) -> None:
     sweep = cirq.to_sweep(r_list_gen())
     assert isinstance(sweep, cirq.Sweep)
     assert list(sweep) == [cirq.ParamResolver({'a': 1}), cirq.ParamResolver({'a': 1.5})]
 
 
-def test_to_sweep_type_error():
+def test_to_sweep_type_error() -> None:
     with pytest.raises(TypeError, match='Unexpected sweep'):
-        cirq.to_sweep(5)
+        cirq.to_sweep(5)  # type: ignore[arg-type]
 
 
-def test_to_sweeps_with_param_dict_appends_metadata():
+def test_to_sweeps_with_param_dict_appends_metadata() -> None:
     params = {'a': 1, 'b': 2, 'c': 3}
     unit_map = {'a': 'ns', 'b': 'ns'}
 
@@ -167,7 +167,7 @@ def test_to_sweeps_with_param_dict_appends_metadata():
     ]
 
 
-def test_to_sweeps_with_param_list_appends_metadata():
+def test_to_sweeps_with_param_list_appends_metadata() -> None:
     resolvers = [cirq.ParamResolver({'a': 2}), cirq.ParamResolver({'a': 1})]
     unit_map = {'a': 'ns'}
 

cirq/study/sweeps.py

@@ -17,7 +17,8 @@ from __future__ import annotations
 import abc
 import collections
 import itertools
-from typing import Any, cast, Iterable, Iterator, overload, Sequence, TYPE_CHECKING, Union
+from collections.abc import Iterable, Iterator, Mapping, Sequence
+from typing import Any, cast, overload, TYPE_CHECKING, Union
 
 import sympy
 
@@ -653,3 +654,27 @@ def dict_to_zip_sweep(factor_dict: ProductOrZipSweepLike) -> Zip:
             for k, v in factor_dict.items()
         )
     )
+
+
+def list_of_dicts_to_zip(params: Sequence[Mapping[str, float]]) -> cirq.Zip:
+    """Converts a list of dictionaries into a cirq.Zip of cirq.Points.
+
+    This will convert lists of dictionaries into a more compact
+    Sweep format.   For large sweeps, this can vastly improve performance.
+
+    This will change [{'a': 1.0, 'b': 2.0}, {'a': 3.0, 'b': 4.0}]
+    into cirq.Zip(cirq.Points('a', [1.0, 3.0]), cirq.Points('b', [2.0, 4.0])_)
+
+    Raises:
+        ValueError if the keys in any of the list items are not the same.
+    """
+    param_keys: dict[str, list[float]] = collections.defaultdict(list)
+    if len(params) < 1:
+        raise ValueError("Input dictionary to convert is empty.")
+    sweep_keys = params[0].keys()
+    for sweep_point in params:
+        if set(sweep_point.keys()) != sweep_keys:
+            raise ValueError("Keys must be the same in each sweep point.")
+        for key, value in sweep_point.items():
+            param_keys[key].append(value)
+    return Zip(*(Points(key, points) for key, points in param_keys.items()))