pybiolib 0.2.951__py3-none-any.whl → 1.2.1890__py3-none-any.whl

biolib/compute_node/webserver/worker_thread.py

@@ -1,17 +1,25 @@
+import base64
+import os
 import random
+import shutil
+import socket
 import sys
-import time
 import threading
-import socket
+import time
 from queue import Queue
+from typing import Optional
 
+from biolib import api, utils
+from biolib.biolib_binary_format import ModuleOutputV2, SystemException, SystemStatusUpdate
+from biolib.biolib_binary_format.utils import LocalFileIndexableBuffer
+from biolib.biolib_logging import logger, logger_no_user_data
+from biolib.compute_node.cloud_utils import CloudUtils
 from biolib.compute_node.job_worker import JobWorkerProcess
+from biolib.compute_node.job_worker.job_storage import JobStorage
 from biolib.compute_node.socker_listener_thread import SocketListenerThread
 from biolib.compute_node.socket_sender_thread import SocketSenderThread
+from biolib.compute_node.utils import SystemExceptionCodes, WorkerThreadException, get_package_type
 from biolib.compute_node.webserver import webserver_utils
-from biolib.biolib_binary_format import AttestationDocument, SystemStatusUpdate, SystemException
-from biolib.compute_node.utils import get_package_type, WorkerThreadException, SystemExceptionCodes
-from biolib.biolib_logging import logger
 
 SOCKET_HOST = '127.0.0.1'
 
@@ -30,37 +38,86 @@ class WorkerThread(threading.Thread):
             self._sender_thread = None
             self._start_and_connect_to_compute_process()
 
-            logger.debug(f"WorkerThread connected to port {self._socket_port}")
+            logger.debug(f'WorkerThread connected to port {self._socket_port}')
 
         except Exception as exception:
-            raise WorkerThreadException(exception, SystemExceptionCodes.FAILED_TO_INITIALIZE_WORKER_THREAD.value,
-                                        worker_thread=self) from exception
+            logger_no_user_data.error(exception)
+            raise WorkerThreadException(
+                exception,
+                SystemExceptionCodes.FAILED_TO_INITIALIZE_WORKER_THREAD.value,
+                worker_thread=self,
+            ) from exception
+
+    @property
+    def _job_uuid(self):
+        return self.compute_state['job_id']
+
+    @property
+    def _job_temporary_dir(self):
+        return self.compute_state['job_temporary_dir']
+
+    def _upload_module_output_and_get_exit_code(self) -> Optional[int]:
+        exit_code = None
+        try:
+            module_output_path = os.path.join(
+                self._job_temporary_dir,
+                JobStorage.module_output_file_name,
+            )
+            if os.path.exists(module_output_path):
+                module_output = ModuleOutputV2(buffer=LocalFileIndexableBuffer(filename=module_output_path))
+                exit_code = module_output.get_exit_code()
+                logger_no_user_data.debug(f'Got exit code: {exit_code}')
+                if utils.IS_RUNNING_IN_CLOUD:
+                    JobStorage.upload_module_output(
+                        job_temporary_dir=self._job_temporary_dir,
+                        job_uuid=self._job_uuid,
+                    )
+        except Exception as error:
+            logger_no_user_data.error(f'Could not upload module output or get exit code: {error}')
+        return exit_code
 
     def run(self):
         try:
             while True:
                 package = self.compute_state['received_messages_queue'].get()
+                if package == b'CANCEL_JOB':
+                    logger_no_user_data.info(f'Job "{self._job_uuid}" got cancel signal')
+                    self.compute_state['status']['error_code'] = SystemExceptionCodes.CANCELLED_BY_USER.value
+                    self.terminate()
+
                 package_type = get_package_type(package)
 
-                if package_type == 'AttestationDocument':
-                    self.compute_state['attestation_document'] = AttestationDocument(package).deserialize()
+                if package_type == 'StdoutAndStderr':
+                    self.compute_state['status']['stdout_and_stderr_packages_b64'].append(
+                        base64.b64encode(package).decode()
+                    )
 
                 elif package_type == 'SystemStatusUpdate':
                     progress, log_message = SystemStatusUpdate(package).deserialize()
