sequence 0.8.3.dev260767962__tar.gz → 0.8.5__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: sequence
-Version: 0.8.3.dev260767962
+Version: 0.8.5
 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}/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}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sequence"
-version = "0.8.3.dev260767962"
+version = "0.8.5"
 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",
 ]
 
@@ -51,6 +54,18 @@ module-name = "sequence"
 [tool.setuptools.package-data]
 sequence = ["gui/user_templates.json", "gui/default_params.json", "gui/starlight.json"]
 
+[tool.pytest.ini_options]
+markers = [
+    "unit: Marks tests as unit tests",
+]
+
+[dependency-groups]
+dev = [
+    "coverage>=7.13.4",
+    "ruff>=0.15.1",
+    "ty>=0.0.16",
+]
+
 [project.urls]
 Homepage = "https://github.com/sequence-toolbox/SeQUeNCe"
 Documentation = "https://sequence-rtd-tutorial.readthedocs.io/"

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

@@ -84,6 +84,17 @@ class RequestApp:
             self.schedule_reservation(reservation)
             log.logger.info(f"Successful reservation of resources for request app on node {self.node.name}")
 
+    def get_other_reservation(self, reservation: Reservation) -> None:
+        """Method to add the approved reservation that is requested by other nodes. The responder will call this method
+
+        Args:
+            reservation (Reservation): reservation that uses the node of an application as the responder
+
+        Side Effects:
+            Will add calls to `add_memo_reservation_map` and `remove_memo_reservation_map` methods.
+        """
+        self.schedule_reservation(reservation)
+
     def add_memo_reservation_map(self, index: int, reservation: Reservation) -> None:
         """Maps memory index to the corresponding reservation.
 
@@ -132,23 +143,18 @@ class RequestApp:
     def get_throughput(self) -> float:
         return self.memory_counter / (self.end_t - self.start_t) * 1e12
 
-    def get_other_reservation(self, reservation: Reservation) -> None:
-        """Method to add the approved reservation that is requested by other nodes. The responder will call this method
 
-        Args:
-            reservation (Reservation): reservation that uses the node of application as the responder
+    def schedule_reservation(self, reservation: Reservation) -> None:
+        """Calling the `add_memo_reservation_map` and `remove_memo_reservation_map` methods at the 
+           reservation's start_time and end_time for all timecards (memory) involved in the reservation.
 
-        Side Effects:
-            Will add calls to `add_memo_reservation_map` and `remove_memo_reservation_map` methods.
+        Args:
+            reservation (Reservation): reservation to schedule
         """
-        self.schedule_reservation(reservation)
-
-    def schedule_reservation(self, reservation: Reservation) -> None:
         if reservation.initiator == self.node.name:
             self.path = reservation.path
 
-        reservation_protocol = self.node.network_manager.protocol_stack[1]
-        for card in reservation_protocol.timecards:
+        for card in self.node.network_manager.get_timecards():
             if reservation in card.reservations:
                 process = Process(self, "add_memo_reservation_map", [card.memory_index, reservation])
                 event = Event(reservation.start_time, process)

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

@@ -166,9 +166,9 @@ class BSM(Entity):
             photon (Photon): photon to measure.
         """
 
-        assert photon.encoding_type["name"] == self.encoding, \
-            "BSM expecting photon with encoding '{}' received photon with encoding '{}'".format(
-                self.encoding, photon.encoding_type["name"])
+        assert photon.encoding_type["name"] == self.encoding, (
+            f"BSM expecting photon with encoding '{self.encoding}' "
+            f"received photon with encoding '{photon.encoding_type['name']}'")
 
         # check if photon arrived later than current photon
         if self.photon_arrival_time < self.timeline.now():
@@ -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}/sequence/components/detector.py

@@ -518,8 +518,8 @@ class QSDetectorFockInterference(QSDetector):
         arrival_time = self.timeline.now()
         self.arrival_times[input_port].append(arrival_time)
         # record in temporary photon list
-        assert not self.temporary_photon_info[input_port], \
-            "At most 1 Photon instance should arrive at an input port at a time."
+        assert not self.temporary_photon_info[input_port], (
+            "At most 1 Photon instance should arrive at an input port at a time.")
         self.temporary_photon_info[input_port]["photon"] = photon
         self.temporary_photon_info[input_port]["time"] = arrival_time
 

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

@@ -61,8 +61,8 @@ class Interferometer(Entity):
             May call get method of one attached receiver from the receivers attribute.
         """
 
