Improvements in response to pull request comments

Author: VictorPrins

cqc/MessageHandler.py

@@ -27,6 +27,7 @@
 # SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 from abc import ABC, abstractmethod
+from collections import defaultdict
 import logging
 
 from cqc.cqcHeader import (
@@ -183,7 +184,7 @@ def __init__(self, factory):
 
         # Dictionary that stores all reference ids and their values privately for each app_id.
         # Query/assign like this: self.references[app_id][ref_id]
-        self.references = {}
+        self.references = defaultdict(dict)
 
     @inlineCallbacks
     def handle_cqc_message(self, header, message, transport=None):
@@ -192,10 +193,6 @@ def handle_cqc_message(self, header, message, transport=None):
         """
         self.return_messages = []
 
-        # References are app_id private. If this app doesn't yet have a references dictionary, create one.
-        if header.app_id not in self.references:
-            self.references[header.app_id] = {}
-
         if header.tp in self.messageHandlers:
             try:
                 should_notify = yield self.messageHandlers[header.tp](header, message)
@@ -417,14 +414,18 @@ def handle_mix(self, header: CQCHeader, data: bytes):
                 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.
-        # See https://stackoverflow.com/questions/2361426/get-the-first-item-from-an-iterable-that-matches-a-condition
-        # and https://stackoverflow.com/questions/1207406/how-to-remove-items-from-a-list-while-iterating
-        self.return_messages[:] = [next(
-            (message for message in self.return_messages if is_error_message(message)),
-            self.create_return_message(header.app_id, CQCType.DONE, cqc_version=header.version)
-        )]
+
+        return_message = None
+        for message in self.return_messages:
+            if is_error_message(message):
+                return_message = message
+                break
+        
+        if return_message is None:
+            return_message = self.create_return_message(header.app_id, CQCType.DONE, cqc_version=header.version)
+
+        self.return_messages[:] = [return_message]
 
         # The other handlers from self.message_handlers return a bool that indicates whether 
         # self.handle_cqc_message should append a TP_DONE message. This handle_mix method does that itself 
@@ -444,19 +445,19 @@ def handle_conditional(self, header: CQCHeader, data: bytes):
 
         try:
             first_operand_value = self.references[header.app_id][if_header.first_operand]
+
+            if if_header.type_of_second_operand is CQCIfHeader.TYPE_VALUE:
+                second_operand_value = if_header.second_operand
+            else:
+                second_operand_value = self.references[header.app_id][if_header.second_operand]
+        # If one of the above lookups in self.references fails because the queried reference IDs haven't 
+        # been assigned earlier, a KeyError will be raised
         except KeyError:
             self.return_messages.append(
                 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
-        else:
-            try:
-                second_operand_value = self.references[header.app_id][if_header.second_operand]
-            except KeyError:
-                self.return_messages.append(
-                    self.create_return_message(header.app_id, CQC_ERR_GENERAL, cqc_version=header.version))
+            # Since the referenced IDs don't exist, we consider this IF-statement to evaluate to False.
+            return if_header.length
 
         if CQCLogicalOperator.is_true(first_operand_value, if_header.operator, second_operand_value):
             return 0

cqc/cqcHeader.py

@@ -397,7 +397,7 @@ def _setVals(
         Set the fields of this header. 
         first_operand must be a reference id.
         second_operand will be interpreted as eiter a reference id or a value, dependent on type_of_second_operand.
-        type_of_second_operand must either be CQCIFHEADER.TYPE_VALUE or CQCIFHEADER.TYPE_REF_ID
+        type_of_second_operand must either be CQCIfHeader.TYPE_VALUE or CQCIfHeader.TYPE_REF_ID
         """
 
         self.first_operand = first_operand

cqc/pythonLib.py

@@ -730,7 +730,7 @@ def release_all_qubits(self):
         """
         return self.release_qubits(self.active_qubits[:])
 
-    # sendFactory is depecrated. Do not use it. #
+    # sendFactory is depecrated. Use flush_factory() instead. #
     def sendFactory(
         self,
         qID,
@@ -1481,14 +1481,14 @@ def ref_id(self):
     # override the == operator
     # other can be a CQCVariable or int
     def __eq__(self, other: Union['CQCVariable', int]):
-        return LogicalFunction(self, CQCLogicalOperator.EQ, other)
+        return _LogicalFunction(self, CQCLogicalOperator.EQ, other)
 
     # override the != operator
     def __ne__(self, other: Union['CQCVariable', int]):
-        return LogicalFunction(self, CQCLogicalOperator.NEQ, other)
+        return _LogicalFunction(self, CQCLogicalOperator.NEQ, other)
 
 
-class LogicalFunction:
+class _LogicalFunction:
     """
     Private helper class. This class should never be used outside this pythonLib.
     """
@@ -1516,8 +1516,8 @@ def __init__(
         self.operator = operator
         self.operand_two = operand_two
 
-    def get_negation(self) -> 'LogicalFunction':
-        return LogicalFunction(self.operand_one, CQCLogicalOperator.opposite_of(self.operator), self.operand_two)
+    def get_negation(self) -> '_LogicalFunction':
+        return _LogicalFunction(self.operand_one, CQCLogicalOperator.opposite_of(self.operator), self.operand_two)
 
     def get_CQCIfHeader(self) -> CQCIfHeader:
         """
@@ -1598,28 +1598,28 @@ def __exit__(self, exc_type, exc_val, exc_tb):
             # current_scope is only used inside CQCMix contexts
             self._conn.current_scope = None
 
-    def cqc_if(self, logical_function: LogicalFunction):
+    def cqc_if(self, logical_function: _LogicalFunction):
         """
         Open a Python Context Manager Type to start an if-statement block.
 
         - **Arguments**
 
-            :logical_function:      A LogicalFunction instance. Never instantiate this explicitely; instead
+            :logical_function:      A _LogicalFunction instance. Never instantiate this explicitely; instead
                                     use the following: CQCVariable == 1 OR CQCVariable == CQCVariable. 
                                     CQCVariable can be any instance that you want to test to a value, or to another  
                                     CQCVariable. The operator can be == or !=. 
                                     The value can be any integer (though only 1 and 0 make sense).
                                 
         """
-        return CQCConditional(self._conn, False, logical_function)
+        return _CQCConditional(self._conn, False, logical_function)
 
     def cqc_else(self):
         """
         Open a Python Context Manager Type to start an else-statement block.
         This will be  an else-block of the last closed cqc_if-block.                    
         """
         # Find out to which if this else belongs
-        return CQCConditional(self._conn, True)
+        return _CQCConditional(self._conn, True)
 
     def loop(self, times: int):
         """
@@ -1630,10 +1630,10 @@ def loop(self, times: int):
             :times:     The number of times the commands inside body of this context should be repeated.
                                 
         """
-        return CQCFactory(self._conn, times)
+        return _CQCFactory(self._conn, times)
 
 
-class CQCFactory:
+class _CQCFactory:
     """
     Private class to create factories inside CQCMix contexts. Never explicitely instantiate this class outside 
     the source code of this library.
@@ -1680,34 +1680,34 @@ def __exit__(self, exc_type, exc_val, exc_tb):
         self.type_header.length = body_length
 
 
-class CQCConditional(NodeMixin):
+class _CQCConditional(NodeMixin):
     """
     Private helper class. Never explicitely instantiate this class outside the source code of this library.
     This Context Manager class is instantiated by CQCMix.cqc_if() and CQCMix.cqc_else(). Its 
     function is to build and pend CQC If headers.
     """
 
-    # This private class variable holds the last CQCConditional that 
+    # This private class variable holds the last _CQCConditional that 
     # functioned as an IF (as opposed to an ELSE) on which __exit__ is invoked. 
     # In other words, it is the last closed IF statement. 
     # This is important so that ELSE statements can find out to which IF statement they belong.
     # If this variable is None, then there either has not been aan IF statement yet, or the last 
-    # CQCConditional was an ELSE.
+    # _CQCConditional was an ELSE.
     _last_closed_conditional = None
 
-    def __init__(self, cqc_connection: CQCConnection, is_else: bool, logical_function: LogicalFunction = None):
+    def __init__(self, cqc_connection: CQCConnection, is_else: bool, logical_function: _LogicalFunction = None):
         self._conn = cqc_connection
         self.is_else = is_else
 
         if is_else:
             # If _last_closed_conditional is None, then there either has not been aan IF statement yet, or the last 
-            # CQCConditional was an ELSE.
-            if CQCConditional._last_closed_conditional is None:
+            # _CQCConditional was an ELSE.
+            if _CQCConditional._last_closed_conditional is None:
                 raise CQCGeneralError('Cannot use an ELSE if there is no IF directly before it.')
             else:
                 # Get the negation of the logical function of the IF, 
                 # which will be the logical function for this ELSE statement
-                logical_function = CQCConditional._last_closed_conditional._logical_function.get_negation()
+                logical_function = _CQCConditional._last_closed_conditional._logical_function.get_negation()
 
         self._logical_function = logical_function
 
@@ -1729,9 +1729,9 @@ def __exit__(self, exc_type, exc_val, exc_tb):
 
         # Set _last_closed_conditional to the correct value
         if (self.is_else):
-            CQCConditional._last_closed_conditional = None
+            _CQCConditional._last_closed_conditional = None
         else:
-            CQCConditional._last_closed_conditional = self
+            _CQCConditional._last_closed_conditional = self
 
         # Calculate the length of the body of the conditional
         # Loop in reverse through all pending_headers to calculate the lenght of all headers
@@ -1949,15 +1949,15 @@ def check_active(self):
                 or self.scope_of_deactivation in self._cqc.current_scope.descendants
             ):
 
-                raise QubitNotActiveError("""
-        Qubit is not active. Possible causes:
-        - Qubit is sent to another node
-        - Qubit is measured (with inplace=False)
-        - Qubit is released
-        - Qubit is not received
-        - Qubit is used and created in the same factory
-        - Qubit is measured (with inplace=False) inside a cqc_if block earlier in the code
-        """)
+                raise QubitNotActiveError(
+                    "Qubit is not active. Possible causes:\n"
+                    "- Qubit is sent to another node\n"
+                    "- Qubit is measured (with inplace=False)\n"
+                    "- Qubit is released\n"
+                    "- Qubit is not received\n"
+                    "- Qubit is used and created in the same factory\n"
+                    "- Qubit is measured (with inplace=False) inside a cqc_if block earlier in the code\n"
+                )
 
     def _set_active(self, be_active):