sl-shared-assets 5.0.1__py3-none-any.whl → 5.1.0__py3-none-any.whl

sl_shared_assets/server/server.py

@@ -1,7 +1,6 @@
-"""This module provides the tools for working with remote compute servers. 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.
+"""This module provides the API for submitting jobs to compute servers and clusters (managed via SLURM) and
+monitoring the running jobs status. Many Sun lab data workflow pipelines use this interface for accessing shared
+compute resources.
 """
 
 import stat
@@ -33,7 +32,7 @@ def generate_server_credentials(
     working_root: str = "/local/storage",
     shared_directory_name: str = "sun_data",
 ) -> None:
-    """Generates a new server access credentials .yaml file under the specified directory, using input information.
+    """Generates the server access credentials .yaml file under the specified directory, using input information.
 
     This function provides a convenience interface for generating new server access credential files. Depending on
     configuration, it either creates user access credentials files or service access credentials files.
@@ -76,13 +75,7 @@ def generate_server_credentials(
 
 @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.
-    """
+    """This class stores the information used to interface with Sun lab's remote compute servers."""
 
     username: str = "YourNetID"
     """The username to use for server authentication."""
@@ -124,16 +117,13 @@ class ServerCredentials(YamlConfig):
 
 
 class Server:
-    """Encapsulates access to a Sun lab processing server.
+    """Establishes and maintains a bidirectional interface that allows working with a remote compute server.
 
-    This class provides the API that allows accessing the remote processing 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.
+    This class provides the API that allows accessing the remote processing server. Primarily, the class is used to
+    submit SLURM-managed jobs to the server and monitor their execution status. It functions as the central interface
+    used by many data workflow 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.
 
@@ -196,54 +186,6 @@ class Server:
         """If the instance is connected to the server, terminates the connection before the instance is destroyed."""
         self.close()
 
-    def create_job(
-        self,
-        job_name: str,
-        conda_environment: str,
-        cpus_to_use: int = 10,
-        ram_gb: int = 10,
-        time_limit: int = 60,
-    ) -> Job:
-        """Creates and returns a new Job instance.
-
-        Use this method to generate Job objects for all headless jobs that need to be run on the remote server. The
-        generated Job is a precursor that requires further configuration by the user before it can be submitted to the
-        server for execution.
-
-        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.
-            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.
-
-        Returns:
-            The initialized Job instance pre-filled with SLURM configuration data and conda activation commands. Modify
-            the returned instance with any additional commands as necessary for the job to fulfill its intended
-            purpose. Note, the Job requires submission via submit_job() to be executed by the server.
-        """
-        # Statically configures the working directory to be stored under:
-        # user working root / job_logs / job_name_timestamp
-        timestamp = get_timestamp()
-        working_directory = Path(self.user_working_root.joinpath("job_logs", f"{job_name}_{timestamp}"))
-        self.create_directory(remote_path=working_directory, parents=True)
-
-        return Job(
-            job_name=job_name,
-            output_log=working_directory.joinpath("stdout.txt"),
-            error_log=working_directory.joinpath("stderr.txt"),
-            working_directory=working_directory,
-            conda_environment=conda_environment,
-            cpus_to_use=cpus_to_use,
-            ram_gb=ram_gb,
-            time_limit=time_limit,
-        )
-
     def launch_jupyter_server(
         self,
         job_name: str,
@@ -255,31 +197,24 @@ class Server:
         port: int = 0,
         jupyter_args: str = "",
     ) -> JupyterJob:
-        """Launches a Jupyter notebook server on the target remote Sun lab server.
+        """Launches a remote Jupyter notebook session (server) on the target remote compute server.
 
-        Use this method to run interactive Jupyter sessions on the remote server under SLURM control. Unlike the
-        create_job(), this method automatically submits the job for execution as part of its runtime. Therefore, the
-        returned JupyterJob instance should only be used to query information about how to connect to the remote
-        Jupyter server.
+        This method allows running interactive Jupyter sessions on the remote server under SLURM control.
 
         Args:
