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

cirq/contrib/paulistring/separate.py

@@ -12,7 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from typing import Iterator, Tuple
+from __future__ import annotations
+
+from typing import Iterator
 
 from cirq import circuits, ops, transformers
 from cirq.contrib.paulistring.clifford_target_gateset import CliffordTargetGateset
@@ -20,7 +22,7 @@ from cirq.contrib.paulistring.clifford_target_gateset import CliffordTargetGates
 
 def convert_and_separate_circuit(
     circuit: circuits.Circuit, leave_cliffords: bool = True, atol: float = 1e-8
-) -> Tuple[circuits.Circuit, circuits.Circuit]:
+) -> tuple[circuits.Circuit, circuits.Circuit]:
     """Converts a circuit into two, one made of PauliStringPhasor and the other Clifford gates.
 
     Args:
@@ -89,8 +91,9 @@ def pauli_string_half(circuit: circuits.Circuit) -> circuits.Circuit:
 
 
 def _pull_non_clifford_before(circuit: circuits.Circuit) -> Iterator[ops.OP_TREE]:
-    def _iter_ops_range_reversed(moment_end):
-        for i in reversed(range(moment_end)):
+
+    def _iter_ops_range(moment_end):
+        for i in range(moment_end):
             moment = circuit[i]
             for op in moment.operations:
                 if not isinstance(op, ops.PauliStringPhasor):
@@ -99,5 +102,5 @@ def _pull_non_clifford_before(circuit: circuits.Circuit) -> Iterator[ops.OP_TREE
     for i, moment in enumerate(circuit):
         for op in moment.operations:
             if isinstance(op, ops.PauliStringPhasor):
-                ops_to_cross = _iter_ops_range_reversed(i)
-                yield op.pass_operations_over(ops_to_cross)
+                ops_to_cross = _iter_ops_range(i)
+                yield op.conjugated_by(ops_to_cross)

cirq/contrib/paulistring/separate_test.py

@@ -12,11 +12,13 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import cirq
 from cirq.contrib.paulistring import convert_and_separate_circuit
 
 
-def test_toffoli_separate():
+def test_toffoli_separate() -> None:
     q0, q1, q2 = cirq.LineQubit.range(3)
     circuit = cirq.testing.nonoptimal_toffoli_circuit(q0, q1, q2)
 

cirq/contrib/qasm_import/_lexer.py

@@ -12,8 +12,9 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import re
-from typing import Optional
 
 import ply.lex as lex
 
@@ -115,5 +116,5 @@ class QasmLexer:
     def input(self, qasm):
         self.lex.input(qasm)
 
-    def token(self) -> Optional[lex.Token]:
+    def token(self) -> lex.Token | None:
         return self.lex.token()

cirq/contrib/qasm_import/_lexer_test.py

@@ -12,20 +12,22 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from __future__ import annotations
+
 import pytest
 
 from cirq.contrib.qasm_import import QasmException
 from cirq.contrib.qasm_import._lexer import QasmLexer
 
 
-def test_empty_circuit():
+def test_empty_circuit() -> None:
     lexer = QasmLexer()
     lexer.input("")
     assert lexer.token() is None
 
 
 @pytest.mark.parametrize('number', ["00000", "03", "3", "0045", "21"])
-def test_natural_numbers(number: str):
+def test_natural_numbers(number: str) -> None:
     lexer = QasmLexer()
     lexer.input(number)
     token = lexer.token()
@@ -34,7 +36,7 @@ def test_natural_numbers(number: str):
     assert token.value == int(number)
 
 
-def test_supported_format():
+def test_supported_format() -> None:
     lexer = QasmLexer()
     lexer.input("OPENQASM 2.0;")
     token = lexer.token()
@@ -43,7 +45,7 @@ def test_supported_format():
     assert token.value == '2.0'
 
 
-def test_qelib_inc():
+def test_qelib_inc() -> None:
     lexer = QasmLexer()
     lexer.input('include "qelib1.inc";')
     token = lexer.token()
@@ -52,26 +54,31 @@ def test_qelib_inc():
     assert token.value == 'include "qelib1.inc";'
 
 
-def test_measurement():
+def test_measurement() -> None:
     lexer = QasmLexer()
     lexer.input("measure q -> c;")
     token = lexer.token()
+    assert token is not None
     assert token.type == "MEASURE"
     assert token.value == 'measure'
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "ID"
     assert token.value == 'q'
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "ARROW"
     assert token.value == '->'
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "ID"
     assert token.value == 'c'
 
     token = lexer.token()
+    assert token is not None
     assert token.type == ";"
     assert token.value == ';'
 
@@ -79,7 +86,7 @@ def test_measurement():
 @pytest.mark.parametrize(
     'identifier', ['b', 'CX', 'abc', 'aXY03', 'a_valid_name_with_02_digits_and_underscores']
 )
-def test_valid_ids(identifier: str):
+def test_valid_ids(identifier: str) -> None:
     lexer = QasmLexer()
     lexer.input(identifier)
     token = lexer.token()
@@ -93,7 +100,7 @@ def test_valid_ids(identifier: str):
     'number',
     ['1e2', '1e0', '3.', '4.e10', '.333', '1.0', '0.1', '2.0e-05', '1.2E+05', '123123.2132312'],
 )
-def test_numbers(number: str):
+def test_numbers(number: str) -> None:
     lexer = QasmLexer()
     lexer.input(number)
     token = lexer.token()
@@ -104,146 +111,175 @@ def test_numbers(number: str):
 
 
 @pytest.mark.parametrize('token', QasmLexer.reserved.keys())
-def test_keywords(token):
+def test_keywords(token) -> None:
     lexer = QasmLexer()
     identifier = f'{token} {token}'
     lexer.input(identifier)
     t = lexer.token()
+    assert t is not None
     assert t.type == QasmLexer.reserved[token]
     assert t.value == token
     t2 = lexer.token()
+    assert t2 is not None
     assert t2.type == QasmLexer.reserved[token]
     assert t2.value == token
 
 
 @pytest.mark.parametrize('token', QasmLexer.reserved.keys())
 @pytest.mark.parametrize('separator', ['', '_'])
-def test_identifier_starts_or_ends_with_keyword(token, separator):
+def test_identifier_starts_or_ends_with_keyword(token, separator) -> None:
     lexer = QasmLexer()
     identifier = f'{token}{separator}{token}'
     lexer.input(identifier)
     t = lexer.token()
+    assert t is not None
     assert t.type == "ID"
     assert t.value == identifier
 
 
-def test_qreg():
+def test_qreg() -> None:
     lexer = QasmLexer()
     lexer.input('qreg [5];')
     token = lexer.token()
+    assert token is not None
     assert token.type == "QREG"
     assert token.value == "qreg"
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "["
     assert token.value == "["
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "NATURAL_NUMBER"
     assert token.value == 5
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "]"
     assert token.value == "]"
 
     token = lexer.token()
+    assert token is not None
     assert token.type == ";"
     assert token.value == ";"
 
 
-def test_creg():
+def test_creg() -> None:
     lexer = QasmLexer()
     lexer.input('creg [8];')
     token = lexer.token()
+    assert token is not None
     assert token.type == "CREG"
     assert token.value == "creg"
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "["
     assert token.value == "["
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "NATURAL_NUMBER"
     assert token.value == 8
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "]"
     assert token.value == "]"
 
     token = lexer.token()
+    assert token is not None
     assert token.type == ";"
     assert token.value == ";"
 
 
-def test_custom_gate():
+def test_custom_gate() -> None:
     lexer = QasmLexer()
     lexer.input('gate name(param1,param2) q1, q2 {X(q1)}')
     token = lexer.token()
+    assert token is not None
     assert token.type == "GATE"
     assert token.value == "gate"
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "ID"
     assert token.value == "name"
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "("
     assert token.value == "("
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "ID"
     assert token.value == "param1"
 
     token = lexer.token()
+    assert token is not None
     assert token.type == ","
     assert token.value == ","
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "ID"
     assert token.value == "param2"
 
     token = lexer.token()
+    assert token is not None
     assert token.type == ")"
     assert token.value == ")"
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "ID"
     assert token.value == "q1"
 
     token = lexer.token()
+    assert token is not None
     assert token.type == ","
     assert token.value == ","
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "ID"
     assert token.value == "q2"
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "{"
     assert token.value == "{"
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "ID"
     assert token.value == "X"
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "("
     assert token.value == "("
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "ID"
     assert token.value == "q1"
 
     token = lexer.token()
+    assert token is not None
     assert token.type == ")"
     assert token.value == ")"
 
     token = lexer.token()
+    assert token is not None
     assert token.type == "}"
     assert token.value == "}"
 
 
-def test_error():
+def test_error() -> None:
     lexer = QasmLexer()
     lexer.input('θ')