libqasm 0.6.6__cp39-cp39-win_amd64.whl → 0.6.7__cp39-cp39-win_amd64.whl

cqasm/v3x/__init__.py

@@ -4,16 +4,58 @@ import libqasm
 
 
 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
+    """!
+    Main class for parsing and analyzing cQASM v3.0 files.
 
-    # parse_file, parse_string, analyze_file, and analyze_string return a vector of strings
-    # If the length of the vector is 1, the string is a serialization of the AST
-    # Otherwise, it is a list of errors
+    This class works as a binding for accessing C++ code from Python.
+
+    The parsing methods are static because they do not change the status of the analyzer.
+    Instead, they just invoke free functions that create a temporary instance of a parser.
+
+    None of the parsing or the analyzing methods perform any version check.
+
+    `parse_file`, `parse_string`, `analyze_file`, and `analyze_string`:
+
+      - return a vector of strings.
+        If the length of the vector is 1, the string is a serialization
+        of the syntactic/semantic (in the case of parsing/analyzing) Abstract Syntax Tree (AST)
+        of the input program.
+        Otherwise, it is a list of errors.
+
+    `parse_file_to_json`, `parse_string_to_json`, `analyze_file_to_json`, and `analyze_string_to_json`:
+
+      - return a string in JSON format.
+        If the parsing was successful, the string contains a JSON representation
+        of the AST of the input program.
+        Otherwise, it will contain a list of errors.
+        The JSON representation of each error follows the Language Server Protocol (LSP) specification.
+        Every error is mapped to an LSP Diagnostic structure:
+        `severity` is hardcoded to 1 at the moment (value corresponding to an Error level).
+
+    `parse_string`, `parse_string_to_json`, `analyze_string, and `analyze_string_to_json`:
+
+      - have an optional second argument: `file_name`. It is only used when reporting errors.
+
+     **Example**:
+
+         result = libqasm.analyze_file("grover.cq");
+
+     **Example**:
+
+         program = r'''
+             version 3.0
+             qubit[2] q
+             bit[2] b
+             H q[0]
+             CNOT q[0], q[1]
+             b = measure q
+         '''
+         result = libqasm.parse_string_to_json(program, "bell.cq");
+    """
 
     @staticmethod
-    def parse_file(*args):
+    def parse_file(*args) -> list[str]:
+        """! Parses a file containing a cQASM v3.0 program."""
         ret = libqasm.V3xAnalyzer.parse_file(*args)
         if len(ret) == 1:
             serialized_ast_str = str(ret[0])
@@ -23,7 +65,13 @@ class Analyzer(libqasm.V3xAnalyzer):
         return [str(error) for error in ret[1:]]
 
     @staticmethod
-    def parse_string(*args):
+    def parse_file_to_json(*args) -> str:
+        """! Parses a file containing a cQASM v3.0 program."""
+        return libqasm.V3xAnalyzer.parse_file_to_json(*args)
+
+    @staticmethod
+    def parse_string(*args) -> list[str]:
+        """! Parses a string containing a cQASM v3.0 program."""
         ret = libqasm.V3xAnalyzer.parse_string(*args)
         if len(ret) == 1:
             serialized_ast_str = str(ret[0])
@@ -32,7 +80,13 @@ class Analyzer(libqasm.V3xAnalyzer):
             return deserialized_ast
         return [str(error) for error in ret[1:]]
 
-    def analyze_file(self, *args):
+    @staticmethod
+    def parse_string_to_json(*args) -> str:
+        """! Parses a string containing a cQASM v3.0 program."""
+        return libqasm.V3xAnalyzer.parse_string_to_json(*args)
+
+    def analyze_file(self, *args) -> list[str]:
+        """! Parses and analyzes a file containing a cQASM v3.0 program."""
         ret = super().analyze_file(*args)
         if len(ret) == 1:
             serialized_ast_str = str(ret[0])
@@ -41,7 +95,12 @@ class Analyzer(libqasm.V3xAnalyzer):
             return deserialized_ast
         return [str(error) for error in ret[1:]]
 
-    def analyze_string(self, *args):
+    def analyze_file_to_json(self, *args) -> str:
+        """! Parses and analyzes a file containing a cQASM v3.0 program."""
+        return super().analyze_file_to_json(*args)
+
+    def analyze_string(self, *args) -> list[str]:
+        """! Parses and analyzes a string containing a cQASM v3.0 program."""
         ret = super().analyze_string(*args)
         if len(ret) == 1:
             serialized_ast_str = str(ret[0])
