sl-shared-assets 1.0.0rc13__py3-none-any.whl → 1.0.0rc15__py3-none-any.whl

sl_shared_assets/server/server.py

@@ -0,0 +1,213 @@
+"""This module provides the tools for working with the Sun lab BioHPC cluster. Specifically, the classes from this
+module establish an API for submitting jobs to the shared data processing cluster (managed via SLURM) and monitoring
+the running job status. All lab processing and analysis pipelines use this interface for accessing shared compute
+resources.
+"""
+
+import time
+from pathlib import Path
+import tempfile
+from dataclasses import dataclass
+
+import paramiko
+
+# noinspection PyProtectedMember
+from simple_slurm import Slurm  # type: ignore
+from paramiko.client import SSHClient
+from ataraxis_base_utilities import LogLevel, console
+from ataraxis_data_structures import YamlConfig
+
+from .job import Job
+
+
+def generate_server_credentials(
+    output_directory: Path, username: str, password: str, host: str = "cbsuwsun.biohpc.cornell.edu"
+) -> None:
+    """Generates a new server_credentials.yaml file under the specified directory, using input information.
+
+    This function provides a convenience interface for generating new BioHPC server credential files. Generally, this is
+    only used when setting up new host-computers in the lab.
+    """
+    ServerCredentials(username=username, password=password, host=host).to_yaml(
+        file_path=output_directory.joinpath("server_credentials.yaml")
+    )
+
+
+@dataclass()
+class ServerCredentials(YamlConfig):
+    """This class stores the hostname and credentials used to log into the BioHPC cluster to run Sun lab processing
+    pipelines.
+
+    Primarily, this is used as part of the sl-experiment library runtime to start data processing once it is
+    transferred to the BioHPC server during preprocessing. However, the same file can be used together with the Server
+    class API to run any computation jobs on the lab's BioHPC server.
+    """
+
+    username: str = "YourNetID"
+    """The username to use for server authentication."""
+    password: str = "YourPassword"
+    """The password to use for server authentication."""
+    host: str = "cbsuwsun.biohpc.cornell.edu"
+    """The hostname or IP address of the server to connect to."""
+
+
+class Server:
+    """Encapsulates access to the Sun lab BioHPC processing server.
+
+    This class provides the API that allows accessing the BioHPC server to create and submit various SLURM-managed jobs
+    to the server. It functions as the central interface used by all processing pipelines in the lab to execute costly
+    data processing on the server.
+
+    Notes:
+        All lab processing pipelines expect the data to be stored on the server and all processing logic to be packaged
+        and installed into dedicated conda environments on the server.
+
+        This class assumes that the target server has SLURM job manager installed and accessible to the user whose
+        credentials are used to connect to the server as part of this class instantiation.
+
+    Args:
+        credentials_path: The path to the locally stored .yaml file that contains the server hostname and access
+            credentials.
+
+    Attributes:
+        _open: Tracks whether the connection to the server is open or not.
+        _client: Stores the initialized SSHClient instance used to interface with the server.
+    """
+
+    def __init__(self, credentials_path: Path) -> None:
+        # Tracker used to prevent __del__ from classing stop() for a partially initialized class.
+        self._open: bool = False
+
+        # Loads the credentials from the provided .yaml file
+        self._credentials: ServerCredentials = ServerCredentials.from_yaml(credentials_path)  # type: ignore
+
+        # Establishes the SSH connection to the specified processing server. At most, attempts to connect to the server
+        # 30 times before terminating with an error
+        attempt = 0
+        while True:
+            console.echo(
+                f"Trying to connect to {self._credentials.host} (attempt {attempt}/30)...", level=LogLevel.INFO
+            )
+            try:
+                self._client: SSHClient = paramiko.SSHClient()
+                self._client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+                self._client.connect(
+                    self._credentials.host, username=self._credentials.username, password=self._credentials.password
+                )
+                console.echo(f"Connected to {self._credentials.host}", level=LogLevel.SUCCESS)
+                break
+            except paramiko.AuthenticationException:
+                message = (
+                    f"Authentication failed when connecting to {self._credentials.host} using "
+                    f"{self._credentials.username} user."
+                )
+                console.error(message, RuntimeError)
+                raise RuntimeError
+            except:
+                if attempt == 30:
+                    message = f"Could not connect to {self._credentials.host} after 30 attempts. Aborting runtime."
+                    console.error(message, RuntimeError)
+                    raise RuntimeError
+
+                console.echo(
+                    f"Could not SSH to {self._credentials.host}, retrying after a 2-second delay...",
+                    level=LogLevel.WARNING,
+                )
+                attempt += 1
+                time.sleep(2)
+
+    def __del__(self) -> None:
+        """If the instance is connected to the server, terminates the connection before the instance is destroyed."""
+        self.close()
+
+    def submit_job(self, job: Job) -> Job:
+        """Submits the input job to the managed BioHPC server via SLURM job manager.
+
+        This method submits various jobs for execution via SLURM-managed BioHPC cluster. As part of its runtime, the
+        method translates the Job object into the shell script, moves the script to the target working directory on
+        the server, and instructs the server to execute the shell script (via SLURM).
+
+        Args:
+            job: The Job object that contains all job data.
+
+        Returns:
+            The job object whose 'job_id' attribute had been modified with the job ID, if the job was successfully
+            submitted.
+
+        Raises:
+            RuntimeError: If job submission to the server fails.
+        """
+
+        # Generates a temporary shell script on the local machine. Uses tempfile to automatically remove the
+        # local script as soon as it is uploaded to the server.
+        with tempfile.TemporaryDirectory() as temp_dir:
+            local_script_path = Path(temp_dir).joinpath(f"{job.job_name}.sh")
+            fixed_script_content = job.command_script
+
+            # Creates a temporary script file locally and dumps translated command data into the file
+            with open(local_script_path, "w") as f:
+                f.write(fixed_script_content)
+
+            # Uploads the command script to the server
+            sftp = self._client.open_sftp()
+            sftp.put(localpath=local_script_path, remotepath=job.remote_script_path)
+            sftp.close()
+
+        # Makes the server-side script executable
+        self._client.exec_command(f"chmod +x {job.remote_script_path}")
+
+        # Submits the job to SLURM with sbatch and verifies submission state
+        job_output = self._client.exec_command(f"sbatch {job.remote_script_path}")[1].read().strip().decode()
+
+        # If batch_job is not in the output received from SLURM in response to issuing the submission command, raises an
+        # error.
+        if "Submitted batch job" not in job_output:
+            message = f"Failed to submit the {job.job_name} job to the BioHPC cluster."
+            console.error(message, RuntimeError)
+
+            # Fallback to appease mypy, should not be reachable
+            raise RuntimeError(message)
+
+        # Otherwise, extracts the job id assigned to the job by SLURM from the response and writes it to the processed
+        # Job object
+        job_id = job_output.split()[-1]
+        job.job_id = job_id
+        return job
+
+    def job_complete(self, job: Job) -> bool:
+        """Returns True if the job managed by the input Job instance has been completed or terminated its runtime due
+        to an error.
+
+        If the job is still running or is waiting inside the execution queue, returns False.
+
+        Args:
+            job: The Job object whose status needs to be checked.
+
+        Raises:
+            ValueError: If the input Job object does not contain a valid job_id, suggesting that it has not been
+                submitted to the server.
+        """
+
+        if job.job_id is None:
+            message = (
+                f"The input Job object for the job {job.job_name} does not contain a valid job_id. This indicates that "
+                f"the job has not been submitted to the server."
+            )
+            console.error(message, ValueError)
+
+            # This is here to appease mypy, it should not be reachable
+            raise ValueError(message)
+
+        if job.job_id not in self._client.exec_command(f"squeue -j {job.job_id}")[1].read().decode().strip():
+            return True
+        else:
+            return False
+
+    def close(self) -> None:
+        """Closes the SSH connection to the server.
+
+        This method has to be called before destroying the class instance to ensure proper resource cleanup.
+        """
+        # Prevents closing already closed connections
+        if self._open:
+            self._client.close()

