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

sl_shared_assets/server/job.pyi

@@ -1,94 +0,0 @@
-from pathlib import Path
-
-from _typeshed import Incomplete
-from simple_slurm import Slurm
-
-class Job:
-    """Aggregates the data of a single SLURM-managed job to be executed on the Sun lab BioHPC cluster.
-
-    This class provides the API for constructing any server-side job in the Sun lab. Internally, it wraps an instance
-    of a Slurm class to package the job data into the format expected by the SLURM job manager. All jobs managed by this
-    class instance should be submitted to an initialized Server class 'submit_job' method to be executed on the server.
-
-    Notes:
-        The initialization method of the class contains the arguments for configuring the SLURM and Conda environments
-        used by the job. Do not submit additional SLURM or Conda commands via the 'add_command' method, as this may
-        produce unexpected behavior.
-
-        Each job can be conceptualized as a sequence of shell instructions to execute on the remote compute server. For
-        the lab, that means that the bulk of the command consists of calling various CLIs exposed by data processing or
-        analysis pipelines, installed in the Conda environment on the server. Other than that, the job contains commands
-        for activating the target conda environment and, in some cases, doing other preparatory or cleanup work. The
-        source code of a 'remote' job is typically identical to what a human operator would type in a 'local' terminal
-        to run the same job on their PC.
-
-        A key feature of server-side jobs is that they are executed on virtual machines managed by SLURM. Since the
-        server has a lot more compute and memory resources than likely needed by individual jobs, each job typically
-        requests a subset of these resources. Upon being executed, SLURM creates an isolated environment with the
-        requested resources and runs the job in that environment.
-
-        Since all jobs are expected to use the CLIs from python packages (pre)installed on the BioHPC server, make sure
-        that the target environment is installed and configured before submitting jobs to the server. See notes in
-        ReadMe to learn more about configuring server-side conda environments.
-
-    Args:
-        job_name: The descriptive name of the SLURM job to be created. Primarily, this name is used in terminal
-            printouts to identify the job to human operators.
-        output_log: The absolute path to the .txt file on the processing server, where to store the standard output
-            data of the job.
-        error_log: The absolute path to the .txt file on the processing server, where to store the standard error
-            data of the job.
-        working_directory: The absolute path to the directory where temporary job files will be stored. During runtime,
-            classes from this library use that directory to store files such as the job's shell script. All such files
-            are automatically removed from the directory at the end of a non-errors runtime.
-        conda_environment: The name of the conda environment to activate on the server before running the job logic. The
-            environment should contain the necessary Python packages and CLIs to support running the job's logic.
-        cpus_to_use: The number of CPUs to use for the job.
-        ram_gb: The amount of RAM to allocate for the job, in Gigabytes.
-        time_limit: The maximum time limit for the job, in minutes. If the job is still running at the end of this time
-            period, it will be forcibly terminated. It is highly advised to always set adequate maximum runtime limits
-            to prevent jobs from hogging the server in case of runtime or algorithm errors.
-
-    Attributes:
-        remote_script_path: Stores the path to the script file relative to the root of the remote server that runs the
-            command.
-        job_id: Stores the unique job identifier assigned by the SLURM manager to this job, when it is accepted for
-            execution. This field initialized to None and is overwritten by the Server class that submits the job.
-        job_name: Stores the descriptive name of the SLURM job.
-        _command: Stores the managed SLURM command object.
-    """
-
-    remote_script_path: Incomplete
-    job_id: str | None
-    job_name: str
-    _command: Slurm
-    def __init__(
-        self,
-        job_name: str,
-        output_log: Path,
-        error_log: Path,
-        working_directory: Path,
-        conda_environment: str,
-        cpus_to_use: int = 10,
-        ram_gb: int = 10,
-        time_limit: int = 60,
-    ) -> None: ...
-    def __repr__(self) -> str:
-        """Returns the string representation of the Job instance."""
-    def add_command(self, command: str) -> None:
-        """Adds the input command string to the end of the managed SLURM job command list.
-
-        This method is a wrapper around simple_slurm's 'add_cmd' method. It is used to iteratively build the shell
-        command sequence of the job.
-
-        Args:
-            command: The command string to add to the command list, e.g.: 'python main.py --input 1'.
-        """
-    @property
-    def command_script(self) -> str:
-        """Translates the managed job data into a shell-script-writable string and returns it to caller.
-
-        This method is used by the Server class to translate the job into the format that can be submitted to and
-        executed on the remote compute server. Do not call this method manually unless you know what you are doing.
-        The returned string is safe to dump into a .sh (shell script) file and move to the BioHPC server for execution.
-        """