@@ -50,16 +109,6 @@ class Analyzer(libqasm.V3xAnalyzer):
             return deserialized_ast
         return [str(error) for error in ret[1:]]
 
-    @staticmethod
-    def 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)
-
-    def analyze_file_to_json(self, *args):
-        return super().analyze_file_to_json(*args)
-
-    def analyze_string_to_json(self, *args):
+    def analyze_string_to_json(self, *args) -> str:
+        """! Parses and analyzes a string containing a cQASM v3.0 program."""
         return super().analyze_string_to_json(*args)

cqasm/v3x/ast.py

@@ -1172,6 +1172,8 @@ class Annotated(Node):
             return Gate._deserialize(cbor, seq_to_ob, links)
         if typ == 'MeasureInstruction':
             return MeasureInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'ResetInstruction':
+            return ResetInstruction._deserialize(cbor, seq_to_ob, links)
         raise ValueError('unknown or unexpected type (@t) found in node serialization')
 
     def _serialize(self, id_map):
@@ -2526,6 +2528,8 @@ class Statement(Annotated):
             return Gate._deserialize(cbor, seq_to_ob, links)
         if typ == 'MeasureInstruction':
             return MeasureInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'ResetInstruction':
+            return ResetInstruction._deserialize(cbor, seq_to_ob, links)
         raise ValueError('unknown or unexpected type (@t) found in node serialization')
 
     def _serialize(self, id_map):
@@ -2588,6 +2592,8 @@ class BlockStatement(Statement):
             return Gate._deserialize(cbor, seq_to_ob, links)
         if typ == 'MeasureInstruction':
             return MeasureInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'ResetInstruction':
+            return ResetInstruction._deserialize(cbor, seq_to_ob, links)
         raise ValueError('unknown or unexpected type (@t) found in node serialization')
 
     def _serialize(self, id_map):
@@ -5003,6 +5009,8 @@ class Instruction(BlockStatement):
             return Gate._deserialize(cbor, seq_to_ob, links)
         if typ == 'MeasureInstruction':
             return MeasureInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'ResetInstruction':
+            return ResetInstruction._deserialize(cbor, seq_to_ob, links)
         raise ValueError('unknown or unexpected type (@t) found in node serialization')
 
     def _serialize(self, id_map):
@@ -9089,6 +9097,296 @@ class MultiProgram(_Multiple):
 
 _typemap['Program'] = Program
 
