Fix issues flagged by linters/formatters

Author: Takishima

.pre-commit-config.yaml

@@ -117,7 +117,7 @@ repos:
     hooks:
       - id: pylint
         args: ['--score=n']
-        additional_dependencies: [pybind11>=2.6, numpy, requests, matplotlib, networkx]
+        additional_dependencies: [pybind11>=2.6, numpy, requests, matplotlib, networkx, qiskit-terra, pyparsing]
 
   - repo: https://github.com/mgedmin/check-manifest
     rev: '0.48'

projectq/backends/_qasm.py

@@ -45,54 +45,43 @@
 # ==============================================================================
 
 
-class OpenQASMBackend(BasicEngine):
+class OpenQASMBackend(BasicEngine):  # pylint: disable=too-many-instance-attributes
     """
-    Engine to convert ProjectQ commands to OpenQASM format (either string or
-    file)
+    Engine to convert ProjectQ commands to OpenQASM format (either string or file)
     """
 
     def __init__(
         self,
-        collate=True,
         collate_callback=None,
-        qubit_callback=lambda qubit_id: 'q{}'.format(qubit_id),
-        bit_callback=lambda qubit_id: 'c{}'.format(qubit_id),
+        qubit_callback='q{}'.format,
+        bit_callback='c{}'.format,
         qubit_id_mapping_redux=True,
     ):
         """
         Initialize an OpenQASMBackend object.
 
-        Contrary to OpenQASM, ProjectQ does not impose the restriction that a
-        programm must start with qubit/bit allocations and end with some
-        measurements.
+        Contrary to OpenQASM, ProjectQ does not impose the restriction that a programm must start with qubit/bit
+        allocations and end with some measurements.
 
-        The user can configure what happens each time a FlushGate() is
-        encountered by setting the `collate` and `collate_func` arguments to
-        an OpenQASMBackend constructor,
+        The user can configure what happens each time a FlushGate() is encountered by setting the `collate` and
+        `collate_func` arguments to an OpenQASMBackend constructor,
 
         Args:
             output (list,file):
-            collate (bool): If True, simply append commands to the exisiting
-                file/string list when a FlushGate is received. If False, you
-                need to specify `collate_callback` arguments as well.
-            collate (function): Only has an effect if `collate` is False. Each
-                time a FlushGate is received, this callback function will be
-                called.
+            collate (function): Each time a FlushGate is received, this callback function will be called. If let
+                unspecified, the commands are appended to the existing file/string.
                 Function signature: Callable[[Sequence[str]], None]
-            qubit_callback (function): Callback function called upon create of
-                each qubit to generate a name for the qubit.
+            qubit_callback (function): Callback function called upon create of each qubit to generate a name for the
+                qubit.
                 Function signature: Callable[[int], str]
-            bit_callback (function): Callback function called upon create of
-                each qubit to generate a name for the qubit.
+            bit_callback (function): Callback function called upon create of each qubit to generate a name for the
+                qubit.
                 Function signature: Callable[[int], str]
-            qubit_id_mapping_redux (bool): If True, try to allocate new Qubit
-                IDs to the next available qreg/creg (if any), otherwise create
-                a new qreg/creg. If False, simply create a new qreg/creg for
-                each new Qubit ID
+            qubit_id_mapping_redux (bool): If True, try to allocate new Qubit IDs to the next available qreg/creg (if
+                any), otherwise create a new qreg/creg. If False, simply create a new qreg/creg for each new Qubit ID
         """
         super().__init__()
-        self._collate = collate
-        self._collate_callback = None if collate else collate_callback
+        self._collate_callback = collate_callback
         self._gen_qubit_name = qubit_callback
         self._gen_bit_name = bit_callback
         self._qubit_id_mapping_redux = qubit_id_mapping_redux