sl_shared_assets/server/server.pyi

@@ -1,95 +0,0 @@
-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__.pyi

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

sl_shared_assets/suite2p/multi_day.pyi

@@ -1,99 +0,0 @@
-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.
-        """

sl_shared_assets/suite2p/single_day.pyi

@@ -1,192 +0,0 @@
-from typing import Any
-from dataclasses import field, dataclass
-
-from _typeshed import Incomplete
-from ataraxis_data_structures import YamlConfig
-
-@dataclass
-class Main:
-    """Stores global parameters that broadly define the suite2p single-day processing configuration."""
-
-    nplanes: int = ...
-    nchannels: int = ...
-    functional_chan: int = ...
-    tau: float = ...
-    force_sktiff: bool = ...
-    fs: float = ...
-    do_bidiphase: bool = ...
-    bidiphase: int = ...
-    bidi_corrected: bool = ...
-    frames_include: int = ...
-    multiplane_parallel: bool = ...
-    ignore_flyback: list[int] = field(default_factory=list)
-
-@dataclass
-class FileIO:
-    """Stores general I/O parameters that specify input data location, format, and working and output directories."""
-
-    fast_disk: list[str] = field(default_factory=list)
-    delete_bin: bool = ...
-    mesoscan: bool = ...
-    bruker: bool = ...
-    bruker_bidirectional: bool = ...
-    h5py: list[str] = field(default_factory=list)
-    h5py_key: str = ...
-    nwb_file: str = ...
-    nwb_driver: str = ...
-    nwb_series: str = ...
-    save_path0: list[str] = field(default_factory=list)
-    save_folder: list[str] = field(default_factory=list)
-    look_one_level_down: bool = ...
-    subfolders: list[str] = field(default_factory=list)
-    move_bin: bool = ...
-
-@dataclass
-class Output:
-    """Stores I/O settings that specify the output format and organization of the data processing results."""
-
-    preclassify: float = ...
-    save_nwb: bool = ...
-    save_mat: bool = ...
-    combined: bool = ...
-    aspect: float = ...
-    report_time: bool = ...
-
-@dataclass
-class Registration:
-    """Stores parameters for rigid registration, which is used to correct motion artifacts between frames."""
-
-    do_registration: bool = ...
-    align_by_chan: int = ...
-    nimg_init: int = ...
-    batch_size: int = ...
-    maxregshift: float = ...
-    smooth_sigma: float = ...
-    smooth_sigma_time: float = ...
-    keep_movie_raw: bool = ...
-    two_step_registration: bool = ...
-    reg_tif: bool = ...
-    reg_tif_chan2: bool = ...
-    subpixel: int = ...
-    th_badframes: float = ...
-    norm_frames: bool = ...
-    force_refImg: bool = ...
-    pad_fft: bool = ...
-
-@dataclass
-class OnePRegistration:
-    """Stores parameters for additional pre-registration processing used to improve the registration of 1-photon
-    datasets."""
-
-    one_p_reg: bool = ...
-    spatial_hp_reg: int = ...
-    pre_smooth: float = ...
-    spatial_taper: float = ...
-
-@dataclass
-class NonRigid:
-    """Stores parameters for non-rigid registration, which is used to improve motion registration in complex
-    datasets."""
-
-    nonrigid: bool = ...
-    block_size: list[int] = field(default_factory=Incomplete)
-    snr_thresh: float = ...
-    maxregshiftNR: float = ...
-
-@dataclass
-class ROIDetection:
-    """Stores parameters for cell ROI detection and extraction."""
-
-    roidetect: bool = ...
-    sparse_mode: bool = ...
-    spatial_scale: int = ...
-    connected: bool = ...
-    threshold_scaling: float = ...
-    spatial_hp_detect: int = ...
-    max_overlap: float = ...
-    high_pass: int = ...
-    smooth_masks: bool = ...
-    max_iterations: int = ...
-    nbinned: int = ...
-    denoise: bool = ...
-
-@dataclass
-class CellposeDetection:
-    """Stores parameters for the Cellpose algorithm, which can optionally be used to improve cell ROI extraction."""
-
-    anatomical_only: int = ...
-    diameter: int = ...
-    cellprob_threshold: float = ...
-    flow_threshold: float = ...
-    spatial_hp_cp: int = ...
-    pretrained_model: str = ...
-
-@dataclass
-class SignalExtraction:
-    """Stores parameters for extracting fluorescence signals from ROIs and surrounding neuropil regions."""
-
-    neuropil_extract: bool = ...
-    allow_overlap: bool = ...
-    min_neuropil_pixels: int = ...
-    inner_neuropil_radius: int = ...
-    lam_percentile: int = ...
-
-@dataclass
-class SpikeDeconvolution:
-    """Stores parameters for deconvolve fluorescence signals to infer spike trains."""
-
-    spikedetect: bool = ...
-    neucoeff: float = ...
-    baseline: str = ...
-    win_baseline: float = ...
-    sig_baseline: float = ...
-    prctile_baseline: float = ...
-
-@dataclass
-class Classification:
-    """Stores parameters for classifying detected ROIs as real cells or artifacts."""
-
-    soma_crop: bool = ...
-    use_builtin_classifier: bool = ...
-    classifier_path: str = ...
-
-@dataclass
-class Channel2:
-    """Stores parameters for processing the second channel in multichannel datasets."""
-
-    chan2_thres: float = ...
-
-@dataclass
-class SingleDayS2PConfiguration(YamlConfig):
-    """Stores the user-addressable suite2p configuration parameters for the single-day (original) pipeline, organized
-    into subsections.
-
-    This class is used during single-day processing to instruct suite2p on how to process the data. This class is based
-    on the 'default_ops' from the original suite2p package. As part of the suite2p refactoring performed in sl-suite2p
-    package, the 'default_ops' has been replaced with this class instance. Compared to 'original' ops, it allows saving
-    configuration parameters as a .YAML file, which offers a better way of viewing and editing the parameters and
-    running suite2p pipeline on remote compute servers.
-
-    Notes:
-        The .YAML file uses section names that match the suite2p documentation sections. This way, users can always
-        consult the suite2p documentation for information on the purpose of each field inside every subsection.
-    """
-
-    main: Main = field(default_factory=Main)
-    file_io: FileIO = field(default_factory=FileIO)
-    output: Output = field(default_factory=Output)
-    registration: Registration = field(default_factory=Registration)
-    one_p_registration: OnePRegistration = field(default_factory=OnePRegistration)
-    non_rigid: NonRigid = field(default_factory=NonRigid)
-    roi_detection: ROIDetection = field(default_factory=ROIDetection)
-    cellpose_detection: CellposeDetection = field(default_factory=CellposeDetection)
-    signal_extraction: SignalExtraction = field(default_factory=SignalExtraction)
-    spike_deconvolution: SpikeDeconvolution = field(default_factory=SpikeDeconvolution)
-    classification: Classification = field(default_factory=Classification)
-    channel2: Channel2 = field(default_factory=Channel2)
-    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 suite2p functions either as an 'ops' or 'db' argument to control the
-        processing runtime.
-        """