+class ResetInstruction(Instruction):
+    __slots__ = [
+        '_attr_name',
+        '_attr_operand',
+    ]
+
+    def __init__(
+        self,
+        name=None,
+        operand=None,
+        annotations=None,
+    ):
+        super().__init__(annotations=annotations)
+        self.name = name
+        self.operand = operand
+
+    @property
+    def name(self):
+        return self._attr_name
+
+    @name.setter
+    def name(self, val):
+        if val is None:
+            del self.name
+            return
+        if not isinstance(val, Identifier):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('name must be of type Identifier')
+            val = Identifier(val)
+        self._attr_name = val
+
+    @name.deleter
+    def name(self):
+        self._attr_name = None
+
+    @property
+    def operand(self):
+        return self._attr_operand
+
+    @operand.setter
+    def operand(self, val):
+        if val is None:
+            del self.operand
+            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')
+            val = Expression(val)
+        self._attr_operand = val
+
+    @operand.deleter
+    def operand(self):
+        self._attr_operand = None
+
+    def __eq__(self, other):
+        """Equality operator. Ignores annotations!"""
+        if not isinstance(other, ResetInstruction):
+            return False
+        if self.name != other.name:
+            return False
+        if self.operand != other.operand:
+            return False
+        if self.annotations != other.annotations:
+            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('ResetInstruction(')
+        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('name: ')
+        if self.name is None:
+            s.append('!MISSING\n')
+        else:
+            s.append('<\n')
+            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('-\n')
+        else:
+            s.append('<\n')
+            s.append(self.operand.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + '>\n')
+        s.append('  '*indent)
+        s.append('annotations: ')
+        if not self.annotations:
+            s.append('-\n')
+        else:
+            s.append('[\n')
+            for child in self.annotations:
+                s.append(child.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + ']\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)
+        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)
+        for el in self._attr_annotations:
+            el.find_reachable(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()
+        if self._attr_name is None:
+            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 not None:
+            self._attr_operand.check_complete(id_map)
+        for child in self._attr_annotations:
+            child.check_complete(id_map)
+
+    def copy(self):
+        """Returns a shallow copy of this node."""
+        return ResetInstruction(
+            name=self._attr_name,
+            operand=self._attr_operand,
+            annotations=self._attr_annotations.copy()
+        )
+
+    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 ResetInstruction(
+            name=_cloned(self._attr_name),
+            operand=_cloned(self._attr_operand),
+            annotations=_cloned(self._attr_annotations)
+        )
+
+    @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 != 'ResetInstruction':
+            raise ValueError('found node serialization for ' + typ + ', but expected ResetInstruction')
+
+        # Deserialize the name field.
+        field = cbor.get('name', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field name')
+        if field.get('@T') != '1':
+            raise ValueError('unexpected edge type for field name')
+        if field.get('@t', None) is None:
+            f_name = None
+        else:
+            f_name = Identifier._deserialize(field, seq_to_ob, links)
+
+        # Deserialize the operand field.
+        field = cbor.get('operand', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field operand')
+        if field.get('@T') != '?':
+            raise ValueError('unexpected edge type for field operand')
+        if field.get('@t', None) is None:
+            f_operand = None
+        else:
+            f_operand = Expression._deserialize(field, seq_to_ob, links)
+
+        # Deserialize the annotations field.
+        field = cbor.get('annotations', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field annotations')
+        if field.get('@T') != '*':
+            raise ValueError('unexpected edge type for field annotations')
+        data = field.get('@d', None)
+        if not isinstance(data, list):
+            raise ValueError('missing serialization of Any/Many contents')
+        f_annotations = MultiAnnotationData()
+        for element in data:
+            if element.get('@T') != '1':
+                raise ValueError('unexpected edge type for Any/Many element')
+            f_annotations.append(AnnotationData._deserialize(element, seq_to_ob, links))
+
+        # Construct the ResetInstruction node.
+        node = ResetInstruction(f_name, f_operand, f_annotations)
+
+        # 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': 'ResetInstruction'}
+
+        # Serialize the name field.
+        field = {'@T': '1'}
+        if self._attr_name is None:
+            field['@t'] = None
+        else:
+            field.update(self._attr_name._serialize(id_map))
+        cbor['name'] = field
+
+        # Serialize the operand field.
+        field = {'@T': '?'}
+        if self._attr_operand is None:
+            field['@t'] = None
+        else:
+            field.update(self._attr_operand._serialize(id_map))
+        cbor['operand'] = field
+
+        # Serialize the annotations field.
+        field = {'@T': '*'}
+        lst = []
+        for el in self._attr_annotations:
+            el = el._serialize(id_map)
+            el['@T'] = '1'
+            lst.append(el)
+        field['@d'] = lst
+        cbor['annotations'] = field
+
+        # Serialize annotations.
+        for key, val in self._annot.items():
+            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
+
+        return cbor
+
+
+class MultiResetInstruction(_Multiple):
+    """Wrapper for an edge with multiple ResetInstruction objects."""
+
+    _T = ResetInstruction
+
+
+_typemap['ResetInstruction'] = ResetInstruction
+
 class ShiftExpression(BinaryExpression):
     __slots__ = []
 

cqasm/v3x/primitives.py

@@ -45,6 +45,11 @@ def serialize(typ, val):
 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:

libqasm/libqasm.py

@@ -1,5 +1,5 @@
 # This file was automatically generated by SWIG (https://www.swig.org).
-# Version 4.1.1
+# Version 4.2.1
 #
 # Do not make changes to this file unless you know what you are doing - modify
 # the SWIG interface file instead.
@@ -443,11 +443,6 @@ class ostream(ios):
 
 # Register ostream in _libqasm:
 _libqasm.ostream_swigregister(ostream)
-cin = cvar.cin
-cout = cvar.cout
-cerr = cvar.cerr
-clog = cvar.clog
-
 class istream(ios):
     thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
     __repr__ = _swig_repr
@@ -507,6 +502,11 @@ class iostream(istream, ostream):
 
 # Register iostream in _libqasm:
 _libqasm.iostream_swigregister(iostream)
+cin = cvar.cin
+cout = cvar.cout
+cerr = cvar.cerr
+clog = cvar.clog
+
 endl_cb_ptr = _libqasm.endl_cb_ptr
 endl = _libqasm.endl
 ends_cb_ptr = _libqasm.ends_cb_ptr

libqasm-0.6.7.dist-info/METADATA

@@ -0,0 +1,127 @@
+Metadata-Version: 2.1
+Name: libqasm
+Version: 0.6.7
+Summary: libqasm Python Package
+Home-page: https://github.com/QuTech-Delft/libqasm
+Author: QuTech, TU Delft
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering
+Description-Content-Type: text/markdown
+License-File: LICENSE.md
+Requires-Dist: numpy
+
+# libQASM
+
+[![CI](https://github.com/QuTech-Delft/libqasm/workflows/Test/badge.svg)](https://github.com/qutech-delft/libqasm/actions)
+[![Conan Center](https://img.shields.io/conan/v/libqasm)](https://conan.io/center/recipes/libqasm)
+[![PyPI](https://badgen.net/pypi/v/libqasm)](https://pypi.org/project/libqasm/)
+![OS](https://img.shields.io/badge/os-emscripten%20%7C%20linux%20%7C%20macos%20%7C%20windows-blue?style=flat-square)
+[![License](https://img.shields.io/badge/License-Apache_2.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+
+libQASM is a library to parse programs written in the cQASM quantum programming language, developed by QuTech. 
+At the moment, libQASM only supports cQASM v3.0 programs.
+
+It performs lexical, syntactic, and semantic analysis of an input program received via a file or a string.
+It produces one of the following results:
+
+- A syntactic or semantic AST (Abstract Syntax Tree) object. Depending on if we are parsing or analysing.
+- A list of parsing or analysing errors. In case the input program was malformed.
+- A JSON representation of either the AST or the list of errors.
+
+It can be used within:
+
+- C++ projects (as a [Conan package](https://conan.io/center/recipes/libqasm)).
+- Python projects (as a [Python package](https://pypi.org/project/libqasm/)).
+- Emscripten projects (via a Typescript frontend).
+
+Check out [QX simulator](https://github.com/QuTech-Delft/qx-simulator)
+and [OpenSquirrel](https://github.com/QuTech-Delft/OpenSquirrel) compiler
+for an example of use in a C++ and a Python project, respectively.
+
+## Getting started
+
+Given a cQASM program `example.cq`.
+
+```cQASM
+version 3.0
+
+qubit[2] q
+bit[2] b
+
+H q[0]
+CNOT q[0], q[1]
+b = measure q
+```
+
+We can parse or analyze this circuit, using libQASM through the following programming language:
+
+### C++
+
+```cpp
+#include "v3/cqasm-py.hpp"
+
+int main() {
+    auto parse_result = V3xAnalyzer::parse_file("example.cq");
+    
+    auto analyzer = V3xAnalyzer();
+    auto analysis_result = analyzer.analyze_file("example.cq");
+}
+```
+
+
+### Emscripten
+
+The emscripten API only allows to input a cQASM program as a string.
+
+```typescript
+import { default as wrapper } from 'cqasm_emscripten.mjs';
+
+wrapper().then(function(result: any) {
+    let analyzer = new result["EmscriptenWrapper"]()
+    let program = `
+        version 3
+        qubit[2] q
+        bit[2] b 
+        H q[0]
+        CNOT q[0], q[1]
+        b = measure q
+    `
+    let output = analyzer.parse_string_to_json(program)
+    analyzer.delete()
+}).catch((error: any) => {
+    console.error("unhandledRejection", error, "\n");
+});
+```
+
+### Python
+
+```python
+from libqasm import Analyzer
+
+if __name__ == "__main__":
+    parse_result = Analyzer.parse_file('example.cq')
+
+    analyzer = Analyzer()
+    analysis_result = analyzer.analyze_file('example.cq')
+```
+
+## Documentation
+
+The [libQASM documentation](https://QuTech-Delft.github.io/libqasm/) is hosted through GitHub Pages.
+
+## License
+
+libQASM is licensed under the Apache License, Version 2.0.
+See [LICENSE](https://github.com/QuTech-Delft/libqasm/blob/master/LICENSE.md) for the full license text.
+
+## Authors
+
+Quantum Inspire: [support@quantum-inspire.com](mailto:"support@quantum-inspire.com")

libqasm-0.6.7.dist-info/RECORD

@@ -0,0 +1,16 @@
+cqasm/__init__.py,sha256=_6Yl-eMBve0mGQA-aiFg4qvQ7GUCV5eGvIcoRf4mEPw,3
+cqasm/v3x/__init__.py,sha256=7TEhDqL-4KxL_9nUkjOWYvgo9nOOY1YiDusYP2Bf8tU,4890
+cqasm/v3x/ast.py,sha256=Zng-B1PS3WLQ21WFnlTmlQli9Fe4SWh5XBaILtfzzkg,431665
+cqasm/v3x/instruction.py,sha256=VAOqFpCH94CrutgMUZnQq8JXFIq_-C-ndTOjHLsg6_8,1219
+cqasm/v3x/primitives.py,sha256=lkxg0gHMFba-O803cOh0QqOANFHsZDK0iHvIluFz-qI,2110
+cqasm/v3x/semantic.py,sha256=wN9awUdn76sNp1WlzV5P4R4Z54r-W0JC4D-xaDzQec4,88679
+cqasm/v3x/types.py,sha256=krT1WB5URT0F7lhKTLwYAs_UtTCn9CZ7-M0WMGmxtU4,65070
+cqasm/v3x/values.py,sha256=SfKw6zIjpMrXJggvN_QGPqsoZXDR7HwUjgUMOBnIzuo,63394
+libqasm/__init__.py,sha256=X0G-HBFW9_uEcsaGROQ1nzxYfHzSuglOiXrpTpjF9_E,752
+libqasm/_libqasm.cp39-win_amd64.pyd,sha256=4wHZ4r_JNkikT-7ewElNxA8I64_gUIFm1QVxfv6wIKY,2302464
+libqasm/libqasm.py,sha256=s0RWrMGoy0vl-lES8ff61BLCa-Rv0FRlQFnaw40u7T0,31677
+libqasm-0.6.7.dist-info/LICENSE.md,sha256=395F6Sje50f5Too7yWFAoS_owYO4aOtjbMeQd_go_sk,579
+libqasm-0.6.7.dist-info/METADATA,sha256=2jnb_TDMrtMvYqgg6fTZXVIkmQFFn-j8A6wIRGb_E0A,4094
+libqasm-0.6.7.dist-info/WHEEL,sha256=Os6_QENWp0Y99Uhn6SmX8k6DheJPHPoZtAIvme4kS_I,99
+libqasm-0.6.7.dist-info/top_level.txt,sha256=iZ8PSLyg3lJwvSUCvWE8VCJGU-nmQY2YIrbMe7M7kLw,14
+libqasm-0.6.7.dist-info/RECORD,,

{libqasm-0.6.6.dist-info → libqasm-0.6.7.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.43.0)
+Generator: setuptools (73.0.1)
 Root-Is-Purelib: false
 Tag: cp39-cp39-win_amd64
 

libqasm-0.6.6.dist-info/METADATA

@@ -1,224 +0,0 @@
-Metadata-Version: 2.1
-Name: libqasm
-Version: 0.6.6
-Summary: libqasm Python Package
-Home-page: https://github.com/QuTech-Delft/libqasm
-Author: QuTech, TU Delft
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: POSIX :: Linux
-Classifier: Operating System :: MacOS
-Classifier: Operating System :: Microsoft :: Windows
-Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Topic :: Scientific/Engineering
-Description-Content-Type: text/markdown
-License-File: LICENSE.md
-Requires-Dist: numpy
-
-# libQASM: Library to parse cQASM v3.0 files
-
-[![CI](https://github.com/QuTech-Delft/libqasm/workflows/Test/badge.svg)](https://github.com/qutech-delft/libqasm/actions)
-[![PyPI](https://badgen.net/pypi/v/libqasm)](https://pypi.org/project/libqasm/)
-
-## File organization
-
-For development, see:
-
-- `include`: public headers.
-- `src`: source files.
-- `test`: test files.
-- `python`: SWIG interface.
-- `res`: resource files, for testing.
-
-For build process, continuous integration, and documentation:
-
-- `conan`: Conan profiles.
-- `emscripten`: bindings and test for the emscripten binaries.
-- `scripts`: helper scripts used during the build process.
-- `.github`: GitHub Actions configuration files.
-- `doc`: documentation.
-
-Build outputs may go into:
-
-- `build/<build type>`: the C++ library output files generated by Conan.
-- `pybuild`: the Python library output files generated by `setup.py`.
-
-## Dependencies
-
-* C++ compiler with C++20 support (gcc 11, clang 14, msvc 17)
-* `CMake` >= 3.12
-* `git`
-* `Python` 3.x plus `pip`, with the following package:
-  * `conan` >= 2.0
-  
-### ARM specific dependencies
-
-We are having problems when using the `zulu-opendjk` Conan package on an ARMv8 architecture.
-`zulu-openjdk` provides the Java JRE required by the ANTLR generator.
-So, for the time being, we are installing Java manually for this platform.
-
-* `Java JRE` >= 11
-
-## Build
-
-This version of `libqasm` can only be compiled via the Conan package manager.
-You'll need to create a default profile before using it for the first time.
-
-The installation of dependencies, as well as the compilation, can be done in one go.
-
-```
-git clone https://github.com/QuTech-Delft/libqasm.git
-cd libqasm
-conan profile detect
-conan build . -pr:a=conan/profiles/tests-debug -b missing
-```
-
-Notice:
-- the `conan profile` command only has to be run only once, and not before every build.
-- the `conan build` command is building `libqasm` in Debug mode with tests using the `tests-debug` profile.
-- the `-b missing` parameter asks `conan` to build packages from sources
-in case it cannot find the binary packages for the current configuration (platform, OS, compiler, build type...). 
-
-### Build profiles
-
-A group of predefined profiles is provided under the `conan/profiles` folder.<br/>
-They follow the `[tests](-build_type)(-compiler)(-os)(-arch)[-shared]` naming convention:
-  - `tests`: if tests are being built.
-  - `build_type`: can be `debug` or `release`.
-  - `compiler`: `apple-clang`, `clang`, `gcc`, `msvc`.
-  - `os`: `emscripten`, `linux`, `macos`, `windows`.
-  - `arch`: `arm64`, `wasm`, `x64`.
-  - `shared`: if the library is being built in shared mode.
-
-All the profiles set the C++ standard to 20.<br/>
-All the `tests`, except for `linux-x64` profiles, enable Address Sanitizer.
-
-### Build options
-
-Profiles are a shorthand for command line options. The command above could be written, similarly,  as: 
-
-```
-conan build . -s:a compiler.cppstd=20 -s:a libqasm/*:build_type=Debug -o libqasm/*:build_tests=True -o libqasm/*:asan_enabled=True -b missing
-```
-
-This is the list of options that could be specified either in a profile or in the command line:
-
-- `libqasm/*:asan_enabled={True,False}`: enables Address Sanitizer.
-- `libqasm/*:build_type={Debug,Release}`: builds in debug or release mode.
-- `libqasm/*:shared={True,False}`: builds a shared object library instead of a static library, if applicable.
-
-Tests are enabled by default. To disable them, use `-c tools.build:skip_test=True`.
-
-## Install
-
-### From Python
-
-Install from the project root directory as follows:
-
-```
-python3 -m pip install --verbose .
-```
-
-You can test if it works by running:
-
-```
-python3 -m pytest
-```
-
-### From C++
-
-The `CMakeLists.txt` file in the root directory includes install targets:
-
-```
-conan create --version 0.6.6 . -pr:a=tests-debug -b missing
-```
-
-You can test if it works by doing:
-
-```
-cd test/Debug
-ctest -C Debug --output-on-failure
-```
-
-## Use from another project
-
-### From Python
-
-The `libqasm` module should provide access to the `V3xAnalyzer` API:
-- `parse_file`,
-- `parse_string`,
-- `analyze_file`, and
-- `analyzer_string`.
-
-The `cqasm.v3x` module is also available for a more fine-grained use of the library.
-
-```
-import cqasm.v3x.ast
-import cqasm.v3x.instruction
-import cqasm.v3x.primitives
-import cqasm.v3x.semantic
-import cqasm.v3x.types
-import cqasm.v3x.values
-```
-
-### From C++
-
-`libqasm` can be requested as a Conan package from a `conanfile.py`.
-
-```
-def build_requirements(self):
-    self.tool_requires("libqasm/0.6.5")
-def requirements(self):
-    self.requires("libqasm/0.6.5")
-```
-
-And then linked against from a `CMakeLists.txt`: 
-
-```
-target_link_libraries(<your target> PUBLIC libqasm::libqasm)
-```
-
-Note that the following dependency is required for `libqasm` to build:
-
-* `Java JRE` >= 11
-
-The header file `cqasm.hpp` should provide access to the following API:
-- `cqasm::v3x::analyze_file`, and
-- `cqasm::v3x::analyze_string`.
-
-Again, other header files are available for a more fine-grained use of the library.
-
-## Docker
-
-This tests the library in a container with the bare minimum requirements for `libqasm`.
-
-```
-docker build .
-```
-
-**Note for Windows users:** The above might fail on Windows due to the `autocrlf` transformation that git does.
-If you are having trouble with this just create new clone of this repository using:
-
-```
-git clone --config core.autocrlf=input git@github.com:QuTech-Delft/libqasm.git
-```
-
-## Emscripten
-
-The generation of emscripten binaries has been tested as a cross-compilation from an ubuntu/x64 platform.
-
-```
-conan build . -pr=conan/profiles/release-clang-emscripten-wasm -pr:b=conan/profiles/release -b missing
-```
-
-The output of this build lives in `build/Release/emscripten`:
-- `cqasm_emscripten.js`.
-- `cqasm_emscripten.wasm`.
-
-Note that `cqasm_emscripten.js` is an ES6 module. An example of how to use it would be:
-
-```
-cd build/Release/emscripten
-mv cqasm_emscripten.js cqasm_emscripten.mjs
-cd ../../../emscripten
-deno run -A test_libqasm.ts
-```

libqasm-0.6.6.dist-info/RECORD

@@ -1,16 +0,0 @@
-cqasm/__init__.py,sha256=_6Yl-eMBve0mGQA-aiFg4qvQ7GUCV5eGvIcoRf4mEPw,3
-cqasm/v3x/__init__.py,sha256=FlmtSTjj083f3t9kTkJBsgs3rQBcgVEkYBqcJ4aKmzs,2850
-cqasm/v3x/ast.py,sha256=snvmnaN80AU5_uJhUAaRsooakjFiMxUG5fUJshkjcVM,420170
-cqasm/v3x/instruction.py,sha256=VAOqFpCH94CrutgMUZnQq8JXFIq_-C-ndTOjHLsg6_8,1219
-cqasm/v3x/primitives.py,sha256=cR3SvCcG5lCzjSFMwHrMSRpf4Bj3Q1tkxUgaaltYJg8,1731
-cqasm/v3x/semantic.py,sha256=wN9awUdn76sNp1WlzV5P4R4Z54r-W0JC4D-xaDzQec4,88679
-cqasm/v3x/types.py,sha256=krT1WB5URT0F7lhKTLwYAs_UtTCn9CZ7-M0WMGmxtU4,65070
-cqasm/v3x/values.py,sha256=SfKw6zIjpMrXJggvN_QGPqsoZXDR7HwUjgUMOBnIzuo,63394
-libqasm/__init__.py,sha256=X0G-HBFW9_uEcsaGROQ1nzxYfHzSuglOiXrpTpjF9_E,752
-libqasm/_libqasm.cp39-win_amd64.pyd,sha256=yeNjv58yvFKmUBJEk5bCrt_N3FpsCNT9jVqd-kWPqJY,2291200
-libqasm/libqasm.py,sha256=TBkHUGljxJ3aWcBoPqTRcftMXAF2cDkwbw6HLP7zZuM,31677
-libqasm-0.6.6.dist-info/LICENSE.md,sha256=395F6Sje50f5Too7yWFAoS_owYO4aOtjbMeQd_go_sk,579
-libqasm-0.6.6.dist-info/METADATA,sha256=Hi6F1jn1w0o-S3SzPjbXbDJUsIMUE5K1Bj3vtNDGzwc,6775
-libqasm-0.6.6.dist-info/WHEEL,sha256=Z6c-bE0pUM47a70GvqO_SvH_XXU0lm62gEAKtoNJ08A,100
-libqasm-0.6.6.dist-info/top_level.txt,sha256=iZ8PSLyg3lJwvSUCvWE8VCJGU-nmQY2YIrbMe7M7kLw,14
-libqasm-0.6.6.dist-info/RECORD,,