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

cqasm/v3x/semantic.py

@@ -1553,22 +1553,22 @@ class Program(Node):
     __slots__ = [
         '_attr_api_version',
         '_attr_version',
-        '_attr_qubit_variable_declaration',
         '_attr_block',
+        '_attr_variables',
     ]
 
     def __init__(
         self,
         api_version=None,
         version=None,
-        qubit_variable_declaration=None,
         block=None,
+        variables=None,
     ):
         super().__init__()
         self.api_version = api_version
         self.version = version
-        self.qubit_variable_declaration = qubit_variable_declaration
         self.block = block
+        self.variables = variables
 
     @property
     def api_version(self):
@@ -1614,27 +1614,6 @@ class Program(Node):
     def version(self):
         self._attr_version = None
 
-    @property
-    def qubit_variable_declaration(self):
-        """Qubit variable."""
-        return self._attr_qubit_variable_declaration
-
-    @qubit_variable_declaration.setter
-    def qubit_variable_declaration(self, val):
-        if val is None:
-            del self.qubit_variable_declaration
-            return
-        if not isinstance(val, Variable):
-            # 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
-
-    @qubit_variable_declaration.deleter
-    def qubit_variable_declaration(self):
-        self._attr_qubit_variable_declaration = None
-
     @property
     def block(self):
         """Global scope block."""
@@ -1656,6 +1635,27 @@ class Program(Node):
     def block(self):
         self._attr_block = None
 
+    @property
+    def variables(self):
+        """The list of variables."""
+        return self._attr_variables
+
+    @variables.setter
+    def variables(self, val):
+        if val is None:
+            del self.variables
+            return
+        if not isinstance(val, MultiVariable):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('variables must be of type MultiVariable')
+            val = MultiVariable(val)
+        self._attr_variables = val
+
+    @variables.deleter
+    def variables(self):
+        self._attr_variables = MultiVariable()
+
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
         if not isinstance(other, Program):
@@ -1664,10 +1664,10 @@ class Program(Node):
             return False
         if self.version != other.version:
             return False
-        if self.qubit_variable_declaration != other.qubit_variable_declaration:
-            return False
         if self.block != other.block:
             return False
+        if self.variables != other.variables:
+            return False
         return True
 
     def dump(self, indent=0, annotations=None, links=1):
@@ -1697,21 +1697,22 @@ class Program(Node):
             s.append(self.version.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + '>\n')
         s.append('  '*indent)
-        s.append('qubit_variable_declaration: ')
-        if self.qubit_variable_declaration is None:
-            s.append('-\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('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')
             s.append('  '*indent + '>\n')
+        s.append('  '*indent)
+        s.append('variables: ')
+        if not self.variables:
+            s.append('-\n')
+        else:
+            s.append('[\n')
+            for child in self.variables:
+                s.append(child.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + ']\n')
         indent -= 1
         s.append('  '*indent)
         s.append(')')
@@ -1731,10 +1732,10 @@ class Program(Node):
         id_map[id(self)] = len(id_map)
         if self._attr_version is not None:
             self._attr_version.find_reachable(id_map)
-        if self._attr_qubit_variable_declaration is not None:
-            self._attr_qubit_variable_declaration.find_reachable(id_map)
         if self._attr_block is not None:
             self._attr_block.find_reachable(id_map)
+        for el in self._attr_variables:
+            el.find_reachable(id_map)
         return id_map
 
     def check_complete(self, id_map=None):
@@ -1748,18 +1749,20 @@ class Program(Node):
             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_qubit_variable_declaration is not None:
-            self._attr_qubit_variable_declaration.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)
+        for child in self._attr_variables:
+            child.check_complete(id_map)
 
     def copy(self):
         """Returns a shallow copy of this node."""
         return Program(
             api_version=self._attr_api_version,
             version=self._attr_version,
-            qubit_variable_declaration=self._attr_qubit_variable_declaration,
-            block=self._attr_block
+            block=self._attr_block,
+            variables=self._attr_variables.copy()
         )
 
     def clone(self):
@@ -1771,8 +1774,8 @@ class Program(Node):
         return Program(
             api_version=_cloned(self._attr_api_version),
             version=_cloned(self._attr_version),
-            qubit_variable_declaration=_cloned(self._attr_qubit_variable_declaration),
-            block=_cloned(self._attr_block)
+            block=_cloned(self._attr_block),
+            variables=_cloned(self._attr_variables)
         )
 
     @staticmethod
