cirq-core 1.1.0.dev20221219200817__py3-none-any.whl → 1.2.0__py3-none-any.whl

cirq/value/digits.py

@@ -182,8 +182,8 @@ def big_endian_int_to_digits(
     if val:
         raise ValueError(
             'Out of range. '
-            'Extracted digits {!r} but the long division process '
-            'left behind {!r} instead of 0.'.format(result, val)
+            f'Extracted digits {result!r} but the long division process '
+            f'left behind {val!r} instead of 0.'
         )
 
     return result[::-1]

cirq/value/linear_dict.py

@@ -18,20 +18,21 @@ from typing import (
     Any,
     Callable,
     Dict,
+    Generic,
     ItemsView,
     Iterable,
     Iterator,
     KeysView,
     Mapping,
     MutableMapping,
+    Optional,
     overload,
     Tuple,
     TypeVar,
     Union,
     ValuesView,
-    Generic,
-    Optional,
 )
+from typing_extensions import Self
 
 Scalar = Union[complex, float, numbers.Complex]
 TVector = TypeVar('TVector')
@@ -41,8 +42,8 @@ TDefault = TypeVar('TDefault')
 
 def _format_coefficient(format_spec: str, coefficient: Scalar) -> str:
     coefficient = complex(coefficient)
-    real_str = '{:{fmt}}'.format(coefficient.real, fmt=format_spec)
-    imag_str = '{:{fmt}}'.format(coefficient.imag, fmt=format_spec)
+    real_str = f'{coefficient.real:{format_spec}}'
+    imag_str = f'{coefficient.imag:{format_spec}}'
     if float(real_str) == 0 and float(imag_str) == 0:
         return ''
     if float(imag_str) == 0:
@@ -70,7 +71,7 @@ def _format_terms(terms: Iterable[Tuple[TVector, Scalar]], format_spec: str):
     formatted_terms = [_format_term(format_spec, vector, coeff) for vector, coeff in terms]
     s = ''.join(formatted_terms)
     if not s:
-        return '{:{fmt}}'.format(0, fmt=format_spec)
+        return f'{0:{format_spec}}'
     if s[0] == '+':
         return s[1:]
     return s
@@ -94,7 +95,7 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, Scalar]):
     def __init__(
         self,
         terms: Optional[Mapping[TVector, Scalar]] = None,
-        validator: Callable[[TVector], bool] = None,
+        validator: Optional[Callable[[TVector], bool]] = None,
     ) -> None:
         """Initializes linear combination from a collection of terms.
 
@@ -113,8 +114,6 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, Scalar]):
         if terms is not None:
             self.update(terms)
 
-    TSelf = TypeVar('TSelf', bound='LinearDict[TVector]')
-
     @classmethod
     def fromkeys(cls, vectors, coefficient=0):
         return LinearDict(dict.fromkeys(vectors, complex(coefficient)))
@@ -123,14 +122,14 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, Scalar]):
         if not self._is_valid(vector):
             raise ValueError(f'{vector} is not compatible with linear combination {self}')
 
-    def clean(self: 'TSelf', *, atol: float = 1e-9) -> 'TSelf':
+    def clean(self, *, atol: float = 1e-9) -> Self:
         """Remove terms with coefficients of absolute value atol or less."""
         negligible = [v for v, c in self._terms.items() if abs(c) <= atol]  # type: ignore[operator]
         for v in negligible:
             del self._terms[v]
         return self
 
-    def copy(self: 'TSelf') -> 'TSelf':
+    def copy(self) -> Self:
         factory = type(self)
         return factory(self._terms.copy())
 
@@ -206,19 +205,19 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, Scalar]):
     def __len__(self) -> int:
         return len([v for v, c in self._terms.items() if c != 0])
 
-    def __iadd__(self: 'TSelf', other: 'TSelf') -> 'TSelf':
+    def __iadd__(self, other: Self) -> Self:
         for vector, other_coefficient in other.items():
             old_coefficient = self._terms.get(vector, 0)
             new_coefficient = old_coefficient + other_coefficient
             self[vector] = new_coefficient
         return self.clean(atol=0)
 
-    def __add__(self: 'TSelf', other: 'TSelf') -> 'TSelf':
+    def __add__(self, other: Self) -> Self:
         result = self.copy()
         result += other
         return result
 
-    def __isub__(self: 'TSelf', other: 'TSelf') -> 'TSelf':
+    def __isub__(self, other: Self) -> Self:
         for vector, other_coefficient in other.items():
             old_coefficient = self._terms.get(vector, 0)
             new_coefficient = old_coefficient - other_coefficient
@@ -226,30 +225,30 @@ class LinearDict(Generic[TVector], MutableMapping[TVector, Scalar]):
         self.clean(atol=0)
         return self
 
-    def __sub__(self: 'TSelf', other: 'TSelf') -> 'TSelf':
+    def __sub__(self, other: Self) -> Self:
         result = self.copy()
         result -= other
         return result
 
-    def __neg__(self: 'TSelf') -> 'TSelf':
+    def __neg__(self) -> Self:
         factory = type(self)
         return factory({v: -c for v, c in self.items()})
 
-    def __imul__(self: 'TSelf', a: Scalar) -> 'TSelf':
+    def __imul__(self, a: Scalar) -> Self:
         for vector in self:
             self._terms[vector] *= a
         self.clean(atol=0)
         return self
 
-    def __mul__(self: 'TSelf', a: Scalar) -> 'TSelf':
+    def __mul__(self, a: Scalar) -> Self:
         result = self.copy()
         result *= a
         return result
 
-    def __rmul__(self: 'TSelf', a: Scalar) -> 'TSelf':
+    def __rmul__(self, a: Scalar) -> Self:
         return self.__mul__(a)
 
-    def __truediv__(self: 'TSelf', a: Scalar) -> 'TSelf':
+    def __truediv__(self, a: Scalar) -> Self:
         return self.__mul__(1 / a)
 
     def __bool__(self) -> bool:

cirq/value/product_state.py

@@ -11,9 +11,10 @@
 # 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 abc
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Dict, Sequence, Tuple, Iterator
+from typing import Dict, Iterator, Optional, Sequence, Tuple, TYPE_CHECKING
 
 import numpy as np
 
@@ -77,7 +78,7 @@ class ProductState:
         if len(dupe_qubits) != 0:
             raise ValueError(
                 "You tried to tensor two states, "
-                "but both contain factors for these qubits: {}".format(sorted(dupe_qubits))
+                f"but both contain factors for these qubits: {sorted(dupe_qubits)}"
             )
 
         new_states = self.states.copy()
@@ -91,7 +92,7 @@ class ProductState:
         states_dict_repr = ', '.join(
             f'{repr(key)}: {repr(val)}' for key, val in self.states.items()
         )
-        return 'cirq.ProductState({%s})' % states_dict_repr
+        return f'cirq.ProductState({{{states_dict_repr}}})'
 
     def __getitem__(self, qubit: 'cirq.Qid') -> _NamedOneQubitState:
         """Return the _NamedOneQubitState at the given qubit."""
@@ -119,7 +120,7 @@ class ProductState:
     def _from_json_dict_(cls, states, **kwargs):
         return cls(states=dict(states))
 
-    def state_vector(self, qubit_order: 'cirq.QubitOrder' = None) -> np.ndarray:
+    def state_vector(self, qubit_order: Optional['cirq.QubitOrder'] = None) -> np.ndarray:
         """The state-vector representation of this state."""
         from cirq import ops
 
@@ -136,7 +137,7 @@ class ProductState:
 
         return mat
 
-    def projector(self, qubit_order: 'cirq.QubitOrder' = None) -> np.ndarray:
+    def projector(self, qubit_order: Optional['cirq.QubitOrder'] = None) -> np.ndarray:
         """The projector associated with this state expressed as a matrix.
 
         This is |s⟩⟨s| where |s⟩ is this state.
