libqasm 0.6.4__cp312-cp312-macosx_10_10_universal2.whl → 0.6.6__cp312-cp312-macosx_10_10_universal2.whl

cqasm/v3x/__init__.py

@@ -1,9 +1,9 @@
 import cqasm.v3x.ast as ast
 import cqasm.v3x.semantic as semantic
-import libQasm
+import libqasm
 
 
-class Analyzer(libQasm.V3xAnalyzer):
+class Analyzer(libqasm.V3xAnalyzer):
     # parse_file and parse_string are static methods because they do not change the status of the analyzer
     # Instead, they just invoke free functions that create a temporary instance of a parser
     # analyze_file and analyze_string are not static methods because they change the status of the analyzer
@@ -14,7 +14,7 @@ class Analyzer(libQasm.V3xAnalyzer):
 
     @staticmethod
     def parse_file(*args):
-        ret = libQasm.V3xAnalyzer.parse_file(*args)
+        ret = libqasm.V3xAnalyzer.parse_file(*args)
         if len(ret) == 1:
             serialized_ast_str = str(ret[0])
             serialized_ast_bytes = serialized_ast_str.encode(encoding='utf-8', errors="surrogateescape")
@@ -24,7 +24,7 @@ class Analyzer(libQasm.V3xAnalyzer):
 
     @staticmethod
     def parse_string(*args):
-        ret = libQasm.V3xAnalyzer.parse_string(*args)
+        ret = libqasm.V3xAnalyzer.parse_string(*args)
         if len(ret) == 1:
             serialized_ast_str = str(ret[0])
             serialized_ast_bytes = serialized_ast_str.encode(encoding='utf-8', errors="surrogateescape")
@@ -52,11 +52,11 @@ class Analyzer(libQasm.V3xAnalyzer):
 
     @staticmethod
     def parse_file_to_json(*args):
-        return libQasm.V3xAnalyzer.parse_file_to_json(*args)
+        return libqasm.V3xAnalyzer.parse_file_to_json(*args)
 
     @staticmethod
     def parse_string_to_json(*args):
-        return libQasm.V3xAnalyzer.parse_string_to_json(*args)
+        return libqasm.V3xAnalyzer.parse_string_to_json(*args)
 
     def analyze_file_to_json(self, *args):
         return super().analyze_file_to_json(*args)

cqasm/v3x/ast.py

@@ -5331,91 +5331,41 @@ _typemap['Gate'] = Gate
 
 class GlobalBlock(Block):
     __slots__ = [
-        '_attr_qubit_variable_declaration',
-        '_attr_gates',
-        '_attr_measure_instructions',
+        '_attr_statements',
     ]
 
     def __init__(
         self,
-        qubit_variable_declaration=None,
-        gates=None,
-        measure_instructions=None,
+        statements=None,
     ):
         super().__init__()
-        self.qubit_variable_declaration = qubit_variable_declaration
-        self.gates = gates
-        self.measure_instructions = measure_instructions
+        self.statements = statements
 
     @property
-    def qubit_variable_declaration(self):
-        return self._attr_qubit_variable_declaration
+    def statements(self):
+        return self._attr_statements
 
-    @qubit_variable_declaration.setter
-    def qubit_variable_declaration(self, val):
+    @statements.setter
+    def statements(self, val):
         if val is None:
-            del self.qubit_variable_declaration
+            del self.statements
             return
-        if not isinstance(val, Variable):
+        if not isinstance(val, MultiStatement):
             # Try to "typecast" if this isn't an obvious mistake.
             if isinstance(val, Node):
-                raise TypeError('qubit_variable_declaration must be of type Variable')
-            val = Variable(val)
-        self._attr_qubit_variable_declaration = val
+                raise TypeError('statements must be of type MultiStatement')
+            val = MultiStatement(val)
+        self._attr_statements = val
 