@@ -107,6 +96,9 @@ def __init__(
 
     @property
     def qasm(self):
+        """
+        Access to the QASM representation of the circuit.
+        """
         return self._output
 
     def is_available(self, cmd):
@@ -150,8 +142,7 @@ def is_available(self, cmd):
             return False
         if not self.is_last_engine:
             return self.next_engine.is_available(cmd)
-        else:
-            return True
+        return True
 
     def receive(self, command_list):
         """
@@ -170,12 +161,11 @@ def receive(self, command_list):
         if not self.is_last_engine:
             self.send(command_list)
 
-    def _store(self, cmd):
+    def _store(self, cmd):  # pylint: disable=too-many-branches,too-many-statements
         """
         Temporarily store the command cmd.
 
-        Translates the command and stores it the _openqasm_circuit attribute
-        (self._openqasm_circuit)
+        Translates the command and stores it the _openqasm_circuit attribute (self._openqasm_circuit)
 
         Args:
             cmd: Command to store
@@ -223,9 +213,8 @@ def _format_angle(angle):
         if gate == Allocate:
             add = True
 
-            # Perform qubit index reduction if possible.  This typically means
-            # that existing qubit keep their indices between FlushGates but
-            # that qubit indices of deallocated qubit may be reused.
+            # Perform qubit index reduction if possible.  This typically means that existing qubit keep their indices
+            # between FlushGates but that qubit indices of deallocated qubit may be reused.
             if self._qubit_id_mapping_redux and self._available_indices:
                 add = False
                 index = self._available_indices.pop()
@@ -263,8 +252,8 @@ def _format_angle(angle):
 
             try:
                 self._output.append('{} {};'.format(_ccontrolled_gates_func[gate], ','.join(controls + targets)))
-            except KeyError:
-                raise RuntimeError('Unable to perform {} gate with n=2 control qubits'.format(gate))
+            except KeyError as err:
+                raise RuntimeError('Unable to perform {} gate with n=2 control qubits'.format(gate)) from err
 
         elif n_controls == 1:
             target_qureg = [self._qreg_dict[qb.id] for qureg in cmd.qubits for qb in qureg]
@@ -300,8 +289,8 @@ def _format_angle(angle):
                             _controlled_gates_func[gate], self._qreg_dict[cmd.control_qubits[0].id], *target_qureg
                         )
                     )
-            except KeyError:
-                raise RuntimeError('Unable to perform {} gate with n=1 control qubits'.format(gate))
+            except KeyError as err:
+                raise RuntimeError('Unable to perform {} gate with n=1 control qubits'.format(gate)) from err
         else:
             target_qureg = [self._qreg_dict[qb.id] for qureg in cmd.qubits for qb in qureg]
             if isinstance(gate, Ph):
@@ -323,7 +312,7 @@ def _reset_after_flush(self):
         """
         Reset the internal quantum circuit after a FlushGate
         """
-        if self._collate:
+        if not self._collate_callback:
             self._output.append('# ' + '=' * 80)
         else:
             self._collate_callback(deepcopy(self._output))

projectq/backends/_qasm_test.py

@@ -346,9 +346,7 @@ def test_qasm_no_collate():
     def _process(output):
         qasm_list.append(output)
 
-    eng = MainEngine(
-        backend=OpenQASMBackend(collate=False, collate_callback=_process, qubit_id_mapping_redux=False), engine_list=[]
-    )
+    eng = MainEngine(backend=OpenQASMBackend(collate_callback=_process, qubit_id_mapping_redux=False), engine_list=[])
     qubit = eng.allocate_qubit()
     ctrls = eng.allocate_qureg(2)
 

projectq/libs/qasm/__init__.py

@@ -21,16 +21,22 @@
 except ImportError:  # pragma: no cover
     try:
         from ._parse_qasm_pyparsing import read_qasm_file, read_qasm_str
