sequence 0.8.3.dev260767962__tar.gz → 0.8.5.dev8889859__tar.gz

{sequence-0.8.3.dev260767962 → sequence-0.8.5.dev8889859}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sequence
-Version: 0.8.3.dev260767962
+Version: 0.8.5.dev8889859
 Summary: Simulator of QUantum Network Communication (SeQUeNCe) is an open-source tool that allows modeling of quantum networks including photonic network components, control protocols, and applications.
 Keywords: quantum,network,discrete,event,simulator
 Author: Xiaoliang Wu, Joaquin Chung, Alexander Kolar, Alexander Kiefer, Eugene Wang, Tian Zhong, Rajkumar Kettimuthu, Martin Suchara, Robert Hayek, Ansh Singal, Caitao Zhan
@@ -22,19 +22,22 @@ Requires-Dist: matplotlib>=3.10.7
 Requires-Dist: networkx>=3.6.1
 Requires-Dist: numpy>=2.3.5
 Requires-Dist: pandas>=2.3.3
+Requires-Dist: pandas-stubs~=2.3.3
 Requires-Dist: plotly>=6.5.0
 Requires-Dist: pytest>=9.0.2
 Requires-Dist: qutip>=5.2.2
 Requires-Dist: qutip-qip>=0.4.1
 Requires-Dist: scipy>=1.16.3
+Requires-Dist: scipy-stubs~=1.16.3
+Requires-Dist: seaborn>=0.13.2
 Requires-Dist: tqdm>=4.67.1
 Maintainer: Caitao Zhan, Robert Hayek
 Maintainer-email: Caitao Zhan <czhan@anl.gov>, Robert Hayek <rhayek@anl.gov>
 Requires-Python: >=3.11, <3.15
-Project-URL: Changelog, https://github.com/sequence-toolbox/SeQUeNCe/blob/master/CHANGELOG.md
-Project-URL: Documentation, https://sequence-rtd-tutorial.readthedocs.io/
 Project-URL: Homepage, https://github.com/sequence-toolbox/SeQUeNCe
+Project-URL: Documentation, https://sequence-rtd-tutorial.readthedocs.io/
 Project-URL: Issues, https://github.com/sequence-toolbox/SeQUeNCe/issues
+Project-URL: Changelog, https://github.com/sequence-toolbox/SeQUeNCe/blob/master/CHANGELOG.md
 Description-Content-Type: text/markdown
 
 <p align="center">
@@ -75,22 +78,46 @@ SeQUeNCe is an open source, discrete-event simulator for quantum networks. As de
 
 These modules can be edited by users to define additional functionality and test protocol schemes, or may be used as-is to test network parameters and topologies.
 