sl_shared_assets/tools/__init__.pyi

@@ -1,5 +0,0 @@
-from .transfer_tools import transfer_directory as transfer_directory
-from .ascension_tools import ascend_tyche_data as ascend_tyche_data
-from .packaging_tools import calculate_directory_checksum as calculate_directory_checksum
-
-__all__ = ["transfer_directory", "calculate_directory_checksum", "ascend_tyche_data"]

sl_shared_assets/tools/ascension_tools.pyi

@@ -1,68 +0,0 @@
-from pathlib import Path
-
-from ..data_classes import (
-    SessionData as SessionData,
-    ProjectConfiguration as ProjectConfiguration,
-)
-from .transfer_tools import transfer_directory as transfer_directory
-from .packaging_tools import calculate_directory_checksum as calculate_directory_checksum
-
-def _generate_session_name(acquisition_path: Path) -> str:
-    """Generates a session name using the last modification time of a zstack.mat or MotionEstimator.me file.
-
-    This worker function uses one of the motion estimation files stored in each Tyche 'acquisition' subfolder to
-    generate a modern Sun lab timestamp-based session name. This is used to translate the original Tyche session naming
-    pattern into the pattern used by all modern Sun lab projects and pipelines.
-
-    Args:
-        acquisition_path: The absolute path to the target acquisition folder. These folders are found under the 'day'
-            folders for each animal, e.g.: Tyche-A7/2022_01_03/1.
-
-    Returns:
-        The modernized session name.
-    """
-
-def _reorganize_data(session_data: SessionData, source_root: Path) -> bool:
-    """Reorganizes and moves the session's data from the source folder in the old Tyche data hierarchy to the raw_data
-    folder in the newly created modern hierarchy.
-
-    This worker function is used to physically rearrange the data from the original Tyche data structure to the
-    new data structure. It both moves the existing files to their new destinations and renames certain files to match
-    the modern naming convention used in the Sun lab.
-
-    Args:
-        session_data: The initialized SessionData instance managing the 'ascended' (modernized) session data hierarchy.
-        source_root: The absolute path to the old Tyche data hierarchy folder that stores session's data.
-
-    Returns:
-        True if the ascension process was successfully completed. False if the process encountered missing data or
-        otherwise did not go as expected. When the method returns False, the runtime function requests user intervention
-        to finalize the process manually.
-    """
-
-def ascend_tyche_data(root_directory: Path, output_root_directory: Path, server_root_directory: Path) -> None:
-    """Reformats the old Tyche data to use the modern Sun lab layout and metadata files.
-
-    This function is used to convert old Tyche data to the modern data management standard. This is used to make the
-    data compatible with the modern Sun lab data workflows.
-
-    Notes:
-        This function is statically written to work with the raw Tyche dataset featured in the OSM manuscript:
-        https://www.nature.com/articles/s41586-024-08548-w. Additionally, it assumes that the dataset has been
-        preprocessed with the early Sun lab mesoscope compression pipeline. The function will not work for any other
-        project or data hierarchy.
-
-        As part of its runtime, the function automatically transfers the ascended session data to the BioHPC server.
-        Since transferring the data over the network is the bottleneck of this pipeline, it runs in a single-threaded
-        mode and is constrained by the communication channel between the local machine and the BioHPC server. Calling
-        this function for a large number of sessions will result in a long processing time due to the network data
-        transfer.
-
-    Args:
-        root_directory: The directory that stores one or more Tyche animal folders. This can be conceptualized as the
-            root directory for the Tyche project.
-        output_root_directory: The path to the local directory where to generate the converted Tyche project hierarchy.
-            Typically, this is the 'root' directory where all other Sun lab projects are stored.
-        server_root_directory: The path to the local filesystem-mounted BioHPC server storage directory. Note, this
-            directory hs to be mapped to the local filesystem via the SMB or equivalent protocol.
-    """