-                    self.compute_state['status']['status_updates'].append({'progress': progress,
-                                                                           'log_message': log_message})
+                    self._set_status_update(progress, log_message)
+
+                    # If 'Computation Finished'
+                    if progress == 94:
+                        self.compute_state['exit_code'] = self._upload_module_output_and_get_exit_code()
+                        self._set_status_update(progress=95, log_message='Result Ready')
+                        self.compute_state['is_completed'] = True
+                        self.terminate()
 
                 elif package_type == 'SystemException':
                     error_code = SystemException(package).deserialize()
                     self.compute_state['status']['error_code'] = error_code
-                    logger.debug("Hit error. Terminating Worker Thread and Compute Process")
+                    logger.debug('Hit error. Terminating Worker Thread and Compute Process')
+                    self.compute_state['progress'] = 95
                     self.terminate()
 
-                elif package_type == 'ModuleOutput' or package_type == 'AesEncryptedPackage':
-                    self.compute_state['result'] = package
-                    self.compute_state['status']['status_updates'].append({'progress': 95,
-                                                                           'log_message': 'Result Ready'})
-                    self.terminate()
+                elif package_type == 'AesEncryptedPackage':
+                    if self.compute_state['progress'] == 94:  # Check if encrypted package is ModuleOutput
+                        self.compute_state['result'] = package
+                        self.terminate()
+                    else:  # Else it is StdoutAndStderr
+                        self.compute_state['status']['stdout_and_stderr_packages_b64'].append(
+                            base64.b64encode(package).decode()
+                        )
 
                 else:
                     raise Exception(f'Package type from child was not recognized: {package}')
@@ -68,30 +125,40 @@ class WorkerThread(threading.Thread):
                 self.compute_state['received_messages_queue'].task_done()
 
         except Exception as exception:
-            raise WorkerThreadException(exception, SystemExceptionCodes.FAILED_TO_HANDLE_PACKAGE_IN_WORKER_THREAD.value,
-                                        worker_thread=self) from exception
+            raise WorkerThreadException(
+                exception,
+                SystemExceptionCodes.FAILED_TO_HANDLE_PACKAGE_IN_WORKER_THREAD.value,
+                worker_thread=self,
+            ) from exception
+
+    def _set_status_update(self, progress: int, log_message: str) -> None:
+        status_update = dict(progress=progress, log_message=log_message)
+        logger_no_user_data.debug(f'Job "{self._job_uuid}" got system log: {status_update}')
+
+        self.compute_state['progress'] = progress
+        self.compute_state['status']['status_updates'].append(status_update)
 
     def _start_and_connect_to_compute_process(self):
         self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-        logger.debug(f"Trying to bind to socket on {SOCKET_HOST}:{self._socket_port}")
+        logger_no_user_data.debug(f'Trying to bind to socket on {SOCKET_HOST}:{self._socket_port}')
         self._socket.bind((SOCKET_HOST, self._socket_port))
 
-        logger.debug(f"Starting to listen to socket on port {self._socket_port}")
+        logger_no_user_data.debug(f'Starting to listen to socket on port {self._socket_port}')
         self._socket.listen()
-        logger.debug(f"Listening to port {self._socket_port}")
+        logger_no_user_data.debug(f'Listening to port {self._socket_port}')
 
         received_messages_queue = Queue()
         messages_to_send_queue = Queue()
 
         # Starting a thread for accepting connections before starting the process that should to connect to the socket
-        logger.debug("Starting connection thread")
-        self._connection_thread = threading.Thread(target=self._accept_new_socket_connection, args=[
-            received_messages_queue,
-            messages_to_send_queue
-        ])
+        logger_no_user_data.debug('Starting connection thread')
+        self._connection_thread = threading.Thread(
+            target=self._accept_new_socket_connection,
+            args=[received_messages_queue, messages_to_send_queue],
+        )
         self._connection_thread.start()
-        logger.debug("Started connection thread")
-        logger.debug("Starting compute process")
+        logger_no_user_data.debug('Started connection thread')
+        logger_no_user_data.debug('Starting compute process')
 
         self._job_worker_process = JobWorkerProcess(socket_port=self._socket_port, log_level=logger.level)
         self._job_worker_process.start()
@@ -108,28 +175,102 @@ class WorkerThread(threading.Thread):
         self._sender_thread = SocketSenderThread(self._connection, messages_to_send_queue)
         self._sender_thread.start()
 
-    def terminate(self):
+    def terminate(self) -> None:
+        cloud_job_uuid = self.compute_state['cloud_job_id']
+        system_exception_code = self.compute_state['status'].get('error_code')
+
+        if utils.IS_RUNNING_IN_CLOUD and system_exception_code not in [
+            SystemExceptionCodes.CANCELLED_BY_USER.value,
+            SystemExceptionCodes.EXCEEDED_MAX_JOB_RUNTIME.value,
+        ]:
+            CloudUtils.finish_cloud_job(
+                cloud_job_id=cloud_job_uuid,
+                system_exception_code=system_exception_code,
+                exit_code=self.compute_state.get('exit_code', None),
+            )
+
+        deregistered_due_to_error = False
         if self._job_worker_process:
-            logger.debug(f'Terminating JobWorkerProcess with PID {self._job_worker_process.pid}')
+            logger_no_user_data.debug(
+                f'Job "{self._job_uuid}" terminating JobWorkerProcess with PID {self._job_worker_process.pid}'
+            )
             self._job_worker_process.terminate()
 
+            clean_up_timeout_in_seconds = 600
+            for _ in range(clean_up_timeout_in_seconds):
+                if self._job_worker_process.exitcode is not None:
+                    logger_no_user_data.debug(
+                        f'Job "{self._job_uuid}" worker process exitcode {self._job_worker_process.exitcode}'
+                    )
+                    break
+                else:
+                    logger_no_user_data.debug(f'Job "{self._job_uuid}" waiting for worker process to exit...')
+                    time.sleep(1)
+
+            if self._job_worker_process.exitcode is None:
+                # TODO: Figure out if more error handling is necessary here
+                logger_no_user_data.error(
+                    f'Job {self._job_uuid} worker process did not exit within {clean_up_timeout_in_seconds} seconds'
+                )
+                if utils.IS_RUNNING_IN_CLOUD:
+                    logger_no_user_data.error('Deregistering compute node...')
+                    CloudUtils.deregister(error='job_cleanup_timed_out')
+                    deregistered_due_to_error = True
+
+            elif system_exception_code in [
+                SystemExceptionCodes.CANCELLED_BY_USER.value,
+                SystemExceptionCodes.EXCEEDED_MAX_JOB_RUNTIME.value,
+            ]:
+                self.compute_state['exit_code'] = self._upload_module_output_and_get_exit_code()
+                CloudUtils.finish_cloud_job(
+                    cloud_job_id=cloud_job_uuid,
+                    system_exception_code=system_exception_code,
+                    exit_code=self.compute_state.get('exit_code', None),
+                )
+
+        # Delete result as error occurred
+        if system_exception_code and os.path.exists(self._job_temporary_dir):
+            shutil.rmtree(self._job_temporary_dir)
+
         if self._socket:
             self._socket.close()
 
         if self._connection:
             self._connection.close()
 
-        if self.compute_state['result']:
-            seconds_to_sleep = 60
-            job_id = self.compute_state['job_id']
-            logger.debug(f'Worker thread sleeping for {seconds_to_sleep} seconds before cleaning up job {job_id}')
-            # sleep to see if the user has begun downloading the result
+        if self.compute_state['progress'] == 95:
+            seconds_to_sleep = 5
+            logger_no_user_data.debug(
+                f'Job "{self._job_uuid}" worker thread sleeping for {seconds_to_sleep} seconds before cleaning up'
+            )
+            # sleep to let the user start downloading the result
             time.sleep(seconds_to_sleep)
-            if self.compute_state['result']:
-                logger.debug(f'Cleaning up job {job_id} as result was not fetched within {seconds_to_sleep} seconds')
-                webserver_utils.finalize_and_clean_up_compute_job(job_id)
+
+        compute_state_dict = webserver_utils.JOB_ID_TO_COMPUTE_STATE_DICT
+        if self._job_uuid in compute_state_dict:
+            # Delete result as user has not started download
+            if compute_state_dict[self._job_uuid]['progress'] == 95 and os.path.exists(self._job_temporary_dir):
+                shutil.rmtree(self._job_temporary_dir)
+
+            webserver_utils.JOB_ID_TO_COMPUTE_STATE_DICT.pop(self._job_uuid)
+            logger_no_user_data.debug(f'Job "{self._job_uuid}" was cleaned up')
+        else:
+            logger_no_user_data.debug(
+                f'Job "{self._job_uuid}" could not be found, maybe it has already been cleaned up'
+            )
+
+        if utils.IS_RUNNING_IN_CLOUD:
+            config = CloudUtils.get_webserver_config()
+            logger_no_user_data.debug(f'Job "{self._job_uuid}" reporting CloudJob "{cloud_job_uuid}" as cleaned up...')
+            api.client.post(
+                path=f'/internal/compute-nodes/cloud-jobs/{cloud_job_uuid}/cleaned-up/',
+                headers={'Compute-Node-Auth-Token': config['compute_node_info']['auth_token']},
+            )
+
+            if deregistered_due_to_error:
+                CloudUtils.shutdown()  # shutdown now
             else:
-                logger.debug(f'Job {job_id} already cleaned up')
+                webserver_utils.update_auto_shutdown_time()
 
-        logger.debug("Terminating Worker Thread")
+        logger_no_user_data.debug(f'Job "{self._job_uuid}" worker thread exiting...')
         sys.exit()

biolib/experiments/experiment.py