sl_shared_assets/server/server.pyi

@@ -0,0 +1,95 @@
+from pathlib import Path
+from dataclasses import dataclass
+
+from simple_slurm import Slurm as Slurm
+from paramiko.client import SSHClient as SSHClient
+from ataraxis_data_structures import YamlConfig
+
+from .job import Job as Job
+
+def generate_server_credentials(
+    output_directory: Path, username: str, password: str, host: str = "cbsuwsun.biohpc.cornell.edu"
+) -> None:
+    """Generates a new server_credentials.yaml file under the specified directory, using input information.
+
+    This function provides a convenience interface for generating new BioHPC server credential files. Generally, this is
+    only used when setting up new host-computers in the lab.
+    """
+@dataclass()
+class ServerCredentials(YamlConfig):
+    """This class stores the hostname and credentials used to log into the BioHPC cluster to run Sun lab processing
+    pipelines.
+
+    Primarily, this is used as part of the sl-experiment library runtime to start data processing once it is
+    transferred to the BioHPC server during preprocessing. However, the same file can be used together with the Server
+    class API to run any computation jobs on the lab's BioHPC server.
+    """
+
+    username: str = ...
+    password: str = ...
+    host: str = ...
+
+class Server:
+    """Encapsulates access to the Sun lab BioHPC processing server.
+
+    This class provides the API that allows accessing the BioHPC server to create and submit various SLURM-managed jobs
+    to the server. It functions as the central interface used by all processing pipelines in the lab to execute costly
+    data processing on the server.
+
+    Notes:
+        All lab processing pipelines expect the data to be stored on the server and all processing logic to be packaged
+        and installed into dedicated conda environments on the server.
+
+        This class assumes that the target server has SLURM job manager installed and accessible to the user whose
+        credentials are used to connect to the server as part of this class instantiation.
+
+    Args:
+        credentials_path: The path to the locally stored .yaml file that contains the server hostname and access
+            credentials.
+
+    Attributes:
+        _open: Tracks whether the connection to the server is open or not.
+        _client: Stores the initialized SSHClient instance used to interface with the server.
+    """
+
+    _open: bool
+    _credentials: ServerCredentials
+    _client: SSHClient
+    def __init__(self, credentials_path: Path) -> None: ...
+    def __del__(self) -> None:
+        """If the instance is connected to the server, terminates the connection before the instance is destroyed."""
+    def submit_job(self, job: Job) -> Job:
+        """Submits the input job to the managed BioHPC server via SLURM job manager.
+
+        This method submits various jobs for execution via SLURM-managed BioHPC cluster. As part of its runtime, the
+        method translates the Job object into the shell script, moves the script to the target working directory on
+        the server, and instructs the server to execute the shell script (via SLURM).
+
+        Args:
+            job: The Job object that contains all job data.
+
+        Returns:
+            The job object whose 'job_id' attribute had been modified with the job ID, if the job was successfully
+            submitted.
+
+        Raises:
+            RuntimeError: If job submission to the server fails.
+        """
+    def job_complete(self, job: Job) -> bool:
+        """Returns True if the job managed by the input Job instance has been completed or terminated its runtime due
+        to an error.
+
+        If the job is still running or is waiting inside the execution queue, returns False.
+
+        Args:
+            job: The Job object whose status needs to be checked.
+
+        Raises:
+            ValueError: If the input Job object does not contain a valid job_id, suggesting that it has not been
+                submitted to the server.
+        """
+    def close(self) -> None:
+        """Closes the SSH connection to the server.
+
+        This method has to be called before destroying the class instance to ensure proper resource cleanup.
+        """

