pybiolib 1.1.1747__py3-none-any.whl → 1.1.2193__py3-none-any.whl

biolib/cli/run.py

@@ -1,4 +1,5 @@
 import sys
+
 import click
 
 from biolib import biolib_errors, utils
@@ -27,13 +28,13 @@ def run(local: bool, non_blocking: bool, uri: str, args: Tuple[str]) -> None:
             stdin = sys.stdin.read()
         return stdin
 
-    blocking = False if non_blocking else True
+    blocking = not non_blocking
     job = app.cli(
         args=list(args),
         stdin=_get_stdin(),
         files=None,
         machine=('local' if local else ''),
-        blocking=blocking
+        blocking=blocking,
     )
 
     if blocking:

biolib/cli/start.py

@@ -24,6 +24,7 @@ def start(host: str, port: int, tls_certificate: Optional[str], tls_key: Optiona
 
     try:
         from biolib.compute_node.webserver import webserver  # pylint: disable=import-outside-toplevel
+
         webserver.start_webserver(
             host=host,
             port=port,

biolib/compute_node/cloud_utils/cloud_utils.py

@@ -7,11 +7,11 @@ import time
 from datetime import datetime
 from socket import gethostbyname, gethostname
 
-from biolib import utils, api
-from biolib.biolib_logging import logger_no_user_data
-from biolib.typing_utils import Optional, List, Dict, cast
+from biolib import api, utils
 from biolib.biolib_api_client import BiolibApiClient
-from biolib.compute_node.webserver.webserver_types import WebserverConfig, ComputeNodeInfo, ShutdownTimes
+from biolib.biolib_logging import logger_no_user_data
+from biolib.compute_node.webserver.webserver_types import ComputeNodeInfo, ShutdownTimes, WebserverConfig
+from biolib.typing_utils import Dict, List, Optional, cast
 
 
 def trust_ceritificates(certs_data: List[str]) -> None:
@@ -54,15 +54,12 @@ class CloudUtils:
                 pybiolib_version=utils.BIOLIB_PACKAGE_VERSION,
             ),
             base_url=CloudUtils._get_environment_variable_or_fail('BIOLIB_BASE_URL'),
-            s3_general_storage_bucket_name=CloudUtils._get_environment_variable_or_fail(
-                'BIOLIB_S3_GENERAL_STORAGE_BUCKET_NAME',
-            ),
             is_dev=os.environ.get('BIOLIB_DEV') == 'TRUE',
             shutdown_times=ShutdownTimes(
                 auto_shutdown_time_in_seconds=CloudUtils._get_environment_variable_as_int(
                     'BIOLIB_CLOUD_AUTO_SHUTDOWN_TIME_IN_SECONDS'
                 ),
-            )
+            ),
         )
 
         return CloudUtils._webserver_config
@@ -81,10 +78,10 @@ class CloudUtils:
                         'error': error,
                     },
                 )
-            except BaseException as error:
-                logger_no_user_data.error(f'Failed to deregister got error: {error}')
+            except BaseException as error_object:
+                logger_no_user_data.error(f'Failed to deregister got error: {error_object}')
         else:
-            logger_no_user_data.error("Not deregistering as environment is not cloud")
+            logger_no_user_data.error('Not deregistering as environment is not cloud')
 
     @staticmethod
     def shutdown() -> None:
@@ -98,7 +95,7 @@ class CloudUtils:
             except Exception as error:  # pylint: disable=broad-except
                 logger_no_user_data.error(f'Failed to shutdown got error: {error}')
         else:
-            logger_no_user_data.error("Not running shutdown as environment is not cloud")
+            logger_no_user_data.error('Not running shutdown as environment is not cloud')
 
     @staticmethod
     def deregister_and_shutdown() -> None:
@@ -131,7 +128,7 @@ class CloudUtils:
                     'auth_token': config['compute_node_info']['auth_token'],
                     'cloud_job_id': cloud_job_id,
                     'system_exception_code': system_exception_code,
-                    'exit_code': exit_code
+                    'exit_code': exit_code,
                 },
             )
         except BaseException as error:
@@ -152,14 +149,14 @@ class CloudUtils:
                 data=cast(Dict[str, str], compute_node_info),
             )
             if response.status_code != 201:
-                raise Exception("Non 201 error code")
+                raise Exception('Non 201 error code')
             else:
