libqasm 0.6.7__cp312-cp312-macosx_10_9_x86_64.whl

cqasm/v3x/instruction.py

@@ -0,0 +1,42 @@
+import cqasm.v3x.types
+
+
+class Instruction(object):
+    def __init__(self, name, types=None):
+        super().__init__()
+        self._name = str(name)
+        if types is None:
+            self._types = ()
+        else:
+            for typ in types:
+                if not isinstance(typ, cqasm.v3x.types.Node):
+                    raise TypeError('types must be an iterable of cqasm.v3x.types.Node if specified')
+            self._types = tuple(types)
+
+    @property
+    def name(self):
+        return self._name
+
+    @property
+    def types(self):
+        return self._types
+
+    def __str__(self):
+        return '{}({})'.format(self._name, ', '.join(map(str, self._types)))
+
+
+class InstructionRef(object):
+    def __init__(self, *args, **kwargs):
+        if not args and not kwargs:
+            self._data = None
+        elif len(args) == 1 and not kwargs and (isinstance(args[0], Instruction) or args[0] is None):
+            self._data = args[0]
+        else:
+            self._data = Instruction(*args, **kwargs)
+
+    @property
+    def data(self):
+        return self._data
+
+    def __str__(self):
+        return 'unresolved' if self._data is None else str(self._data)

cqasm/v3x/primitives.py

@@ -0,0 +1,72 @@
+import cqasm.v3x.instruction
+import cqasm.v3x.types
+
+Str = str
+Bool = bool
+Int = int
+Float = float
+Complex = complex
+
+
+class Version(tuple):
+    """cQASM file version number."""
+
+    def __new__(cls, elements):
+        if isinstance(elements, str):
+            elements = elements.split('.')
+        return super(Version, cls).__new__(cls, tuple(map(int, elements)))
+
+
+def serialize(typ, val):
+    if isinstance(typ, str):
+        return None
+    elif typ is Str:
+        return {'x': val}
+    elif typ is Bool:
+        return {'x': val}
+    elif typ is Int:
+        return {'x': val}
+    elif typ is Float:
+        return {'x': val}
+    elif typ is Version:
+        return {'x': list(val)}
+    elif typ is cqasm.v3x.instruction.InstructionRef:
+        if val.data is None:
+            return {}
+        else:
+            return {
+                'n': val.data.name,
+                't': [x.serialize() for x in val.data.types]
+            }
+    else:
+        assert False
+
+
+def deserialize(typ, val):
+    if isinstance(typ, str):
+        return None
+    elif typ is Str and isinstance(val['x'], bytes):
+        # CBOR strings are bytes objects. The correct conversion to Str would be through a decoding.
+        # Str(b'qubit', 'utf-8') would generate the string "qubit". This is the same as b'qubit'.decode('utf-8')
+        # Whereas Str(b'qubit') would generate the string "b'qubit'"
+        return Str(val['x'], 'utf-8')
+    elif typ is Str:
+        return Str(val['x'])
+    elif typ is Bool:
+        return Bool(val['x'])
+    elif typ is Int:
+        return Int(val['x'])
+    elif typ is Float:
+        return Float(val['x'])
+    elif typ is Version:
+        return Version(val['x'])
+    elif typ is cqasm.v3x.instruction.InstructionRef:
+        if 'n' in val:
+            return cqasm.v3x.instruction.InstructionRef(
+                val['n'],
+                [cqasm.v3x.types.Node.deserialize(x) for x in val['t']]
+            )
+        else:
+            return cqasm.v3x.instruction.InstructionRef()
+    else:
+        assert False