qtomos 0.1.0__py3-none-any.whl

qtomos/__init__.py

@@ -0,0 +1,6 @@
+# qtomos/__init__.py
+# Marks qtomos/ as a Python package.
+
+from .circuits_catalog import create_ghz
+from .acquisition import measure_observable, measure_all_observables
+

qtomos/acquisition.py

@@ -0,0 +1,186 @@
+# lib/acquisition.py
+
+import copy
+import datetime
+import os
+from dotenv import load_dotenv
+
+from spinqit import NMRConfig, get_basic_simulator, get_compiler, BasicSimulatorConfig, get_nmr, draw as sq_draw, Circuit
+from spinqit import H, Sd, QasmBackend
+from spinqit.backend.nmr_backend import NMRBackend
+
+load_dotenv()
+
+TWO_QUBIT_OBSERVABLES = [
+    "XX", "XY", "XZ",
+    "YX", "YY", "YZ",
+    "ZX", "ZY", "ZZ",
+]
+
+THREE_QUBIT_OBSERVABLES = [
+    "XXX", "XXY", "XXZ",
+    "XYX", "XYY", "XYZ",
+    "XZX", "XZY", "XZZ",
+
+    "YXX", "YXY", "YXZ",
+    "YYX", "YYY", "YYZ",
+    "YZX", "YZY", "YZZ",
+
+    "ZXX", "ZXY", "ZXZ",
+    "ZYX", "ZYY", "ZYZ",
+    "ZZX", "ZZY", "ZZZ",
+]
+
+def append_observation_basis(circuit: Circuit, observable: str):
+    """
+    Appends the necessary gates to change the measurement basis 
+    to match the Pauli observable.
+    
+    This function applies the required gates (H for X, Sd+H for Y) sequentially 
+    to the first N qubits of the circuit, where N is the length of the observable string.
+    
+    Examples of `observable` strings: "XX", "XY", "XYZ", "ZZZ"
+    """
+    for qubit_index, pauli in enumerate(observable):
+        if pauli == "X":
+            circuit << (H, qubit_index)
+        elif pauli == "Y":
+            circuit << (Sd, qubit_index)
+            circuit << (H, qubit_index)
+        elif pauli == "Z":
+            pass
+
+def simulate(c: Circuit, shots: int = 1024):
+    comp = get_compiler("native")
+    engine = get_basic_simulator()
+    # Compile
+    optimization_level = 0
+    exe = comp.compile(c, optimization_level)
+    # Run
+    config = BasicSimulatorConfig()
+    config.configure_shots(shots)
+    result = engine.execute(exe, config)
+    return result.counts
+
+def run(c: Circuit, shots: int = 1024):
+    IP = os.environ.get("IP")
+    PORT = int(os.environ.get("PORT"))
+    USERNAME = os.environ.get("USERNAME")        
+    PASSWORD = os.environ.get("PASSWORD")
+        
+    comp = get_compiler("native")
+    optimization_level = 0
+    exe = comp.compile(c, optimization_level)   
+    engine = get_nmr()
+    config = NMRConfig()
+    config.configure_ip(IP)
+    config.configure_port(PORT)
+    config.configure_account(USERNAME, PASSWORD)
+    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    task_name = getattr(c, 'name', "circuit")
+    task_desc = f"Execution of {task_name} at {timestamp}"
+    config.configure_task(task_name, task_desc)
+    config.configure_shots(shots) 
+    resultado = engine.execute(exe, config)
+    return resultado.counts
+
+def draw(c: Circuit):
+    compiler = get_compiler('native')
+    ir = compiler.compile(c, level=0)
+    name = getattr(c, 'name', "circuit")
+    filename = f"{name.replace(' ', '_')}.png"
+    sq_draw(ir, filename=filename)
+    print(f"Circuit drawing saved to {filename}")
+
+def normalize_counts(counts, endian="big"):
+    return {
+        str(bitstring) if endian == "big" else str(bitstring)[::-1]: int(count)
+        for bitstring, count in counts.items()
+    }
+
+def measure_observable(circuit: Circuit, observable: str, mode: str, endian="big", shots: int = 1024):
+    circuit_name = getattr(circuit, 'name', 'circuit')
+    print(f"Starting measurement task for circuit '{circuit_name}', observable '{observable}'...")
+    
+    c = copy.deepcopy(circuit)
+    append_observation_basis(c, observable)
+
+    start_time = datetime.datetime.now().astimezone().isoformat()
+    
+    # Compile to get QASM representations
+    compiler = get_compiler('native')
+    ir = compiler.compile(c, level=0)
+    qasm_str = QasmBackend.convert_ir_to_qasm(ir)
+    
+    # Assemble to Native hardware IR and get Native QASM
+    ir_native = copy.deepcopy(ir)
+    try:
+        NMRBackend().assemble(ir_native)
+        native_qasm_str = QasmBackend.convert_ir_to_qasm(ir_native)
+    except Exception as e:
+        native_qasm_str = f"Error generating native QASM: {e}"
+
+    if mode == "draw":
+        draw(c)
+        counts = {}
+    elif mode == "qpu":
+        counts = run(c, shots)
+    else:
+        counts = simulate(c, shots)
+        
+    end_time = datetime.datetime.now().astimezone().isoformat()
+    
+    print(f"Finished measurement task for circuit '{circuit_name}', observable '{observable}'.")
+    
+    return {
+        observable: {
+            "circuit_name": circuit_name,
+            "mode": mode,
+            "shots": shots,
+            "endian": endian,
+            "timestamps": {
+                "start": start_time,
+                "end": end_time
+            },
+            "counts": normalize_counts(counts, endian),
+            "qasm": qasm_str,
+            "native": native_qasm_str
+        }
+    }
+
+def measure_all_observables(circuit: Circuit, mode: str, endian="big", shots: int = 1024):
+    start_time = datetime.datetime.now().astimezone().isoformat()
+    results = {}
+    qubits = circuit.qubits_num
+    observables = TWO_QUBIT_OBSERVABLES if qubits == 2 else THREE_QUBIT_OBSERVABLES
+    
+    for observable in observables:
+        obs_data = measure_observable(circuit, observable, mode, endian, shots)
+        res = obs_data[observable]
+        
+        # Remove common metadata properties to avoid duplication
+        res.pop("circuit_name", None)
+        res.pop("mode", None)
+        res.pop("shots", None)
+        res.pop("endian", None)
+        
+        results[observable] = res
+
+    end_time = datetime.datetime.now().astimezone().isoformat()
+    
+    return {
+        "metadata": {
+            "circuit_name": getattr(circuit, 'name', "circuit"),
+            "qubits": qubits,
+            "mode": mode,
+            "shots": shots,
+            "endian": endian,
+            "timestamps": {
+                "start": start_time,
+                "end": end_time
+            }
+        },
+        "measurements": results
+    }
+
+