-                logger_no_user_data.info("Compute node registered!")
+                logger_no_user_data.info('Compute node registered!')
                 response_data = response.json()
-                logger_no_user_data.info(f"Got data on register: {json.dumps(response_data)}")
+                logger_no_user_data.info(f'Got data on register: {json.dumps(response_data)}')
                 certs = []
-                for federation in response_data["federation"]:
-                    for cert_b64 in federation["certs_b64"]:
+                for federation in response_data['federation']:
+                    for cert_b64 in federation['certs_b64']:
                         certs.append(base64.b64decode(cert_b64).decode())
                 trust_ceritificates(certs)
 

biolib/compute_node/job_worker/cache_state.py

@@ -16,7 +16,7 @@ class DockerCacheStateError(CacheStateError):
 
 class LfsCacheState(CacheState):
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
 
         self._storage_path_for_write: str = self._get_storage_path_for_write()

biolib/compute_node/job_worker/executors/docker_executor.py

@@ -1,43 +1,42 @@
+import io
 import json
+import os
+import re
+import shlex
 import subprocess
+import tarfile
 import tempfile
 import time
-import tarfile
 import zipfile
-import os
-import io
-import re
-import shlex
 from copy import copy
 from datetime import datetime
 
 import docker  # type: ignore
 import docker.types  # type: ignore
-
-from docker.errors import ImageNotFound, APIError  # type: ignore
+from docker.errors import APIError, ImageNotFound  # type: ignore
 from docker.models.containers import Container  # type: ignore
 
 from biolib import utils
+from biolib._internal.runtime import RuntimeJobDataDict
 from biolib.biolib_binary_format import ModuleInput, ModuleOutputV2
+from biolib.biolib_binary_format.file_in_container import FileInContainer
 from biolib.biolib_docker_client import BiolibDockerClient
-from biolib.biolib_errors import DockerContainerNotFoundDuringExecutionException, BioLibError
+from biolib.biolib_errors import BioLibError, DockerContainerNotFoundDuringExecutionException
 from biolib.biolib_logging import logger, logger_no_user_data
 from biolib.compute_node import utils as compute_node_utils
 from biolib.compute_node.cloud_utils import CloudUtils
 from biolib.compute_node.job_worker.docker_image_cache import DockerImageCache
-from biolib.biolib_binary_format.file_in_container import FileInContainer
 from biolib.compute_node.job_worker.executors.docker_types import DockerDiffKind
-from biolib.compute_node.job_worker.executors.types import StatusUpdate, LocalExecutorOptions
+from biolib.compute_node.job_worker.executors.types import LocalExecutorOptions, StatusUpdate
 from biolib.compute_node.job_worker.mappings import Mappings, path_without_first_folder
-from biolib.compute_node.job_worker.utils import ComputeProcessException
 from biolib.compute_node.job_worker.utilization_reporter_thread import UtilizationReporterThread
+from biolib.compute_node.job_worker.utils import ComputeProcessException
 from biolib.compute_node.utils import SystemExceptionCodes
-from biolib.typing_utils import List, Dict, Optional
+from biolib.typing_utils import Dict, List, Optional
 
 
 class DockerExecutor:
-
-    def __init__(self, options: LocalExecutorOptions):
+    def __init__(self, options: LocalExecutorOptions) -> None:
         self._options: LocalExecutorOptions = options
         self._is_cleaning_up = False
 
@@ -81,11 +80,12 @@ class DockerExecutor:
             raise Exception('Docker container was None')
         return self._docker_container
 
-    def execute_module(self, module_input_serialized: bytes, module_output_path: str) -> None:
+    def execute_module(self, module_input_path: str, module_output_path: str) -> None:
         try:
             job_uuid = self._options['job']['public_id']
             send_status_update = self._options['send_status_update']
-            module_input = ModuleInput(module_input_serialized).deserialize()
+            with open(module_input_path, 'rb') as fp:
+                module_input = ModuleInput(fp.read()).deserialize()
 
             send_status_update(StatusUpdate(progress=55, log_message='Pulling images...'))
 
@@ -113,35 +113,49 @@ class DockerExecutor:
             except Exception:  # pylint: disable=broad-except
                 logger_no_user_data.error('DockerExecutor failed to clean up container')
 
