pybiolib 1.2.1187__tar.gz → 1.2.1232__tar.gz

{pybiolib-1.2.1187 → pybiolib-1.2.1232}/PKG-INFO

@@ -1,8 +1,9 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: pybiolib
-Version: 1.2.1187
+Version: 1.2.1232
 Summary: BioLib Python Client
 License: MIT
+License-File: LICENSE
 Keywords: biolib
 Author: biolib
 Author-email: hello@biolib.com
@@ -17,6 +18,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Provides-Extra: compute-node
 Requires-Dist: appdirs (>=1.4.3)
 Requires-Dist: click (>=8.0.0)

{pybiolib-1.2.1187 → pybiolib-1.2.1232}/biolib/_internal/push_application.py

@@ -248,13 +248,15 @@ def push_application(
                     f'(str, int, float, bool, list, dict, null) are used. Original error: {e}'
                 ) from e
 
-        app_data = config.get('app_data') or config.get('assets')
-        if app_data:
-            if config.get('app_data') and config.get('assets'):
-                raise BioLibError(
-                    'In .biolib/config.yml you cannot specify both "app_data" and "assets" fields. Please use only one.'
-                )
+        if 'assets' in config and 'app_data' not in config:
+            config['app_data'] = config.pop('assets')
+        elif 'assets' in config and 'app_data' in config:
+            raise BioLibError(
+                'In .biolib/config.yml you cannot specify both "app_data" and "assets" fields. Please use only one.'
+            )
 