-    except ImportError as e:
-        err = (
+    except ImportError:
+        ERROR_MSG = (
             'Unable to import either qiskit or pyparsing\nPlease install either of them if you want to use '
             'projectq.libs.qasm (e.g. using the command python -m pip install projectq[qiskit])'
         )
 
         def read_qasm_file(eng, filename):
+            """
+            Dummy implementation
+            """
             # pylint: disable=unused-argument
-            raise RuntimeError(err)
+            raise RuntimeError(ERROR_MSG)
 
         def read_qasm_str(eng, qasm_str):
+            """
+            Dummy implementation
+            """
             # pylint: disable=unused-argument
-            raise RuntimeError(err)
+            raise RuntimeError(ERROR_MSG)

projectq/libs/qasm/_parse_qasm_pyparsing.py

@@ -434,18 +434,15 @@ def __init__(self, s, loc, toks):
             self.params = param_str[param_str.find('(') + 1 : param_str.rfind(')')].split(',')  # noqa: E203
             self.qubits = [QubitProxy(qubit) for qubit in toks[2]]
 
-    def eval(self, eng):
+    def eval(self, eng):  # pylint: disable=too-many-branches
         """
         Evaluate a GateOp
 
         Args:
             eng (projectq.BasicEngine): ProjectQ MainEngine to use
         """
         if self.name in gates_conv_table:
-            if self.params:
-                gate = gates_conv_table[self.name](*[parse_expr(p) for p in self.params])
-            else:
-                gate = gates_conv_table[self.name]
+            gate = gates_conv_table[self.name](*[parse_expr(p) for p in self.params])
 
             qubits = []
             for qureg in [qubit.eval(eng) for qubit in self.qubits]:

projectq/libs/qasm/_parse_qasm_qiskit.py

@@ -14,10 +14,10 @@
 #   limitations under the License.
 """ Define function to read OpenQASM file format (using Qiskit). """
 
-from projectq.ops import All, Measure
-
 from qiskit.circuit import QuantumCircuit, Clbit
 
+from projectq.ops import All, Measure
+
 from ._qiskit_conv import gates_conv_table
 from ._utils import apply_gate
 
@@ -28,9 +28,8 @@ def apply_op(eng, gate, qubits, bits, bits_map):
     """
     Apply a qiskit operation.
 
-    This function takes care of converting between qiskit gates and ProjectQ
-    gates, as well as handling the translation between qiskit's and ProjectQ's
-    qubit and bits.
+    This function takes care of converting between qiskit gates and ProjectQ gates, as well as handling the
+    translation between qiskit's and ProjectQ's qubit and bits.
 
     Args:
         eng (MainEngine): MainEngine to use to the operation(s)
@@ -64,10 +63,7 @@ def apply_op(eng, gate, qubits, bits, bits_map):
                     eng, gate_sub, [gate_args[qubit.register.name][qubit.index] for qubit in quregs_sub], [], bits_map
                 )
         else:
-            if gate.params:
-                gate_projectq = gates_conv_table[gate.name](*gate.params)
-            else:
-                gate_projectq = gates_conv_table[gate.name]
+            gate_projectq = gates_conv_table[gate.name](*gate.params)
 
             if gate.condition:
                 # OpenQASM 2.0
@@ -100,8 +96,7 @@ def _convert_qiskit_circuit(eng, circuit):
         circuit (qiskit.QuantumCircuit): Quantum circuit to process
 
     Note:
-        At this time, we support most of OpenQASM 2.0 and some of 3.0,
-        although the latter is still experimental.
+        At this time, we support most of OpenQASM 2.0 and some of 3.0, although the latter is still experimental.
     """
     # Create maps between qiskit and ProjectQ for qubits and bits
     qubits_map = {qureg.name: eng.allocate_qureg(qureg.size) for qureg in circuit.qregs}
@@ -119,19 +114,16 @@ def _convert_qiskit_circuit(eng, circuit):
 
 def read_qasm_str(eng, qasm_str):
     """
-    Read an OpenQASM (2.0, 3.0 is experimental) string and convert it to
-    ProjectQ commands.
+    Read an OpenQASM (2.0, 3.0 is experimental) string and convert it to ProjectQ commands.
 
-    This version of the function uses Qiskit in order to parse the *.qasm
-    file.
+    This version of the function uses Qiskit in order to parse the *.qasm file.
 
     Args:
         eng (MainEngine): MainEngine to use for creating qubits and commands.
         filename (string): Path to *.qasm file
 
     Note:
-        At this time, we support most of OpenQASM 2.0 and some of 3.0,
-        although the latter is still experimental.
+        At this time, we support most of OpenQASM 2.0 and some of 3.0, although the latter is still experimental.
     """
     circuit = QuantumCircuit.from_qasm_str(qasm_str)
     return _convert_qiskit_circuit(eng, circuit)
@@ -142,19 +134,16 @@ def read_qasm_str(eng, qasm_str):
 
 def read_qasm_file(eng, filename):
     """
-    Read an OpenQASM (2.0, 3.0 is experimental) file and convert it to
-    ProjectQ commands.
+    Read an OpenQASM (2.0, 3.0 is experimental) file and convert it to ProjectQ commands.
 
-    This version of the function uses Qiskit in order to parse the *.qasm
-    file.
+    This version of the function uses Qiskit in order to parse the *.qasm file.
 
     Args:
         eng (MainEngine): MainEngine to use for creating qubits and commands.
         filename (string): Path to *.qasm file
 
     Note:
-        At this time, we support most of OpenQASM 2.0 and some of 3.0,
-        although the latter is still experimental.
+        At this time, we support most of OpenQASM 2.0 and some of 3.0, although the latter is still experimental.
     """
 
     circuit = QuantumCircuit.from_qasm_file(filename)

projectq/libs/qasm/_qiskit_conv.py

@@ -12,39 +12,61 @@
 #   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 projectq.ops import Barrier, H, S, Sdagger, T, Tdagger, X, Y, Z, Rx, Ry, Rz, Swap, Toffoli, C, CNOT, U2, U3
+
+"""Contains some helper variables for the Qiskit conversion functions"""
+
+from projectq.ops import (
+    Barrier,
+    HGate,
+    SGate,
+    Sdagger,
+    TGate,
+    Tdagger,
+    XGate,
+    YGate,
+    ZGate,
+    Rx,
+    Ry,
+    Rz,
+    SwapGate,
+    Toffoli,
+    C,
+    CNOT,
+    U2,
+    U3,
+)
 
 # ==============================================================================
 # Conversion map between Qiskit gate names and ProjectQ gates
 
 gates_conv_table = {
-    'barrier': Barrier,
-    'h': H,
-    's': S,
-    'sdg': Sdagger,
-    't': T,
-    'tdg': Tdagger,
-    'x': X,
-    'y': Y,
-    'z': Z,
-    'swap': Swap,
-    'rx': lambda a: Rx(a),
-    'ry': lambda a: Ry(a),
-    'rz': lambda a: Rz(a),
-    'u1': lambda a: Rz(a),
-    'u2': lambda p, l: U2(p, l),
-    'u3': lambda t, p, l: U3(t, p, l),
-    'phase': lambda a: Rz(a),
+    'barrier': lambda: Barrier,
+    'h': HGate,
+    's': SGate,
+    'sdg': lambda: Sdagger,
+    't': TGate,
+    'tdg': lambda: Tdagger,
+    'x': XGate,
+    'y': YGate,
+    'z': ZGate,
+    'swap': SwapGate,
+    'rx': Rx,
+    'ry': Ry,
+    'rz': Rz,
+    'u1': Rz,
+    'u2': U2,
+    'u3': U3,
+    'phase': Rz,
     # Controlled gates
-    'ch': C(H),
-    'cx': CNOT,
-    'cy': C(Y),
-    'cz': C(Z),
-    'cswap': C(Swap),
+    'ch': lambda: C(HGate()),
+    'cx': lambda: CNOT,
+    'cy': lambda: C(YGate()),
+    'cz': lambda: C(ZGate()),
+    'cswap': lambda: C(SwapGate()),
     'crz': lambda a: C(Rz(a)),
     'cu1': lambda a: C(Rz(a)),
     'cu2': lambda p, l: C(U2(p, l)),
     'cu3': lambda t, p, l: C(U3(t, p, l)),
     # Doubly-controlled gates
-    "ccx": Toffoli,
+    "ccx": lambda: Toffoli,
 }