Fixed linting errors.

Author: VictorPrins

.flake8

@@ -1,6 +1,6 @@
 [flake8]
 count = True
 exclude = docs, .git, .idea, __pycache__
-ignore = E203 W291 W293 E743 E265 W605
+ignore = E203 W291 W293 E743 E265 W605 W503
 max-line-length = 120
 statistics = True

cqc/MessageHandler.py

@@ -38,10 +38,6 @@
     CQC_CMD_ROT_X,
     CQC_CMD_ROT_Y,
     CQC_CMD_ROT_Z,
-    CQC_TP_HELLO,
-    CQC_TP_COMMAND,
-    CQC_TP_FACTORY,
-    CQC_TP_GET_TIME,
     CQC_CMD_I,
     CQC_CMD_X,
     CQC_CMD_Y,
@@ -67,7 +63,6 @@
     CQC_ERR_UNSUPP,
     CQC_ERR_UNKNOWN,
     CQC_ERR_GENERAL,
-    CQCSequenceHeader,
     CQCFactoryHeader,
     CQCType,
     CQCTypeHeader,
@@ -106,6 +101,7 @@ def has_extra(cmd):
 
     return False
 
+
 def is_error_message(message: bytes):
 
     # Only CQCHeaders can be error messages, so if the length does not correspond it is not an error message
@@ -130,8 +126,6 @@ def is_error_message(message: bytes):
     else:
         return False
 
-    
-
 
 def print_error(error):
     logging.error("Uncaught twisted error found: {}".format(error))
@@ -191,7 +185,6 @@ def __init__(self, factory):
         # Query/assign like this: self.references[app_id][ref_id]
         self.references = {}
 
-
     @inlineCallbacks
     def handle_cqc_message(self, header, message, transport=None):
         """
@@ -390,17 +383,18 @@ def handle_factory(self, header, data):
 
         return succ and should_notify
 
-
     @inlineCallbacks
     def handle_mix(self, header: CQCHeader, data: bytes):
         """