@@ -322,4 +323,4 @@ document(
 )
 
 PAULI_STATES = [KET_PLUS, KET_MINUS, KET_IMAG, KET_MINUS_IMAG, KET_ZERO, KET_ONE]
-document(PAULI_STATES, """All one-qubit states stabalized by the pauli operators.""")
+document(PAULI_STATES, """All one-qubit states stabilized by the pauli operators.""")

cirq/value/value_equality_attr.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 """Defines `@cirq.value_equality`, for easy __eq__/__hash__ methods."""
 
-from typing import Union, Callable, overload, Any
+from typing import Any, Callable, Optional, overload, Union
 
 from typing_extensions import Protocol
 
@@ -132,7 +132,7 @@ def value_equality(
 
 
 def value_equality(
-    cls: type = None,
+    cls: Optional[type] = None,
     *,
     unhashable: bool = False,
     distinct_child_types: bool = False,

cirq/vis/heatmap.py

@@ -316,7 +316,7 @@ class TwoQubitInteractionHeatmap(Heatmap):
 
         Args:
             value_map: A map from a qubit tuple location to a value.
-            **kwargs: Optinal kwargs including
+            **kwargs: Optional kwargs including
                 coupler_margin: float, default = 0.03
                 coupler_width: float, default = 0.6
         """

cirq/vis/heatmap_test.py

@@ -97,7 +97,7 @@ def test_cell_colors(ax, colormap_name):
     )
     _, mesh = random_heatmap.plot(ax)
 
-    colormap = mpl.cm.get_cmap(colormap_name)
+    colormap = mpl.colormaps[colormap_name]
     for path, facecolor in zip(mesh.get_paths(), mesh.get_facecolors()):
         vertices = path.vertices[0:4]
         row = int(round(np.mean([v[1] for v in vertices])))
@@ -218,7 +218,7 @@ def test_non_float_values(ax, format_string):
 
     _, mesh = random_heatmap.plot(ax)
 
-    colormap = mpl.cm.get_cmap(colormap_name)
+    colormap = mpl.colormaps[colormap_name]
     for path, facecolor in zip(mesh.get_paths(), mesh.get_facecolors()):
         vertices = path.vertices[0:4]
         row = int(round(np.mean([v[1] for v in vertices])))

cirq/work/collector.py

@@ -19,7 +19,7 @@ from typing_extensions import Protocol
 import duet
 import numpy as np
 
-from cirq import circuits, study, value
+from cirq import study, value
 
 if TYPE_CHECKING:
     import cirq
@@ -29,7 +29,7 @@ if TYPE_CHECKING:
 class CircuitSampleJob:
     """Describes a sampling task."""
 
-    def __init__(self, circuit: circuits.Circuit, *, repetitions: int, tag: Any = None):
+    def __init__(self, circuit: 'cirq.AbstractCircuit', *, repetitions: int, tag: Any = None):
         """Inits CircuitSampleJob.
 
         Args:

cirq/work/observable_measurement_data.py

@@ -14,7 +14,7 @@
 
 import dataclasses
 import datetime
-from typing import Any, Dict, Iterable, List, Mapping, Tuple, TYPE_CHECKING, Union
+from typing import Any, Dict, Iterable, List, Mapping, Optional, Tuple, TYPE_CHECKING, Union
 
 import numpy as np
 import sympy
@@ -212,10 +212,10 @@ class BitstringAccumulator:
         meas_spec: _MeasurementSpec,
         simul_settings: List[InitObsSetting],
         qubit_to_index: Dict['cirq.Qid', int],
-        bitstrings: np.ndarray = None,
-        chunksizes: np.ndarray = None,
-        timestamps: np.ndarray = None,
-        readout_calibration: 'BitstringAccumulator' = None,
+        bitstrings: Optional[np.ndarray] = None,
+        chunksizes: Optional[np.ndarray] = None,
+        timestamps: Optional[np.ndarray] = None,
+        readout_calibration: Optional['BitstringAccumulator'] = None,
     ):
         self._meas_spec = meas_spec
         self._simul_settings = simul_settings

cirq/work/observable_readout_calibration.py

@@ -17,7 +17,9 @@ def calibrate_readout_error(
 ):
     # We know there won't be any fancy sweeps or observables so we can
     # get away with more repetitions per job
-    stopping_criteria = dataclasses.replace(stopping_criteria, repetitions_per_chunk=100_000)
+    stopping_criteria = dataclasses.replace(
+        stopping_criteria, repetitions_per_chunk=100_000  # type: ignore[type-var]
+    )
 
     # Simultaneous readout characterization:
     # We can measure all qubits simultaneously (i.e. _max_setting is ZZZ..ZZ

cirq/work/observable_settings.py

@@ -55,7 +55,7 @@ class InitObsSetting:
             raise ValueError(
                 "`observable`'s qubits should be a subset of those "
                 "found in `init_state`. "
-                "observable qubits: {}. init_state qubits: {}".format(obs_qs, init_qs)
+                f"observable qubits: {obs_qs}. init_state qubits: {init_qs}"
             )
 
     def __str__(self):

cirq/work/pauli_sum_collector.py

@@ -17,7 +17,7 @@ from typing import cast, Dict, Optional, Union, TYPE_CHECKING
 
 import numpy as np
 
-from cirq import circuits, ops
+from cirq import ops
 from cirq.work import collector
 
 if TYPE_CHECKING:
@@ -29,7 +29,7 @@ class PauliSumCollector(collector.Collector):
 
     def __init__(
         self,
-        circuit: 'cirq.Circuit',
+        circuit: 'cirq.AbstractCircuit',
         observable: 'cirq.PauliSumLike',
         *,
         samples_per_term: int,
@@ -99,11 +99,12 @@ class PauliSumCollector(collector.Collector):
 
 
 def _circuit_plus_pauli_string_measurements(
-    circuit: 'cirq.Circuit', pauli_string: 'cirq.PauliString'
-) -> 'cirq.Circuit':
+    circuit: 'cirq.AbstractCircuit', pauli_string: 'cirq.PauliString'
+) -> 'cirq.AbstractCircuit':
     """A circuit measuring the given observable at the end of the given circuit."""
     assert pauli_string
-    circuit = circuit.copy()
-    circuit.append(circuits.Moment(pauli_string.to_z_basis_ops()))
-    circuit.append(circuits.Moment([ops.measure(*sorted(pauli_string.keys()), key='out')]))
-    return circuit
+    return circuit.from_moments(
+        *circuit,
+        pauli_string.to_z_basis_ops(),
+        ops.measure(*sorted(pauli_string.keys()), key='out'),
+    )

cirq/work/sampler.py

@@ -211,6 +211,7 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
         Returns:
             Result list for this run; one for each possible parameter resolver.
         """
+        raise NotImplementedError
 
     @value.alternative(requires='run_sweep', implementation=_run_sweep_async_impl)
     async def run_sweep_async(
@@ -230,6 +231,7 @@ class Sampler(metaclass=value.ABCMetaImplementAnyOneOf):
         Returns:
             Result list for this run; one for each possible parameter resolver.
         """
+        raise NotImplementedError
 
     def run_batch(
         self,

cirq/work/zeros_sampler.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 
 import abc
-from typing import List, TYPE_CHECKING
+from typing import List, Optional, TYPE_CHECKING
 
 import numpy as np
 
@@ -26,7 +26,7 @@ if TYPE_CHECKING:
 class ZerosSampler(work.Sampler, metaclass=abc.ABCMeta):
     """A dummy sampler for testing. Immediately returns zeroes."""
 
-    def __init__(self, device: devices.Device = None):
+    def __init__(self, device: Optional[devices.Device] = None):
         """Construct a sampler that returns 0 for all measurements.
 
         Args:

{cirq_core-1.1.0.dev20221219200817.dist-info → cirq_core-1.2.0.dist-info}/METADATA

@@ -1,24 +1,23 @@
 Metadata-Version: 2.1
 Name: cirq-core
-Version: 1.1.0.dev20221219200817
+Version: 1.2.0
 Summary: A framework for creating, editing, and invoking Noisy Intermediate Scale Quantum (NISQ) circuits.
 Home-page: http://github.com/quantumlib/cirq
 Author: The Cirq Developers
 Author-email: cirq-dev@googlegroups.com
 License: Apache 2
-Platform: UNKNOWN
-Requires-Python: >=3.7.0
-Requires-Dist: duet (~=0.2.7)
+Requires-Python: >=3.9.0
+License-File: LICENSE
+Requires-Dist: duet (~=0.2.8)
 Requires-Dist: matplotlib (~=3.0)
-Requires-Dist: networkx (~=2.4)
-Requires-Dist: numpy (<1.24,>=1.16)
+Requires-Dist: networkx (>=2.4)
+Requires-Dist: numpy (~=1.16)
 Requires-Dist: pandas
 Requires-Dist: sortedcontainers (~=2.0)
 Requires-Dist: scipy
 Requires-Dist: sympy
-Requires-Dist: typing-extensions
+Requires-Dist: typing-extensions (>=4.2)
 Requires-Dist: tqdm
-Requires-Dist: backports.cached-property (~=1.0.1) ; python_version < "3.8"
 Provides-Extra: contrib
 Requires-Dist: ply (>=3.6) ; extra == 'contrib'
 Requires-Dist: pylatex (~=1.3.0) ; extra == 'contrib'
@@ -27,11 +26,6 @@ Requires-Dist: opt-einsum ; extra == 'contrib'
 Requires-Dist: autoray ; extra == 'contrib'
 Requires-Dist: numba (>=0.53.0) ; extra == 'contrib'
 
-**This is a development version of Cirq-core and may be unstable.**
-
-**For the latest stable release of Cirq-core see**
-`here <https://pypi.org/project/cirq-core>`__.
-
 .. image:: https://raw.githubusercontent.com/quantumlib/Cirq/master/docs/images/Cirq_logo_color.png
   :target: https://github.com/quantumlib/cirq
   :alt: Cirq
@@ -50,5 +44,3 @@ To install the stable version of only **cirq-core**, use `pip install cirq-core`
 To install the pre-release version of only **cirq-core**, use `pip install cirq-core --pre`.
 
 To get all the optional modules installed as well, you'll have to use `pip install cirq` or `pip install cirq --pre` for the pre-release version.
-
-