pulserver 0.1.2__tar.gz → 0.1.4__tar.gz

{pulserver-0.1.2 → pulserver-0.1.4}/.github/workflows/tags-release.yml

@@ -95,26 +95,26 @@ jobs:
         '${{ github.ref_name }}' dist/**
         --repo '${{ github.repository }}'
 
-  publish-to-testpypi:
-    name: Publish Python 🐍 distribution 📦 to TestPyPI
-    needs:
-    - build
-    runs-on: ubuntu-latest
+  # publish-to-testpypi:
+    # name: Publish Python 🐍 distribution 📦 to TestPyPI
+    # needs:
+    # - build
+    # runs-on: ubuntu-latest
 
-    environment:
-      name: testpypi
-      url: https://test.pypi.org/p/<package-name>
+    # environment:
+      # name: testpypi
+      # url: https://test.pypi.org/p/<package-name>
 
-    permissions:
-      id-token: write  # IMPORTANT: mandatory for trusted publishing
+    # permissions:
+      # id-token: write  # IMPORTANT: mandatory for trusted publishing
 
-    steps:
-    - name: Download all the dists
-      uses: actions/download-artifact@v4
-      with:
-        name: python-package-distributions
-        path: dist/
-    - name: Publish distribution 📦 to TestPyPI
-      uses: pypa/gh-action-pypi-publish@release/v1
-      with:
-        repository-url: https://test.pypi.org/legacy/
+    # steps:
+    # - name: Download all the dists
+      # uses: actions/download-artifact@v4
+      # with:
+        # name: python-package-distributions
+        # path: dist/
+    # - name: Publish distribution 📦 to TestPyPI
+      # uses: pypa/gh-action-pypi-publish@release/v1
+      # with:
+        # repository-url: https://test.pypi.org/legacy/

{pulserver-0.1.2 → pulserver-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pulserver
-Version: 0.1.2
+Version: 0.1.4
 Summary: A PyPulseq-based client/server MR sequence design toolbox.
 Author-email: Matteo Cencini <matteo.cencini@gmail.com>
 Project-URL: Homepage, https://github.com/INFN-MRI/pulserver
@@ -16,14 +16,13 @@ Classifier: Programming Language :: Python :: 3.12
 Requires-Python: >=3.10
 Description-Content-Type: text/x-rst
 License-File: LICENSE.txt
-Requires-Dist: pyyaml
 Requires-Dist: numpy<2.0
 Requires-Dist: scipy<1.14
 Requires-Dist: numba
 Requires-Dist: pypulseq
 Requires-Dist: pulpy
 Requires-Dist: mri-nufft
-Requires-Dist: ismrmrd
+Requires-Dist: mrd-python
 Requires-Dist: ipywidgets
 Provides-Extra: dev
 Requires-Dist: black; extra == "dev"

{pulserver-0.1.2 → pulserver-0.1.4}/docs/api.rst

@@ -10,7 +10,6 @@ Core sequence representation.
    :nosignatures:
 
    pulserver.Sequence
-   pulserver.SequenceParams
    pulserver.Opts 
 
 Blocks

{pulserver-0.1.2 → pulserver-0.1.4}/docs/hands-on.ipynb

@@ -4,7 +4,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "# Hands-on: a 2D GRE (Gradient-Recalled Echo) Sequence Example\n",
+    "# Hands-on: a 2D SPGR (Spoiled Gradient-Recalled Echo) Sequence Example\n",
     "\n",
     "This tutorial aims to illustrate the sequence design features of Pulserver through building a minimal 2D Spoiled Gradient Recalled Echo (2D SPGR) sequence.\n",
     "We will demonstrate the built-in high-level design functions as well as show how to customize the sequence using lower-level routines, assuming a basic knowledge of the [(Py)Pulseq](https://github.com/imr-framework/pypulseq/tree/dev) formalism.\n",
@@ -30,7 +30,7 @@
     "n_slices = 1  # Single slice acquisition\n",
     "\n",
     "flip_angle = 15.0  # Flip angle in degrees\n",
-    "slice_thickness = 5.0  # Slab thickness in mm"
+    "slice_thickness = 5.0  # Slice thickness in mm"
    ]
   },
   {
@@ -84,7 +84,7 @@
     "You can notice that gradient and slew rate are automatically converted to ``[Hz]`` and ``[Hz/m/s]``, respectively.\n",
     "\n",
     "## 2. Instantiate the Sequence object\n",
-    "Now, we instantiate the sequence object. This is designed to provide a similar use experience as native Pulseq's `Sequence` class, but is effectively a [builder]([https://en.wikipedia.org/wiki/Builder_pattern) we use to create the actual PyPulseq `Sequence` object or the equivalent representations for other Pulseq interpreters (for now, GEHC TOPPE). The aim is providing a familiar syntax to Pulseq users, while minimizing the computationally expensive conversions steps required to adapt the format to different platforms."
+    "Now, we instantiate the sequence object. This is designed to provide a similar use experience as native Pulseq's `Sequence` class, but is effectively a `builder <(https://en.wikipedia.org/wiki/Builder_pattern>` we use to create the actual PyPulseq `Sequence` object or the equivalent representations for other Pulseq interpreters (for now, GEHC TOPPE). The aim is providing a familiar syntax to Pulseq users, while minimizing the computationally expensive conversion steps required to adapt the format to different platforms."
    ]
   },
   {
@@ -95,7 +95,7 @@
    "source": [
     "seq = pulserver.Sequence(\n",
     "    system_limits, platform=\"pulseq\"\n",
-    ")  # 'format' specify the internal Sequence"
+    ")  # 'platform' specifies the internal Sequence type"
    ]
   },
   {
@@ -253,7 +253,7 @@
     "- **RF Excitation**:this consists of the simultaneous execution of an RF event and its accompanying slice selection gradient on z-axis.\n",
     "- **Slice Rephasing**: this consists of the slice rephasing gradient event on z-axis.\n",
     "- **Phase encoding**: this consists of simultaneous execution of the phase encoding gradient event on y-axis and the readout pre-winder event on the x-axis.\n",
-    "- **Readout**: this block consists of the simultaneous execution of the readout gradient (x-axis) and the ADC event (to record the MR signal).\n",
+    "- **Readout**: this consists of the simultaneous execution of the readout gradient (x-axis) and the ADC event (to record the MR signal).\n",
     "- **Rewinder**: this is a repetition of the **Phase encoding**, with a scaling factor equal to -1.0 for the y-axis gradient event (reverse polarity).\n",
     "- **Spoiler**: this consists of the spoiling gradient event on z-axis.\n",
     "\n",
@@ -363,7 +363,7 @@
     "\n",
     "Throughout the scan loop, the basic sequence structure is repeated while changing the phase $\\Phi_n$ phase of the RF pulse (RF spoiling), its frequency offset (to excite different slices) and the scaling of the y-gradient events in both **Phase encoding** and **Rewinder** blocks to sample different ky lines in k-space. The gradient amplitude scaling and RF phase and frequency offsets are examples of dynamic sequence parameters, which also include RF amplitude scaling, gradient rotations and variable delay times, that are used to control the image contrast and k-space sampling pattern.\n",
     "\n",
-    "Hence, the user needs to create the schedule for these dynamic sequence parameters. As this require a lot of effort, especially to obtain specific sampling pattern for Parallel Imaging and Compressed Sensing (e.g., CAIPIRINHA and Poisson Disk sampling), we include support routine to 1) generate such sampling masks and RF modulation patterns and 2) retrieve the corresponding gradient / RF amplitude settings at each TR. These support routines are included in `pulserver.plan` subpackage.\n",
+    "Hence, the user needs to create the schedule for these dynamic sequence parameters. As this require a lot of effort, especially to obtain specific sampling pattern for Parallel Imaging and Compressed Sensing (e.g., CAIPIRINHA and Poisson Disk sampling), we include support routines to 1) generate such sampling masks and RF modulation patterns and 2) retrieve the corresponding gradient / RF amplitude settings at each TR. These support routines are included in `pulserver.plan` subpackage.\n",
     "\n",
     "We now use this package to create a Cartesian sampling mask and the RF phase list required to obtain RF spoiling:"
    ]
@@ -670,7 +670,7 @@
     "    # initialize sequence object\n",
     "    seq = pulserver.Sequence(\n",
     "        system_limits, platform=\"pulseq\"\n",
-    "    )  # 'format' specify the internal Sequence\n",
+    "    )  # 'platform' specifies the internal Sequence type\n",
     "\n",
     "    # Define Blocks\n",
     "    # -------------\n",

{pulserver-0.1.2 → pulserver-0.1.4}/pyproject.toml

@@ -41,14 +41,13 @@ classifiers = [  # Optional
 ]
 
 dependencies = [
-"pyyaml",
 "numpy<2.0",
 "scipy<1.14",
 "numba",
 "pypulseq",
 "pulpy",
 "mri-nufft",
-"ismrmrd",
+"mrd-python",
 "ipywidgets",
 ]
 

{pulserver-0.1.2 → pulserver-0.1.4}/src/pulserver/__init__.py

@@ -5,13 +5,14 @@ __all__ = []
 from pypulseq import Opts  # noqa
 
 from . import blocks  # noqa
+from . import parsing  # noqa
 from . import plan  # noqa
 from . import sequences  # noqa
 
 from . import _server  # noqa
 
 from ._core import Sequence  # noqa
-from ._core import SequenceParams  # noqa
+from ._opts import get_opts  # noqa
 
-__all__.append("Opts")
-__all__.extend(["Sequence", "SequenceParams"])
+__all__.extend(["Opts", "get_opts"])
+__all__.extend(["Sequence", "ParamsParser"])

pulserver-0.1.4/src/pulserver/_apps/SPGR2D.py

@@ -0,0 +1,23 @@
+"""2D Spoiled Gradient Echo sequence."""
+
+__all__ = ["SPGR2D"]
+
+from pulserver.parsing import Cartesian2DParams
+from pulserver.sequences import design_2D_spgr
+
+
+def SPGR2D(kwargs):
+    """
+    Generate a 2D Spoiled Gradient Recalled Echo (SPGR) pulse sequence.
+
+    This function wraps ``pulserver.sequences.design_2D_spgr`` - see
+    the corresponding docstrings for more information.
+
+    """
+    # parse parameters
+    params = Cartesian2DParams(**kwargs, fudge_factor=0.9)
+
+    # call design function (exclude header for now)
+    seq, _ = design_2D_spgr(**params.asdict(), platform="gehc")
+
+    return seq.export(), None

{pulserver-0.1.2 → pulserver-0.1.4}/src/pulserver/_cli.py

@@ -8,7 +8,7 @@ from . import _server
 
 
 @click.group()
-def cli():
+def cli():  # noqa
     pass
 
 
@@ -22,24 +22,25 @@ def cli():
 @click.option("--recon-server-port", default=None, help="Reconstruction server port.")
 def start(
     config_path, scanner_address, scanner_port, recon_server_address, recon_server_port
-):
+):  # noqa
     """
     Start sequence design server.
     """
-    if config_path is not None:
-        os.environ["PULSEFORGE_CONFIG"] = config_path
-    else:
-        if scanner_address is not None:
-            os.environ["PULSEFORGE_SCANNER_ADDRESS"] = scanner_address
-        if scanner_port is not None:
-            os.environ["PULSEFORGE_SCANNER_PORT"] = scanner_port
-        if recon_server_address is not None:
-            os.environ["PULSEFORGE_RECON_SERVER_ADDRESS"] = recon_server_address
-        if recon_server_port is not None:
-            os.environ["PULSEFORGE_RECON_SERVER_PORT"] = recon_server_port
+    # Get configuration
+    config = _server.load_config()
+
+    # Replace with provided arguments
+    if scanner_address is not None:
+        os.environ["SCANNER_ADDRESS"] = scanner_address
+    if scanner_port is not None:
+        os.environ["SCANNER_PORT"] = scanner_port
+    if recon_server_address is not None:
+        os.environ["RECON_SERVER_ADDRESS"] = recon_server_address
+    if recon_server_port is not None:
+        os.environ["RECON_SERVER_PORT"] = recon_server_port
 
     # start the server
-    _server.start_server()
+    _server.start_server(config)
 
 
 @click.command()
@@ -48,12 +49,15 @@ def start(
     default=None,
     help="Function whose docstring we want to see. If not provided, print list of available commands.",
 )
-def apps(name):
+def apps(name):  # noqa
     """
     Design function documentations
     """
+    # Get configuration
+    config = _server.load_config()
+
     # Load plugin list
-    plugins = _server.load_plugins()
+    plugins = _server.load_plugins(config)
     if name is None:
         for fun in plugins.values():
             name = fun.__name__

{pulserver-0.1.2 → pulserver-0.1.4}/src/pulserver/_core/__init__.py

@@ -6,7 +6,6 @@ native pypulseq Sequence and Ceq structure.
 
 __all__ = []
 
-from ._ceq import SequenceParams  # noqa
 from ._sequence import Sequence  # noqa
 
-__all__.extend(["Sequence", "SequenceParams"])
+__all__.append("Sequence")

{pulserver-0.1.2 → pulserver-0.1.4}/src/pulserver/_core/_ceq.py

@@ -1,11 +1,9 @@
 """Ceq structure definition."""
 
-__all__ = ["Ceq", "PulseqBlock", "SequenceParams"]
+__all__ = ["Ceq", "PulseqBlock"]
 
 from dataclasses import dataclass
-from dataclasses import asdict as _asdict
 from types import SimpleNamespace
-from typing import Optional
 
 import struct
 import numpy as np
@@ -37,7 +35,7 @@ class PulseqShapeArbitrary:
 
         # determine amplitude and normalize waveform
         self.amplitude = abs(self.magnitude).max()
-        self.magnitude *= 32767 / self.amplitude
+        self.magnitude /= self.amplitude
 
     def to_bytes(self, endian=">") -> bytes:
         _bytes = struct.pack(endian + "i", self.n_samples) + struct.pack(
@@ -80,6 +78,7 @@ class PulseqShapeTrap:
 @dataclass
 class PulseqRF:
     type: int
+    complexflag: int
     wav: PulseqShapeArbitrary
     duration: float
     delay: float
@@ -87,6 +86,7 @@ class PulseqRF:
     def to_bytes(self, endian=">") -> bytes:
         return (
             struct.pack(endian + "h", self.type)
+            + struct.pack(endian + "h", self.complexflag)
             + self.wav.to_bytes(endian)
             + struct.pack(endian + "f", self.duration)
             + struct.pack(endian + "f", self.delay)
@@ -108,11 +108,21 @@ class PulseqRF:
             raster = 0.0
             time = data.t
 
-        rho = np.abs(data.signal)
-        theta = np.angle(data.signal)
+        sum_rf_real = sum(abs(data.signal.real))
+        sum_rf_imag = sum(abs(data.signal.imag))
+
+        if sum_rf_real > 100 * sum_rf_imag:
+            complexflag = 0
+            rho = data.signal.real
+            theta = None
+        else:
+            complexflag = 1
+            rho = np.abs(data.signal)
+            theta = np.angle(data.signal)
 
         return cls(
             type=type,
+            complexflag=complexflag,
             wav=PulseqShapeArbitrary(n_samples, raster, time, rho, theta),
             duration=data.shape_dur,
             delay=data.delay,
@@ -134,7 +144,6 @@ class PulseqGrad:
 
     @classmethod
     def from_struct(cls, data: SimpleNamespace) -> "PulseqGrad":
-        print(data)
         if data.type == "trap":
             type = 1
             shape_obj = PulseqShapeTrap(
@@ -147,12 +156,10 @@ class PulseqGrad:
             dt = np.unique(np.diff(np.round(data.tt * 1e6))) / 1e6
 
             if len(dt) == 1:  # uniform raster -> arbitrary shape
-                print("arbitrary")
                 type = 2
                 raster = dt.item()
                 time = None
             else:  # non-uniform raster -> extended trapezoid
-                print("extended")
                 type = 3
                 raster = 0.0
                 time = data.tt
@@ -300,32 +307,41 @@ class Ceq:
         segments = _build_segments(loop, sections_edges)
 
         # build CEQ structure
-        self.n_max = loop.shape[0]
         self.n_parent_blocks = len(parent_blocks)
-        self.n_segments = len(segments)
         self.parent_blocks = parent_blocks
+        self.n_segments = len(segments)
         self.segments = segments
+        self.n_max = loop.shape[0]
         self.n_columns_in_loop_array = loop.shape[1] - 2  # discard "hasrot", "hasadc"
         self.loop = loop[:, :-2]
+
+        # Safety, RF scaling and scan duration info
+        self.max_rf_power = 0.0
         self.max_b1 = _find_b1_max(parent_blocks)
+        self.max_grad = _find_grad_max(parent_blocks)
+        self.max_slew = _find_slew_max(parent_blocks)
         self.duration = _calc_duration(self.loop[:, 0], self.loop[:, 9])
         self.n_readouts = int(np.sum(loop[:, -2]))
+        self.n_gain = 0
 
     def to_bytes(self, endian=">") -> bytes:  # noqa
-        bytes_data = (
-            struct.pack(endian + "i", self.n_max)
-            + struct.pack(endian + "h", self.n_parent_blocks)
-            + struct.pack(endian + "h", self.n_segments)
-        )
+        bytes_data = struct.pack(endian + "h", self.n_parent_blocks)
         for block in self.parent_blocks:
             bytes_data += block.to_bytes(endian)
+        bytes_data += struct.pack(endian + "h", self.n_segments)
         for segment in self.segments:
             bytes_data += segment.to_bytes(endian)
+        bytes_data += struct.pack(endian + "i", self.n_max)
         bytes_data += struct.pack(endian + "h", self.n_columns_in_loop_array)
         bytes_data += self.loop.astype(endian + "f4").tobytes()
+
+        bytes_data += struct.pack(endian + "f", self.max_rf_power)
         bytes_data += struct.pack(endian + "f", self.max_b1)
+        bytes_data += struct.pack(endian + "f", self.max_grad)
+        bytes_data += struct.pack(endian + "f", self.max_slew)
         bytes_data += struct.pack(endian + "f", self.duration)
         bytes_data += struct.pack(endian + "i", self.n_readouts)
+        bytes_data += struct.pack(endian + "i", self.n_gain)
 
         return bytes_data
 
@@ -336,150 +352,6 @@ class Ceq:
             return self.to_bytes(endian="<")
 
 
-@dataclass
-class SequenceParams:
-    """
-    Python representation of the C SequenceParams struct.
-
-    Attributes
-    ----------
-    FOVx : Optional[float]
-        Field of view in mm (x-direction).
-    FOVy : Optional[float]
-        Field of view in mm (y-direction).
-    Nx : Optional[int]
-        Matrix size (x-direction).
-    Ny : Optional[int]
-        Matrix size (y-direction).
-    Nslices : Optional[int]
-        Number of slices.
-    Nechoes : Optional[int]
-        Number of echoes.
-    Nphases : Optional[int]
-        Number of phases.
-    slice_thickness : Optional[float]
-        Thickness of each slice (mm).
-    slice_spacing : Optional[float]
-        Spacing between slices (mm).
-    Rplane : Optional[float]
-        In-plane undersampling factor.
-    Rplane2 : Optional[float]
-        Additional in-plane undersampling factor.
-    Rslice : Optional[float]
-        Through-plane undersampling factor.
-    PFplane : Optional[float]
-        In-plane partial fourier.
-    PFslice : Optional[float]
-        Through-plane partial fourier.
-    ETL : Optional[int]
-        Number of k-space shots per readout.
-    TE : Optional[float]
-        Echo time (ms).
-    TE0 : Optional[float]
-        First echo time (ms) for multiecho.
-    TR : Optional[float]
-        Repetition time (ms).
-    Tprep : Optional[float]
-        Preparation time (ms).
-    Trecovery : Optional[float]
-        Recovery time (ms).
-    flip : Optional[float]
-        Flip angle in degrees.
-    flip2 : Optional[float]
-        Second flip angle in degrees.
-    refoc_flip : Optional[float]
-        Refocusing flip angle in degrees.
-    freq_dir : Optional[int]
-        Frequency direction (0: A/P; 1: S/L).
-    freq_verse : Optional[int]
-        Frequency verse (1: normal; -1: swapped).
-    phase_verse : Optional[int]
-        Phase verse (1: normal; -1: swapped).
-    bipolar_echoes : Optional[int]
-        Bipolar echoes (0: false, 1: true).
-    dwell : Optional[float]
-        ADC dwell time (s).
-    raster : Optional[float]
-        Waveform raster time (s).
-    gmax : Optional[float]
-        Maximum gradient strength (mT/m).
-    smax : Optional[float]
-        Maximum gradient slew rate (T/m/s).
-    b1_max : Optional[float]
-        Maximum RF value (uT).
-    b0_field : Optional[float]
-        System field strength (T).
-    """
-
-    FOVx: float | None = None
-    FOVy: float | None = None
-    Nx: int | None = None
-    Ny: int | None = None
-    Nslices: int | None = None
-    Nechoes: int | None = None
-    Nphases: int | None = None
-    slice_thickness: float | None = None
-    slice_spacing: float | None = None
-    Rplane: float | None = None
-    Rplane2: float | None = None
-    Rslice: float | None = None
-    PFplane: float | None = None
-    PFslice: float | None = None
-    ETL: int | None = None
-    TE: float | None = None
-    TE0: float | None = None
-    TR: float | None = None
-    Tprep: float | None = None
-    Trecovery: float | None = None
-    flip: float | None = None
-    flip2: float | None = None
-    refoc_flip: float | None = None
-    freq_dir: int | None = None
-    freq_verse: int | None = None
-    phase_verse: int | None = None
-    bipolar_echoes: int | None = None
-    dwell: float | None = None
-    raster: float | None = None
-    gmax: float | None = None
-    smax: float | None = None
-    b1_max: float | None = None
-    b0_field: float | None = None
-
-    @classmethod
-    def from_bytes(cls, data: bytes) -> "SequenceParams":
-        """
-        Deserialize from a byte array into a SequenceParams object.
-
-        Parameters
-        ----------
-        data : bytes
-            A byte array representing a serialized SequenceParams object.
-
-        Returns
-        -------
-        SequenceParams
-            A SequenceParams instance with attributes filled.
-        """
-        format_string = "2f 5h 2f 5f h 5f 3f 3h h 6f"
-        unpacked = struct.unpack(format_string, data)
-
-        # Replace -1 values with None
-        unpacked = [None if x == -1 or x == -1.0 else x for x in unpacked]
-
-        return cls(*unpacked)
-
-    def asdict(self) -> dict:
-        """
-        Return a dictionary of the dataclass, excluding None values.
-
-        Returns
-        -------
-        dict
-            A dictionary of the dataclass fields, excluding None values.
-        """
-        return {k: v for k, v in _asdict(self).items() if v is not None}
-
-
 # %% local subroutines
 def _build_segments(loop, sections_edges):
     hasrot = np.ascontiguousarray(loop[:, -1]).astype(int)
@@ -531,11 +403,21 @@ def _find_b1_max(parent_blocks):
     )
 
 
+# TODO: implement this
+def _find_grad_max(parent_blocks):
+    return 0.0
+
+
+# TODO: implement this
+def _find_slew_max(parent_blocks):
+    return 0.0
+
+
 def _calc_duration(segment_id, block_duration):
     block_duration = block_duration.sum()
 
     # total segment ringdown
-    n_seg_boundaries = (np.diff(segment_id) != 0).sum()
+    n_seg_boundaries = (np.diff(segment_id + 1) != 0).sum()
     seg_ringdown_duration = SEGMENT_RINGDOWN_TIME * n_seg_boundaries
 
     return block_duration + seg_ringdown_duration