-        Handler for messages of TP_MIX. Notice that header is the CQC Header, and data is the complete body, excluding the CQC Header.
+        Handler for messages of TP_MIX. Notice that header is the CQC Header, 
+        and data is the complete body, excluding the CQC Header.
         """
         # Strategy for handling TP_MIX:
         # The first bit of data will be a CQCType header. We extract this header.
         # We extract from this first CQCType header the type of the following instructions, and we invoke the 
         # corresponding handler from self.messageHandlers. This handler expects as parameter "header" a CQCHeader. 
-        # Therefore, we construct the CQCHeader that corresponds to the CQCType header (remember that the CQCType header is just a reduced CQCHeader),
+        # Therefore, we construct the CQCHeader that corresponds to the CQCType header 
+        # (remember that the CQCType header is just a reduced CQCHeader),
         # and input that constructed CQCHeader as "header" parameter.
         # After this handler returns, we repeat until the end of the program.
 
@@ -423,7 +417,6 @@ def handle_mix(self, header: CQCHeader, data: bytes):
             if type_header.type == CQCType.IF:
                 current_position += result
 
-
         # A TP_MIX should return the first error if there is an error message present, and otherwise return one TP_DONE
         # We use the next function to retrieve the first error message from the list.
         # Notice the [:] syntax. This ensures the underlying list is updated, and not just the variable.
@@ -445,15 +438,17 @@ def handle_conditional(self, header: CQCHeader, data: bytes):
         # Strategy for handling TP_IF:
         # We extract the CQCIFHeader from the data. We then extract all necessary variables from the header.
         # We then evaluate the conditional. If the conditional evaluates to FALSE, then we return the bodylength of
-        # the IF. The mix handler will then skip this bodylength. If the conditional evaluates to True, then we return 0.
+        # the IF. The mix handler will then skip this bodylength. 
+        # If the conditional evaluates to True, then we return 0.
 
         if_header = CQCIFHeader(data[:CQCIFHeader.HDR_LENGTH])
 
         try:
             first_operand_value = self.references[header.app_id][if_header.first_operand]
         except KeyError:
             self.return_messages.append(
-                    self.create_return_message(header.app_id, CQC_ERR_GENERAL, cqc_version=header.version))
+                self.create_return_message(header.app_id, CQC_ERR_GENERAL, cqc_version=header.version)
+            )
 
         if if_header.type_of_second_operand is CQCIFHeader.TYPE_VALUE:
             second_operand_value = if_header.second_operand
@@ -469,7 +464,6 @@ def handle_conditional(self, header: CQCHeader, data: bytes):
         else:
             return if_header.length
 
-
     @abstractmethod
     def handle_hello(self, header, data):
         pass

cqc/cqcHeader.py

@@ -29,7 +29,7 @@
 
 
 # This import allows to use type hints for classes that have not been defined yet. 
-# See https://stackoverflow.com/questions/33533148/how-do-i-specify-that-the-return-type-of-a-method-is-the-same-as-the-class-itsel
+# See https://stackoverflow.com/questions/33533148/
 # This import must be the very first import in this file, otherwise an error is raised
 from __future__ import annotations
 
@@ -134,8 +134,8 @@ class CQCType(IntEnum):
     GET_TIME = 8  # Get creation time of qubit
     INF_TIME = 9  # Return timinig information
     NEW_OK = 10  # Created a new qubit
-    MIX = 11 # Indicate that the CQC program will contain multiple header types
-    IF = 12 # Announce a CQC IF header
+    MIX = 11  # Indicate that the CQC program will contain multiple header types
+    IF = 12  # Announce a CQC IF header
 
     ERR_GENERAL = 20  # General purpose error (no details
     ERR_NOQUBIT = 21  # No more qubits available
@@ -146,16 +146,16 @@ class CQCType(IntEnum):
 
 
 class CQCLogicalOperator(IntEnum):
-    EQ = 0 # Equal
-    NEQ = 1 # Not equal
+    EQ = 0  # Equal
+    NEQ = 1  # Not equal
 
     @staticmethod
-    def opposite_of(operator: 'CQCLogicalOperator'): # String literal type hint because it is a forward reference
-       opposites = {
-           CQCLogicalOperator.EQ: CQCLogicalOperator.NEQ,
-           CQCLogicalOperator.NEQ: CQCLogicalOperator.EQ
-       }
-       return opposites[operator]
+    def opposite_of(operator: CQCLogicalOperator):
+        opposites = {
+            CQCLogicalOperator.EQ: CQCLogicalOperator.NEQ,
+            CQCLogicalOperator.NEQ: CQCLogicalOperator.EQ
+        }
+        return opposites[operator]
 
     @staticmethod
     def is_true(first_operand: int, operator: CQCLogicalOperator, second_operand: int):
@@ -165,6 +165,7 @@ def is_true(first_operand: int, operator: CQCLogicalOperator, second_operand: in
         }
         return comparison_method[operator](second_operand)
 
+
 class Header(metaclass=abc.ABCMeta):
     """
     Abstact class for headers.
@@ -342,22 +343,19 @@ class CQCTypeHeader(Header):
     PACKAGING_FORMAT = "!BI"
     HDR_LENGTH = struct.calcsize(PACKAGING_FORMAT)
 
-
-    def _setVals(self, tp: CQCType=0, length: int=0) -> None:
+    def _setVals(self, tp: CQCType = 0, length: int = 0) -> None:
         """
         Set using given values.
         """
         self.type = tp
         self.length = length
 
-
     def _pack(self) -> bytes:
         """
         Pack data into packet format. For defnitions see cLib/cgc.h
         """
         return struct.pack(self.PACKAGING_FORMAT, self.type, self.length)
 
-
     def _unpack(self, headerBytes) -> None:
         """
         Unpack packet data.
@@ -366,24 +364,21 @@ def _unpack(self, headerBytes) -> None:
         self.type = unpacked[0]
         self.length = unpacked[1]
 
-
-
     def _printable(self) -> str:
         """
         Produce a printable string for information purposes.
         """
         return "CQC Type header. Type=" + str(self.type) + " | Length=" + str(self.length)
 
-
     def make_equivalent_CQCHeader(self, version: int, app_id: int) -> CQCHeader:
         """
-        Produce a CQC Header that is equivalent to this CQCTypeHeader. This method does not make any modifications to self.
+        Produce a CQC Header that is equivalent to this CQCTypeHeader. 
+        This method does not make any modifications to self.
         """
         cqc_header = CQCHeader()
         cqc_header.setVals(version, self.type, app_id, self.length)
         return cqc_header
-        
-
+    
 
 class CQCIFHeader(Header):
     """
