sl-shared-assets 1.0.0rc19__py3-none-any.whl → 1.0.0rc20__py3-none-any.whl

sl_shared_assets/server/job.pyi

@@ -0,0 +1,94 @@
+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

@@ -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__.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

@@ -3,11 +3,11 @@ extends the original suite2p code to support tracking the same objects (cells) a
 (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 pathlib import Path
+from dataclasses import field, asdict, dataclass
+
 import numpy as np
 from ataraxis_base_utilities import ensure_directory_exists
-
 from ataraxis_data_structures import YamlConfig
 
 
@@ -60,8 +60,7 @@ class Hardware:
 
 @dataclass()
 class CellDetection:
-    """Stores parameters for selecting single-day-registered cells (ROIs) to be tracked across multiple sessions (days).
-    """
+    """Stores parameters for selecting single-day-registered cells (ROIs) to be tracked across multiple sessions (days)."""
 
     probability_threshold: float = 0.85
     """The minimum required probability score assigned to the cell (ROI) by the single-day suite2p classifier. Cells 
@@ -85,8 +84,7 @@ class CellDetection:
 
 @dataclass()
 class Registration:
-    """Stores parameters for aligning (registering) the sessions from multiple days to the same visual (sampling) space.
-    """
+    """Stores parameters for aligning (registering) the sessions from multiple days to the same visual (sampling) space."""
 
     image_type: str = "enhanced"
     """The type of suite2p-generated reference image to use for across-day registration. Supported options are 
@@ -192,7 +190,8 @@ class MultiDayS2PConfiguration(YamlConfig):
         """
         ensure_directory_exists(output_directory)  # Creates the directory, if necessary
         file_path = output_directory.joinpath("ops.npy")  # Computes the output path
-        np.save(file_path, self.to_ops(), allow_pickle=True)  # Dumps the configuration data to 'ops.npy' file.
+        # Dumps the configuration data to 'ops.npy' file.
+        np.save(file_path, self.to_ops(), allow_pickle=True)  # type: ignore
 
     def to_config(self, output_directory: Path) -> None:
         """Saves the managed configuration data as a 'multi_day_s2p_configuration.yaml' file under the target
@@ -210,7 +209,7 @@ class MultiDayS2PConfiguration(YamlConfig):
             saved.
         """
         ensure_directory_exists(output_directory)  # Creates the directory, if necessary
-        file_path = output_directory.joinpath("multi_day_s2p_configuration.yaml")   # Computes the output path
+        file_path = output_directory.joinpath("multi_day_s2p_configuration.yaml")  # Computes the output path
 
         # Note, this uses the same configuration name as the SessionData class, making it automatically compatible with
         # Sun lab data structure.

sl_shared_assets/suite2p/multi_day.pyi

@@ -0,0 +1,104 @@
+from typing import Any
+from pathlib import Path
+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."""
+
+    session_ids: list[str] = field(default_factory=list)
+    session_folders: list[str] = field(default_factory=list)
+
+@dataclass()
+class Hardware:
+    """Stores parameters that control how the suite2p interacts with the hardware of the host-computer to accelerate
+    processing speed."""
+
+    parallelize_registration: bool = ...
+    registration_workers: int = ...
+    parallelize_extraction: bool = ...
+    parallel_sessions: int = ...
+
+@dataclass()
+class CellDetection:
+    """Stores parameters for selecting single-day-registered cells (ROIs) to be tracked across multiple sessions (days)."""
+
+    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 (sampling) space."""
+
+    image_type: str = ...
+    grid_sampling_factor: float = ...
+    scale_sampling: int = ...
+    speed_factor: float = ...
+
+@dataclass()
+class Clustering:
+    """Stores parameters for tracking (clustering) cell (ROI) masks across multiple registered sessions (days)."""
+
+    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 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 multi-day 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 or
+    ops.npy format, expected by the multi-day sl-suite2p pipeline.
+    """
+
+    io: IO = field(default_factory=IO)
+    hardware: Hardware = field(default_factory=Hardware)
+    cell_detection: CellDetection = field(default_factory=CellDetection)
+    registration: Registration = field(default_factory=Registration)
+    clustering: Clustering = field(default_factory=Clustering)
+    def to_npy(self, output_directory: Path) -> None:
+        """Saves the managed configuration data as an 'ops.npy' file under the target directory.
+
+        This method is mostly called by internal sl-suite2p functions to translate the user-specified configuration
+        file into the format used by suite2p pipelines.
+
+        Notes:
+            If the target output directory does not exist when this method is called, it will be created.
+
+        Args:
+            output_directory: The path to the directory where the 'ops.npy' file should be saved.
+        """
+    def to_config(self, output_directory: Path) -> None:
+        """Saves the managed configuration data as a 'multi_day_s2p_configuration.yaml' file under the target
+        directory.
+
+        This method is typically used to dump the 'default' configuration parameters to disk as a user-editable
+        .yaml file. The user is then expected to modify these parameters as needed, before the class data is loaded and
+        used by the suite2p pipeline.
+
+        Notes:
+            If the target output directory does not exist when this method is called, it will be created.
+
+        Args:
+            output_directory: The path to the directory where the 'multi_day_s2p_configuration.yaml' file should be
+            saved.
+        """
+    def to_ops(self) -> dict[str, Any]:
+        """Converts the class instance to a dictionary and returns it to caller.
+
+        This method is mostly called by internal sl-suite2p functions to translate the default configuration parameters
+        to the dictionary format used by suite2p pipelines.
+        """

sl_shared_assets/suite2p/single_day.py

@@ -4,11 +4,11 @@ is used as the first step of the multi-day brain activity processing pipeline us
 (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 pathlib import Path
+from dataclasses import field, asdict, dataclass
+
 import numpy as np
 from ataraxis_base_utilities import ensure_directory_exists
-
 from ataraxis_data_structures import YamlConfig
 
 
@@ -519,7 +519,8 @@ class SingleDayS2PConfiguration(YamlConfig):
         """
         ensure_directory_exists(output_directory)  # Creates the directory, if necessary
         file_path = output_directory.joinpath("ops.npy")  # Computes the output path
-        np.save(file_path, self.to_ops(), allow_pickle=True)  # Dumps the configuration data to 'ops.npy' file.
+        # Dumps the configuration data to 'ops.npy' file.
+        np.save(file_path, self.to_ops(), allow_pickle=True)  # type: ignore
 
     def to_config(self, output_directory: Path) -> None:
         """Saves the managed configuration data as a 'single_day_s2p_configuration.yaml' file under the target
@@ -537,7 +538,7 @@ class SingleDayS2PConfiguration(YamlConfig):
             saved.
         """
         ensure_directory_exists(output_directory)  # Creates the directory, if necessary
-        file_path = output_directory.joinpath("single_day_s2p_configuration.yaml")   # Computes the output path
+        file_path = output_directory.joinpath("single_day_s2p_configuration.yaml")  # Computes the output path
 
         # Note, this uses the same configuration name as the SessionData class, making it automatically compatible with
         # Sun lab data structure.

sl_shared_assets/suite2p/single_day.pyi

@@ -0,0 +1,220 @@
+from typing import Any
+from pathlib import Path
+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 = ...
+    parallel_planes: int = ...
+    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: str = ...
+    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: str = ...
+    save_folder: str = ...
+    data_path: 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 parameters for aggregating and saving the processing results of each plane as a unified directory or
+    file."""
+
+    save_nwb: bool = ...
+    save_mat: bool = ...
+    combined: bool = ...
+    aspect: float = ...
+
+@dataclass
+class Registration:
+    """Stores parameters for rigid registration, which is used to correct motion artifacts between frames by
+    counter-shifting the entire frame."""
+
+    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 = ...
+    th_badframes: float = ...
+    norm_frames: bool = ...
+    force_refImg: bool = ...
+    pad_fft: bool = ...
+    do_regmetrics: bool = ...
+    reg_metric_n_pc: int = ...
+
+@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 by dividing frames into subregions and shifting each subregion independently of other subregions."""
+
+    nonrigid: bool = ...
+    block_size: list[int] = field(default_factory=Incomplete)
+    snr_thresh: float = ...
+    maxregshiftNR: float = ...
+
+@dataclass
+class ROIDetection:
+    """Stores parameters for cell ROI detection."""
+
+    preclassify: float = ...
+    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):
+    """Aggregates all user-addressable parameters of the single-day suite2p pipeline used to discover cell ROIs and
+    extract their fluorescence data.
+
+    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 the '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.
+    """
+
+    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_npy(self, output_directory: Path) -> None:
+        """Saves the managed configuration data as an 'ops.npy' file under the target directory.
+
+        This method is mostly called by internal sl-suite2p functions to translate the user-specified configuration
+        file into the format used by suite2p pipelines.
+
+        Notes:
+            If the target output directory does not exist when this method is called, it will be created.
+
+        Args:
+            output_directory: The path to the directory where the 'ops.npy' file should be saved.
+        """
+    def to_config(self, output_directory: Path) -> None:
+        """Saves the managed configuration data as a 'single_day_s2p_configuration.yaml' file under the target
+        directory.
+
+        This method is typically used to dump the 'default' configuration parameters to disk as a user-editable
+        .yaml file. The user is then expected to modify these parameters as needed, before the class data is loaded and
+        used by the suite2p pipeline.
+
+        Notes:
+            If the target output directory does not exist when this method is called, it will be created.
+
+        Args:
+            output_directory: The path to the directory where the 'single_day_s2p_configuration.yaml' file should be
+            saved.
+        """
+    def to_ops(self) -> dict[str, Any]:
+        """Converts the class instance to a dictionary and returns it to caller.
+
+        This method is mostly called by internal sl-suite2p functions to translate the default configuration parameters
+        to the dictionary format used by suite2p pipelines.
+        """

sl_shared_assets/tools/__init__.pyi

@@ -0,0 +1,5 @@
+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"]