-    def _pull(self):
-        try:
-            start_time = time.time()
-            if utils.IS_RUNNING_IN_CLOUD and not self._options['job'].get('federated_job_uuid'):
-                DockerImageCache().get(
-                    image_uri=self._absolute_image_uri,
-                    estimated_image_size_bytes=self._options['module']['estimated_image_size_bytes'],
-                    job_id=self._options['job']['public_id'],
-                )
-            else:
-                docker_client = BiolibDockerClient.get_docker_client()
-                try:
-                    docker_client.images.get(self._absolute_image_uri)
-                except ImageNotFound:
-                    job_uuid = self._options['job'].get('federated_job_uuid') or self._options['job']['public_id']
-                    docker_client.images.pull(
-                        self._absolute_image_uri,
-                        auth_config={'username': 'biolib', 'password': f',{job_uuid}'},
-                    )
+    def _pull(self) -> None:
+        retries = 3
+        last_error: Optional[Exception] = None
+        estimated_image_size_bytes = self._options['module']['estimated_image_size_bytes']
+        assert estimated_image_size_bytes is not None, 'No estimated image size'
 
-            logger_no_user_data.debug(f'Pulled image in: {time.time() - start_time}')
+        for retry_count in range(retries + 1):
+            if retry_count > 0:
+                logger_no_user_data.debug(f'Retrying Docker image pull of "{self._absolute_image_uri}"')
+                time.sleep(5 * retry_count)
+            try:
+                start_time = time.time()
+                if utils.IS_RUNNING_IN_CLOUD and not self._options['job'].get('federated_job_uuid'):
+                    DockerImageCache().get(
+                        image_uri=self._absolute_image_uri,
+                        estimated_image_size_bytes=estimated_image_size_bytes,
+                        job_id=self._options['job']['public_id'],
+                    )
+                else:
+                    docker_client = BiolibDockerClient.get_docker_client()
+                    try:
+                        docker_client.images.get(self._absolute_image_uri)
+                    except ImageNotFound:
+                        job_uuid = self._options['job'].get('federated_job_uuid') or self._options['job']['public_id']
+                        docker_client.images.pull(
+                            self._absolute_image_uri,
+                            auth_config={'username': 'biolib', 'password': f',{job_uuid}'},
+                        )
+
+                logger_no_user_data.debug(f'Pulled image in: {time.time() - start_time}')
+                return
+            except Exception as error:
+                logger_no_user_data.warning(
+                    f'Pull of Docker image "{self._absolute_image_uri}" returned error: {error}'
+                )
+                last_error = error
 
-        except Exception as exception:
-            raise ComputeProcessException(
-                exception,
-                SystemExceptionCodes.FAILED_TO_PULL_DOCKER_IMAGE.value,
-                self._send_system_exception,
-                may_contain_user_data=False
-            ) from exception
+        raise ComputeProcessException(
+            last_error or Exception('Retries exceeded: failed to pull Docker image'),
+            SystemExceptionCodes.FAILED_TO_PULL_DOCKER_IMAGE.value,
+            self._send_system_exception,
+            may_contain_user_data=False,
+        )
 
     def _execute_helper(self, module_input, module_output_path: str) -> None:
         job_uuid = self._options['job']['public_id']
@@ -152,10 +166,10 @@ class DockerExecutor:
             logger_no_user_data.debug(f'Job "{job_uuid}" starting utilization metrics reporter thread...')
             config = CloudUtils.get_webserver_config()
             node_auth_token = config['compute_node_info']['auth_token']  # pylint: disable=unsubscriptable-object
-            cloud_job = self._options["cloud_job"]
+            cloud_job = self._options['cloud_job']
             include_gpu_stats = False
             if cloud_job:
-                include_gpu_stats = cloud_job.get("reserved_gpu_count", 0) > 0
+                include_gpu_stats = cloud_job.get('reserved_gpu_count', 0) > 0
             UtilizationReporterThread(
                 container=self._container,
                 job_uuid=job_uuid,
@@ -210,7 +224,7 @@ class DockerExecutor:
             raise ComputeProcessException(
                 MemoryError(),
                 SystemExceptionCodes.OUT_OF_MEMORY.value,
-                self._send_system_exception
+                self._send_system_exception,
             )
 
         logger_no_user_data.debug(f'Docker container exited with code {exit_code} for {job_uuid}')
@@ -241,24 +255,23 @@ class DockerExecutor:
         for path_to_delete in [self._input_tar_path, self._runtime_tar_path]:
             if os.path.exists(path_to_delete):
                 os.remove(path_to_delete)
-        logger_no_user_data.debug(f"Deleted tars in: {time.time() - tar_time}")
+        logger_no_user_data.debug(f'Deleted tars in: {time.time() - tar_time}')
 
         container_time = time.time()
         if self._docker_container:
             self._docker_container.remove(force=True)
 
         if utils.IS_RUNNING_IN_CLOUD:
-            DockerImageCache().detach_job(
-                image_uri=self._absolute_image_uri,
-                job_id=self._options['job']['public_id']
-            )
+            DockerImageCache().detach_job(image_uri=self._absolute_image_uri, job_id=self._options['job']['public_id'])
 
-        logger_no_user_data.debug(f"Deleted compute container in: {time.time() - container_time}")
+        logger_no_user_data.debug(f'Deleted compute container in: {time.time() - container_time}')
         self._tmp_secrets_dir.cleanup()
 
     # TODO: type this method
     def _initialize_docker_container(self, module_input):
         try:
+            job_uuid = self._options['job']['public_id']
+            logger_no_user_data.debug(f'Job "{job_uuid}" initializing Docker container...')
             module = self._options['module']
             logger.debug(f"Initializing docker container with command: {module['command']}")
 
@@ -267,12 +280,13 @@ class DockerExecutor:
             internal_network = self._options['internal_network']
             extra_hosts: Dict[str, str] = {}
 
-            biolib_system_secret = {
-                'version': '1.0.0',
-                'job_requested_machine': self._options['job']['requested_machine'],
-                'job_uuid': self._options['job']['public_id'],
-                'job_auth_token': self._options['job']['auth_token'],
-            }
+            biolib_system_secret = RuntimeJobDataDict(
+                version='1.0.0',
+                job_requested_machine=self._options['job']['requested_machine'],
+                job_uuid=self._options['job']['public_id'],
+                job_auth_token=self._options['job']['auth_token'],
+                app_uri=self._options['job']['app_uri'],
+            )
             secrets: Dict[str, str] = dict(
                 **module.get('secrets', {}),
                 biolib_system_secret=json.dumps(biolib_system_secret, indent=4),
@@ -288,32 +302,40 @@ class DockerExecutor:
             )
             if app_version_created_at < datetime(2022, 11, 30, 0, 0):
                 environment_vars = module.get('secrets', {})
-                environment_vars.update({
-                    'BIOLIB_JOB_UUID': self._options['job']['public_id'],
-                    'BIOLIB_JOB_AUTH_TOKEN': self._options['job']['auth_token']
-                })
+                environment_vars.update(
+                    {
+                        'BIOLIB_JOB_UUID': self._options['job']['public_id'],
+                        'BIOLIB_JOB_AUTH_TOKEN': self._options['job']['auth_token'],
+                    }
+                )
 
             if utils.IS_RUNNING_IN_CLOUD and self._options['cloud_job']:
-                environment_vars.update({
-                    'BIOLIB_JOB_MAX_RUNTIME_IN_SECONDS': self._options['cloud_job']['max_runtime_in_seconds'],
-                })
+                environment_vars.update(
+                    {
+                        'BIOLIB_JOB_MAX_RUNTIME_IN_SECONDS': self._options['cloud_job']['max_runtime_in_seconds'],
+                    }
+                )
 
+            logger_no_user_data.debug(f'Job "{job_uuid}" initializing Docker container. Getting IPs for proxies...')
             for proxy in self._options['remote_host_proxies']:
                 proxy_ip = proxy.get_ip_address_on_network(internal_network)
                 if proxy.is_app_caller_proxy:
                     logger_no_user_data.debug('Found app caller proxy, setting both base URLs in compute container')
-                    environment_vars.update({
-                        'BIOLIB_BASE_URL': f'http://{proxy_ip}',
-                        'BIOLIB_CLOUD_BASE_URL': f'http://{proxy_ip}',
-                        # This should be removed eventually, but will break apps calling apps on older versions
-                        'BIOLIB_CLOUD_RESULTS_BASE_URL': f'http://{proxy_ip}',
-                        'BIOLIB_CLOUD_JOB_STORAGE_BASE_URL': f'http://{proxy_ip}',
-                        # Inform container if we are targeting public biolib as we change the BIOLIB_BASE_URL
-                        'BIOLIB_ENVIRONMENT_IS_PUBLIC_BIOLIB': bool(utils.BASE_URL_IS_PUBLIC_BIOLIB)
-                    })
+                    environment_vars.update(
+                        {
+                            'BIOLIB_BASE_URL': f'http://{proxy_ip}',
+                            'BIOLIB_CLOUD_BASE_URL': f'http://{proxy_ip}',
+                            # This should be removed eventually, but will break apps calling apps on older versions
+                            'BIOLIB_CLOUD_RESULTS_BASE_URL': f'http://{proxy_ip}',
+                            'BIOLIB_CLOUD_JOB_STORAGE_BASE_URL': f'http://{proxy_ip}',
+                            # Inform container if we are targeting public biolib as we change the BIOLIB_BASE_URL
+                            'BIOLIB_ENVIRONMENT_IS_PUBLIC_BIOLIB': bool(utils.BASE_URL_IS_PUBLIC_BIOLIB),
+                        }
+                    )
                 else:
                     extra_hosts[proxy.hostname] = proxy_ip
 
+            logger_no_user_data.debug(f'Job "{job_uuid}" initializing Docker container. Constructing container args...')
             create_container_args = {
                 'environment': environment_vars,
                 'extra_hosts': extra_hosts,
@@ -325,45 +347,38 @@ class DockerExecutor:
 
             if self._options['job'].get('arguments_override_command'):
                 # In this case, arguments contains a user specified command to run in the app
-                create_container_args.update({
-                    'command': module_input['arguments'],
-                    'entrypoint': ''
-                })
+                create_container_args.update({'command': module_input['arguments'], 'entrypoint': ''})
 
             else:
-                create_container_args.update({
-                    'command': shlex.split(module['command']) + module_input['arguments']
-                })
+                create_container_args.update({'command': shlex.split(module['command']) + module_input['arguments']})
 
             app_version = self._options['job']['app_version']
             if app_version.get('main_output_file') or app_version.get('stdout_render_type') == 'text':
                 create_container_args['tty'] = True
 
             if utils.IS_RUNNING_IN_CLOUD:
-                cloud_job = self._options["cloud_job"]
+                cloud_job = self._options['cloud_job']
                 create_container_args['mem_limit'] = f'{cloud_job["reserved_memory_in_bytes"]}b'
-                create_container_args['nano_cpus'] = cloud_job["reserved_cpu_in_nano_shares"]
+                create_container_args['nano_cpus'] = cloud_job['reserved_cpu_in_nano_shares']
+                create_container_args['pids_limit'] = 10_000
 
                 biolib_identity_user_email: Optional[str] = cloud_job.get('biolib_identity_user_email')
                 if biolib_identity_user_email:
-                    create_container_args['environment'].update({
-                        'BIOLIB_IDENTITY_USER_EMAIL': biolib_identity_user_email
-                    })
+                    create_container_args['environment'].update(
+                        {'BIOLIB_IDENTITY_USER_EMAIL': biolib_identity_user_email}
+                    )
 
             docker_runtime = os.getenv('BIOLIB_DOCKER_RUNTIME')
             if docker_runtime is not None:
                 create_container_args['runtime'] = docker_runtime
 
-            self._docker_container = BiolibDockerClient.get_docker_client().containers.create(
-                **create_container_args
-            )
-
-            logger_no_user_data.debug('Finished initializing docker container')
+            docker_client = BiolibDockerClient.get_docker_client()
+            logger_no_user_data.debug(f'Job "{job_uuid}" initializing Docker container. Creating container...')
+            self._docker_container = docker_client.containers.create(**create_container_args)
+            logger_no_user_data.debug(f'Job "{job_uuid}" finished initializing Docker container.')
         except Exception as exception:
             raise ComputeProcessException(
-                exception,
-                SystemExceptionCodes.FAILED_TO_START_COMPUTE_CONTAINER.value,
-                self._send_system_exception
+                exception, SystemExceptionCodes.FAILED_TO_START_COMPUTE_CONTAINER.value, self._send_system_exception
             ) from exception
 
     def _add_file_to_tar(self, tar, current_path, mapped_path, data):
@@ -430,7 +445,7 @@ class DockerExecutor:
             raise ComputeProcessException(
                 exception,
                 SystemExceptionCodes.FAILED_TO_COPY_INPUT_FILES_TO_COMPUTE_CONTAINER.value,
-                self._send_system_exception
+                self._send_system_exception,
             ) from exception
 
     def _map_and_copy_runtime_files_to_container(self, runtime_zip_data, arguments: List[str], remove_root_folder=True):
@@ -445,17 +460,17 @@ class DockerExecutor:
             raise ComputeProcessException(
                 exception,
                 SystemExceptionCodes.FAILED_TO_COPY_RUNTIME_FILES_TO_COMPUTE_CONTAINER.value,
-                self._send_system_exception
+                self._send_system_exception,
             ) from exception
 
     def _write_module_output_to_file(
-            self,
-            arguments: List[str],
-            exit_code: int,
-            module_output_path: str,
-            stderr: bytes,
-            stdout: bytes,
-            pre_start_diff: List[Dict],
+        self,
+        arguments: List[str],
+        exit_code: int,
+        module_output_path: str,
+        stderr: bytes,
+        stdout: bytes,
+        pre_start_diff: List[Dict],
     ) -> None:
         mapped_files: List[FileInContainer] = []
         try:
@@ -500,9 +515,11 @@ class DockerExecutor:
             result = subprocess.run(
                 args=[
                     'ctr',
-                    '--namespace', 'moby',
+                    '--namespace',
+                    'moby',
                     'snapshots',
-                    '--snapshotter', 'nydus',
+                    '--snapshotter',
+                    'nydus',
                     'mounts',
                     '/some_arbitrary_path',
                     str(self._container.id),
@@ -524,9 +541,10 @@ class DockerExecutor:
         pre_start_diff_paths = [obj['Path'] for obj in pre_start_diff]
         post_run_diff = self._container.diff()
         run_diff_paths: List[str] = [
-            obj['Path'] for obj in post_run_diff if
-            obj['Kind'] in (DockerDiffKind.CHANGED.value, DockerDiffKind.ADDED.value) and
-            obj['Path'] not in pre_start_diff_paths
+            obj['Path']
+            for obj in post_run_diff
+            if obj['Kind'] in (DockerDiffKind.CHANGED.value, DockerDiffKind.ADDED.value)
+            and obj['Path'] not in pre_start_diff_paths
         ]
 
         known_directories = set()
@@ -536,7 +554,7 @@ class DockerExecutor:
                 if idx == 0:
                     continue  # always skip root
 
-                folder = '/' + '/'.join(parent_folders[1:idx + 1])
+                folder = '/' + '/'.join(parent_folders[1 : idx + 1])
                 known_directories.add(folder)
 
         def path_is_included_in_from_mappings(path: str) -> bool:
@@ -556,11 +574,13 @@ class DockerExecutor:
         files_and_empty_dirs: List[FileInContainer] = []
         for path in run_diff_paths:
             if path not in known_directories and path_is_included_in_from_mappings(path):
-                files_and_empty_dirs.append(FileInContainer(
-                    container=self._container,
-                    overlay_upper_dir_path=overlay_upper_dir_path,
-                    path_in_container=path,
-                ))
+                files_and_empty_dirs.append(
+                    FileInContainer(
+                        container=self._container,
+                        overlay_upper_dir_path=overlay_upper_dir_path,
+                        path_in_container=path,
+                    )
+                )
 
         return files_and_empty_dirs
 

biolib/compute_node/job_worker/job_storage.py

@@ -10,6 +10,7 @@ from biolib.utils.multipart_uploader import get_chunk_iterator_from_file_object
 
 
 class JobStorage:
+    module_input_file_name = 'input-output.bbf'
     module_output_file_name = 'module-output.bbf'
 
     @staticmethod
@@ -81,7 +82,7 @@ class JobStorage:
         )
 
     @staticmethod
-    def get_module_input(job: CreatedJobDict) -> bytes:
+    def download_module_input(job: CreatedJobDict, path: str):
         job_uuid = job['public_id']
         logger_no_user_data.debug(f'Job "{job_uuid}" downloading module input...')
         presigned_download_url = BiolibJobApi.get_job_storage_download_url(
@@ -89,7 +90,5 @@ class JobStorage:
             job_auth_token=job['auth_token'],
             storage_type='input',
         )
-        response = HttpClient.request(url=presigned_download_url)
-        data: bytes = response.content
+        HttpClient.request(url=presigned_download_url, response_path=path)
         logger_no_user_data.debug(f'Job "{job_uuid}" module input downloaded')
-        return data