sl_shared_assets/tools/packaging_tools.pyi

@@ -1,52 +0,0 @@
-from pathlib import Path
-
-def _calculate_file_checksum(base_directory: Path, file_path: Path) -> tuple[str, bytes]:
-    """Calculates xxHash3-128 checksum for a single file and its path relative to the base directory.
-
-    This function is passed to parallel workers used by the calculate_directory_hash() method that iteratively
-    calculates the checksum for all files inside a directory. Each call to this function returns the checksum for the
-    target file, which includes both the contents of the file and its path relative to the base directory.
-
-    Args:
-        base_directory: The path to the base (root) directory which is being checksummed by the main
-            'calculate_directory_checksum' function.
-        file_path: The absolute path to the target file.
-
-    Returns:
-        A tuple with two elements. The first element is the path to the file relative to the base directory. The second
-        element is the xxHash3-128 checksum that covers the relative path and the contents of the file.
-    """
-
-def calculate_directory_checksum(
-    directory: Path, num_processes: int | None = None, batch: bool = False, save_checksum: bool = True
-) -> str:
-    """Calculates xxHash3-128 checksum for the input directory, which includes the data of all contained files and
-    the directory structure information.
-
-    This function is used to generate a checksum for the raw_data directory of each experiment or training session.
-    Checksums are used to verify the session data integrity during transmission between the PC that acquired the data
-    and long-term storage locations, such as the Synology NAS or the BioHPC server. The function can be configured to
-    write the generated checksum as a hexadecimal string to the ax_checksum.txt file stored at the highest level of the
-    input directory.
-
-    Note:
-        This method uses multiprocessing to efficiently parallelize checksum calculation for multiple files. In
-        combination with xxHash3, this achieves a significant speedup over more common checksums, such as MD5 and
-        SHA256. Note that xxHash3 is not suitable for security purposes and is only used to ensure data integrity.
-
-        The method notifies the user about the checksum calculation process via the terminal.
-
-        The returned checksum accounts for both the contents of each file and the layout of the input directory
-        structure.
-
-    Args:
-        directory: The Path to the directory to be checksummed.
-        num_processes: The number of CPU processes to use for parallelizing checksum calculation. If set to None, the
-            function defaults to using (logical CPU count - 4).
-        batch: Determines whether the function is called as part of batch-processing multiple directories. This is used
-            to optimize progress reporting to avoid cluttering the terminal.
-        save_checksum: Determines whether the checksum should be saved (written to) a .txt file.
-
-    Returns:
-        The xxHash3-128 checksum for the input directory as a hexadecimal string.
-    """