-    @qubit_variable_declaration.deleter
-    def qubit_variable_declaration(self):
-        self._attr_qubit_variable_declaration = None
-
-    @property
-    def gates(self):
-        return self._attr_gates
-
-    @gates.setter
-    def gates(self, val):
-        if val is None:
-            del self.gates
-            return
-        if not isinstance(val, MultiGate):
-            # Try to "typecast" if this isn't an obvious mistake.
-            if isinstance(val, Node):
-                raise TypeError('gates must be of type MultiGate')
-            val = MultiGate(val)
-        self._attr_gates = val
-
-    @gates.deleter
-    def gates(self):
-        self._attr_gates = MultiGate()
-
-    @property
-    def measure_instructions(self):
-        return self._attr_measure_instructions
-
-    @measure_instructions.setter
-    def measure_instructions(self, val):
-        if val is None:
-            del self.measure_instructions
-            return
-        if not isinstance(val, MultiMeasureInstruction):
-            # Try to "typecast" if this isn't an obvious mistake.
-            if isinstance(val, Node):
-                raise TypeError('measure_instructions must be of type MultiMeasureInstruction')
-            val = MultiMeasureInstruction(val)
-        self._attr_measure_instructions = val
-
-    @measure_instructions.deleter
-    def measure_instructions(self):
-        self._attr_measure_instructions = MultiMeasureInstruction()
+    @statements.deleter
+    def statements(self):
+        self._attr_statements = MultiStatement()
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
         if not isinstance(other, GlobalBlock):
             return False
-        if self.qubit_variable_declaration != other.qubit_variable_declaration:
-            return False
-        if self.gates != other.gates:
-            return False
-        if self.measure_instructions != other.measure_instructions:
+        if self.statements != other.statements:
             return False
         return True
 
@@ -5435,29 +5385,12 @@ class GlobalBlock(Block):
         s.append('\n')
         indent += 1
         s.append('  '*indent)
-        s.append('qubit_variable_declaration: ')
-        if self.qubit_variable_declaration is None:
-            s.append('!MISSING\n')
-        else:
-            s.append('<\n')
-            s.append(self.qubit_variable_declaration.dump(indent + 1, annotations, links) + '\n')
-            s.append('  '*indent + '>\n')
-        s.append('  '*indent)
-        s.append('gates: ')
-        if not self.gates:
-            s.append('-\n')
-        else:
-            s.append('[\n')
-            for child in self.gates:
-                s.append(child.dump(indent + 1, annotations, links) + '\n')
-            s.append('  '*indent + ']\n')
-        s.append('  '*indent)
-        s.append('measure_instructions: ')
-        if not self.measure_instructions:
+        s.append('statements: ')
+        if not self.statements:
             s.append('-\n')
         else:
             s.append('[\n')
-            for child in self.measure_instructions:
+            for child in self.statements:
                 s.append(child.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + ']\n')
         indent -= 1
@@ -5477,11 +5410,7 @@ class GlobalBlock(Block):
         if id(self) in id_map:
             raise NotWellFormed('node {!r} with id {} occurs more than once'.format(self, id(self)))
         id_map[id(self)] = len(id_map)
-        if self._attr_qubit_variable_declaration is not None:
-            self._attr_qubit_variable_declaration.find_reachable(id_map)
-        for el in self._attr_gates:
-            el.find_reachable(id_map)
-        for el in self._attr_measure_instructions:
+        for el in self._attr_statements:
             el.find_reachable(id_map)
         return id_map
 
@@ -5492,21 +5421,13 @@ class GlobalBlock(Block):
         id() codes to tree indices for all reachable nodes."""
         if id_map is None:
             id_map = self.find_reachable()
-        if self._attr_qubit_variable_declaration is None:
-            raise NotWellFormed('qubit_variable_declaration is required but not set')
-        if self._attr_qubit_variable_declaration is not None:
-            self._attr_qubit_variable_declaration.check_complete(id_map)
-        for child in self._attr_gates:
-            child.check_complete(id_map)
-        for child in self._attr_measure_instructions:
+        for child in self._attr_statements:
             child.check_complete(id_map)
 
     def copy(self):
         """Returns a shallow copy of this node."""
         return GlobalBlock(
-            qubit_variable_declaration=self._attr_qubit_variable_declaration,
-            gates=self._attr_gates.copy(),
-            measure_instructions=self._attr_measure_instructions.copy()
+            statements=self._attr_statements.copy()
         )
 
     def clone(self):
@@ -5516,9 +5437,7 @@ class GlobalBlock(Block):
         is the desired behavior, you may want to use the copy.deepcopy() from
         the stdlib instead, which should copy links correctly."""
         return GlobalBlock(
-            qubit_variable_declaration=_cloned(self._attr_qubit_variable_declaration),
-            gates=_cloned(self._attr_gates),
-            measure_instructions=_cloned(self._attr_measure_instructions)
+            statements=_cloned(self._attr_statements)
         )
 
     @staticmethod