-        assert photon.encoding_type["name"] == "time_bin", \
-            "Invalid photon encoding {} received by interferometer".format(photon.encoding_type["name"])
+        assert photon.encoding_type["name"] == "time_bin", (
+            "Invalid photon encoding {} received by interferometer".format(photon.encoding_type["name"]))
         if photon.use_qm:
             raise NotImplementedError("Interferometer usage not configured for quantum manager.")
 

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

@@ -4,10 +4,10 @@ This module defines the Memory class to simulate single atom memories as well as
 Memories will attempt to send photons through the `send_qubit` interface of nodes.
 Photons should be routed to a BSM device for entanglement generation, or through optical hardware for purification and swapping.
 """
-
+from __future__ import annotations
 from copy import copy
 from math import inf
-from typing import Any, TYPE_CHECKING
+from typing import Any, TYPE_CHECKING, Iterator
 from collections.abc import Callable
 from numpy import exp, array
 from scipy import stats
@@ -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,15 +60,16 @@ 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)
-        self.memories = []
+        self.memories: list[Memory] = []
         self.memory_name_to_index = {}
 
         if decoherence_errors is not None:
-            assert QuantumManager.get_active_formalism() == BELL_DIAGONAL_STATE_FORMALISM, \
-                "Decoherence errors can only be set when formalism is Bell Diagonal"
+            assert QuantumManager.get_active_formalism() == BELL_DIAGONAL_STATE_FORMALISM, (
+                "Decoherence errors can only be set when formalism is Bell Diagonal")
 
         # Set the default pauli errors if BDS formalism
         if QuantumManager.get_active_formalism() == BELL_DIAGONAL_STATE_FORMALISM and decoherence_errors is None:
@@ -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)
@@ -91,6 +92,9 @@ class MemoryArray(Entity):
     def __len__(self) -> int:
         return len(self.memories)
 
+    def __iter__(self) -> Iterator[Memory]:
+        return iter(self.memories)
+
     def init(self):
         """Implementation of Entity interface (see base class).
 
@@ -127,7 +131,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 +191,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 +206,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)
@@ -221,10 +226,11 @@ class Memory(Entity):
 
         self.decoherence_errors = decoherence_errors
         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."
+            error_msg = "Decoherence errors refer to probabilities for each Pauli error to happen if an error happens, thus should be normalized."
+            assert len(self.decoherence_errors) == 3 and abs(sum(self.decoherence_errors) - 1) < EPSILON, error_msg
+        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 +365,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:
@@ -380,13 +386,13 @@ class Memory(Entity):
             time = (self.timeline.now() - self.last_update_time) * 1e-12  # duration of memory idling (in s)
             if time > 0 and self.last_update_time > 0:  # time > 0 means time has progressed, self.last_update_time > 0 means the memory has not been reset
 