-            job_name: The descriptive name of the Jupyter SLURM job to be created. Primarily, this name is used in
-                terminal printouts to identify the job to human operators.
+            job_name: The descriptive name of the Jupyter SLURM job to be created.
             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. For Jupyter jobs, this necessarily includes the Jupyter notebook and jupyterlab packages.
             port: The connection port number for the Jupyter server. If set to 0 (default), a random port number between
-                8888 and 9999 will be assigned to this connection to reduce the possibility of colliding with other
+                8888 and 9999 is assigned to this connection to reduce the possibility of colliding with other
                 user sessions.
-            notebook_directory: The directory to use as Jupyter's root. During runtime, Jupyter will only have GUI
-                access to items stored in or under this directory. For most runtimes, this should be set to the user's
-                root data or working directory.
-            cpus_to_use: The number of CPUs to allocate to the Jupyter server. Keep this value as small as possible to
-                avoid interfering with headless data processing jobs.
-            ram_gb: The amount of RAM, in GB, to allocate to the Jupyter server. Keep this value as small as possible to
-                avoid interfering with headless data processing jobs.
-            time_limit: The maximum Jupyter server uptime, in minutes. Set this to the expected duration of your jupyter
-                session.
+            notebook_directory: The root directory where to run the Jupyter notebook. During runtime, the notebook will
+                only have access to items stored under this directory. For most runtimes, this should be set to the
+                user's root working directory.
+            cpus_to_use: The number of CPUs to allocate to the Jupyter server.
+            ram_gb: The amount of RAM, in GB, to allocate to the Jupyter server.
+            time_limit: The maximum Jupyter server uptime, in minutes.
             jupyter_args: Stores additional arguments to pass to jupyter notebook initialization command.
 
         Returns:
@@ -320,28 +255,37 @@ class Server:
         return self.submit_job(job)  # type: ignore[return-value]
 
     def submit_job(self, job: Job | JupyterJob, verbose: bool = True) -> Job | JupyterJob:
-        """Submits the input job to the managed BioHPC server via SLURM job manager.
+        """Submits the input job to the managed remote compute server via the SLURM job manager.
 
-        This method submits various jobs for execution via the 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).
+        This method functions as the entry point for all headless jobs that are executed on the remote compute
+        server.
 
         Args:
-            job: The Job object that contains all job data.
-            verbose: Determines whether to notify the user about non-error states of the job submission task. Typically,
-                this is disabled when batch-submitting jobs (for example, as part of running a processing pipeline) and
-                enabled when submitting single jobs.
+            job: The initialized Job instance that contains remote job's data.
+            verbose: Determines whether to notify the user about non-error states of the job submission process.
 
         Returns:
-            The job object whose 'job_id' attribute had been modified with the job ID if the job was successfully
-            submitted.
+            The job object whose 'job_id' attribute had been modified to include the SLURM-assigned job ID if the job
+            was successfully submitted.
 
         Raises:
-            RuntimeError: If job submission to the server fails.
+            RuntimeError: If the job cannot be submitted to the server for any reason.
         """
         if verbose:
             console.echo(message=f"Submitting '{job.job_name}' job to the remote server {self.host}...")
 
+        # If the Job object already has a job ID, this indicates that the job has already been submitted to the server.
+        # In this case returns it to the caller with no further modifications.
+        if job.job_id is not None:
+            console.echo(
+                message=(
+                    f"The '{job.job_name}' job has already been submitted to the server. No further actions have "
+                    f"been taken as part of this submission cycle."
+                ),
+                level=LogLevel.WARNING,
+            )
+            return job
+
         # 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:
@@ -439,7 +383,7 @@ class Server:
         """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, the method returns False.
+        If the job is still running or queued for runtime, the method returns False.
 
         Args:
             job: The Job object whose status needs to be checked.