@@ -5537,49 +5456,23 @@ class GlobalBlock(Block):
         if typ != 'GlobalBlock':
             raise ValueError('found node serialization for ' + typ + ', but expected GlobalBlock')
 
-        # Deserialize the qubit_variable_declaration field.
-        field = cbor.get('qubit_variable_declaration', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field qubit_variable_declaration')
-        if field.get('@T') != '1':
-            raise ValueError('unexpected edge type for field qubit_variable_declaration')
-        if field.get('@t', None) is None:
-            f_qubit_variable_declaration = None
-        else:
-            f_qubit_variable_declaration = Variable._deserialize(field, seq_to_ob, links)
-
-        # Deserialize the gates field.
-        field = cbor.get('gates', None)
+        # Deserialize the statements field.
+        field = cbor.get('statements', None)
         if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field gates')
+            raise ValueError('missing or invalid serialization of field statements')
         if field.get('@T') != '*':
-            raise ValueError('unexpected edge type for field gates')
+            raise ValueError('unexpected edge type for field statements')
         data = field.get('@d', None)
         if not isinstance(data, list):
             raise ValueError('missing serialization of Any/Many contents')
-        f_gates = MultiGate()
+        f_statements = MultiStatement()
         for element in data:
             if element.get('@T') != '1':
                 raise ValueError('unexpected edge type for Any/Many element')
-            f_gates.append(Gate._deserialize(element, seq_to_ob, links))
-
-        # Deserialize the measure_instructions field.
-        field = cbor.get('measure_instructions', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field measure_instructions')
-        if field.get('@T') != '*':
-            raise ValueError('unexpected edge type for field measure_instructions')
-        data = field.get('@d', None)
-        if not isinstance(data, list):
-            raise ValueError('missing serialization of Any/Many contents')
-        f_measure_instructions = MultiMeasureInstruction()
-        for element in data:
-            if element.get('@T') != '1':
-                raise ValueError('unexpected edge type for Any/Many element')
-            f_measure_instructions.append(MeasureInstruction._deserialize(element, seq_to_ob, links))
+            f_statements.append(Statement._deserialize(element, seq_to_ob, links))
 
         # Construct the GlobalBlock node.
-        node = GlobalBlock(f_qubit_variable_declaration, f_gates, f_measure_instructions)
+        node = GlobalBlock(f_statements)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -5605,33 +5498,15 @@ class GlobalBlock(Block):
         integers, to use for the sequence number representation of links."""
         cbor = {'@i': id_map[id(self)], '@t': 'GlobalBlock'}
 
-        # Serialize the qubit_variable_declaration field.
-        field = {'@T': '1'}
-        if self._attr_qubit_variable_declaration is None:
-            field['@t'] = None
-        else:
-            field.update(self._attr_qubit_variable_declaration._serialize(id_map))
-        cbor['qubit_variable_declaration'] = field
-
-        # Serialize the gates field.
-        field = {'@T': '*'}
-        lst = []
-        for el in self._attr_gates:
-            el = el._serialize(id_map)
-            el['@T'] = '1'
-            lst.append(el)
-        field['@d'] = lst
-        cbor['gates'] = field
-
-        # Serialize the measure_instructions field.
+        # Serialize the statements field.
         field = {'@T': '*'}
         lst = []
-        for el in self._attr_measure_instructions:
+        for el in self._attr_statements:
             el = el._serialize(id_map)
             el['@T'] = '1'
             lst.append(el)
         field['@d'] = lst
-        cbor['measure_instructions'] = field
+        cbor['statements'] = field
 
         # Serialize annotations.
         for key, val in self._annot.items():
@@ -7952,20 +7827,28 @@ class MultiLogicalXorExpression(_Multiple):
 _typemap['LogicalXorExpression'] = LogicalXorExpression
 
 class MeasureInstruction(Instruction):
+    """For some instructions, like the measure instruction, we want to
+    differentiate between left hand side and right and side operands. For a
+    measure instruction, the right hand side operand should be a qubit, and the
+    left hand side operand a bit."""
+
     __slots__ = [
         '_attr_name',
-        '_attr_operand',
+        '_attr_lhs',
+        '_attr_rhs',
     ]
 
     def __init__(
         self,
         name=None,
-        operand=None,
+        lhs=None,
+        rhs=None,
         annotations=None,
     ):
         super().__init__(annotations=annotations)
         self.name = name
-        self.operand = operand
+        self.lhs = lhs
+        self.rhs = rhs
 
     @property
     def name(self):
@@ -7988,24 +7871,44 @@ class MeasureInstruction(Instruction):
         self._attr_name = None
 
     @property
-    def operand(self):
-        return self._attr_operand
+    def lhs(self):
+        return self._attr_lhs
 
-    @operand.setter
-    def operand(self, val):
+    @lhs.setter
+    def lhs(self, val):
         if val is None:
-            del self.operand
+            del self.lhs
             return
         if not isinstance(val, Expression):
             # Try to "typecast" if this isn't an obvious mistake.
             if isinstance(val, Node):
-                raise TypeError('operand must be of type Expression')
+                raise TypeError('lhs must be of type Expression')
             val = Expression(val)
-        self._attr_operand = val
+        self._attr_lhs = val
 
-    @operand.deleter
-    def operand(self):
-        self._attr_operand = None
+    @lhs.deleter
+    def lhs(self):
+        self._attr_lhs = None
+
+    @property
+    def rhs(self):
+        return self._attr_rhs
+
+    @rhs.setter
+    def rhs(self, val):
+        if val is None:
+            del self.rhs
+            return
+        if not isinstance(val, Expression):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('rhs must be of type Expression')
+            val = Expression(val)
+        self._attr_rhs = val
+
+    @rhs.deleter
+    def rhs(self):
+        self._attr_rhs = None
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
@@ -8013,7 +7916,9 @@ class MeasureInstruction(Instruction):
             return False
         if self.name != other.name:
             return False
-        if self.operand != other.operand:
+        if self.lhs != other.lhs:
+            return False
+        if self.rhs != other.rhs:
             return False
         if self.annotations != other.annotations:
             return False
@@ -8043,12 +7948,20 @@ class MeasureInstruction(Instruction):
             s.append(self.name.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + '>\n')
         s.append('  '*indent)
-        s.append('operand: ')
-        if self.operand is None:
+        s.append('lhs: ')
+        if self.lhs is None:
             s.append('!MISSING\n')
         else:
             s.append('<\n')
-            s.append(self.operand.dump(indent + 1, annotations, links) + '\n')
+            s.append(self.lhs.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + '>\n')
+        s.append('  '*indent)
+        s.append('rhs: ')
+        if self.rhs is None:
+            s.append('!MISSING\n')
+        else:
+            s.append('<\n')
+            s.append(self.rhs.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + '>\n')
         s.append('  '*indent)
         s.append('annotations: ')
@@ -8078,8 +7991,10 @@ class MeasureInstruction(Instruction):
         id_map[id(self)] = len(id_map)
         if self._attr_name is not None:
             self._attr_name.find_reachable(id_map)
-        if self._attr_operand is not None:
-            self._attr_operand.find_reachable(id_map)
+        if self._attr_lhs is not None:
+            self._attr_lhs.find_reachable(id_map)
+        if self._attr_rhs is not None:
+            self._attr_rhs.find_reachable(id_map)
         for el in self._attr_annotations:
             el.find_reachable(id_map)
         return id_map
@@ -8095,10 +8010,14 @@ class MeasureInstruction(Instruction):
             raise NotWellFormed('name is required but not set')
         if self._attr_name is not None:
             self._attr_name.check_complete(id_map)
-        if self._attr_operand is None:
-            raise NotWellFormed('operand is required but not set')
-        if self._attr_operand is not None:
-            self._attr_operand.check_complete(id_map)
+        if self._attr_lhs is None:
+            raise NotWellFormed('lhs is required but not set')
+        if self._attr_lhs is not None:
+            self._attr_lhs.check_complete(id_map)
+        if self._attr_rhs is None:
+            raise NotWellFormed('rhs is required but not set')
+        if self._attr_rhs is not None:
+            self._attr_rhs.check_complete(id_map)
         for child in self._attr_annotations:
             child.check_complete(id_map)
 
@@ -8106,7 +8025,8 @@ class MeasureInstruction(Instruction):
         """Returns a shallow copy of this node."""
         return MeasureInstruction(
             name=self._attr_name,
-            operand=self._attr_operand,
+            lhs=self._attr_lhs,
+            rhs=self._attr_rhs,
             annotations=self._attr_annotations.copy()
         )
 
@@ -8118,7 +8038,8 @@ class MeasureInstruction(Instruction):
         the stdlib instead, which should copy links correctly."""
         return MeasureInstruction(
             name=_cloned(self._attr_name),
-            operand=_cloned(self._attr_operand),
+            lhs=_cloned(self._attr_lhs),
+            rhs=_cloned(self._attr_rhs),
             annotations=_cloned(self._attr_annotations)
         )
 
@@ -8149,16 +8070,27 @@ class MeasureInstruction(Instruction):
         else:
             f_name = Identifier._deserialize(field, seq_to_ob, links)
 
-        # Deserialize the operand field.
-        field = cbor.get('operand', None)
+        # Deserialize the lhs field.
+        field = cbor.get('lhs', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field lhs')
+        if field.get('@T') != '1':
+            raise ValueError('unexpected edge type for field lhs')
+        if field.get('@t', None) is None:
+            f_lhs = None
+        else:
+            f_lhs = Expression._deserialize(field, seq_to_ob, links)
+
+        # Deserialize the rhs field.
+        field = cbor.get('rhs', None)
         if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field operand')
+            raise ValueError('missing or invalid serialization of field rhs')
         if field.get('@T') != '1':
-            raise ValueError('unexpected edge type for field operand')
+            raise ValueError('unexpected edge type for field rhs')
         if field.get('@t', None) is None:
-            f_operand = None
+            f_rhs = None
         else:
-            f_operand = Expression._deserialize(field, seq_to_ob, links)
+            f_rhs = Expression._deserialize(field, seq_to_ob, links)
 
         # Deserialize the annotations field.
         field = cbor.get('annotations', None)
@@ -8176,7 +8108,7 @@ class MeasureInstruction(Instruction):
             f_annotations.append(AnnotationData._deserialize(element, seq_to_ob, links))
 
         # Construct the MeasureInstruction node.
-        node = MeasureInstruction(f_name, f_operand, f_annotations)
+        node = MeasureInstruction(f_name, f_lhs, f_rhs, f_annotations)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -8210,13 +8142,21 @@ class MeasureInstruction(Instruction):
             field.update(self._attr_name._serialize(id_map))
         cbor['name'] = field
 
-        # Serialize the operand field.
+        # Serialize the lhs field.
         field = {'@T': '1'}
-        if self._attr_operand is None:
+        if self._attr_lhs is None:
             field['@t'] = None
         else:
-            field.update(self._attr_operand._serialize(id_map))
-        cbor['operand'] = field
+            field.update(self._attr_lhs._serialize(id_map))
+        cbor['lhs'] = field
+
+        # Serialize the rhs field.
+        field = {'@T': '1'}
+        if self._attr_rhs is None:
+            field['@t'] = None
+        else:
+            field.update(self._attr_rhs._serialize(id_map))
+        cbor['rhs'] = field
 
         # Serialize the annotations field.
         field = {'@T': '*'}
@@ -8991,7 +8931,7 @@ class Program(Root):
         s.append('  '*indent)
         s.append('block: ')
         if self.block is None:
-            s.append('-\n')
+            s.append('!MISSING\n')
         else:
             s.append('<\n')
             s.append(self.block.dump(indent + 1, annotations, links) + '\n')
@@ -9030,6 +8970,8 @@ class Program(Root):
             raise NotWellFormed('version is required but not set')
         if self._attr_version is not None:
             self._attr_version.check_complete(id_map)
+        if self._attr_block is None:
+            raise NotWellFormed('block is required but not set')
         if self._attr_block is not None:
             self._attr_block.check_complete(id_map)
 
@@ -9082,7 +9024,7 @@ class Program(Root):
         field = cbor.get('block', None)
         if not isinstance(field, dict):
             raise ValueError('missing or invalid serialization of field block')
-        if field.get('@T') != '?':
+        if field.get('@T') != '1':
             raise ValueError('unexpected edge type for field block')
         if field.get('@t', None) is None:
             f_block = None
@@ -9125,7 +9067,7 @@ class Program(Root):
         cbor['version'] = field
 
         # Serialize the block field.
-        field = {'@T': '?'}
+        field = {'@T': '1'}
         if self._attr_block is None:
             field['@t'] = None
         else: