pybiolib 1.1.1629__py3-none-any.whl → 1.1.1881__py3-none-any.whl

biolib/lfs/utils.py

@@ -1,31 +1,15 @@
 import io
-import json
 import os
 import zipfile as zf
-from collections import namedtuple
 from pathlib import Path
-from struct import Struct
 
-import requests
-
-from biolib import utils
-from biolib.app import BioLibApp
-from biolib.biolib_api_client.biolib_account_api import BiolibAccountApi
-from biolib.biolib_api_client.biolib_large_file_system_api import BiolibLargeFileSystemApi
+from biolib import utils, api
 from biolib.biolib_api_client import BiolibApiClient
+from biolib.biolib_api_client.lfs_types import LargeFileSystem, LargeFileSystemVersion
 from biolib.biolib_logging import logger
 from biolib.biolib_errors import BioLibError
 from biolib.typing_utils import List, Tuple, Iterator, Optional
-from biolib.utils.zip.remote_zip import RemoteZip  # type:ignore
-
-
-def _get_lfs_info_from_uri(lfs_uri):
-    lfs_uri_parts = lfs_uri.split('/')
-    lfs_uri_parts = [uri_part for uri_part in lfs_uri_parts if '@' not in uri_part]  # Remove hostname
-    team_account_handle = lfs_uri_parts[0]
-    lfs_name = lfs_uri_parts[1]
-    account = BiolibAccountApi.fetch_by_handle(team_account_handle)
-    return account, lfs_name
+from biolib.utils.app_uri import parse_app_uri
 
 
 def get_files_and_size_of_directory(directory: str) -> Tuple[List[str], int]:
@@ -99,14 +83,23 @@ def get_iterable_zip_stream(files: List[str], chunk_size: int) -> Iterator[bytes
         yield chunk
 
 
-def create_large_file_system(lfs_uri: str):
+def create_large_file_system(lfs_uri: str) -> str:
     BiolibApiClient.assert_is_signed_in(authenticated_action_description='create a Large File System')
-    lfs_account, lfs_name = _get_lfs_info_from_uri(lfs_uri)
-    lfs_resource = BiolibLargeFileSystemApi.create(account_uuid=lfs_account['public_id'], name=lfs_name)
-    logger.info(f"Successfully created new Large File System '{lfs_resource['uri']}'")
 
+    uri_parsed = parse_app_uri(lfs_uri)
+    response = api.client.post(
+        path='/lfs/',
+        data={
+            'account_handle': uri_parsed['account_handle_normalized'],
+            'name': uri_parsed['app_name'],
+        },
+    )
+    lfs: LargeFileSystem = response.json()
+    logger.info(f"Successfully created new Large File System '{lfs['uri']}'")
+    return lfs['uri']
 
-def push_large_file_system(lfs_uri: str, input_dir: str, chunk_size_in_mb: Optional[int] = None) -> None:
+
+def push_large_file_system(lfs_uri: str, input_dir: str, chunk_size_in_mb: Optional[int] = None) -> str:
     BiolibApiClient.assert_is_signed_in(authenticated_action_description='push data to a Large File System')
 
     if not os.path.isdir(input_dir):
@@ -115,8 +108,6 @@ def push_large_file_system(lfs_uri: str, input_dir: str, chunk_size_in_mb: Optio
     if os.path.realpath(input_dir) == '/':
         raise BioLibError('Pushing your root directory is not possible')
 
-    lfs_resource = BioLibApp(lfs_uri)
-
     original_working_dir = os.getcwd()
     os.chdir(input_dir)
     files_to_zip, data_size_in_bytes = get_files_and_size_of_directory(directory=os.getcwd())
@@ -138,108 +129,25 @@ def push_large_file_system(lfs_uri: str, input_dir: str, chunk_size_in_mb: Optio
     data_size_in_mb = round(data_size_in_bytes / 10 ** 6)
     print(f'Zipping {len(files_to_zip)} files, in total ~{data_size_in_mb}mb of data')
 
-    lfs_resource_version = BiolibLargeFileSystemApi.create_version(resource_uuid=lfs_resource.uuid)
-    lfs_resource_version_uuid = lfs_resource_version['uuid']
-
+    response = api.client.post(path='/lfs/versions/', data={'resource_uri': lfs_uri})
+    lfs_version: LargeFileSystemVersion = response.json()
     iterable_zip_stream = get_iterable_zip_stream(files=files_to_zip, chunk_size=chunk_size_in_bytes)
 
-    base_url = BiolibApiClient.get().base_url
     multipart_uploader = utils.MultiPartUploader(
         use_process_pool=True,
         get_presigned_upload_url_request=dict(
             headers=None,
             requires_biolib_auth=True,
-            url=f'{base_url}/api/lfs/versions/{lfs_resource_version_uuid}/presigned_upload_url/',
+            path=f"/lfs/versions/{lfs_version['uuid']}/presigned_upload_url/",
         ),
         complete_upload_request=dict(
             headers=None,
             requires_biolib_auth=True,
-            url=f'{base_url}/api/lfs/versions/{lfs_resource_version_uuid}/complete_upload/',
+            path=f"/lfs/versions/{lfs_version['uuid']}/complete_upload/",
         ),
     )
 
     multipart_uploader.upload(payload_iterator=iterable_zip_stream, payload_size_in_bytes=data_size_in_bytes)
-    logger.info(f"Successfully pushed a new LFS version '{lfs_resource_version['uri']}'")
     os.chdir(original_working_dir)
-
-
-def describe_large_file_system(lfs_uri: str, output_as_json: bool = False) -> None:
-    BiolibApiClient.assert_is_signed_in(authenticated_action_description='describe a Large File System')
-    lfs_resource = BioLibApp(lfs_uri)
-    lfs_version = BiolibLargeFileSystemApi.fetch_version(lfs_version_uuid=lfs_resource.version['public_id'])
-
-    files = []
-    total_size = 0
-    with RemoteZip(url=lfs_version['presigned_download_url']) as remote_zip:
-        central_directory = remote_zip.get_central_directory()
-        for file in central_directory.values():
-            files.append(dict(path=file['filename'], size_bytes=file['file_size']))
-            total_size += file['file_size']
-
-    lfs_version_metadata = dict(files=files, **lfs_version)
-    lfs_version_metadata['size_bytes'] = total_size
-
-    if output_as_json:
-        print(json.dumps(lfs_version_metadata, indent=4))
-    else:
-        print(f"Large File System {lfs_version_metadata['uri']}\ntotal {lfs_version_metadata['size_bytes']} bytes\n")
-        print('size bytes    path')
-        for file in files:
-            size_string = str(file['size_bytes'])
-            leading_space_string = ' ' * (10 - len(size_string))
-            print(f"{leading_space_string}{size_string}    {file['path']}")
-
-
-def get_file_data_from_large_file_system(lfs_uri: str, file_path: str) -> bytes:
-    BiolibApiClient.assert_is_signed_in(authenticated_action_description='get file from a Large File System')
-    lfs_resource = BioLibApp(lfs_uri)
-    lfs_version = BiolibLargeFileSystemApi.fetch_version(lfs_version_uuid=lfs_resource.version['public_id'])
-    lfs_url = lfs_version['presigned_download_url']
-
-    with RemoteZip(lfs_url) as remote_zip:
-        central_directory = remote_zip.get_central_directory()
-        if file_path not in central_directory:
-            raise Exception('File not found in Large File System')
-
-        file_info = central_directory[file_path]
-
-        local_file_header_signature_bytes = b'\x50\x4b\x03\x04'
-        local_file_header_struct = Struct('<H2sHHHIIIHH')
-        LocalFileHeader = namedtuple('LocalFileHeader', (
-            'version',
-            'flags',
-            'compression_raw',
-            'mod_time',
-            'mod_date',
-            'crc_32_expected',
-            'compressed_size_raw',
-            'uncompressed_size_raw',
-            'file_name_len',
-            'extra_field_len',
-        ))
-
-        local_file_header_start = file_info['header_offset'] + len(local_file_header_signature_bytes)
-        local_file_header_end = local_file_header_start + local_file_header_struct.size
-
-        local_file_header_response = requests.get(
-            url=lfs_url,
-            stream=True,
-            headers={'range': f'bytes={local_file_header_start}-{local_file_header_end - 1}'},
-            timeout=300,
-        )
-        local_file_header_response.raise_for_status()
-        local_file_header_bytes: bytes = local_file_header_response.raw.data
-        local_file_header = LocalFileHeader._make(local_file_header_struct.unpack(local_file_header_bytes))
-
-        file_start = local_file_header_end + local_file_header.file_name_len + local_file_header.extra_field_len
-        file_end = file_start + file_info['file_size']
-
-        response = requests.get(
-            url=lfs_url,
-            stream=True,
-            headers={'range': f'bytes={file_start}-{file_end - 1}'},
-            timeout=300,  # timeout after 5 min
-        )
-        response.raise_for_status()
-        data: bytes = response.raw.data
-        return data
+    logger.info(f"Successfully pushed a new LFS version '{lfs_version['uri']}'")
+    return lfs_version['uri']

biolib/runtime/__init__.py

@@ -1 +1,13 @@
-from .results import set_main_result_prefix
+import warnings
+from biolib.sdk import Runtime as _Runtime
+
+
+def set_main_result_prefix(result_prefix: str) -> None:
+    warnings.warn(
+        'The "biolib.runtime.set_main_result_prefix" function is deprecated. '
+        'It will be removed in future releases from mid 2024. '
+        'Please use "from biolib.sdk import Runtime" and then "Runtime.set_main_result_prefix" instead.',
+        DeprecationWarning,
+        stacklevel=2,
+    )
+    _Runtime.set_main_result_prefix(result_prefix)

biolib/sdk/__init__.py

@@ -1,24 +1,33 @@
+# Imports to hide and use as private internal utils
+from biolib._internal.data_record import DataRecord as _DataRecord
 from biolib._internal.push_application import push_application as _push_application
 from biolib._internal.push_application import set_app_version_as_active as _set_app_version_as_active
-
 from biolib.app import BioLibApp as _BioLibApp
+from biolib.typing_utils import Optional as _Optional
+
+# Imports to expose as public API
+from biolib._internal.runtime import Runtime
+
 
 def push_app_version(uri: str, path: str) -> _BioLibApp:
     push_data = _push_application(
         app_uri=uri,
         app_path=path,
         app_version_to_copy_images_from=None,
-        is_dev_version=True)
+        is_dev_version=True,
+    )
     uri = f'{push_data["app_uri"]}:{push_data["sematic_version"]}'
     return _BioLibApp(uri)
 
+
 def set_app_version_as_default(app_version: _BioLibApp) -> None:
     app_version_uuid = app_version.version['public_id']
     _set_app_version_as_active(app_version_uuid)
 
+
 def get_app_version_pytest_plugin(app_version: _BioLibApp):
     try:
-        import pytest # type: ignore # pylint: disable=import-outside-toplevel,import-error
+        import pytest  # type: ignore # pylint: disable=import-outside-toplevel,import-error
     except BaseException:
         raise Exception('Failed to import pytest; please make sure it is installed') from None
 
@@ -27,7 +36,11 @@ def get_app_version_pytest_plugin(app_version: _BioLibApp):
             self.app_version_ref = app_version_ref
 
         @pytest.fixture(scope='session')
-        def app_version(self, request): # pylint: disable=unused-argument
+        def app_version(self, request):  # pylint: disable=unused-argument
             return self.app_version_ref
 
     return AppVersionFixturePlugin(app_version)
+
+
+def create_data_record(destination: str, data_path: str, name: _Optional[str] = None) -> _DataRecord:
+    return _DataRecord.create(destination, data_path, name)

biolib/user/sign_in.py

@@ -1,19 +1,11 @@
 import time
-import uuid
+import webbrowser
 
 from biolib.biolib_api_client import BiolibApiClient
 from biolib.biolib_api_client.auth import BiolibAuthChallengeApi
 from biolib.biolib_logging import logger_no_user_data
 from biolib.utils import IS_RUNNING_IN_NOTEBOOK
-
-
-def _open_browser_window(url_to_open: str) -> None:
-    from IPython.display import display, Javascript, update_display  # type:ignore # pylint: disable=import-error, import-outside-toplevel
-
-    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)
+from biolib._internal.utils import open_browser_window_from_notebook
 
 
 def sign_out() -> None:
@@ -21,7 +13,7 @@ def sign_out() -> None:
     api_client.sign_out()
 
 
-def sign_in() -> None:
+def sign_in(open_in_default_browser: bool = False) -> None:
     api_client = BiolibApiClient.get()
     if api_client.is_signed_in:
         logger_no_user_data.info('Already signed in')
@@ -37,7 +29,11 @@ def sign_in() -> None:
     if IS_RUNNING_IN_NOTEBOOK:
         print(f'Opening authorization page at: {frontend_sign_in_url}')
         print('If your browser does not open automatically, click on the link above.')
-        _open_browser_window(frontend_sign_in_url)
+        open_browser_window_from_notebook(frontend_sign_in_url)
+    elif open_in_default_browser:
+        print(f'Opening authorization page at: {frontend_sign_in_url}')
+        print('If your browser does not open automatically, click on the link above.')
+        webbrowser.open(frontend_sign_in_url)
     else:
         print('Please copy and paste the following link into your browser:')
         print(frontend_sign_in_url)

biolib/utils/__init__.py

@@ -1,22 +1,19 @@
 import collections.abc
 import multiprocessing
 import os
-import time
 import socket
 import sys
-from urllib.parse import urlparse
 
-import requests
 from importlib_metadata import version, PackageNotFoundError
 
+from biolib.typing_utils import Optional
 from biolib.utils.seq_util import SeqUtil, SeqUtilRecord
-
-# try fetching version, if it fails (usually when in dev), add default
-from biolib.biolib_errors import BioLibError
+from biolib._internal.http_client import HttpClient
 from biolib.biolib_logging import logger_no_user_data, logger
 from biolib.typing_utils import Tuple, Iterator
 from .multipart_uploader import MultiPartUploader, get_chunk_iterator_from_bytes
 
+# try fetching version, if it fails (usually when in dev), add default
 try:
     BIOLIB_PACKAGE_VERSION = version('pybiolib')
 except PackageNotFoundError:
@@ -25,7 +22,7 @@ except PackageNotFoundError:
 IS_DEV = os.getenv('BIOLIB_DEV', '').upper() == 'TRUE'
 
 
-def _get_base_url() -> str:
+def load_base_url_from_env() -> str:
     base_url = os.getenv('BIOLIB_BASE_URL')
     if base_url:
         return base_url.lower().rstrip('/')
@@ -53,8 +50,8 @@ def _get_base_url() -> str:
     return 'https://biolib.com'
 
 
-BIOLIB_BASE_URL = _get_base_url()
-BIOLIB_SITE_HOSTNAME = urlparse(BIOLIB_BASE_URL).hostname
+BIOLIB_BASE_URL: Optional[str] = None
+BIOLIB_SITE_HOSTNAME: Optional[str] = None
 
 BIOLIB_CLOUD_BASE_URL = os.getenv('BIOLIB_CLOUD_BASE_URL', '').lower()
 
@@ -66,8 +63,7 @@ BIOLIB_SECRETS_TMPFS_PATH = os.environ.get('BIOLIB_SECRETS_TMPFS_PATH')
 
 IS_RUNNING_IN_CLOUD = BIOLIB_CLOUD_ENVIRONMENT == 'non-enclave'
 
-BASE_URL_IS_PUBLIC_BIOLIB = BIOLIB_BASE_URL.endswith('biolib.com') or \
-                            os.environ.get('BIOLIB_ENVIRONMENT_IS_PUBLIC_BIOLIB', '').upper() == 'TRUE'
+BASE_URL_IS_PUBLIC_BIOLIB: Optional[bool] = None
 
 # sys.stdout is an instance of OutStream in Jupyter and Colab which does not have .buffer
 if not hasattr(sys.stdout, 'buffer'):
@@ -88,38 +84,17 @@ DownloadChunkInputTuple = Tuple[ByteRangeTuple, str]
 
 
 def _download_chunk(input_tuple: DownloadChunkInputTuple) -> bytes:
-    max_download_retries = 10
-
     byte_range, presigned_url = input_tuple
     start, end = byte_range
 
-    for retry_attempt in range(max_download_retries):
-        if retry_attempt > 0:
-            logger_no_user_data.debug(f'Attempt number {retry_attempt} for part {start}')
-        try:
-            response = requests.get(
-                url=presigned_url,
-                stream=True,
-                headers={'range': f'bytes={start}-{end}'},
-                timeout=300,  # timeout after 5 min
-            )
-            if response.ok:
-                return_value: bytes = response.raw.data
-                logger_no_user_data.debug(f'Returning raw data for part {start}')
-                return return_value
-            else:
-                logger_no_user_data.warning(
-                    f'Got not ok response when downloading part {start}:{end}. '
-                    f'Got response status {response.status_code} and content: {response.content.decode()} '
-                    f'Retrying...'
-                )
-        except Exception:  # pylint: disable=broad-except
-            logger_no_user_data.warning(f'Encountered error when downloading part {start}:{end}. Retrying...')
-
-        time.sleep(5)
-
-    logger_no_user_data.debug(f'Max retries hit, when downloading part {start}:{end}. Exiting...')
-    raise BioLibError(f'Max retries hit, when downloading part {start}:{end}. Exiting...')
+    response = HttpClient.request(
+        url=presigned_url,
+        headers={'range': f'bytes={start}-{end}'},
+        timeout_in_seconds=300,  # timeout after 5 min
+        retries=10,
+    )
+    logger_no_user_data.debug(f'Returning raw data for part {start}')
+    return response.content
 
 
 class ChunkIterator(collections.abc.Iterator):
@@ -154,11 +129,8 @@ class ChunkIterator(collections.abc.Iterator):
 def download_presigned_s3_url(presigned_url: str, output_file_path: str) -> None:
     chunk_size = 50_000_000
 
-    with requests.get(presigned_url, stream=True, headers={'range': 'bytes=0-1'}) as response:
-        if not response.ok:
-            raise Exception(f'Got response status code {response.status_code} and content {response.content.decode()}')
-
-        file_size = int(response.headers['Content-Range'].split('/')[1])
+    response = HttpClient.request(url=presigned_url, headers={'range': 'bytes=0-1'})
+    file_size = int(response.headers['Content-Range'].split('/')[1])
 
     chunk_iterator = ChunkIterator(file_size, chunk_size, presigned_url)
 

biolib/utils/app_uri.py

@@ -12,17 +12,18 @@ class SemanticVersion(TypedDict):
 
 class AppUriParsed(TypedDict):
     account_handle_normalized: str
-    app_name_normalized: str
+    app_name_normalized: Optional[str]
+    app_name: Optional[str]
     resource_name_prefix: Optional[str]
     version: Optional[SemanticVersion]
 
 
-def normalize(string):
+def normalize(string: str) -> str:
     return string.replace('-', '_').lower()
 
 
 # Mainly copied from backend
-def parse_app_uri(uri: str) -> AppUriParsed:
+def parse_app_uri(uri: str, use_account_as_name_default: bool = True) -> AppUriParsed:
     uri_regex = r'^(@(?P<resource_name_prefix>[\w._-]+)/)?(?P<account_handle>[\w-]+)(/(?P<app_name>[\w-]+))?' \
                 r'(:(?P<version>(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)))?$'
 
@@ -36,12 +37,18 @@ def parse_app_uri(uri: str) -> AppUriParsed:
     app_name: Optional[str] = matches.group('app_name')
 
     # Default to account_handle if app_name is not supplied
-    app_name_normalized = normalize(app_name) if app_name is not None else account_handle_normalized
+    if app_name:
+        app_name_normalized = normalize(app_name)
+    elif use_account_as_name_default:
+        app_name_normalized = account_handle_normalized
+    else:
+        app_name_normalized = None
 
     return AppUriParsed(
         resource_name_prefix=resource_name_prefix.lower() if resource_name_prefix is not None else 'biolib.com',
         account_handle_normalized=account_handle_normalized,
         app_name_normalized=app_name_normalized,
+        app_name=app_name if app_name is not None or not use_account_as_name_default else account_handle_normalized,
         version=None if not matches.group('version') else SemanticVersion(
             major=int(matches.group('major')),
             minor=int(matches.group('minor')),

biolib/utils/cache_state.py

@@ -10,7 +10,7 @@ from biolib.biolib_errors import BioLibError
 from biolib.biolib_logging import logger_no_user_data
 from biolib.typing_utils import Optional, Generic, TypeVar
 
-StateType = TypeVar('StateType')
+StateType = TypeVar('StateType')  # pylint: disable=invalid-name
 
 
 class CacheStateError(BioLibError):
@@ -37,7 +37,7 @@ class CacheState(abc.ABC, Generic[StateType]):
     def _state_lock_path(self) -> str:
         return f'{self._state_path}.lock'
 
-    def __init__(self):
+    def __init__(self) -> None:
         self._state: Optional[StateType] = None
 
     def __enter__(self) -> StateType:

biolib/utils/multipart_uploader.py

@@ -5,10 +5,9 @@ import os
 import time
 from urllib.parse import urlparse
 
-import requests
-
+import biolib.api
+from biolib._internal.http_client import HttpClient
 from biolib.biolib_api_client import BiolibApiClient
-from biolib.biolib_api_client.auth import BearerAuth
 from biolib.biolib_errors import BioLibError
 from biolib.biolib_logging import logger, logger_no_user_data
 from biolib.typing_utils import TypedDict, List, Iterator, Tuple, Optional, Dict
@@ -33,7 +32,7 @@ def get_chunk_iterator_from_file_object(file_object, chunk_size_in_bytes: int =
 class RequestOptions(TypedDict):
     headers: Optional[Dict[str, str]]
     requires_biolib_auth: bool
-    url: str
+    path: str
 
 
 class _PartMetadata(TypedDict):
@@ -67,20 +66,15 @@ class MultiPartUploader:
         logger_no_user_data.debug(f'Starting multipart upload of payload with size {payload_size_in_bytes} bytes')
 
         if self._start_multipart_upload_request:
-            requires_biolib_auth = self._start_multipart_upload_request['requires_biolib_auth']
-            start_multipart_upload = requests.post(
-                auth=BearerAuth(BiolibApiClient.get().access_token) if requires_biolib_auth else None,
-                headers=self._start_multipart_upload_request['headers'],
-                timeout=30,
-                url=self._start_multipart_upload_request['url'],
-            )
-            if start_multipart_upload.ok:
-                logger_no_user_data.debug('Multipart upload started')
-            else:
-                logger_no_user_data.debug(
-                    f'Failed to start multipart upload got response status: {start_multipart_upload.status_code}'
+            try:
+                biolib.api.client.post(
+                    authenticate=self._start_multipart_upload_request['requires_biolib_auth'],
+                    headers=self._start_multipart_upload_request['headers'],
+                    path=self._start_multipart_upload_request['path'],
                 )
-                raise Exception('Failed to start multipart upload')
+            except BaseException as error:
+                logger_no_user_data.debug(f'Failed to start multipart upload got error: {error}')
+                raise error
 
         # if multiprocessing start method is spawn or we are running in a daemon process,
         # multiprocessing.Pool may fail when called from script
@@ -116,30 +110,12 @@ class MultiPartUploader:
             BiolibApiClient.refresh_auth_token()
 
         logger_no_user_data.debug(f'Uploaded {len(parts)} parts, now calling complete upload...')
-        for index in range(3):
-            try:
-                complete_upload_response = requests.post(
-                    auth=BearerAuth(BiolibApiClient.get().access_token) if requires_biolib_auth else None,
-                    headers=self._complete_upload_request['headers'],
-                    json={'parts': parts, 'size_bytes': self._bytes_uploaded},
-                    timeout=30,
-                    url=self._complete_upload_request['url'],
-                )
-                if complete_upload_response.ok:
-                    logger_no_user_data.debug('Multipart upload completed returning')
-                    return
-
-                logger_no_user_data.warning(
-                    f'Failed to complete multipart upload got response status {complete_upload_response.status_code}. '
-                    f'Retrying...'
-                )
-
-            except Exception as error:  # pylint: disable=broad-except
-                logger_no_user_data.warning('Encountered error when completing multipart upload. Retrying...')
-                logger.debug(f'Multipart complete error: {error}')
-                time.sleep(index * index + 2)
-
-        raise BioLibError('Max retries hit, when completing multipart upload')
+        biolib.api.client.post(
+            authenticate=requires_biolib_auth,
+            headers=self._complete_upload_request['headers'],
+            data={'parts': parts, 'size_bytes': self._bytes_uploaded},
+            path=self._complete_upload_request['path'],
+        )
 
     def _upload_chunk(self, _input: _UploadChunkInputType) -> _UploadChunkReturnType:
         part_number, chunk = _input
@@ -150,44 +126,42 @@ class MultiPartUploader:
                 BiolibApiClient.refresh_auth_token()
 
             logger_no_user_data.debug(f'Uploading part number {part_number} with size {len(chunk)} bytes...')
+            presigned_upload_url = None
             try:
                 logger_no_user_data.debug(f'Getting upload URL for chunk {part_number}...')
-                get_url_response = requests.get(
-                    auth=BearerAuth(BiolibApiClient.get().access_token) if requires_biolib_auth else None,
+                get_url_response = biolib.api.client.get(
+                    authenticate=requires_biolib_auth,
                     headers=self._get_presigned_upload_url_request['headers'],
                     params={'part_number': part_number},
-                    timeout=30,
-                    url=self._get_presigned_upload_url_request['url'],
+                    path=self._get_presigned_upload_url_request['path'],
                 )
-                if not get_url_response.ok:
-                    raise Exception(
-                        f'Failed to get upload URL for part {part_number} got response status code '
-                        f'{get_url_response.status_code}'
-                    )
 
                 presigned_upload_url = get_url_response.json()['presigned_upload_url']
 
-                app_caller_proxy_job_storage_base_url = os.getenv('BIOLIB_CLOUD_JOB_STORAGE_BASE_URL', '')
-                if app_caller_proxy_job_storage_base_url:
-                    # Done to hit App Caller Proxy when uploading result from inside an app
-                    parsed_url = urlparse(presigned_upload_url)
-                    presigned_upload_url = \
-                        f'{app_caller_proxy_job_storage_base_url}{parsed_url.path}?{parsed_url.query}'
-
-                put_chunk_response = requests.put(url=presigned_upload_url, data=chunk, timeout=300)
+            except Exception as error:  # pylint: disable=broad-except
+                logger_no_user_data.warning(f'Error when getting url for part {part_number}. Retrying...')
+                logger.debug(f'Upload error: {error}')
 
-                if put_chunk_response.ok:
-                    return _PartMetadata(PartNumber=part_number, ETag=put_chunk_response.headers['ETag']), len(chunk)
-                else:
-                    logger_no_user_data.warning(
-                        f'Got response with status {put_chunk_response.status_code} when uploading part {part_number}. '
-                        'Retrying...'
+            if presigned_upload_url:
+                try:
+                    app_caller_proxy_job_storage_base_url = os.getenv('BIOLIB_CLOUD_JOB_STORAGE_BASE_URL', '')
+                    if app_caller_proxy_job_storage_base_url:
+                        # Done to hit App Caller Proxy when uploading result from inside an app
+                        parsed_url = urlparse(presigned_upload_url)
+                        presigned_upload_url = \
+                            f'{app_caller_proxy_job_storage_base_url}{parsed_url.path}?{parsed_url.query}'
+
+                    put_chunk_response = HttpClient.request(
+                        url=presigned_upload_url,
+                        data=chunk,
+                        method='PUT',
+                        timeout_in_seconds=300,
                     )
-                    logger.debug(f'Response content: {put_chunk_response.content.decode()}')
+                    return _PartMetadata(PartNumber=part_number, ETag=put_chunk_response.headers['ETag']), len(chunk)
 
-            except Exception as error:  # pylint: disable=broad-except
-                logger_no_user_data.warning(f'Encountered error when uploading part {part_number}. Retrying...')
-                logger.debug(f'Upload error: {error}')
+                except Exception as error:  # pylint: disable=broad-except
+                    logger_no_user_data.warning(f'Encountered error when uploading part {part_number}. Retrying...')
+                    logger.debug(f'Upload error: {error} ({presigned_upload_url})')
 
             time.sleep(index * index + 2)