+        app_data = config.get('app_data')
+        if app_data:
             field_name = 'app_data' if 'app_data' in config else 'assets'
             if not isinstance(app_data, str):
                 raise BioLibError(

pybiolib-1.2.1232/biolib/_internal/utils/__init__.py

@@ -0,0 +1,43 @@
+import time
+import uuid
+from fnmatch import fnmatch
+
+from biolib.biolib_binary_format.utils import LazyLoadedFile
+from biolib.typing_utils import Callable, List, Union, cast
+
+PathFilter = Union[str, Callable[[str], bool]]
+
+
+def filter_lazy_loaded_files(files: List[LazyLoadedFile], path_filter: PathFilter) -> List[LazyLoadedFile]:
+    if not (isinstance(path_filter, str) or callable(path_filter)):
+        raise Exception('Expected path_filter to be a string or a function')
+
+    if callable(path_filter):
+        return list(filter(lambda x: path_filter(x.path), files))  # type: ignore
+
+    glob_filter = cast(str, path_filter)
+
+    # since all file paths start with /, make sure filter does too
+    if not glob_filter.startswith('/'):
+        glob_filter = '/' + glob_filter
+
+    def _filter_function(file: LazyLoadedFile) -> bool:
+        return fnmatch(file.path, glob_filter)
+
+    return list(filter(_filter_function, files))
+
+
+def open_browser_window_from_notebook(url_to_open: str) -> None:
+    try:
+        from IPython.display import (  # type:ignore # pylint: disable=import-error, import-outside-toplevel
+            Javascript,
+            display,
+            update_display,
+        )
+    except ImportError as error:
+        raise Exception('Unexpected environment. This function can only be called from a notebook.') from error
+
+    display_id = str(uuid.uuid4())
+    display(Javascript(f'window.open("{url_to_open}");'), display_id=display_id)
+    time.sleep(1)
+    update_display(Javascript(''), display_id=display_id)

{pybiolib-1.2.1187 → pybiolib-1.2.1232}/biolib/experiments/experiment.py

@@ -1,5 +1,6 @@
 import time
 from collections import OrderedDict
+from pathlib import Path
 
 from biolib import api
 from biolib._internal.types.experiment import DeprecatedExperimentDict, ExperimentDict
@@ -8,6 +9,7 @@ from biolib._internal.utils import open_browser_window_from_notebook
 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
@@ -223,6 +225,80 @@ class Experiment:
         """
         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:
         api.client.patch(f'/resources/{self.uuid}/', data={'uri': destination})
         self._refetch()

{pybiolib-1.2.1187 → pybiolib-1.2.1232}/biolib/jobs/job.py

@@ -10,7 +10,7 @@ import biolib.api.client
 from biolib import utils
 from biolib._internal.http_client import HttpClient
 from biolib._internal.tree_utils import build_tree_from_files, build_tree_str
-from biolib._internal.utils import open_browser_window_from_notebook
+from biolib._internal.utils import PathFilter, filter_lazy_loaded_files, open_browser_window_from_notebook
 from biolib.api.client import ApiClient
 from biolib.biolib_api_client import BiolibApiClient, CreatedJobDict
 from biolib.biolib_api_client.biolib_app_api import BiolibAppApi
@@ -18,11 +18,12 @@ from biolib.biolib_api_client.biolib_job_api import BiolibJobApi
 from biolib.biolib_binary_format import LazyLoadedFile, ModuleInput, ModuleInputDict, ModuleOutputV2
 from biolib.biolib_binary_format.remote_endpoints import RemoteJobStorageEndpoint
 from biolib.biolib_binary_format.stdout_and_stderr import StdoutAndStderr
+from biolib.biolib_binary_format.utils import InMemoryIndexableBuffer
 from biolib.biolib_errors import BioLibError, CloudJobFinishedError
 from biolib.biolib_logging import logger, logger_no_user_data
 from biolib.compute_node.job_worker.job_storage import JobStorage
 from biolib.compute_node.utils import SystemExceptionCodeMap, SystemExceptionCodes
-from biolib.jobs.job_result import JobResult, PathFilter
+from biolib.jobs.job_result import JobResult
 from biolib.jobs.types import CloudJobDict, CloudJobStartedDict, JobDict
 from biolib.tables import BioLibTable
 from biolib.typing_utils import Dict, List, Optional, Union, cast
@@ -187,6 +188,45 @@ class Result:
         """
         return self.result.list_output_files(path_filter=path_filter)
 
+    def list_input_files(
+        self,
+        path_filter: Optional[PathFilter] = None,
+    ) -> List[LazyLoadedFile]:
+        """List input files from the result.
+
+        Args:
+            path_filter (PathFilter, optional): Filter to apply to the input files.
+                Can be a string glob pattern or a callable that takes a path string and returns a boolean.
+
+        Returns:
+            List[LazyLoadedFile]: List of input files.
+
+        Example::
+            >>> result = biolib.get_result("result_id")
+            >>> input_files = result.list_input_files()
+            >>> # Filter files with a glob pattern
+            >>> input_files = result.list_input_files("*.txt")
+        """
+        presigned_download_url = BiolibJobApi.get_job_storage_download_url(
+            job_uuid=self.id,
+            job_auth_token=self._auth_token,
+            storage_type='input',
+        )
+        response = HttpClient.request(url=presigned_download_url)
+        module_input_serialized: bytes = response.content
+        module_input = ModuleInput(module_input_serialized).deserialize()
+
+        files = []
+        for path, data in module_input['files'].items():
+            buffer = InMemoryIndexableBuffer(data)
+            lazy_file = LazyLoadedFile(path=path, buffer=buffer, start=0, length=len(data))
+            files.append(lazy_file)
+
+        if not path_filter:
+            return files
+
+        return filter_lazy_loaded_files(files, path_filter)
+
     def get_output_file(self, filename: str) -> LazyLoadedFile:
         return self.result.get_output_file(filename=filename)
 
@@ -256,7 +296,7 @@ class Result:
         self,
         output_dir: str,
         path_filter: Optional[PathFilter] = None,
-        skip_file_if_exists: Optional[bool] = None,
+        skip_file_if_exists: bool = False,
         overwrite: bool = False,
     ) -> None:
         self.result.save_files(

{pybiolib-1.2.1187 → pybiolib-1.2.1232}/biolib/jobs/job_result.py

@@ -1,16 +1,14 @@
 import time
-from fnmatch import fnmatch
 from pathlib import Path
 
+from biolib._internal.utils import PathFilter, filter_lazy_loaded_files
 from biolib.biolib_binary_format import ModuleOutputV2
 from biolib.biolib_binary_format.remote_endpoints import RemoteJobStorageEndpoint
 from biolib.biolib_binary_format.remote_stream_seeker import StreamSeeker
 from biolib.biolib_binary_format.utils import LazyLoadedFile, RemoteIndexableBuffer
 from biolib.biolib_errors import BioLibError
 from biolib.biolib_logging import logger
-from biolib.typing_utils import Callable, List, Optional, Union, cast
-
-PathFilter = Union[str, Callable[[str], bool]]
+from biolib.typing_utils import List, Optional
 
 
 class JobResult:
@@ -38,12 +36,12 @@ class JobResult:
         self,
         output_dir: str,
         path_filter: Optional[PathFilter] = None,
-        skip_file_if_exists: Optional[bool] = None,
+        skip_file_if_exists: bool = False,
         overwrite: bool = False,
     ) -> None:
         module_output = self._get_module_output()
         output_files = module_output.get_files()