qtomos/circuits_catalog.py

@@ -0,0 +1,67 @@
+# lib/circuits_catalog.py
+
+from spinqit import Circuit, H, CX, Ry, Rx, X
+import math
+import random
+
+def create_ghz(qubits: int) -> Circuit:
+    """Generates a GHZ state preparation circuit."""
+    c = Circuit()
+    c.name = "ghz"
+    c.allocateQubits(qubits)
+    
+    c << (H, 0)
+    for i in range(1, qubits):
+        c.append(CX, [0, i])
+        
+    return c
+
+def create_phi_plus(qubits: int) -> Circuit:
+    """Creates a 2-qubit Phi+ Bell state. Ignores qubits > 2."""
+    c = Circuit()
+    c.name = "phi_plus"
+    c.allocateQubits(2)
+    c << (H, 0)
+    c << (CX, [0, 1])
+    return c
+
+def create_w(qubits: int) -> Circuit:
+    """Creates a 3-qubit W state. Ignores qubits parameter."""
+    c = Circuit()
+    c.name = "w"
+    c.allocateQubits(3)
+    
+    # 1. Ry to create 1/sqrt(3)|0> + sqrt(2/3)|1> on q0
+    theta = 2 * math.acos(1 / math.sqrt(3))
+    c.append(Ry, [0], [], theta)
+    
+    # 2. Controlled-H equivalent (acts as H on |0> when controlled)
+    c.append(Ry, [1], [], math.pi/4)
+    c.append(CX, [0, 1])
+    c.append(Ry, [1], [], -math.pi/4)
+    
+    # 3. Entangle q2
+    c.append(CX, [1, 2])
+    
+    # 4. Flip remaining states
+    c.append(CX, [0, 1])
+    c.append(X, [0])
+    
+    return c
+
+def create_random(qubits: int) -> Circuit:
+    """Creates a random parameterized circuit for the given number of qubits."""
+    c = Circuit()
+    c.name = "random"
+    c.allocateQubits(qubits)
+    
+    # Apply random rotations
+    for i in range(qubits):
+        c.append(Rx, [i], [], random.uniform(0, 2*math.pi))
+        c.append(Ry, [i], [], random.uniform(0, 2*math.pi))
+        
+    # Apply entangling chain
+    for i in range(qubits - 1):
+        c.append(CX, [i, i+1])
+        
+    return c