@@ -467,9 +411,9 @@ class Server:
     def abort_job(self, job: Job | JupyterJob) -> None:
         """Aborts the target job if it is currently running on the server.
 
-        Use this method to immediately abort running or queued jobs without waiting for the timeout guard. If the job
-        is queued, this method will remove it from the SLURM queue. If the job is already terminated, this method will
-        do nothing.
+        If the job is currently running, this method forcibly terminates its runtime. If the job is queued for
+        execution, this method removes it from the SLURM queue. If the job is already terminated, this method will do
+        nothing.
 
         Args:
             job: The Job object that needs to be aborted.
@@ -597,7 +541,7 @@ class Server:
             sftp.close()
 
     def _recursive_remove(self, sftp: paramiko.SFTPClient, remote_path: Path) -> None:
-        """Recursively removes a directory and all its contents.
+        """Recursively removes the specified remote directory and all its contents.
 
         This worker method is used by the user-facing remove() method to recursively remove non-empty directories.
 
@@ -627,10 +571,7 @@ class Server:
             console.echo(f"Unable to remove the specified directory {remote_path}: {e!s}", level=LogLevel.WARNING)
 
     def create_directory(self, remote_path: Path, parents: bool = True) -> None:
-        """Creates the specified directory tree on the managed remote server via SFTP.
-
-        This method creates directories on the remote server, with options to create parent directories and handle
-        existing directories gracefully.
+        """Creates the specified directory tree on the managed remote server.
 
         Args:
             remote_path: The absolute path to the directory to create on the remote server, relative to the server

sl_shared_assets/tools/__init__.py

@@ -5,6 +5,8 @@ from .transfer_tools import delete_directory, transfer_directory
 from .packaging_tools import calculate_directory_checksum
 from .project_management_tools import (
     ProjectManifest,
+    acquire_lock,
+    release_lock,
     archive_session,
     prepare_session,
     resolve_checksum,
@@ -13,11 +15,13 @@ from .project_management_tools import (
 
 __all__ = [
     "ProjectManifest",
+    "acquire_lock",
     "archive_session",
     "calculate_directory_checksum",
     "delete_directory",
     "generate_project_manifest",
     "prepare_session",
+    "release_lock",
     "resolve_checksum",
     "transfer_directory",
 ]

sl_shared_assets/tools/packaging_tools.py

@@ -13,7 +13,7 @@ import xxhash
 
 # Defines a 'blacklist' set of files. Primarily, this list contains the service files that may change after the session
 # data has been acquired. Therefore, it does not make sense to include them in the checksum, as they do not reflect the
-# data that should remain permanently unchanged. Note, make sure all service files are added to this set!
+# data that should remain permanently unchanged.
 _excluded_files = {
     "ax_checksum.txt",
     "ubiquitin.bin",

sl_shared_assets/tools/project_management_tools.py

@@ -1,6 +1,5 @@
-"""This module provides tools for managing the data of any Sun lab project. Tools from this module extend the
-functionality of the SessionData class via a convenient API to automate routine tasks that primarily support data
-processing pipelines."""
+"""This module provides tools for managing the data of any Sun lab project. Tools from this module are primarily used
+to support data processing pipelines that make up the Sun lab data workflow and run on the remote compute server."""
 
 from pathlib import Path
 from datetime import datetime
@@ -24,6 +23,62 @@ from .transfer_tools import delete_directory, transfer_directory
 from .packaging_tools import calculate_directory_checksum
 
 
+def acquire_lock(
+    session_path: Path, manager_id: int, processed_data_root: Path | None = None, reset_lock: bool = False
+) -> None:
+    """Acquires the target session's data lock for the specified manager process.
+
+    Calling this function locks the target session's data to make it accessible only for the specified manager process.
+
+    Notes:
+        Each time this function is called, the release_lock() function must also be called to release the lock file.
+
+    Args:
+        session_path: The path to the session directory to be locked.
+        manager_id: The unique identifier of the manager process that acquires the lock.
+        reset_lock: Determines whether to reset the lock file before executing the runtime. This allows recovering
+            from deadlocked runtimes, but otherwise should not be used to ensure that the lock performs its intended
+            function of limiting access to session's data.
+        processed_data_root: The path to the root directory used to store the processed data from all Sun lab projects,
+            if different from the 'session_path' root.
+    """
+
+    # Resolves the session directory hierarchy
+    session = SessionData.load(session_path=session_path, processed_data_root=processed_data_root)
+
+    # Instantiates the lock instance for the session
+    lock = SessionLock(file_path=session.tracking_data.session_lock_path)
+
+    # If requested, forcibly resets the lock state before re-acquiring the lock for the specified manager
+    if reset_lock:
+        lock.force_release()
+
+    # Acquires the lock for the specified manager.
+    lock.acquire(manager_id=manager_id)
+
+
+def release_lock(session_path: Path, manager_id: int, processed_data_root: Path | None = None) -> None:
+    """Releases the target session's data lock if it is owned by the specified manager process.
+
+    Calling this function unlocks the session's data, making it possible for other manager processes to acquire the
+    lock and work with the session's data. This step has to be performed by every manager process as part of its
+    shutdown sequence if the manager called the acquire_lock() function.
+
+    Args:
+        session_path: The path to the session directory to be unlocked.
+        manager_id: The unique identifier of the manager process that releases the lock.
+        processed_data_root: The path to the root directory used to store the processed data from all Sun lab projects,
+            if different from the 'session_path' root.
+    """
+
+    # Resolves the session directory hierarchy
+    session = SessionData.load(session_path=session_path, processed_data_root=processed_data_root)
+
+    # Releases the lock for the target session
+    lock = SessionLock(file_path=session.tracking_data.session_lock_path)
+    lock.release(manager_id=manager_id)
+
+
 def resolve_checksum(
     session_path: Path,
     manager_id: int,
@@ -54,7 +109,7 @@ def resolve_checksum(
         reset_tracker: Determines whether to reset the tracker file before executing the runtime. This allows
             recovering from deadlocked runtimes, but otherwise should not be used to ensure runtime safety.
         regenerate_checksum: Determines whether to update the checksum stored in the ax_checksum.txt file before
-            carrying out the verification. In this case, the verification necessarily succeeds and the session's
+            carrying out the verification. In this case, the verification necessarily succeeds, and the session's
             reference checksum is changed to reflect the current state of the session data.
     """
 