-                x_rate, y_rate, z_rate = self.decoherence_rate * self.decoherence_errors[0], \
-                                        self.decoherence_rate * self.decoherence_errors[1], \
-                                        self.decoherence_rate * self.decoherence_errors[2]
-                p_I, p_X, p_Y, p_Z = _p_id(x_rate, y_rate, z_rate, time), \
-                                    _p_xerr(x_rate, y_rate, z_rate, time), \
-                                    _p_yerr(x_rate, y_rate, z_rate, time), \
-                                    _p_zerr(x_rate, y_rate, z_rate, time)
+                x_rate = self.decoherence_rate * self.decoherence_errors[0]
+                y_rate = self.decoherence_rate * self.decoherence_errors[1]
+                z_rate = self.decoherence_rate * self.decoherence_errors[2]
+                p_I = _p_id(x_rate, y_rate, z_rate, time)
+                p_X = _p_xerr(x_rate, y_rate, z_rate, time)
+                p_Y = _p_yerr(x_rate, y_rate, z_rate, time)
+                p_Z = _p_zerr(x_rate, y_rate, z_rate, time)
 
                 state_now = self.timeline.quantum_manager.states[self.qstate_key].state  # current diagonal elements
                 transform_mtx = array([[p_I, p_Z, p_X, p_Y],
@@ -443,7 +449,7 @@ class Memory(Entity):
         for observer in self._observers:
             observer.memory_expire(self)
 
-    def detach(self, observer: 'EntanglementProtocol'):  # observer could be a MemoryArray
+    def detach(self, observer: "EntanglementProtocol | MemoryArray"):  # observer could be a MemoryArray
         if observer in self._observers:
             self._observers.remove(observer)
 
@@ -460,7 +466,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/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}/sequence/entanglement_management/entanglement_protocol.py

@@ -25,7 +25,6 @@ class EntanglementProtocol(Protocol):
     def __init__(self, owner: "Node", name: str):
         super().__init__(owner, name)
         self.rule = None
-        self.protocol_type = None
         self.memories = []
 
     @abstractmethod

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

@@ -180,8 +180,7 @@ class BarretKokA(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)

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

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from math import sqrt
-from typing import TYPE_CHECKING, List, Dict, Type, Any
+from typing import TYPE_CHECKING, Any
 
 from .generation_message import EntanglementGenerationMessage, GenerationMsgType
 from ...resource_management.memory_manager import MemoryInfo
@@ -30,7 +30,7 @@ class EntanglementGenerationA(EntanglementProtocol, ABC):
        This class provides a framework for implementing entanglement generation protocols
     
     Class Attributes:
-        _registry (dict[str, Type['EntanglementGenerationA']]): A registry mapping protocol names to their corresponding classes.
+        _registry (dict[str, type['EntanglementGenerationA']]): A registry mapping protocol names to their corresponding classes.
         _global_type (str): The globally set protocol type used when creating new instances. Defaults to BARRET_KOK, other options: SINGLE_HERALDED
 
     Instance Attributes:
@@ -39,14 +39,14 @@ class EntanglementGenerationA(EntanglementProtocol, ABC):
         remote_node_name (str): The name of the remote node involved in the protocol.
         remote_protocol_name (str): The name of the remote protocol instance paired to this protocol.
         memory (Memory): The memory managed by this protocol.
-        memories (List[Memory]): A list containing the single memory managed by this protocol.
+        memories (list[Memory]): A list containing the single memory managed by this protocol.
         remote_memo_id (str): The identifier (name) of the remote memory used in the protocol.
         qc_delay (int): The quantum channel delay to the middle node (in ps).
         expected_time (int): expected time for middle BSM node to receive the photon (in ps).
         fidelity (float): The fidelity of the entangled state produced by the protocol.
         ent_round (int): The current round of entanglement generation (total two rounds in Barrett-Kok).
-        bsm_res (List[int]): The result of the Bell State Measurement (BSM), initialized to [-1, -1].
-        scheduled_events (List[Event]): A list of scheduled events for the protocol.
+        bsm_res (list[int]): The result of the Bell State Measurement (BSM), initialized to [-1, -1].
+        scheduled_events (list[Event]): A list of scheduled events for the protocol.
         primary (bool): Indicates if this node is the primary node in the protocol (based on lexicographical order of node names).
         _qstate_key (int): The key of the quantum states associated with the memory used in the protocol.
     """
@@ -121,8 +121,7 @@ class EntanglementGenerationA(EntanglementProtocol, ABC):
         return list(cls._registry.keys())
 
     def set_others(self, protocol: str, node: str, memories: list[str]) -> None:
-        assert self.remote_protocol_name == '', \
-            "Remote protocol name has been set before, cannot set again."
+        assert self.remote_protocol_name == '', "Remote protocol name has been set before, cannot set again."
 
         self.remote_protocol_name = protocol
         self.remote_memo_id = memories[0]
@@ -169,8 +168,7 @@ class EntanglementGenerationA(EntanglementProtocol, ABC):
         return self.remote_protocol_name != ''
 
     def memory_expire(self, memory: "Memory") -> None:
-        assert memory == self.memory, \
-            "Memory to expire does not match the protocol's memory"
+        assert memory == self.memory, "Memory to expire does not match the protocol's memory"
         self.update_resource_manager(memory, MemoryInfo.RAW)
         for event in self.scheduled_events:
             if event.time >= self.owner.timeline.now():