@@ -1811,30 +1814,34 @@ class Program(Node):
         else:
             f_version = Version._deserialize(field, seq_to_ob, links)
 
-        # 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') != '?':
-            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 block field.
         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
         else:
             f_block = Block._deserialize(field, seq_to_ob, links)
 
+        # Deserialize the variables field.
+        field = cbor.get('variables', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field variables')
+        if field.get('@T') != '*':
+            raise ValueError('unexpected edge type for field variables')
+        data = field.get('@d', None)
+        if not isinstance(data, list):
+            raise ValueError('missing serialization of Any/Many contents')
+        f_variables = MultiVariable()
+        for element in data:
+            if element.get('@T') != '1':
+                raise ValueError('unexpected edge type for Any/Many element')
+            f_variables.append(Variable._deserialize(element, seq_to_ob, links))
+
         # Construct the Program node.
-        node = Program(f_api_version, f_version, f_qubit_variable_declaration, f_block)
+        node = Program(f_api_version, f_version, f_block, f_variables)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -1874,22 +1881,24 @@ class Program(Node):
             field.update(self._attr_version._serialize(id_map))
         cbor['version'] = field
 
-        # Serialize the qubit_variable_declaration field.
-        field = {'@T': '?'}
-        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 block field.
-        field = {'@T': '?'}
+        field = {'@T': '1'}
         if self._attr_block is None:
             field['@t'] = None
         else:
             field.update(self._attr_block._serialize(id_map))
         cbor['block'] = field
 
+        # Serialize the variables field.
+        field = {'@T': '*'}
+        lst = []
+        for el in self._attr_variables:
+            el = el._serialize(id_map)
+            el['@T'] = '1'
+            lst.append(el)
+        field['@d'] = lst
+        cbor['variables'] = field
+
         # Serialize annotations.
         for key, val in self._annot.items():
             cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))

cqasm/v3x/types.py

@@ -639,8 +639,12 @@ class TypeBase(Node):
             return Int._deserialize(cbor, seq_to_ob, links)
         if typ == 'Float':
             return Float._deserialize(cbor, seq_to_ob, links)
+        if typ == 'Bit':
+            return Bit._deserialize(cbor, seq_to_ob, links)
         if typ == 'Qubit':
             return Qubit._deserialize(cbor, seq_to_ob, links)
+        if typ == 'BitArray':
+            return BitArray._deserialize(cbor, seq_to_ob, links)
         if typ == 'QubitArray':
             return QubitArray._deserialize(cbor, seq_to_ob, links)
         raise ValueError('unknown or unexpected type (@t) found in node serialization')
@@ -673,6 +677,308 @@ class MultiTypeBase(_Multiple):
 
 _typemap['TypeBase'] = TypeBase
 