@@ -396,12 +391,14 @@ class CQCIFHeader(Header):
     TYPE_VALUE = 0
     TYPE_REF_ID = 1
 
-    def _setVals(self, 
-        first_operand: int=0, 
-        operator: CQCLogicalOperator=0,
-        type_of_second_operand: int=0, 
-        second_operand: int=0,
-        length: int=0) -> None:
+    def _setVals(
+        self, 
+        first_operand: int = 0, 
+        operator: CQCLogicalOperator = 0,
+        type_of_second_operand: int = 0, 
+        second_operand: int = 0,
+        length: int = 0
+    ) -> None:
         """
         Set the fields of this header. 
         first_operand must be a reference id.
@@ -415,7 +412,6 @@ def _setVals(self,
         self.second_operand = second_operand
         self.length = length
 
-
     def _pack(self) -> bytes:
         """
         Pack data into packet format. For defnitions see cLib/cgc.h
@@ -428,8 +424,7 @@ def _pack(self) -> bytes:
             self.type_of_second_operand, 
             self.second_operand, 
             self.length
-        )
-        
+        )     
 
     def _unpack(self, headerBytes) -> None:
         """
@@ -443,7 +438,6 @@ def _unpack(self, headerBytes) -> None:
         self.second_operand = unpacked[3]
         self.length = unpacked[4]
 
-
     def _printable(self) -> str:
         """
         Produce a printable string for information purposes.
@@ -455,11 +449,12 @@ def _printable(self) -> str:
             operand_type = "Value"
 
         # parenthesis to concatenate the string over multiple lines
-        return ("CQC IF header. RefID=" + str(self.first_operand)
-        + " | Operator=" + str(self.operator)
-        + " | " + operand_type + "=" + str(self.second_operand)
-        + " | Second_operand_type=" + operand_type
-        + " | Body_length=" + str(self.length)
+        return (
+            "CQC IF header. RefID=" + str(self.first_operand)
+            + " | Operator=" + str(self.operator)
+            + " | " + operand_type + "=" + str(self.second_operand)
+            + " | Second_operand_type=" + operand_type
+            + " | Body_length=" + str(self.length)
         )
 
 
@@ -471,7 +466,6 @@ class CQCCmdHeader(Header):
     PACKAGING_FORMAT = "!HBB"
     HDR_LENGTH = struct.calcsize(PACKAGING_FORMAT)
 
-
     def _setVals(self, qubit_id=0, instr=0, notify=False, block=False, action=False):
         """
         Set using given values.
@@ -540,23 +534,20 @@ class CQCAssignHeader(Header):
 
     PACKAGING_FORMAT = "!I"
     HDR_LENGTH = struct.calcsize(PACKAGING_FORMAT)
-    
 
-    def _setVals(self, ref_id: int=0) -> None:
+    def _setVals(self, ref_id: int = 0) -> None:
         """
         Set using given values.
         """
         self.ref_id = ref_id
 
-
     def _pack(self) -> bytes:
         """
         Pack data into packet format. For defnitions see cLib/cgc.h
         """
 
         return struct.pack(self.PACKAGING_FORMAT, self.ref_id)
 
-
     def _unpack(self, headerBytes) -> None:
         """
         Unpack packet data. For definitions see cLib/cqc.h
@@ -565,7 +556,6 @@ def _unpack(self, headerBytes) -> None:
 
         self.ref_id = unpacked[0]
 
-
     def _printable(self) -> str:
         """
         Produce a printable string for information purposes.
@@ -574,9 +564,6 @@ def _printable(self) -> str:
         return "CQC Assign sub header. RefID=" + str(self.ref_id)
 
 
-
-
-
 class CQCXtraHeader(Header):
     """
     Optional addtional cmd header information. Only relevant for certain commands.
@@ -782,7 +769,7 @@ class CQCCommunicationHeader(Header):
 
     PACKAGING_FORMAT = "!HHL"
     PACKAGING_FORMAT_V1 = "!HLH"
-    HDR_LENGTH = struct.calcsize(PACKAGING_FORMAT) # Both versions have the same size
+    HDR_LENGTH = struct.calcsize(PACKAGING_FORMAT)  # Both versions have the same size
 
     def __init__(self, headerBytes=None, cqc_version=CQC_VERSION):
         """