qtomos/cli.py

@@ -0,0 +1,65 @@
+import json
+import argparse
+import inspect
+from dotenv import load_dotenv
+from . import circuits_catalog
+from .acquisition import measure_observable, measure_all_observables
+
+def main():
+    load_dotenv()
+
+    parser = argparse.ArgumentParser(description="Acquire SpinQ Tomographic Data")
+    
+    # Dynamically discover circuits in the catalog
+    circuit_funcs = {
+        name.replace("create_", ""): func 
+        for name, func in inspect.getmembers(circuits_catalog, inspect.isfunction) 
+        if name.startswith("create_")
+    }
+
+    parser.add_argument("-m", "--mode", choices=["sim", "qpu", "draw"], required=True, help="Execution mode: sim (simulator), qpu (real computer), or draw (print circuit)")
+    parser.add_argument("-c", "--circuit", choices=list(circuit_funcs.keys()), required=True, help="Circuit to prepare")
+    parser.add_argument("-q", "--qubits", type=int, help="Number of qubits (inferred from observable if omitted, defaults to 3)")
+    parser.add_argument("-e", "--endian", choices=["big", "little"], default="big", help="Endianness for output bitstrings: big (q[0] is leftmost) or little (q[0] is rightmost)")
+    parser.add_argument("--shots", type=int, default=1024, help="Number of shots for execution")
+    
+    parser.add_argument("-f", "--file", type=str, required=True, help="Output JSON file path")
+    parser.add_argument("-o", "--observable", type=str, help="Measure a single observable (e.g., XX, XYZ)")
+    
+    args = parser.parse_args()
+
+    # Determine number of qubits
+    if args.qubits is not None:
+        num_qubits = args.qubits
+    else:
+        num_qubits = len(args.observable) if args.observable else 3
+        
+    # Retrieve the dynamically selected circuit creation function
+    create_func = circuit_funcs[args.circuit]
+    c = create_func(num_qubits)
+    
+    # Check for inconsistencies
+    if args.observable and len(args.observable) != c.qubits_num:
+        parser.error(f"Length of observable '{args.observable}' ({len(args.observable)}) does not match the actual circuit size ({c.qubits_num} qubits).")
+
+    if args.observable:
+        output = measure_observable(
+            circuit=c,
+            observable=args.observable,
+            mode=args.mode,
+            endian=args.endian,
+            shots=args.shots
+        )
+    else:
+        output = measure_all_observables(
+            circuit=c,
+            mode=args.mode,
+            endian=args.endian,
+            shots=args.shots
+        )
+
+    with open(args.file, "w") as f:
+        json.dump(output, f, indent=2)
+
+if __name__ == "__main__":
+    main()

qtomos/utils.py