@@ -0,0 +1,356 @@
+import time
+from collections import OrderedDict
+from pathlib import Path
+
+from biolib import api
+from biolib._internal.utils import open_browser_window_from_notebook
+from biolib._shared.types import DeprecatedExperimentDict, ExperimentDict, ResourceDetailedDict
+from biolib.api.client import ApiClient
+from biolib.biolib_api_client import BiolibApiClient
+from biolib.biolib_errors import BioLibError
+from biolib.jobs.job import Job
+from biolib.jobs.job_result import PathFilter
+from biolib.jobs.types import JobsPaginatedResponse
+from biolib.tables import BioLibTable
+from biolib.typing_utils import Dict, List, Optional, Union
+from biolib.utils import IS_RUNNING_IN_NOTEBOOK
+
+
+class Experiment:
+    _BIOLIB_EXPERIMENTS: List['Experiment'] = []
+
+    # Columns to print in table when showing Job
+    _table_columns_to_row_map = OrderedDict(
+        {
+            'Name': {'key': 'name', 'params': {}},
+            'Job Count': {'key': 'job_count', 'params': {}},
+            'Created At': {'key': 'created_at', 'params': {}},
+        }
+    )
+
+    def __init__(
+        self,
+        uri: str,
+        _resource_dict: Optional[ResourceDetailedDict] = None,
+        _api_client: Optional[ApiClient] = None,
+    ):
+        self._api_client = _api_client or api.client
+        self._resource_dict: ResourceDetailedDict = _resource_dict or self._get_or_create_resource_dict(uri)
+
+    def __enter__(self):
+        Experiment._BIOLIB_EXPERIMENTS.append(self)
+
+    def __exit__(self, type, value, traceback):  # pylint: disable=redefined-builtin
+        Experiment._BIOLIB_EXPERIMENTS.pop()
+
+    def __str__(self):
+        return f'Experiment: {self.uri}'
+
+    def __repr__(self):
+        return f'Experiment: {self.uri}'
+
+    @property
+    def uuid(self) -> str:
+        return self._resource_dict['uuid']
+
+    @property
+    def id(self) -> str:
+        return self.uuid
+
+    @property
+    def name(self) -> str:
+        return self._resource_dict['name']
+
+    @property
+    def uri(self) -> str:
+        return self._resource_dict['uri']
+
+    @property
+    def _experiment_dict(self) -> DeprecatedExperimentDict:
+        if not self._resource_dict['experiment']:
+            raise ValueError(f'Resource {self.uri} is not an Experiment')
+
+        return self._resource_dict['experiment']
+
+    @staticmethod
+    def get_experiment_in_context() -> Optional['Experiment']:
+        if Experiment._BIOLIB_EXPERIMENTS:
+            return Experiment._BIOLIB_EXPERIMENTS[-1]
+        return None
+
+    # Prints a table listing info about experiments accessible to the user
+    @staticmethod
+    def show_experiments(count: int = 25) -> None:
+        pagniated_response = api.client.get(path='/experiments/', params={'page_size': str(count)}).json()
+        experiment_dicts: List[ExperimentDict] = pagniated_response['results']
+        BioLibTable(
+            columns_to_row_map=Experiment._table_columns_to_row_map,
+            rows=experiment_dicts,
+            title='Experiments',
+        ).print_table()
+
+    @staticmethod
+    def get_by_uri(uri: str) -> 'Experiment':
+        query_param_key = 'uri' if '/' in uri else 'name'
+        resource_dict: ResourceDetailedDict = api.client.get('/resource/', params={query_param_key: uri}).json()
+        if not resource_dict['experiment']:
+            raise ValueError(f'Resource {uri} is not an experiment')
+
+        return Experiment(uri=resource_dict['uri'], _resource_dict=resource_dict)
+
+    def wait(self) -> None:
+        self._refetch()
+        while self._experiment_dict['job_running_count'] > 0:
+            print(f"Waiting for {self._experiment_dict['job_running_count']} jobs to finish", end='\r')
+            time.sleep(5)
+            self._refetch()
+
+        print(f'All jobs of experiment {self.name} have finished')
+
+    def add_job(self, job: Optional[Union[Job, str]] = None, job_id: Optional[str] = None) -> None:
+        if job_id is not None:
+            print(
+                'WARNING: job_id argument is deprecated and may be removed in a future release.'
+                'Please use job argument instead.'
+            )
+        elif isinstance(job, Job):
+            job_id = job.id
+        elif isinstance(job, str):
+            job_id = job
+        elif job is None and job_id is None:
+            raise BioLibError('A job ID or job object must be provided to add job')
+        self._api_client.post(
+            path=f'/experiments/{self.uuid}/jobs/',
+            data={'job_uuid': job_id},
+        )
+
+    def remove_job(self, job: Union[Job, str]) -> None:
+        if isinstance(job, Job):
+            job_id = job.id
+        elif isinstance(job, str):
+            job_id = job
+        else:
+            raise BioLibError('A job ID or job object must be provided to remove job')
+
+        self._api_client.delete(path=f'/experiments/{self.uuid}/jobs/{job_id}/')
+
+    def mount_files(self, mount_path: str) -> None:
+        try:
+            # Only attempt to import FUSE dependencies when strictly necessary
+            from biolib._internal.fuse_mount import (  # pylint: disable=import-outside-toplevel
+                ExperimentFuseMount as _ExperimentFuseMount,
+            )
+        except ImportError as error:
+            raise ImportError(
+                'Failed to import FUSE mounting utils. Please ensure FUSE is installed on your system.'
+            ) from error
+
+        _ExperimentFuseMount.mount_experiment(experiment=self, mount_path=mount_path)
+
+    def export_job_list(self, export_format='dicts'):
+        valid_formats = ('dicts', 'dataframe')
+        if export_format not in valid_formats:
+            raise BioLibError(f'Format can only be one of {valid_formats}')
+
+        job_dict_list = [job.to_dict() for job in self.get_jobs()]
+        if export_format == 'dicts':
+            return job_dict_list
+
+        elif export_format == 'dataframe':
+            try:
+                import pandas as pd  # type: ignore  # pylint: disable=import-outside-toplevel
+            except ImportError as error:
+                raise ImportError(
+                    'Pandas must be installed to use this method. '
+                    'Alternatively, use .get_jobs() to get a list of job objects.'
+                ) from error
+
+            jobs_df = pd.DataFrame.from_dict(job_dict_list)
+            jobs_df.started_at = pd.to_datetime(jobs_df.started_at)
+            jobs_df.created_at = pd.to_datetime(jobs_df.created_at)
+            jobs_df.finished_at = pd.to_datetime(jobs_df.finished_at)
+            return jobs_df
+
+    # Prints a table containing info about this experiment
+    def show(self) -> None:
+        BioLibTable(
+            columns_to_row_map=Experiment._table_columns_to_row_map,
+            rows=[dict(**self._experiment_dict, name=self.name, created_at=self._resource_dict['created_at'])],
+            title=f'Experiment: {self.name}',
+        ).print_table()
+
+    # Prints a table listing info about the jobs in this experiment
+    def show_jobs(self) -> None:
+        response: JobsPaginatedResponse = self._api_client.get(
+            path=f'/experiments/{self.uuid}/jobs/',
+            params=dict(page_size=10),
+        ).json()
+        jobs: List[Job] = [Job(job_dict) for job_dict in response['results']]
+
+        BioLibTable(
+            columns_to_row_map=Job.table_columns_to_row_map,
+            rows=[job._job_dict for job in jobs],  # pylint: disable=protected-access
+            title=f'Jobs in experiment: "{self.name}"',
+        ).print_table()
+
+    def get_jobs(self, status: Optional[str] = None) -> List[Job]:
+        job_states = ['in_progress', 'completed', 'failed', 'cancelled']
+        if status is not None and status not in job_states:
+            raise Exception('Invalid status filter')
+
+        url = f'/experiments/{self.uuid}/jobs/'
+        params: Dict[str, Union[str, int]] = dict(page_size=1_000)
+        if status:
+            params['status'] = status
+
+        response: JobsPaginatedResponse = self._api_client.get(url, params=params).json()
+        jobs: List[Job] = [Job(job_dict) for job_dict in response['results']]
+
+        for page_number in range(2, response['page_count'] + 1):
+            page_response: JobsPaginatedResponse = self._api_client.get(
+                url, params=dict(**params, page=page_number)
+            ).json()
+            jobs.extend([Job(job_dict) for job_dict in page_response['results']])
+
+        return jobs
+
+    def get_results(self, status: Optional[str] = None) -> List[Job]:
+        r"""Get a list of results in this experiment, optionally filtered by status.
+
+        Args:
+            status (str, optional): Filter results by status. One of:
+                'in_progress', 'completed', 'failed', 'cancelled'
+
+        Returns:
+            List[Job]: List of result objects in this experiment
+
+        Example::
+
+            >>> # Get all results in the experiment
+            >>> results = experiment.get_results()
+            >>> # Get only completed results
+            >>> completed_results = experiment.get_results(status='completed')
+        """
+        return self.get_jobs(status=status)
+
+    def save_completed_results(
+        self,
+        output_dir: Optional[str] = None,
+        path_filter: Optional[PathFilter] = None,
+        skip_file_if_exists: bool = False,
+        overwrite: bool = False,
+    ) -> None:
+        r"""Save all completed results in this experiment to local folders.
+
+        Creates a folder structure with the experiment name as the root directory,
+        containing a subfolder for each completed result. Only results with
+        'completed' status will be saved.
+
+        Args:
+            output_dir (str, optional): Base directory where the experiment folder
+                will be created. If None, uses the current working directory.
+            path_filter (PathFilter, optional): Filter to select which files in the results to save.
+                Can be a glob pattern string or a callable function.
+            skip_file_if_exists (bool, optional): Whether to skip files that already exist
+                locally instead of raising an error. Defaults to False.
+            overwrite (bool, optional): Whether to overwrite existing files.
+                Defaults to False.
+
+        Example::
+
+            >>> # Save all completed results to current directory
+            >>> experiment.save_completed_results()
+            >>> # This creates: ./experiment_name/result_1/, ./experiment_name/result_2/, etc.
+
+            >>> # Save to specific directory
+            >>> experiment.save_completed_results(output_dir="/path/to/save")
+            >>> # This creates: /path/to/save/experiment_name/result_1/, etc.
+        """
+        base_dir = Path(output_dir) if output_dir else Path.cwd()
+
+        if base_dir == Path('/'):
+            raise BioLibError("Cannot save experiment results to root directory '/'")
+
+        experiment_folder = base_dir / self.name
+        experiment_folder.mkdir(parents=True, exist_ok=True)
+
+        completed_results: List[Job] = []
+        failed_results = False
+        print('Getting experiment status...')
+        for result in self.get_results():
+            if result.get_status() == 'completed':
+                completed_results.append(result)
+            elif result.get_status() != 'in_progress':
+                failed_results = True
+
+        if failed_results:
+            print(
+                'WARNING: Found failed or cancelled results in the experiment. '
+                'Please verify you have all your results, and consider removing the failed ones.'
+            )
+        if not completed_results:
+            print(f"No completed results found in experiment '{self.name}'")
+            return
+
+        print(f"Saving {len(completed_results)} completed results from experiment '{self.name}' to {experiment_folder}")
+
+        for result in completed_results:
+            result_name = result.get_name()
+            result_folder = experiment_folder / result_name
+
+            result_folder.mkdir(parents=True, exist_ok=True)
+
+            result.save_files(
+                output_dir=str(result_folder),
+                path_filter=path_filter,
+                skip_file_if_exists=skip_file_if_exists,
+                overwrite=overwrite,
+            )
+
+    def rename(self, destination: str) -> None:
+        r"""Rename this experiment to a new URI.
+
+        Args:
+            destination (str): The new URI for the experiment
+                (e.g., 'username/new-experiment-name').
+
+        Example::
+
+            >>> experiment = biolib.get_experiment(uri='username/my-experiment')
+            >>> experiment.rename('username/my-renamed-experiment')
+            >>> print(experiment.uri)
+            'username/my-renamed-experiment'
+        """
+        self._api_client.patch(f'/resources/{self.uuid}/', data={'uri': destination})
+        self._refetch()
+
+    def _get_resource_dict_by_uuid(self, uuid: str) -> ResourceDetailedDict:
+        resource_dict: ResourceDetailedDict = self._api_client.get(f'/resources/{uuid}/').json()
+        if not resource_dict['experiment']:
+            raise ValueError('Resource from URI is not an experiment')
+
+        return resource_dict
+
+    def _get_or_create_resource_dict(self, uri: str) -> ResourceDetailedDict:
+        response_dict = self._api_client.post(path='/experiments/', data={'uri' if '/' in uri else 'name': uri}).json()
+        return self._get_resource_dict_by_uuid(uuid=response_dict['uuid'])
+
+    def _refetch(self) -> None:
+        self._resource_dict = self._get_resource_dict_by_uuid(uuid=self._resource_dict['uuid'])
+
+    def open_browser(self) -> None:
+        """Open a browser window to view this experiment.
+
+        If running in a notebook, this will attempt to open a new browser window.
+        Otherwise, it will print a URL that you can copy and paste.
+        """
+        api_client = BiolibApiClient.get()
+        url_to_open = f'{api_client.base_url}/experiments/{self.id}/'
+
+        if IS_RUNNING_IN_NOTEBOOK:
+            print(f'Opening experiment page at: {url_to_open}')
+            print('If your browser does not open automatically, click on the link above.')
+            open_browser_window_from_notebook(url_to_open)
+        else:
+            print('Please copy and paste the following link into your browser:')
+            print(url_to_open)

biolib/jobs/__init__.py

@@ -0,0 +1 @@
+from biolib.jobs.job import Job