+class Bit(TypeBase):
+    __slots__ = []
+
+    def __init__(
+        self,
+        size=None,
+    ):
+        super().__init__(size=size)
+
+    def __eq__(self, other):
+        """Equality operator. Ignores annotations!"""
+        if not isinstance(other, Bit):
+            return False
+        if self.size != other.size:
+            return False
+        return True
+
+    def dump(self, indent=0, annotations=None, links=1):
+        """Returns a debug representation of this tree as a multiline string.
+        indent is the number of double spaces prefixed before every line.
+        annotations, if specified, must be a set-like object containing the key
+        strings of the annotations that are to be printed. links specifies the
+        maximum link recursion depth."""
+        s = ['  '*indent]
+        s.append('Bit(')
+        if annotations is None:
+            annotations = []
+        for key in annotations:
+            if key in self:
+                s.append(' # {}: {}'.format(key, self[key]))
+        s.append('\n')
+        indent += 1
+        s.append('  '*indent)
+        s.append('size: ')
+        s.append(str(self.size) + '\n')
+        indent -= 1
+        s.append('  '*indent)
+        s.append(')')
+        return ''.join(s)
+
+    __str__ = dump
+    __repr__ = dump
+
+    def find_reachable(self, id_map=None):
+        """Returns a dictionary mapping Python id() values to stable sequence
+        numbers for all nodes in the tree rooted at this node. If id_map is
+        specified, found nodes are appended to it."""
+        if id_map is None:
+            id_map = {}
+        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)
+        return id_map
+
+    def check_complete(self, id_map=None):
+        """Raises NotWellFormed if the tree rooted at this node is not
+        well-formed. If id_map is specified, this tree is only a subtree in the
+        context of a larger tree, and id_map must be a dict mapping from Python
+        id() codes to tree indices for all reachable nodes."""
+        if id_map is None:
+            id_map = self.find_reachable()
+
+    def copy(self):
+        """Returns a shallow copy of this node."""
+        return Bit(
+            size=self._attr_size
+        )
+
+    def clone(self):
+        """Returns a deep copy of this node. This mimics the C++ interface,
+        deficiencies with links included; that is, links always point to the
+        original tree. If you're not cloning a subtree in a context where this
+        is the desired behavior, you may want to use the copy.deepcopy() from
+        the stdlib instead, which should copy links correctly."""
+        return Bit(
+            size=_cloned(self._attr_size)
+        )
+
+    @staticmethod
+    def _deserialize(cbor, seq_to_ob, links):
+        """Attempts to deserialize the given cbor object (in Python primitive
+        representation) into a node of this type. All (sub)nodes are added to
+        the seq_to_ob dict, indexed by their cbor sequence number. All links are
+        registered in the links list by means of a two-tuple of the setter
+        function for the link field and the sequence number of the target node.
+        """
+        if not isinstance(cbor, dict):
+            raise TypeError('node description object must be a dict')
+        typ = cbor.get('@t', None)
+        if typ is None:
+            raise ValueError('type (@t) field is missing from node serialization')
+        if typ != 'Bit':
+            raise ValueError('found node serialization for ' + typ + ', but expected Bit')
+
+        # Deserialize the size field.
+        field = cbor.get('size', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field size')
+        if hasattr(cqasm.v3x.primitives.Int, 'deserialize_cbor'):
+            f_size = cqasm.v3x.primitives.Int.deserialize_cbor(field)
+        else:
+            f_size = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Int, field)
+
+        # Construct the Bit node.
+        node = Bit(f_size)
+
+        # Deserialize annotations.
+        for key, val in cbor.items():
+            if not (key.startswith('{') and key.endswith('}')):
+                continue
+            key = key[1:-1]
+            node[key] = cqasm.v3x.primitives.deserialize(key, val)
+
+        # Register node in sequence number lookup.
+        seq = cbor.get('@i', None)
+        if not isinstance(seq, int):
+            raise ValueError('sequence number field (@i) is not an integer or missing from node serialization')
+        if seq in seq_to_ob:
+            raise ValueError('duplicate sequence number %d' % seq)
+        seq_to_ob[seq] = node
+
+        return node
+
+    def _serialize(self, id_map):
+        """Serializes this node to the Python primitive representation of its
+        CBOR serialization. The tree that the node belongs to must be
+        well-formed. id_map must match Python id() calls for all nodes to unique
+        integers, to use for the sequence number representation of links."""
+        cbor = {'@i': id_map[id(self)], '@t': 'Bit'}
+
+        # Serialize the size field.
+        if hasattr(self._attr_size, 'serialize_cbor'):
+            cbor['size'] = self._attr_size.serialize_cbor()
+        else:
+            cbor['size'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Int, self._attr_size)
+
+        # Serialize annotations.
+        for key, val in self._annot.items():
+            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
+
+        return cbor
+
+
+class MultiBit(_Multiple):
+    """Wrapper for an edge with multiple Bit objects."""
+
+    _T = Bit
+
+
+_typemap['Bit'] = Bit
+
+class BitArray(TypeBase):
+    __slots__ = []
+
+    def __init__(
+        self,
+        size=None,
+    ):
+        super().__init__(size=size)
+
+    def __eq__(self, other):
+        """Equality operator. Ignores annotations!"""
+        if not isinstance(other, BitArray):
+            return False
+        if self.size != other.size:
+            return False
+        return True
+
+    def dump(self, indent=0, annotations=None, links=1):
+        """Returns a debug representation of this tree as a multiline string.
+        indent is the number of double spaces prefixed before every line.
+        annotations, if specified, must be a set-like object containing the key
+        strings of the annotations that are to be printed. links specifies the
+        maximum link recursion depth."""
+        s = ['  '*indent]
+        s.append('BitArray(')
+        if annotations is None:
+            annotations = []
+        for key in annotations:
+            if key in self:
+                s.append(' # {}: {}'.format(key, self[key]))
+        s.append('\n')
+        indent += 1
+        s.append('  '*indent)
+        s.append('size: ')
+        s.append(str(self.size) + '\n')
+        indent -= 1
+        s.append('  '*indent)
+        s.append(')')
+        return ''.join(s)
+
+    __str__ = dump
+    __repr__ = dump
+
+    def find_reachable(self, id_map=None):
+        """Returns a dictionary mapping Python id() values to stable sequence
+        numbers for all nodes in the tree rooted at this node. If id_map is
+        specified, found nodes are appended to it."""
+        if id_map is None:
+            id_map = {}
+        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)
+        return id_map
+
+    def check_complete(self, id_map=None):
+        """Raises NotWellFormed if the tree rooted at this node is not
+        well-formed. If id_map is specified, this tree is only a subtree in the
+        context of a larger tree, and id_map must be a dict mapping from Python
+        id() codes to tree indices for all reachable nodes."""
+        if id_map is None:
+            id_map = self.find_reachable()
+
+    def copy(self):
+        """Returns a shallow copy of this node."""
+        return BitArray(
+            size=self._attr_size
+        )
+
+    def clone(self):
+        """Returns a deep copy of this node. This mimics the C++ interface,
+        deficiencies with links included; that is, links always point to the
+        original tree. If you're not cloning a subtree in a context where this
+        is the desired behavior, you may want to use the copy.deepcopy() from
+        the stdlib instead, which should copy links correctly."""
+        return BitArray(
+            size=_cloned(self._attr_size)
+        )
+
+    @staticmethod
+    def _deserialize(cbor, seq_to_ob, links):
+        """Attempts to deserialize the given cbor object (in Python primitive
+        representation) into a node of this type. All (sub)nodes are added to
+        the seq_to_ob dict, indexed by their cbor sequence number. All links are
+        registered in the links list by means of a two-tuple of the setter
+        function for the link field and the sequence number of the target node.
+        """
+        if not isinstance(cbor, dict):
+            raise TypeError('node description object must be a dict')
+        typ = cbor.get('@t', None)
+        if typ is None:
+            raise ValueError('type (@t) field is missing from node serialization')
+        if typ != 'BitArray':
+            raise ValueError('found node serialization for ' + typ + ', but expected BitArray')
+
+        # Deserialize the size field.
+        field = cbor.get('size', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field size')
+        if hasattr(cqasm.v3x.primitives.Int, 'deserialize_cbor'):
+            f_size = cqasm.v3x.primitives.Int.deserialize_cbor(field)
+        else:
+            f_size = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Int, field)
+
+        # Construct the BitArray node.
+        node = BitArray(f_size)
+
+        # Deserialize annotations.
+        for key, val in cbor.items():
+            if not (key.startswith('{') and key.endswith('}')):
+                continue
+            key = key[1:-1]
+            node[key] = cqasm.v3x.primitives.deserialize(key, val)
+
+        # Register node in sequence number lookup.
+        seq = cbor.get('@i', None)
+        if not isinstance(seq, int):
+            raise ValueError('sequence number field (@i) is not an integer or missing from node serialization')
+        if seq in seq_to_ob:
+            raise ValueError('duplicate sequence number %d' % seq)
+        seq_to_ob[seq] = node
+
+        return node
+
+    def _serialize(self, id_map):
+        """Serializes this node to the Python primitive representation of its
+        CBOR serialization. The tree that the node belongs to must be
+        well-formed. id_map must match Python id() calls for all nodes to unique
+        integers, to use for the sequence number representation of links."""
+        cbor = {'@i': id_map[id(self)], '@t': 'BitArray'}
+
+        # Serialize the size field.
+        if hasattr(self._attr_size, 'serialize_cbor'):
+            cbor['size'] = self._attr_size.serialize_cbor()
+        else:
+            cbor['size'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Int, self._attr_size)
+
+        # Serialize annotations.
+        for key, val in self._annot.items():
+            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
+
+        return cbor
+
+
+class MultiBitArray(_Multiple):
+    """Wrapper for an edge with multiple BitArray objects."""
+
+    _T = BitArray
+
+
+_typemap['BitArray'] = BitArray
+
 class Bool(TypeBase):
     """Type of a boolean."""
 

{libQasm → libqasm}/__init__.py

@@ -20,6 +20,6 @@ if version_info[0] != 3:
 del version_info
 
 # Import the SWIG-generated module.
-from .libQasm import *
+from .libqasm import *
 
 # __all__ = [ init, schedule, compile ]