@@ -64,9 +119,9 @@ def resolve_checksum(
         processed_data_root=processed_data_root,
     )
 
-    # Acquires the exclusive session data access lock.
+    # Ensures that the manager process is holding the session lock
     lock = SessionLock(file_path=session_data.tracking_data.session_lock_path)
-    lock.acquire(manager_id=manager_id)
+    lock.check_owner(manager_id=manager_id)
 
     # Initializes the ProcessingTracker instance
     tracker = ProcessingTracker(
@@ -155,9 +210,9 @@ def prepare_session(
         processed_data_root=processed_data_root,
     )
 
-    # Acquires the exclusive session data access lock.
+    # Ensures that the manager process is holding the session lock
     lock = SessionLock(file_path=session_data.tracking_data.session_lock_path)
-    lock.acquire(manager_id=manager_id)
+    lock.check_owner(manager_id=manager_id)
 
     # Initializes the ProcessingTracker instances for preparation and archiving pipelines.
     preparation_tracker = ProcessingTracker(
@@ -260,10 +315,10 @@ def archive_session(
     Args:
         session_path: The path to the session directory to be processed.
         manager_id: The unique identifier of the manager process that manages the runtime.
-        processed_data_root: The path to the root directory used to store the processed data from all Sun lab projects,
-            if different from the 'session_path' root.
         reset_tracker: Determines whether to reset the tracker file before executing the runtime. This allows
             recovering from deadlocked runtimes, but otherwise should not be used to ensure runtime safety.
+        processed_data_root: The path to the root directory used to store the processed data from all Sun lab projects,
+            if different from the 'session_path' root.
 
     Notes:
         This function inverses the result of running the prepare_session() function.
@@ -274,9 +329,9 @@ def archive_session(
         processed_data_root=processed_data_root,
     )
 
-    # Acquires the exclusive session data access lock.
+    # Ensures that the manager process is holding the session lock
     lock = SessionLock(file_path=session_data.tracking_data.session_lock_path)
-    lock.acquire(manager_id=manager_id)
+    lock.check_owner(manager_id=manager_id)
 
     # Initializes the ProcessingTracker instances for preparation and archiving pipelines.
     preparation_tracker = ProcessingTracker(

{sl_shared_assets-5.0.1.dist-info → sl_shared_assets-5.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sl-shared-assets
-Version: 5.0.1
+Version: 5.1.0
 Summary: Provides data acquisition and processing assets shared between Sun (NeuroAI) lab libraries.
 Project-URL: Homepage, https://github.com/Sun-Lab-NBB/sl-shared-assets
 Project-URL: Documentation, https://sl-shared-assets-api-docs.netlify.app/

sl_shared_assets-5.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+sl_shared_assets/__init__.py,sha256=b4dg24AJKMTNxp050maE2vlqNu57nGHrzvyQUEFTwMM,2753
+sl_shared_assets/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+sl_shared_assets/command_line_interfaces/__init__.py,sha256=dbcCiuBCe1uqz6d1D-dFpSkRwYP603tEGkc1RbZcI6w,126
+sl_shared_assets/command_line_interfaces/configure.py,sha256=lAWhLzJ7UmdvUZlges9Hg5pnblQuXSDlgzr12y41108,6140
+sl_shared_assets/command_line_interfaces/manage.py,sha256=hFsj5r2UTiFwdr3N6FHOGYRnXBmdcJ4N_bpjsqcE5iA,10766
+sl_shared_assets/data_classes/__init__.py,sha256=7Cslz_z0K2VmgXjOR1u-NBySoWYfUNawBHh_1xLiFZ0,2092
+sl_shared_assets/data_classes/configuration_data.py,sha256=9gVo7bQShCMqAuau8d9BML6RrQyA4wg8ZFol1RJfJ7g,41334
+sl_shared_assets/data_classes/runtime_data.py,sha256=z7C40ZeNOePqRZD4zE3KbmK2yvbox1N-6flvcEE2d_4,17400
+sl_shared_assets/data_classes/session_data.py,sha256=gfzdFnBXwawWXQWiwZ3UXQeYajauKErkhnBph5mwXtA,48890
+sl_shared_assets/data_classes/surgery_data.py,sha256=-rENeSjAPmoIc-fp_skI4-EW_uxbK0Ps9aTLPWLkTSQ,7624
+sl_shared_assets/server/__init__.py,sha256=cIZFNE8pPPujp_FxIt6yT22L-4V4XBb1e_x4cnTrtSI,685
+sl_shared_assets/server/job.py,sha256=_u27gXwSfg3ztCemAtiskC9KnDfqF-RvWlTYYk0wHvQ,18704
+sl_shared_assets/server/pipeline.py,sha256=Uqg210L6N71OHTy4--8iocRz_bV5cBSUOVZnOk_u1zg,32157
+sl_shared_assets/server/server.py,sha256=FEBx9isTswndAKFaZ6MM4qyFp75FcE2ZWUiwc_uycMI,32825
+sl_shared_assets/tools/__init__.py,sha256=gMyKO3ZA70pmG7Hh8fIA5CLrkOXtN5pQk2o4NrKUjXM,813
+sl_shared_assets/tools/packaging_tools.py,sha256=9kwUSQQRCOycpNA7ovthCTXYX1HCC7p1iDnCYz2K2B8,6978
+sl_shared_assets/tools/project_management_tools.py,sha256=I1EqSapoQU2zspoMc_OxOrUMw_iYIqX6uIfmZZ3paGU,43205
+sl_shared_assets/tools/transfer_tools.py,sha256=6lwk4zyHWWB0QeWQageiQ1pPIGUV0IhBNNzsbgQ_qH4,9026
+sl_shared_assets-5.1.0.dist-info/METADATA,sha256=l_Ww8_R1Mw13mkxGrxzlWmPYPa8TRy6dSqtsz85yhEk,46884
+sl_shared_assets-5.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sl_shared_assets-5.1.0.dist-info/entry_points.txt,sha256=19NzFPG5CcW-4RhEacTcX3J2TbrvmjOE4tlLCH2O5wI,161
+sl_shared_assets-5.1.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+sl_shared_assets-5.1.0.dist-info/RECORD,,

sl_shared_assets-5.0.1.dist-info/RECORD

@@ -1,23 +0,0 @@
-sl_shared_assets/__init__.py,sha256=97oYSDN15AVCv-nk1MzIs_7FfsQP8ENR1wkJYQc6vEY,2677
-sl_shared_assets/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sl_shared_assets/command_line_interfaces/__init__.py,sha256=dbcCiuBCe1uqz6d1D-dFpSkRwYP603tEGkc1RbZcI6w,126
-sl_shared_assets/command_line_interfaces/configure.py,sha256=lAWhLzJ7UmdvUZlges9Hg5pnblQuXSDlgzr12y41108,6140
-sl_shared_assets/command_line_interfaces/manage.py,sha256=aGLn_iOrAGTXLFvhrjex4qXo7Crutmp8e8dWQ8YWuy4,8738
-sl_shared_assets/data_classes/__init__.py,sha256=SiOY1JjK_W7lc-EkeZ4O8SCepMPsC5OILUkPe6geU1Q,2119
-sl_shared_assets/data_classes/configuration_data.py,sha256=X6p5V15Verpu6ycO_fJhGOCyNp-IacVLktERc5eYF4k,45394
-sl_shared_assets/data_classes/runtime_data.py,sha256=ruo5KZ1VSfGwSg_gtSyWTbLBFcfG7Az455cKxiUpDoc,17565
-sl_shared_assets/data_classes/session_data.py,sha256=q34M6xDl_ntnvIG_tdDlGrkSXbHR1MzMGjhNBwM2rkk,47038
-sl_shared_assets/data_classes/surgery_data.py,sha256=riwyULMdZ8pDXFLdyNByNSeMk1-mVTo1FcCl5FrThas,7495
-sl_shared_assets/server/__init__.py,sha256=6REoeUvHW39V1Uwal_Af4uZ8J6UYDmR2N-saZoau30E,869
-sl_shared_assets/server/job.py,sha256=92nCVaLYqEJH7-xaS0bZmIVoGp-nJ5gh6dnwyRyZ9gI,19406
-sl_shared_assets/server/pipeline.py,sha256=0Peuq499BxKA3GaebQyhl_9VLepuaJQuwwt2vuM5ULg,33503
-sl_shared_assets/server/server.py,sha256=BUELEQbO-sx-9E2epGURCYSGN-I9WAD2dRETMWEPcRU,36483
-sl_shared_assets/tools/__init__.py,sha256=Pf8_MqZOLiityR112Txkermxf1bBLHYdEdw-raeY9Fc,737
-sl_shared_assets/tools/packaging_tools.py,sha256=hvOrdRwQCoe199G_XHhIpbKtIx-I0ad9O4SLZwhgj7U,7035
-sl_shared_assets/tools/project_management_tools.py,sha256=AcZpkzcXyAv4aBn-LIXawQgd7le7-vtZ9dl5MvMFmkg,40365
-sl_shared_assets/tools/transfer_tools.py,sha256=6lwk4zyHWWB0QeWQageiQ1pPIGUV0IhBNNzsbgQ_qH4,9026
-sl_shared_assets-5.0.1.dist-info/METADATA,sha256=kH_5OOIkoJbGKbiBoAG8_Ghg5iSisLLsxAV3NjTPY4E,46884
-sl_shared_assets-5.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sl_shared_assets-5.0.1.dist-info/entry_points.txt,sha256=19NzFPG5CcW-4RhEacTcX3J2TbrvmjOE4tlLCH2O5wI,161
-sl_shared_assets-5.0.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-sl_shared_assets-5.0.1.dist-info/RECORD,,