sl_shared_assets/tools/transfer_tools.pyi

@@ -1,53 +0,0 @@
-from pathlib import Path
-
-from .packaging_tools import calculate_directory_checksum as calculate_directory_checksum
-
-def _transfer_file(source_file: Path, source_directory: Path, destination_directory: Path) -> None:
-    """Copies the input file from the source directory to the destination directory while preserving the file metadata.
-
-    This is a worker method used by the transfer_directory() method to move multiple files in parallel.
-
-    Notes:
-        If the file is found under a hierarchy of subdirectories inside the input source_directory, that hierarchy will
-        be preserved in the destination directory.
-
-    Args:
-        source_file: The file to be copied.
-        source_directory: The root directory where the file is located.
-        destination_directory: The destination directory where to move the file.
-    """
-
-def transfer_directory(source: Path, destination: Path, num_threads: int = 1, verify_integrity: bool = True) -> None:
-    """Copies the contents of the input directory tree from source to destination while preserving the folder
-    structure.
-
-    This function is used to assemble the experimental data from all remote machines used in the acquisition process on
-    the VRPC before the data is preprocessed. It is also used to transfer the preprocessed data from the VRPC to the
-    SynologyNAS and the Sun lab BioHPC server.
-
-    Notes:
-        This method recreates the moved directory hierarchy on the destination if the hierarchy does not exist. This is
-        done before copying the files.
-
-        The method executes a multithreading copy operation. It does not clean up the source files. That job is handed
-        to the specific preprocessing function from the sl_experiment or sl-forgery libraries that calls this function.
-
-        If the method is configured to verify transferred file integrity, it reruns the xxHash3-128 checksum calculation
-        and compares the returned checksum to the one stored in the source directory. The method assumes that all input
-        directories contain the 'ax_checksum.txt' file that stores the 'source' directory checksum at the highest level
-        of the input directory tree.
-
-    Args:
-        source: The path to the directory that needs to be moved.
-        destination: The path to the destination directory where to move the contents of the source directory.
-        num_threads: The number of threads to use for parallel file transfer. This number should be set depending on the
-            type of transfer (local or remote) and is not guaranteed to provide improved transfer performance. For local
-            transfers, setting this number above 1 will likely provide a performance boost. For remote transfers using
-            a single TCP / IP socket (such as non-multichannel SMB protocol), the number should be set to 1.
-        verify_integrity: Determines whether to perform integrity verification for the transferred files. Note,
-            integrity verification is a time-consuming process and generally would not be a concern for most runtimes.
-            Therefore, it is often fine to disable this option to optimize method runtime speed.
-
-    Raises:
-        RuntimeError: If the transferred files do not pass the xxHas3-128 checksum integrity verification.
-    """