@@ -0,0 +1,73 @@
+# lib/utils.py
+
+import numpy as np
+
+def get_pauli(label):
+    """Return the Pauli matrix corresponding to the label."""
+    paulis = {
+        'I': np.array([[1, 0], [0, 1]], dtype=complex),
+        'X': np.array([[0, 1], [1, 0]], dtype=complex),
+        'Y': np.array([[0, -1j], [1j, 0]], dtype=complex),
+        'Z': np.array([[1, 0], [0, -1]], dtype=complex)
+    }
+    return paulis[label]
+
+def construct_pauli_string(p_str):
+    """Construct an N-qubit Pauli matrix from a string (e.g. 'XX')."""
+    result = np.array([[1]])
+    for p in p_str:
+        result = np.kron(result, get_pauli(p))
+    return result
+
+def expectation_value(counts, endian="big"):
+    """
+    Calculate the expectation value from counts.
+    If the bitstring has an even number of 1s, it corresponds to eigenvalue +1.
+    If it has an odd number of 1s, it corresponds to eigenvalue -1.
+    """
+    total = sum(counts.values())
+    if total == 0:
+        return 0.0
+    
+    exp_val = 0.0
+    for bitstring, count in counts.items():
+        # count number of 1s
+        ones = bitstring.count('1')
+        eigenvalue = 1 if ones % 2 == 0 else -1
+        exp_val += eigenvalue * (count / total)
+        
+    return exp_val
+
+def marginal_expectation_value(counts, p_str, m_str):
+    """
+    Calculate the expectation value of a Pauli string p_str (which may contain 'I')
+    from the counts of a measured Pauli string m_str (which has no 'I' and matches
+    p_str on all non-'I' positions).
+    """
+    total = sum(counts.values())
+    if total == 0:
+        return 0.0
+    
+    active_indices = [i for i, char in enumerate(p_str) if char != 'I']
+    if not active_indices:
+        return 1.0
+        
+    exp_val = 0.0
+    for bitstring, count in counts.items():
+        sub_bits = [bitstring[i] for i in active_indices]
+        ones = sub_bits.count('1')
+        eigenvalue = 1 if ones % 2 == 0 else -1
+        exp_val += eigenvalue * (count / total)
+        
+    return exp_val
+
+def matches(p_str, m_str):
+    """Check if the measured Pauli string m_str matches the target p_str."""
+    for p_char, m_char in zip(p_str, m_str):
+        if p_char != 'I' and p_char != m_char:
+            return False
+    return True
+
+def generate_all_pauli_strings(n_qubits):
+    import itertools
+    return [''.join(p) for p in itertools.product(['I', 'X', 'Y', 'Z'], repeat=n_qubits)]

qtomos-0.1.0.dist-info/METADATA