-## Installing
-SeQUeNCe requires [Python](https://www.python.org/downloads/) 3.11 or later. You can simply install SeQUeNCe using `pip`:
+## Installation
+### For Users
+SeQUeNCe requires [Python](https://www.python.org/downloads/) 3.11 or later. You can install SeQUeNCe using `pip`:
 ```
 pip install sequence
 ```
 
-If you wish to make your own edits to the codebase, SeQUeNCe should be installed in [development mode](https://setuptools.pypa.io/en/latest/userguide/development_mode.html) (a.k.a. editable install).
-To do so, clone and install the simulator as follows:
+### Development Environment Setup     
+If you wish to modify the source code, use an editable installation with [uv](https://docs.astral.sh/uv/):
+
+#### Install uv ([Astral Instructions](https://docs.astral.sh/uv/getting-started/installation/))
+```bash
+# macOS/Linux
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# Windows
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
 ```
+
+#### Clone the repository and create the virtual environment
+Here we clone the repository and let uv configure the development environment with the target python version.
+```bash
 git clone https://github.com/sequence-toolbox/SeQUeNCe.git
-cd SeQUeNCe
-pip install --editable . --config-settings editable_mode=strict
+cd sequence
+uv sync
 ```
 
-For Linux and Mac users, you could use `make install_editable` instead of `pip install --editable . --config-settings editable_mode=strict`
+#### Activate the virtual environment
+Now that the virtual environment is created with all dependencies installed, you can activate it using the following command.
+
+```bash
+source .venv/bin/activate # macOS/Linux
+source .venv\Scripts\activate # Windows
+```
 
+#### Running the test suite
+SeQUeNCe includes a comprehensive test suite, this can be ran with the following command
+```
+uv run pytest tests
+```
 
 ## Citation
 Please cite us, thank you!
@@ -111,7 +138,7 @@ publisher = {IOP Publishing},
 <!-- * X. Wu, A. Kolar, J. Chung, D. Jin, T. Zhong, R. Kettimuthu and M. Suchara. "SeQUeNCe: Simulator of QUantum Network Communication." GitHub repository, https://github.com/sequence-toolbox/SeQUeNCe, 2021. -->
 
 ## Running the GUI
-Once SeQUeNCe has been installed as described above, simply run the `gui.py` script found in the root of the project directory
+Once SeQUeNCe has been installed as described above, run the `gui.py` script found in the root of the project directory
 ```
 python gui.py
 ```
@@ -122,9 +149,9 @@ Many examples of SeQUeNCe in action can be found in the [example](/example) fold
 ## Additional Tools
 
 ### Network Visualization
-The example directory contains an example json file `starlight.json` to specify a network topology, and the utils directory contains the script `draw_topo.py` to visualize json files. To use this script, the Graphviz library must be installed. Installation information can be found on the [Graphviz website](https://www.graphviz.org/download/).
+The example directory contains an example .json file `starlight.json` to specify a network topology, and the utils directory contains the script `draw_topo.py` to visualize json files. To use this script, the Graphviz library must be installed. Installation information can be found on the [Graphviz website](https://www.graphviz.org/download/).
 
-To view a network, simply run the script and specify the relative location of your json file:
+To view a network, run the script and specify the relative location of your .json file:
 ```
 python utils/draw_topo.py example/starlight.json
 ```
@@ -159,5 +186,6 @@ If you have questions, please contact [Caitao Zhan](https://caitaozhan.github.io
 
 * C. Zhan et al., ["Design and Simulation of the Adaptive Continuous Entanglement Generation Protocol"](https://arxiv.org/abs/2502.01964), QCNC 2025. [GitHub Repository](https://github.com/caitaozhan/adaptive-continuous)
 
+* H. Miller et al., ["Simulation of a Heterogeneous Quantum Network"](https://arxiv.org/abs/2512.04211), arXiv preprint, 2025
 
 Please do a Pull Request to add your paper here! 

{sequence-0.8.3.dev260767962 → sequence-0.8.5.dev8889859}/README.md

@@ -36,22 +36,46 @@ SeQUeNCe is an open source, discrete-event simulator for quantum networks. As de
 
 These modules can be edited by users to define additional functionality and test protocol schemes, or may be used as-is to test network parameters and topologies.
 
-## Installing
-SeQUeNCe requires [Python](https://www.python.org/downloads/) 3.11 or later. You can simply install SeQUeNCe using `pip`:
+## Installation
+### For Users
+SeQUeNCe requires [Python](https://www.python.org/downloads/) 3.11 or later. You can install SeQUeNCe using `pip`:
 ```
 pip install sequence
 ```
 
-If you wish to make your own edits to the codebase, SeQUeNCe should be installed in [development mode](https://setuptools.pypa.io/en/latest/userguide/development_mode.html) (a.k.a. editable install).
-To do so, clone and install the simulator as follows:
+### Development Environment Setup     
+If you wish to modify the source code, use an editable installation with [uv](https://docs.astral.sh/uv/):
+
+#### Install uv ([Astral Instructions](https://docs.astral.sh/uv/getting-started/installation/))
+```bash
+# macOS/Linux
+curl -LsSf https://astral.sh/uv/install.sh | sh
+
+# Windows
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
 ```
+
+#### Clone the repository and create the virtual environment
+Here we clone the repository and let uv configure the development environment with the target python version.
+```bash
 git clone https://github.com/sequence-toolbox/SeQUeNCe.git
-cd SeQUeNCe
-pip install --editable . --config-settings editable_mode=strict
+cd sequence
+uv sync
 ```
 
-For Linux and Mac users, you could use `make install_editable` instead of `pip install --editable . --config-settings editable_mode=strict`
+#### Activate the virtual environment
+Now that the virtual environment is created with all dependencies installed, you can activate it using the following command.
 
+```bash
+source .venv/bin/activate # macOS/Linux
+source .venv\Scripts\activate # Windows
+```
+
+#### Running the test suite
+SeQUeNCe includes a comprehensive test suite, this can be ran with the following command
+```
+uv run pytest tests
+```
 
 ## Citation
 Please cite us, thank you!
@@ -72,7 +96,7 @@ publisher = {IOP Publishing},
 <!-- * X. Wu, A. Kolar, J. Chung, D. Jin, T. Zhong, R. Kettimuthu and M. Suchara. "SeQUeNCe: Simulator of QUantum Network Communication." GitHub repository, https://github.com/sequence-toolbox/SeQUeNCe, 2021. -->
 
 ## Running the GUI
-Once SeQUeNCe has been installed as described above, simply run the `gui.py` script found in the root of the project directory
+Once SeQUeNCe has been installed as described above, run the `gui.py` script found in the root of the project directory
 ```
 python gui.py
 ```
@@ -83,9 +107,9 @@ Many examples of SeQUeNCe in action can be found in the [example](/example) fold
 ## Additional Tools
 
 ### Network Visualization
-The example directory contains an example json file `starlight.json` to specify a network topology, and the utils directory contains the script `draw_topo.py` to visualize json files. To use this script, the Graphviz library must be installed. Installation information can be found on the [Graphviz website](https://www.graphviz.org/download/).
+The example directory contains an example .json file `starlight.json` to specify a network topology, and the utils directory contains the script `draw_topo.py` to visualize json files. To use this script, the Graphviz library must be installed. Installation information can be found on the [Graphviz website](https://www.graphviz.org/download/).
 
-To view a network, simply run the script and specify the relative location of your json file:
+To view a network, run the script and specify the relative location of your .json file:
 ```
 python utils/draw_topo.py example/starlight.json
 ```
@@ -120,5 +144,6 @@ If you have questions, please contact [Caitao Zhan](https://caitaozhan.github.io
 
 * C. Zhan et al., ["Design and Simulation of the Adaptive Continuous Entanglement Generation Protocol"](https://arxiv.org/abs/2502.01964), QCNC 2025. [GitHub Repository](https://github.com/caitaozhan/adaptive-continuous)
 
+* H. Miller et al., ["Simulation of a Heterogeneous Quantum Network"](https://arxiv.org/abs/2512.04211), arXiv preprint, 2025
 
 Please do a Pull Request to add your paper here! 

{sequence-0.8.3.dev260767962 → sequence-0.8.5.dev8889859}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sequence"
-version = "0.8.3.dev260767962"
+version = "0.8.5.dev8889859"
 authors = [
     { name = "Xiaoliang Wu, Joaquin Chung, Alexander Kolar, Alexander Kiefer, Eugene Wang, Tian Zhong, Rajkumar Kettimuthu, Martin Suchara, Robert Hayek, Ansh Singal, Caitao Zhan", email = "czhan@anl.gov" }
 ]
@@ -32,11 +32,14 @@ dependencies = [
     "networkx>=3.6.1",
     "numpy>=2.3.5",
     "pandas>=2.3.3",
+    "pandas-stubs~=2.3.3",
     "plotly>=6.5.0",
     "pytest>=9.0.2",
     "qutip>=5.2.2",
     "qutip-qip>=0.4.1",
     "scipy>=1.16.3",
+    "scipy-stubs~=1.16.3",
+    "seaborn>=0.13.2",
     "tqdm>=4.67.1",
 ]
 

{sequence-0.8.3.dev260767962 → sequence-0.8.5.dev8889859}/sequence/components/bsm.py

@@ -678,8 +678,8 @@ class SingleHeraldedBSM(BSM):
                 log.logger.debug(f'{self.name}: photonic BSM failed')
             else:
                 p0, p1 = self.photons
-                # if both memory successfully emit the photon in this round (consider memory emission inefficiency)
                 if self.get_generator().random() > p0.loss and self.get_generator().random() > p1.loss:
+                    # if both photons successfully arrive (not lost in memory or optical fiber) and the BSM is successful
                     for idx, photon in enumerate(self.photons):
                         detector = self.detectors[idx]
                         detector.get(photon)

{sequence-0.8.3.dev260767962 → sequence-0.8.5.dev8889859}/sequence/components/memory.py

@@ -46,7 +46,7 @@ class MemoryArray(Entity):
 
     def __init__(self, name: str, timeline: "Timeline", num_memories=10,
                  fidelity=0.85, frequency=80e6, efficiency=1, coherence_time=-1, wavelength=500,
-                 decoherence_errors: list[float] = None, cutoff_ratio = 1):
+                 decoherence_errors: list[float] = None, cutoff_ratio: float = 1, cutoff_flag: bool = True):
         """Constructor for the Memory Array class.
 
         Args:
@@ -60,6 +60,7 @@ class MemoryArray(Entity):
             wavelength (int): wavelength (in nm) of photons emitted by memories (default 500).
             decoherence_errors (list[int]): pauli decoherence errors. Passed to memory object.
             cutoff_ratio (float): the ratio between cutoff time and memory coherence time (default 1, should be between 0 and 1).
+            cutoff_flag (bool): Flag to enable or disable expiry events
         """
 
         Entity.__init__(self, name, timeline)
@@ -77,7 +78,7 @@ class MemoryArray(Entity):
         for i in range(num_memories):
             memory_name = self.name + f"[{i}]"
             self.memory_name_to_index[memory_name] = i
-            memory = Memory(memory_name, timeline, fidelity, frequency, efficiency, coherence_time, wavelength, decoherence_errors, cutoff_ratio)
+            memory = Memory(memory_name, timeline, fidelity, frequency, efficiency, coherence_time, wavelength, decoherence_errors, cutoff_ratio, cutoff_flag)
             memory.attach(self)
             self.memories.append(memory)
             memory.set_memory_array(self)
@@ -127,7 +128,7 @@ class MemoryArray(Entity):
         
         Args:
             name (str): name of memory
-        Return:
+        Returns:
             (Memory): the memory object
         """
         index = self.memory_name_to_index.get(name, -1)
@@ -187,7 +188,7 @@ class Memory(Entity):
     """
 
     def __init__(self, name: str, timeline: "Timeline", fidelity: float, frequency: float,
-                 efficiency: float, coherence_time: float, wavelength: int, decoherence_errors: list[float] = None, cutoff_ratio: float = 1):
+                 efficiency: float, coherence_time: float, wavelength: int, decoherence_errors: list[float] = None, cutoff_ratio: float = 1, cutoff_flag: bool = True):
         """Constructor for the Memory class.
 
         Args:
@@ -202,7 +203,8 @@ class Memory(Entity):
             decoherence_errors (list[float]): assuming the memory (qubit) decoherence channel being Pauli channel,
                 probability distribution of X, Y, Z Pauli errors
                 (default value is None, meaning not using BDS or further density matrix representation)
-            cutoff_ratio (float): the ratio between cutoff time and memory coherence time (default 1, should be between 0 and 1).
+            cutoff_ratio (float): the ratio between cutoff time and memory coherence time (default 1, should be > 0).
+            cutoff_flag (bool): Flag for the cutoff behavior
         """
 
         super().__init__(name, timeline)
@@ -223,8 +225,9 @@ class Memory(Entity):
         if self.decoherence_errors is not None:
                 assert len(self.decoherence_errors) == 3 and abs(sum(self.decoherence_errors) - 1) < EPSILON, \
                 "Decoherence errors refer to probabilities for each Pauli error to happen if an error happens, thus should be normalized."
+        self.cutoff_flag = cutoff_flag
         self.cutoff_ratio = cutoff_ratio
-        assert 0 < self.cutoff_ratio <= 1, "Ratio of cutoff time and coherence time should be between 0 and 1"
+        assert 0 < self.cutoff_ratio, "Ratio of cutoff time and coherence time should be greater than 0."
         self.generation_time = -1
         self.last_update_time = -1
         self.is_in_application = False
@@ -359,7 +362,7 @@ class Memory(Entity):
         self.entangled_memory = {'node_id': None, 'memo_id': None}
 
         # schedule expiration
-        if self.coherence_time > 0:
+        if self.coherence_time > 0 and self.cutoff_flag:
             self._schedule_expiration()
 
     def bds_decohere(self) -> None:
@@ -460,7 +463,7 @@ class Memory(Entity):
     def get_bds_fidelity(self) -> float:
         """Will get the fidelity from the BDS state
 
-        Return:
+        Returns:
             (float): the fidelity of the BDS state
         """
         state_obj = self.timeline.quantum_manager.get(self.qstate_key)

sequence-0.8.5.dev8889859/sequence/constants.py

@@ -0,0 +1,58 @@
+"""Shared constants used across SeQUeNCe.
+
+This module centralizes immutable values that are reused by simulation and
+network components, including:
+
+- Physical constants (for example, speed of light in meters per picosecond).
+- Canonical quantum state vectors (basis states and Bell states).
+- Numerical tolerances (`EPSILON`) for floating-point comparisons.
+- Time unit conversion factors in picoseconds (`NANOSECOND` to `SECOND`).
+- Built-in formalism and protocol identifier strings.
+"""
+
+from typing import Final
+
+#: Speed of light in meters per picosecond.
+SPEED_OF_LIGHT: Final = 2e-4
+
+#: Qubit computational basis state |0>.
+KET0: Final = (1, 0)
+#: Qubit computational basis state |1>.
+KET1: Final = (0, 1)
+
+#: Normalization factor 1/sqrt(2) used by Bell states.
+SQRT_HALF: Final = 0.5 ** 0.5
+#: Bell state |Phi+>.
+PHI_PLUS:  Final = (SQRT_HALF, 0, 0,  SQRT_HALF)
+#: Bell state |Phi->.
+PHI_MINUS: Final = (SQRT_HALF, 0, 0, -SQRT_HALF)
+#: Bell state |Psi+>.
+PSI_PLUS:  Final = (0, SQRT_HALF,  SQRT_HALF, 0)
+#: Bell state |Psi->.
+PSI_MINUS: Final = (0, SQRT_HALF, -SQRT_HALF, 0)
+
+#: Small tolerance value for floating-point comparisons.
+EPSILON: Final = 1e-8
+
+#: Number of picoseconds in one nanosecond.
+NANOSECOND:  Final = 10**3
+#: Number of picoseconds in one microsecond.
+MICROSECOND: Final = 10**6
+#: Number of picoseconds in one millisecond.
+MILLISECOND: Final = 10**9
+#: Number of picoseconds in one second.
+SECOND:      Final = 10**12
+
+#: Built-in ket-vector formalism identifier.
+KET_STATE_FORMALISM: Final = "ket_vector"
+#: Built-in density-matrix formalism identifier.
+DENSITY_MATRIX_FORMALISM: Final = "density_matrix"
+#: Built-in Fock density-matrix formalism identifier.
+FOCK_DENSITY_MATRIX_FORMALISM: Final = "fock_density"
+#: Built-in Bell-diagonal-state formalism identifier.
+BELL_DIAGONAL_STATE_FORMALISM: Final = "bell_diagonal"
+
+#: Built-in Barrett-Kok generation protocol identifier.
+BARRET_KOK: Final = 'barret_kok'
+#: Built-in single-heralded generation protocol identifier.
+SINGLE_HERALDED: Final = 'single_heralded'

{sequence-0.8.3.dev260767962 → sequence-0.8.5.dev8889859}/sequence/entanglement_management/generation/single_heralded.py

@@ -22,13 +22,29 @@ if TYPE_CHECKING:
 
 @EntanglementGenerationA.register(SINGLE_HERALDED)
 class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
+    """
+    Class for single heralded entanglement generation protocol A.
+    This protocol is used on the two end nodes of the entanglement generation process.
+
+    Attributes:
+        owner (Node): node that protocol instance is attached to.
+        name (str): label for protocol instance.
+        middle (str): name of the middle BSM node.
+        other (str): name of the other end node.
+        memory (Memory): memory object used for entanglement generation.
+        raw_fidelity (float): the raw fidelity of generated entangled pair.
+        raw_epr_errors (list[float]): the raw EPR pair Pauli error rates in X, Y, Z order.
+        bsm_res (list[int]): the BSM measurement results from the middle BSM node.
+    """
     def __init__(self, owner: Node, name: str, middle: str, other: str, memory: Memory,
                  raw_fidelity: float = None, raw_epr_errors: list[float] = None):
         super().__init__(owner, name, middle, other, memory)
 
         self.protocol_type = SINGLE_HERALDED
-        assert QuantumManager.get_active_formalism() == BELL_DIAGONAL_STATE_FORMALISM, \
-            f"Single Heralded Entanglement generation protocol only supports Bell diagonal state formalism; got {QuantumManager.get_active_formalism()}"
+        active_formalism = QuantumManager.get_active_formalism()
+        assert_message = ("Single Heralded Entanglement generation protocol only" 
+                          f"supports Bell diagonal state formalism; got {active_formalism}")
+        assert active_formalism == BELL_DIAGONAL_STATE_FORMALISM, assert_message
 
         if raw_fidelity:
             self.raw_fidelity = raw_fidelity
@@ -40,8 +56,7 @@ class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
         if self.raw_epr_errors is None:
             self.raw_epr_errors = [1 / 3, 1 / 3, 1 / 3]
         if self.raw_epr_errors:
-            assert len(self.raw_epr_errors) == 3, \
-                "Raw EPR pair pauli error list should have three elements in X, Y, Z order."
+            assert len(self.raw_epr_errors) == 3, "Raw EPR pair pauli error list should have three elements in X, Y, Z order."
 
         self.bsm_res = [0, 0]
 
@@ -130,8 +145,7 @@ class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
 
         msg_type = msg.msg_type
 
-        log.logger.debug("{} {} received message from node {} of type {}, round={}".format(
-            self.owner.name, self.name, src, msg.msg_type, self.ent_round))
+        log.logger.debug(f"{self.owner.name} {self.name} received message from node {src} of type {msg.msg_type}, round={self.ent_round}")
 
         if msg_type is GenerationMsgType.NEGOTIATE:  # primary -> non-primary
             # configure params
@@ -141,8 +155,7 @@ class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
 
             # get time for first excite event
             memory_excite_time = self.memory.next_excite_time
-            min_time = max(self.owner.timeline.now(),
-                           memory_excite_time) + other_qc_delay - self.qc_delay + cc_delay  # cc_delay time for NEGOTIATE_ACK
+            min_time = max(self.owner.timeline.now(), memory_excite_time) + other_qc_delay - self.qc_delay + cc_delay  # cc_delay time for NEGOTIATE_ACK
             emit_time = self.owner.schedule_qubit(self.middle, min_time)  # used to send memory
             self.expected_time = emit_time + self.qc_delay  # expected time for middle BSM node to receive the photon
 
@@ -154,17 +167,13 @@ class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
 
             # send negotiate_ack
             other_emit_time = emit_time + self.qc_delay - other_qc_delay
-            message = EntanglementGenerationMessage(GenerationMsgType.NEGOTIATE_ACK,
-                                                    self.remote_protocol_name,
-                                                    protocol_type=self.protocol_type,
-                                                    emit_time=other_emit_time)
+            message = EntanglementGenerationMessage(GenerationMsgType.NEGOTIATE_ACK, self.remote_protocol_name,
+                                                    self.protocol_type, emit_time=other_emit_time)
             self.owner.send_message(src, message)
 
-            # schedule start if necessary (current is first round, need second round),
-            # else schedule update_memory (currently second round)
+            # schedule start if necessary (current is first round, need second round), else schedule update_memory (currently second round)
             # TODO: base future start time on resolution
-            future_start_time = self.expected_time + self.owner.cchannels[
-                self.middle].delay + 10  # delay is for sending the BSM_RES to end nodes, 10 is a small gap
+            future_start_time = self.expected_time + self.owner.cchannels[self.middle].delay + 10  # delay is for sending the BSM_RES to end nodes, 10 is a small gap
             if self.ent_round == 1:
                 process = Process(self, "start", [])  # for the second round
             else:
@@ -183,8 +192,7 @@ class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
 
             # schedule emit
             emit_time = self.owner.schedule_qubit(self.middle, msg.emit_time)
-            assert emit_time == msg.emit_time, \
-                f"Invalid eg emit times {emit_time} {msg.emit_time} {self.owner.timeline.now()}"
+            assert emit_time == msg.emit_time, f"Invalid eg emit times {emit_time} {msg.emit_time} {self.owner.timeline.now()}"
 
             process = Process(self, "emit_event", [])
             event = Event(msg.emit_time, process)
@@ -210,7 +218,7 @@ class SingleHeraldedA(EntanglementGenerationA, QuantumCircuitMixin):
             resolution = msg.resolution
 
             log.logger.debug("{} received MEAS_RES={} at time={:,}, expected={:,}, resolution={}, round={}".format(
-                self.owner.name, detector, time, self.expected_time, resolution, self.ent_round))
+                              self.owner.name, detector, time, self.expected_time, resolution, self.ent_round))
 
             if valid_trigger_time(time, self.expected_time, resolution):
                 self.bsm_res[detector] += 1
@@ -244,9 +252,7 @@ class SingleHeraldedB(EntanglementGenerationB):
             bsm (SingleAtomBSM or SingleHeraldedBSM): bsm object calling method.
             info (Dict[str, any]): information passed from bsm.
         """
-        assert bsm.encoding == SINGLE_HERALDED, \
-            "SingleHeraldedB should only be used with SingleHeraldedBSM."
-
+        assert bsm.encoding == SINGLE_HERALDED, "SingleHeraldedB should only be used with SingleHeraldedBSM."
         assert info['info_type'] == 'BSM_res'
 
         res = info['res']
@@ -254,10 +260,6 @@ class SingleHeraldedB(EntanglementGenerationB):
         resolution = bsm.resolution
 
         for node in self.others:
-            message = EntanglementGenerationMessage(GenerationMsgType.MEAS_RES,
-                                                    receiver=None,
-                                                    protocol_type=self.protocol_type,
-                                                    detector=res,
-                                                    time=time,
-                                                    resolution=resolution)
+            message = EntanglementGenerationMessage(GenerationMsgType.MEAS_RES, None, self.protocol_type,
+                                                    detector=res, time=time, resolution=resolution)
             self.owner.send_message(node, message)

{sequence-0.8.3.dev260767962 → sequence-0.8.5.dev8889859}/sequence/gui/app.py

@@ -358,8 +358,6 @@ class QuantumGUI:
             Topology.ALL_Q_CONNECT: qconnections,
             Topology.ALL_C_CHANNEL: cchannels,
             Topology.ALL_TEMPLATES: templates,
-
-            RouterNetTopo.IS_PARALLEL: False,
             Topology.STOP_TIME: int(1e12)
         }
 

{sequence-0.8.3.dev260767962 → sequence-0.8.5.dev8889859}/sequence/kernel/eventlist.py

@@ -4,12 +4,10 @@ This module defines the EventList class, used by the timeline to order and execu
 EventList is implemented as a min heap ordered by simulation time.
 """
 
-from typing import TYPE_CHECKING
-
-if TYPE_CHECKING:
-    from .event import Event
-
 from heapq import heappop, heappush
+from typing import Iterator
+
+from .event import Event
 
 
 class EventList:
@@ -22,27 +20,27 @@ class EventList:
     """
 
     def __init__(self):
-        self.data: list["Event"] = []
+        self.data: list[Event] = []
 
     def __len__(self):
         return len(self.data)
 
-    def __iter__(self):
+    def __iter__(self) -> Iterator[Event]:
         yield from self.data
 
-    def push(self, event: "Event") -> "None":
+    def push(self, event: Event) -> None:
         heappush(self.data, event)
 
-    def pop(self) -> "Event":
+    def pop(self) -> Event:
         return heappop(self.data)
 
-    def top(self) -> "Event":
+    def top(self) -> Event:
         return self.data[0]
 
     def isempty(self) -> bool:
         return len(self.data) == 0
 
-    def remove(self, event: "Event") -> None:
+    def remove(self, event: Event) -> None:
         """Method to remove events from heap.
 
         The event is set as the invalid state to save the time of removing event from heap.
@@ -50,7 +48,7 @@ class EventList:
 
         event.set_invalid()
 
-    def update_event_time(self, event: "Event", time: int):
+    def update_event_time(self, event: Event, time: int):
         """Method to update the timestamp of event and maintain the min-heap structure.
         """
         if time == event.time:

{sequence-0.8.3.dev260767962 → sequence-0.8.5.dev8889859}/sequence/kernel/quantum_manager.py

@@ -551,8 +551,8 @@ class QuantumManagerDensity(QuantumManager):
                 key = keys[0]
                 num_states = len(all_keys)
                 state_index = all_keys.index(key)
-                state_0, state_1, prob_0 = \
-                    measure_entangled_state_with_cache_density(tuple(map(tuple, state)), state_index, num_states)
+                state_0, state_1, prob_0 = measure_entangled_state_with_cache_density(tuple(map(tuple, state)), 
+                                                                                      state_index, num_states)
                 if meas_samp < prob_0:
                     new_state = array(state_0, dtype=complex)
                     result = 0
@@ -795,15 +795,13 @@ class QuantumManagerDensityFock(QuantumManager):
                 key = keys[0]
                 num_states = len(all_keys)
                 state_index = all_keys.index(key)
-                states, probs = \
-                    measure_entangled_state_with_cache_fock_density(state_tuple, state_index, num_states, povm_tuple,
-                                                                    self.truncation)
+                states, probs = measure_entangled_state_with_cache_fock_density(state_tuple, state_index, num_states, 
+                                                                                povm_tuple, self.truncation)
 
         else:
             indices = tuple([all_keys.index(key) for key in keys])
-            states, probs = \
-                measure_multiple_with_cache_fock_density(state_tuple, indices, len(all_keys), povm_tuple,
-                                                         self.truncation)
+            states, probs = measure_multiple_with_cache_fock_density(state_tuple, indices, len(all_keys), 
+                                                                     povm_tuple, self.truncation)
 
         # calculate result based on measurement sample.
         prob_sum = cumsum(probs)