-        filtered_output_files = self._get_filtered_files(output_files, path_filter) if path_filter else output_files
+        filtered_output_files = filter_lazy_loaded_files(output_files, path_filter) if path_filter else output_files
 
         if len(filtered_output_files) == 0:
             logger.debug('No output files to save')
@@ -100,7 +98,7 @@ class JobResult:
 
     def get_output_file(self, filename) -> LazyLoadedFile:
         files = self._get_module_output().get_files()
-        filtered_files = self._get_filtered_files(files, path_filter=filename)
+        filtered_files = filter_lazy_loaded_files(files, path_filter=filename)
         if not filtered_files:
             raise BioLibError(f'File {filename} not found in results.')
 
@@ -114,26 +112,7 @@ class JobResult:
         if not path_filter:
             return files
 
-        return self._get_filtered_files(files, path_filter)
-
-    @staticmethod
-    def _get_filtered_files(files: List[LazyLoadedFile], path_filter: PathFilter) -> List[LazyLoadedFile]:
-        if not (isinstance(path_filter, str) or callable(path_filter)):
-            raise Exception('Expected path_filter to be a string or a function')
-
-        if callable(path_filter):
-            return list(filter(lambda x: path_filter(x.path), files))  # type: ignore
-
-        glob_filter = cast(str, path_filter)
-
-        # since all file paths start with /, make sure filter does too
-        if not glob_filter.startswith('/'):
-            glob_filter = '/' + glob_filter
-
-        def _filter_function(file: LazyLoadedFile) -> bool:
-            return fnmatch(file.path, glob_filter)
-
-        return list(filter(_filter_function, files))
+        return filter_lazy_loaded_files(files, path_filter)
 
     def _get_module_output(self) -> ModuleOutputV2:
         if self._module_output is None:

{pybiolib-1.2.1187 → pybiolib-1.2.1232}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "pybiolib"
-version = "1.2.1187"
+version = "1.2.1232"
 description = "BioLib Python Client"
 readme = "PYPI_README.md"
 license = "MIT"

pybiolib-1.2.1187/biolib/_internal/utils/__init__.py

@@ -1,18 +0,0 @@
-import time
-import uuid
-
-
-def open_browser_window_from_notebook(url_to_open: str) -> None:
-    try:
-        from IPython.display import (  # type:ignore # pylint: disable=import-error, import-outside-toplevel
-            Javascript,
-            display,
-            update_display,
-        )
-    except ImportError as error:
-        raise Exception('Unexpected environment. This function can only be called from a notebook.') from error
-
-    display_id = str(uuid.uuid4())
-    display(Javascript(f'window.open("{url_to_open}");'), display_id=display_id)
-    time.sleep(1)
-    update_display(Javascript(''), display_id=display_id)