pybiolib 1.2.1228__tar.gz → 1.2.1235__tar.gz

{pybiolib-1.2.1228 → pybiolib-1.2.1235}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pybiolib
-Version: 1.2.1228
+Version: 1.2.1235
 Summary: BioLib Python Client
 License: MIT
 License-File: LICENSE

pybiolib-1.2.1235/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.1228 → pybiolib-1.2.1235}/biolib/app/app.py

@@ -72,7 +72,7 @@ class BioLibApp:
         result_prefix: Optional[str] = None,
         timeout: Optional[int] = None,
         notify: bool = False,
-        machine_count: Optional[int] = None,
+        max_workers: Optional[int] = None,
         experiment: Optional[str] = None,
         temporary_client_secrets: Optional[Dict[str, str]] = None,
         check: bool = False,
@@ -112,7 +112,7 @@ class BioLibApp:
             override_command=override_command,
             result_prefix=result_prefix,
             timeout=timeout,
-            requested_machine_count=machine_count,
+            requested_machine_count=max_workers,
             temporary_client_secrets=temporary_client_secrets,
             api_client=self._api_client,
         )

{pybiolib-1.2.1228 → pybiolib-1.2.1235}/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)
 

{pybiolib-1.2.1228 → pybiolib-1.2.1235}/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:
@@ -43,7 +41,7 @@ class JobResult:
     ) -> 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.1228 → pybiolib-1.2.1235}/pyproject.toml

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

pybiolib-1.2.1228/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)