sl_shared_assets/suite2p/__init__.py

@@ -0,0 +1,8 @@
+"""This package provides the configuration classes used by the Sun lab maintained version of the suite2p library
+(sl-suite2p package, https://github.com/Sun-Lab-NBB/suite2p) to process brain activity data within and across sessions
+(days)."""
+
+from .multi_day import MultiDayS2PConfiguration
+from .single_day import SingleDayS2PConfiguration
+
+__all__ = ["MultiDayS2PConfiguration", "SingleDayS2PConfiguration"]

sl_shared_assets/suite2p/__init__.pyi

@@ -0,0 +1,4 @@
+from .multi_day import MultiDayS2PConfiguration as MultiDayS2PConfiguration
+from .single_day import SingleDayS2PConfiguration as SingleDayS2PConfiguration
+
+__all__ = ["MultiDayS2PConfiguration", "SingleDayS2PConfiguration"]

sl_shared_assets/suite2p/multi_day.py

@@ -0,0 +1,193 @@
+"""This module stores the classes used to configure the multi-day (across-session) sl-suite2p pipeline. This pipeline
+extends the original suite2p code to support tracking the same objects (cells) across multiple days. Both single-day
+(original) and multi-day (extended) pipelines are available as part of the Sun lab maintained sl-suite2p package."""
+
+from typing import Any
+from dataclasses import field, asdict, dataclass
+
+from ataraxis_data_structures import YamlConfig
+
+
+@dataclass()
+class IO:
+    """Stores parameters that control data input and output during various stages of the pipeline."""
+
+    sessions: list[str] = field(default_factory=list)
+    """Specifies the list of sessions to register across days, as absolute paths to their /suite2p directories 
+    e.g: root/project/animal/session/processed_data/suite2p. The suite2p directory is created as part of the 
+    'single-day' suite2p runtime, assuming the default value of the 'save_folder' SingleDayS2PConfiguration class 
+    attribute was not modified. Note, each suite2p directory has to contain the 'combined' plane folder, which is 
+    created if the 'combined' SingleDayS2PConfiguration class attribute is 'True'."""
+
+    mesoscan: bool = True
+    """Indicates whether the processed session /suite2p folders contain registered Mesoscope frames."""
+
+
+@dataclass()
+class CellDetection:
+    """Stores parameters for selecting single-day-registered cells (ROIs) to be tracked across multiple sessions (days).
+
+    To maximize the tracking pipeline reliability, it is beneficial to pre-filter the cells whose identity (as cells)
+    is not certain or that may be hard to track across sessions.
+    """
+
+    probability_threshold: float = 0.85
+    """The minimum required probability score assigned to the cell (ROI) by the suite2p classifier. Cells with a lower 
+    classifier score are excluded from processing."""
+
+    maximum_size: int = 1000
+    """The maximum allowed cell (ROI) size, in pixels. Cells with a larger pixel size are excluded from processing."""
+
+    mesoscope_stripe_borders: list[int] = field(default_factory=list)
+    """Stores the x-coordinates of mesoscope combined image stripe (ROI) borders. For mesoscope images, 'stripes' are 
+    the individual imaging ROIs acquired in the 'multiple-ROI' mode. If this field is not overwritten by the user, the 
+    pipeline will read the border data from the combined plane 'ops.npy' file generated by single-day suite2p pipeline.
+    """
+
+    stripe_margin: int = 30
+    """The minimum required distance, in pixels, between the center-point (the median x-coordinate) of the cell (ROI) 
+    and the mesoscope stripe border. Cells that are too close to stripe borders are excluded from processing to avoid 
+    ambiguities associated with tracking cells that span multiple stripes."""
+
+
+@dataclass()
+class Registration:
+    """Stores parameters for aligning (registering) the sessions from multiple days to the same visual space.
+
+    Registration is used to create a 'shared' visual space, allowing to track the same cells (ROIs) across otherwise
+    variable visual space of each session.
+    """
+
+    image_type: str = "enhanced"
+    """The type of single-day suite2p-generated image to use for across-day registration. Supported options are 
+    'enhanced', 'mean' and 'max'. This 'template' image is used to calculate the necessary deformation (transformations)
+    to register (align) all sessions to the same visual space."""
+
+    grid_sampling_factor: float = 1
+    """Determines to what extent the grid sampling scales with the deformed image scale. Has to be between 0 and 1. By 
+    making this value lower than 1, the grid is relatively fine at the the higher scales, allowing for more 
+    deformations. This is used when resizing session images as part of the registration process."""
+
+    scale_sampling: int = 30
+    """The number of iterations for each level (i.e. between each factor two in scale) to perform when computing the 
+    deformations. Values between 20 and 30 are reasonable in most situations, but higher values yield better results in
+    general. The speed of the algorithm scales linearly with this value."""
+
+    speed_factor: float = 3
+    """The relative force of the deformation transform applied when registering the sessions to the same visual space.
+    This is the most important parameter to tune."""
+
+
+@dataclass()
+class Clustering:
+    """Stores parameters for clustering cell (ROI) masks across multiple registered sessions.
+
+    Clustering is used to track cells across sessions. If a group of ROIs across sessions is clustered together, it
+    is likely that they represent the same cell (ROI) across all sessions. This process involves first creating a
+    'template' mask that tracks a cell using the registered (deformed) visual space and then using this template to
+    track the cell in the original (non-deformed) visual space of each session.
+    """
+
+    criterion: str = "distance"
+    """Specifies the criterion for clustering (grouping) cell (ROI) masks from different sessions. Currently, the only 
+    valid option is 'distance'."""
+
+    threshold: float = 0.75
+    """Specifies the threshold for the clustering algorithm. Cell masks will be clustered (grouped) together if their  
+    clustering criterion is below this threshold value."""
+
+    mask_prevalence: int = 50
+    """Specifies the minimum percentage of all registered sessions that must include the clustered cell mask. Cell masks
+    present in fewer percent of sessions than this value are excluded from processing. This parameter is used to isolate
+    the cells that are present (active) across sessions."""
+
+    pixel_prevalence: int = 50
+    """Specifies the minimum percentage of all registered sessions in which a pixel from a given cell mask must be 
+    present for it to be used to construct the template mask. Pixels present in fewer percent of sessions than this 
+    value are not used to define the 'template' mask coordinates. Template masks are used to extract the cell 
+    fluorescence from the 'original' visual space of every session. This parameter is used to isolate the part of the
+    cell that is stable across sessions."""
+
+    step_sizes: list[int] = field(default_factory=lambda: [200, 200])
+    """Specifies the block size for the clustering process, in pixels. Clustering is applied in blocks of this size, 
+    sampled across the processed plane image, to reduce the memory (RAM) overhead."""
+
+    bin_size: int = 50
+    """Specifies the size of bins used to discover cell masks within blocks during clustering. To avoid edge cases, the 
+    algorithm clusters the cell masks within the region defined by the center-point of each cell +- bin_size."""
+
+    maximum_distance: int = 20
+    """Specifies the maximum distance, in pixels, that can separate masks across multiple sessions. The clustering 
+    algorithm will consider cell masks located at most within this distance from each-other across days as the same 
+    cells during tacking."""
+
+    minimum_size: int = 25
+    """The minimum size of the non-overlapping (with other cells) cell (ROI) region, in pixels, that has to be covered 
+    by the template mask, for the cell to be assigned to that template. This is used to determine which template(s) the 
+    cell belongs to (if any), for the purpose of tracking it across sessions."""
+
+
+@dataclass()
+class Demix:
+    """Stores settings used to deconvolve fluorescence signals from cells tracked across multiple days.
+
+    This step applies the suite2p spike deconvolution algorithm to the cell masks isolated during clustering to extract
+    the fluorescence of the cells tracked across multiple sessions (days). Generally, it should use the same parameters
+    as were used by the single-day suite2p pipeline.
+    """
+
+    baseline: str = "maximin"
+    """Specifies the method to compute the baseline of each trace. This baseline is then subtracted from each cell. 
+    ‘maximin’ computes a moving baseline by filtering the data with a Gaussian of width 'sig_baseline' * 'fs', and then 
+    minimum filtering with a window of 'win_baseline' * 'fs', and then maximum filtering with the same window. 
+    ‘constant’ computes a constant baseline by filtering with a Gaussian of width 'sig_baseline' * 'fs' and then taking 
+    the minimum value of this filtered trace. ‘constant_percentile’ computes a constant baseline by taking the 
+    'prctile_baseline' percentile of the trace."""
+
+    win_baseline: float = 60.0
+    """The time window, in seconds, over which to compute the baseline filter."""
+
+    sig_baseline: float = 10.0
+    """The standard deviation, in seconds, of the Gaussian filter applied to smooth the baseline signal."""
+
+    l2_reg: float = 0.1
+    """The L2 regularization strength applied during spike deconvolution."""
+
+    neucoeff: float = 0.7
+    """The neuropil coefficient applied for signal correction before deconvolution."""
+
+
+@dataclass()
+class MultiDayS2PConfiguration(YamlConfig):
+    """Aggregates all parameters for the multi-day suite2p pipeline used to track cells across multiple days
+    (sessions) and extract their activity.
+
+    These settings are used to configure the multiday suite2p extraction pipeline, which is based on the reference
+    implementation here: https://github.com/sprustonlab/multiday-suite2p-public. This class behaves similar to the
+    SingleDayS2PConfiguration class. It can be saved and loaded from a .YAML file and translated to dictionary format,
+    expected by the multi-day sl-suite2p pipeline.
+    """
+
+    cell_detection: CellDetection = field(default_factory=CellDetection)
+    """Stores parameters for selecting single-day-registered cells (ROIs) to be tracked across multiple sessions 
+    (days)."""
+    registration: Registration = field(default_factory=Registration)
+    """Stores parameters for aligning (registering) the sessions from multiple days to the same visual space."""
+    clustering: Clustering = field(default_factory=Clustering)
+    """Stores parameters for clustering (tracking) cell (ROI) masks across multiple registered sessions."""
+    demix: Demix = field(default_factory=Demix)
+    """Stores settings used to deconvolve fluorescence signals from cells tracked across multiple days."""
+    io: IO = field(default_factory=IO)
+    """Stores parameters that control data input and output during various stages of the pipeline."""
+
+    def to_ops(self) -> dict[str, Any]:
+        """Converts the class instance to a dictionary and returns it to caller.
+
+        This dictionary can be passed to sl-suite2p multi-day functions as the 'ops' argument.
+
+        Notes:
+            Unlike the single-day configuration class, the dictionary generated by this method uses section names as
+            top level keys and parameter names as second-level keys. This mimics the original multiday-pipeline
+            configuration scheme.
+        """
+        return asdict(self)