@@ -0,0 +1,225 @@
+Metadata-Version: 2.1
+Name: qtomos
+Version: 0.1.0
+Summary: A SpinQ quantum state tomography data acquisition toolset
+Author-email: Tomas <tomas@example.com>
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: spinqit
+Requires-Dist: python-dotenv
+
+# Quantum State Tomography
+
+Quantum State Tomography is the process of completely characterizing the quantum state of a system by performing a series of measurements on identical copies of the state. It allows us to mathematically reconstruct the density matrix, which fully describes the system.
+
+Quantum State Tomography is generally a two-phase process:
+1. **Data Acquisition**: Run quantum circuits on a simulator or real hardware to gather measurement statistics for a complete set of observables. In this toolset, we specifically use the complete set of tensor products of the non-identity Pauli matrices ($X, Y, Z$).
+2. **State Reconstruction**: Use the acquired measurement data to mathematically reconstruct the density matrix of the quantum state.
+
+> [!NOTE]
+> This toolset is solely focused on **Data Acquisition (`qtomos`)**. State reconstruction is not handled by this repository.
+
+Currently, data acquisition supports multiple predefined quantum states (GHZ, Phi+, W, and random circuits) defined in the `circuits_catalog`. You can dynamically select which circuit to prepare during acquisition.
+
+This is now you basically use this tool:
+
+```bash
+# acquire data for the complete set of tensor products of the non-identity Pauli matrices (X, Y, Z), on the noiseless simulator, on a three qubit GHZ, using 500 shots for each measurement, saving the results to output.json
+qtomos --circuit ghz --mode sim --shots 500 --file output.json
+```
+
+Read on to learn how to install and use this tool.
+
+**IMPORTANT**: to connect to a real SpinQ QPU you need to provide your connection credentials. Read section "Acquire Data from the QPU" below. Do not put your access credentials in a file that is commited to the repository. 
+
+---
+
+# Install
+
+SpinQit currently works only on Python 3.8. 
+
+The file .python-version will most likely take care of setting up your environment with the correct Python version (if 3.8 is installed on your machine; if not, use pyenv, Conda or whatever manager you prefer to install it). 
+
+We suggest installing everything in a virtual environment. 
+
+To set up your environment, run:
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+pip install -e .
+```
+
+On Arm based Macs, you'll have issues with the default location of SPinQit libraries. Use the ```fix-spinqit-macos-arm.sh```script to fix it (changes will only affect that venv)
+
+---
+
+## Data Acquisition
+
+The first time you run `qtomos`, it may take longer (the SpinQ SDK might be downloading required assets).
+
+### Simulate Acquisition
+
+To run a simulation for a specific observable (e.g., `XX`) on a GHZ state:
+```bash
+qtomos --circuit ghz --mode sim --observable XX --file output.json
+```
+
+### Selecting a Circuit
+
+You can select the quantum state to prepare using the `-c` or `--circuit` argument. The CLI dynamically exposes all circuits defined in `qtomos/circuits_catalog.py`. Current available states include `ghz` (default), `phi_plus`, `w`, and `random`.
+
+```bash
+# Acquire the ZZZ observable for a W state
+qtomos --circuit w --mode sim --observable ZZZ --file output.json
+
+# Acquire the full set for a random circuit
+qtomos --circuit random --mode sim --file output.json
+```
+
+By default, the measurement bitstrings use Big-Endian format (qubit 0 is the leftmost bit). If you prefer Little-Endian (qubit 0 is the rightmost bit, similar to Qiskit), use the `--endian little` flag:
+```bash
+qtomos --circuit ghz --mode sim --observable XX --endian little --file output.json
+```
+
+### Acquire Data from the QPU
+
+Before running on the real hardware (QPU), you need to configure your environment variables. 
+Copy the `.env.example` file to `.env` and fill in your connection details:
+
+```bash
+cp .env.example .env
+```
+
+Edit `.env` to match your credentials:
+```env
+IP=192.168.172.233
+PORT=50177
+USERNAME=your_username
+PASSWORD=your_password
+```
+
+Then, to acquire data for the same specific observable on the real hardware:
+```bash
+qtomos --circuit ghz --mode qpu --observable XX --file output.json
+```
+
+### Drawing Circuits
+
+To generate a visual representation of the quantum circuit instead of simulating it or running it on the QPU, use the `draw` mode. This will save a `.png` image of the circuit in your current directory (e.g., `XX_of_a_Ghz.png`):
+```bash
+qtomos --circuit ghz --mode draw --observable XX --file output.json
+```
+
+### Full Tomographic Acquisition
+
+To perform a full tomographic acquisition (all observables), omit the `--observable` argument. This defaults to 3 qubits.
+
+```bash
+# 3-qubit full tomographic acquisition on simulator
+qtomos --circuit ghz --mode sim --file output.json
+
+# 3-qubit full tomographic acquisition on QPU
+qtomos --circuit ghz --mode qpu --file output.json
+```
+
+### Parametrizing Shots
+
+By default, execution uses `1024` shots. You can customize the number of shots using the `--shots` flag:
+
+```bash
+qtomos --circuit ghz --mode sim --file output.json --shots 500
+```
+
+### Saving Output and Format
+
+The output JSON file has the following structure:
+
+```json
+{
+  "metadata": {
+    "circuit_name": "ghz",
+    "qubits": 2,
+    "mode": "sim",
+    "shots": 500,
+    "endian": "big",
+    "timestamps": {
+      "start": "2026-06-25T20:51:33.528965-03:00",
+      "end": "2026-06-25T20:51:33.530752-03:00"
+    }
+  },
+  "measurements": {
+    "XX": {
+      "timestamps": {
+        "start": "2026-06-25T20:51:33.529028-03:00",
+        "end": "2026-06-25T20:51:33.530740-03:00"
+      },
+      "counts": {
+        "00": 250,
+        "11": 250
+      },
+      "qasm": "...",
+      "native": "..."
+    },
+    ...
+  }
+}
+```
+
+### Help (qtomos)
+
+For a complete list of options, use the `--help` flag:
+
+```bash
+$ qtomos --help
+usage: qtomos [-h] [-m {sim,qpu,draw}] [-c {ghz,phi_plus,random,w}]
+                  [-q QUBITS] [-e {big,little}] [--shots SHOTS] -f FILE
+                  [-o OBSERVABLE]
+
+Acquire SpinQ Tomographic Data
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -m {sim,qpu,draw}, --mode {sim,qpu,draw}
+                        Execution mode: sim (simulator), qpu (real computer),
+                        or draw (print circuit)
+  -c {ghz,phi_plus,random,w}, --circuit {ghz,phi_plus,random,w}
+                        Circuit to prepare
+  -q QUBITS, --qubits QUBITS
+                        Number of qubits (inferred from observable if omitted,
+                        defaults to 3)
+  -e {big,little}, --endian {big,little}
+                        Endianness for output bitstrings: big (q[0] is
+                        leftmost) or little (q[0] is rightmost)
+  --shots SHOTS         Number of shots for execution
+  -f FILE, --file FILE  Output JSON file path
+  -o OBSERVABLE, --observable OBSERVABLE
+                        Measure a single observable (e.g., XX, XYZ)
+```
+
+
+## Project Structure
+
+The codebase is structured as follows:
+
+*   **`pyproject.toml`**: The package configuration file defining dependencies and the CLI entry point.
+*   **`qtomos/`**: Directory containing the project's internal modules and CLI:
+    *   **`qtomos/__init__.py`**: Initializer that exposes `qtomos` as a Python package.
+    *   **`qtomos/cli.py`**: CLI entry-point script for data acquisition. It handles argument parsing (simulator, real QPU, or circuit drawing, shots, endianness) and prints the structured JSON output with metadata.
+    *   **`qtomos/acquisition.py`**: Contains the core logic and programmatic API (`measure_observable` and `measure_all_observables`) for executing the quantum circuits and gathering measurement statistics.
+    *   **`qtomos/circuits_catalog.py`**: A catalog of pre-defined quantum circuits. The CLI dynamically discovers states defined here (e.g., `ghz`, `phi_plus`, `w`, `random`).
+    *   **`qtomos/utils.py`**: Contains all shared mathematical utilities, including Pauli basis generation, match filtering, and average expectation calculation for marginal operators.
+*   **`tests/`**: Directory for automated tests:
+    *   **`tests/test_tomography.py`**: Unit test suite to validate supporting mathematical operations.
+
+---
+
+## Running Unit Tests
+
+To run the automated unit tests and verify the consistency of the project, execute the following command from the repository root:
+
+```bash
+python tests/test_tomography.py
+```

qtomos-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+qtomos/__init__.py,sha256=gA0HOy7-XNvFIsiecv17qFY8HJSfMLBEbaGKpTnt3Fc,170
+qtomos/acquisition.py,sha256=mA2B-r2dieIWAQkUkNpPQcrmKkscBi_ovO8lC0K33dQ,5759
+qtomos/circuits_catalog.py,sha256=BN_kMzr1JK6EnrDo5FlDE0RlFqQHYJUPgKWUPsrt3EU,1712
+qtomos/cli.py,sha256=9GmTqqqirFZfuXFQ6wtaF4UST8RTjinW7S4XPrQxskY,2583
+qtomos/utils.py,sha256=zh1KsvzxsW_I2UQ0pgvL1JtCRXm-weAcw9n7pbv09Ko,2349
+qtomos-0.1.0.dist-info/METADATA,sha256=GnIXnDL_qsm91pC-Y9A8QKa3Dqo-Pr8gnArQW01ZpXc,8589
+qtomos-0.1.0.dist-info/WHEEL,sha256=BNRMDyzLkkcmlv0J8ppDQkk2VED33SesJDynr9ED1gc,91
+qtomos-0.1.0.dist-info/entry_points.txt,sha256=cpFSVjh9Ac7xw7c1jtLMkgtD0-eLlej6ljtBRpyrIlQ,43
+qtomos-0.1.0.dist-info/top_level.txt,sha256=mOU_AweQC25ZmDdwueoM8kHDGI4NqqlMmRz0d7PIOHs,7
+qtomos-0.1.0.dist-info/RECORD,,

qtomos-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.3.4)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

qtomos-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+qtomos = qtomos.cli:main

qtomos-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+qtomos