sl_shared_assets/suite2p/multi_day.pyi

@@ -0,0 +1,99 @@
+from typing import Any
+from dataclasses import field, dataclass
+
+from _typeshed import Incomplete
+from ataraxis_data_structures import YamlConfig
+
+@dataclass()
+class IO:
+    """Stores parameters that control data input and output during various stages of the pipeline."""
+
+    sessions: list[str] = field(default_factory=list)
+    mesoscan: bool = ...
+
+@dataclass()
+class CellDetection:
+    """Stores parameters for selecting single-day-registered cells (ROIs) to be tracked across multiple sessions (days).
+
+    To maximize the tracking pipeline reliability, it is beneficial to pre-filter the cells whose identity (as cells)
+    is not certain or that may be hard to track across sessions.
+    """
+
+    probability_threshold: float = ...
+    maximum_size: int = ...
+    mesoscope_stripe_borders: list[int] = field(default_factory=list)
+    stripe_margin: int = ...
+
+@dataclass()
+class Registration:
+    """Stores parameters for aligning (registering) the sessions from multiple days to the same visual space.
+
+    Registration is used to create a 'shared' visual space, allowing to track the same cells (ROIs) across otherwise
+    variable visual space of each session.
+    """
+
+    image_type: str = ...
+    grid_sampling_factor: float = ...
+    scale_sampling: int = ...
+    speed_factor: float = ...
+
+@dataclass()
+class Clustering:
+    """Stores parameters for clustering cell (ROI) masks across multiple registered sessions.
+
+    Clustering is used to track cells across sessions. If a group of ROIs across sessions is clustered together, it
+    is likely that they represent the same cell (ROI) across all sessions. This process involves first creating a
+    'template' mask that tracks a cell using the registered (deformed) visual space and then using this template to
+    track the cell in the original (non-deformed) visual space of each session.
+    """
+
+    criterion: str = ...
+    threshold: float = ...
+    mask_prevalence: int = ...
+    pixel_prevalence: int = ...
+    step_sizes: list[int] = field(default_factory=Incomplete)
+    bin_size: int = ...
+    maximum_distance: int = ...
+    minimum_size: int = ...
+
+@dataclass()
+class Demix:
+    """Stores settings used to deconvolve fluorescence signals from cells tracked across multiple days.
+
+    This step applies the suite2p spike deconvolution algorithm to the cell masks isolated during clustering to extract
+    the fluorescence of the cells tracked across multiple sessions (days). Generally, it should use the same parameters
+    as were used by the single-day suite2p pipeline.
+    """
+
+    baseline: str = ...
+    win_baseline: float = ...
+    sig_baseline: float = ...
+    l2_reg: float = ...
+    neucoeff: float = ...
+
+@dataclass()
+class MultiDayS2PConfiguration(YamlConfig):
+    """Aggregates all parameters for the multi-day suite2p pipeline used to track cells across multiple days
+    (sessions) and extract their activity.
+
+    These settings are used to configure the multiday suite2p extraction pipeline, which is based on the reference
+    implementation here: https://github.com/sprustonlab/multiday-suite2p-public. This class behaves similar to the
+    SingleDayS2PConfiguration class. It can be saved and loaded from a .YAML file and translated to dictionary format,
+    expected by the multi-day sl-suite2p pipeline.
+    """
+
+    cell_detection: CellDetection = field(default_factory=CellDetection)
+    registration: Registration = field(default_factory=Registration)
+    clustering: Clustering = field(default_factory=Clustering)
+    demix: Demix = field(default_factory=Demix)
+    io: IO = field(default_factory=IO)
+    def to_ops(self) -> dict[str, Any]:
+        """Converts the class instance to a dictionary and returns it to caller.
+
+        This dictionary can be passed to sl-suite2p multi-day functions as the 'ops' argument.
+
+        Notes:
+            Unlike the single-day configuration class, the dictionary generated by this method uses section names as
+            top level keys and parameter names as second-level keys. This mimics the original multiday-pipeline
+            configuration scheme.
+        """