pybiolib 1.2.576__tar.gz → 1.2.582__tar.gz

{pybiolib-1.2.576 → pybiolib-1.2.582}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: pybiolib
-Version: 1.2.576
+Version: 1.2.582
 Summary: BioLib Python Client
 License: MIT
 Keywords: biolib

pybiolib-1.2.582/biolib/_session/session.py

@@ -0,0 +1,39 @@
+from biolib import utils
+from biolib._internal.types import Optional
+from biolib.api.client import ApiClient, ApiClientInitDict
+from biolib.app import BioLibApp
+
+
+class Session:
+    def __init__(self, _init_dict: ApiClientInitDict) -> None:
+        self._api = ApiClient(_init_dict=_init_dict)
+
+    @staticmethod
+    def get_session(refresh_token: str, base_url: Optional[str] = None) -> 'Session':
+        return Session(
+            _init_dict=ApiClientInitDict(
+                refresh_token=refresh_token,
+                base_url=base_url or utils.load_base_url_from_env(),
+            )
+        )
+
+    def load(self, uri: str) -> BioLibApp:
+        r"""Load a BioLib application by its URI or website URL.
+
+        Args:
+            uri (str): The URI or website URL of the application to load. Can be either:
+                - App URI (e.g., 'biolib/myapp:1.0.0')
+                - Website URL (e.g., 'https://biolib.com/biolib/myapp/')
+
+        Returns:
+            BioLibApp: The loaded application object
+
+        Example::
+
+            >>> # Load by URI
+            >>> app = biolib.load('biolib/myapp:1.0.0')
+            >>> # Load by website URL
+            >>> app = biolib.load('https://biolib.com/biolib/myapp/')
+            >>> result = app.cli('--help')
+        """
+        return BioLibApp(uri=uri, _api_client=self._api)

pybiolib-1.2.582/biolib/api/client.py

@@ -0,0 +1,207 @@
+import base64
+import binascii
+import json
+from datetime import datetime, timezone
+from json.decoder import JSONDecodeError
+from urllib.parse import urlencode, urljoin
+
+import importlib_metadata
+
+from biolib._internal.http_client import HttpClient, HttpResponse
+from biolib._internal.types.typing import Any, Dict, Optional, TypedDict, Union, cast
+from biolib.biolib_api_client import BiolibApiClient as DeprecatedApiClient
+from biolib.biolib_errors import BioLibError
+from biolib.biolib_logging import logger
+
+OptionalHeaders = Union[
+    Optional[Dict[str, str]],
+    Optional[Dict[str, Union[str, None]]],
+]
+
+
+def _get_biolib_package_version() -> str:
+    # try fetching version, if it fails (usually when in dev), add default
+    try:
+        return cast(str, importlib_metadata.version('pybiolib'))
+    except importlib_metadata.PackageNotFoundError:
+        return '0.0.0'
+
+
+class ApiClientInitDict(TypedDict):
+    refresh_token: str
+    base_url: str
+
+
+class JwtDecodeError(Exception):
+    pass
+
+
+class ApiClient(HttpClient):
+    _biolib_package_version: str = _get_biolib_package_version()
+
+    def __init__(self, _init_dict: Optional[ApiClientInitDict] = None) -> None:
+        self._access_token: Optional[str] = None
+        self._refresh_token: Optional[str] = _init_dict['refresh_token'] if _init_dict else None
+        self._base_url: Optional[str] = _init_dict['base_url'] if _init_dict else None
+
+    def get(
+        self,
+        path: str,
+        params: Optional[Dict[str, Union[str, int]]] = None,
+        headers: OptionalHeaders = None,
+        authenticate: bool = True,
+        retries: int = 10,
+    ) -> HttpResponse:
+        return self.request(
+            headers=self._get_headers(opt_headers=headers, authenticate=authenticate),
+            method='GET',
+            retries=retries,
+            url=self._get_absolute_url(path=path, query_params=params),
+        )
+
+    def post(
+        self,
+        path: str,
+        data: Optional[Union[Dict, bytes]] = None,
+        headers: OptionalHeaders = None,
+        authenticate: bool = True,
+        retries: int = 50,  # TODO: reduce this back to 5 when timeout errors have been solved
+    ) -> HttpResponse:
+        return self.request(
+            data=data,
+            headers=self._get_headers(opt_headers=headers, authenticate=authenticate),
+            method='POST',
+            retries=retries,
+            url=self._get_absolute_url(path=path, query_params=None),
+        )
+
+    def patch(
+        self,
+        path: str,
+        data: Dict,
+        headers: OptionalHeaders = None,
+        retries: int = 5,
+        params: Optional[Dict[str, Union[str, int]]] = None,
+    ) -> HttpResponse:
+        return self.request(
+            data=data,
+            headers=self._get_headers(opt_headers=headers, authenticate=True),
+            method='PATCH',
+            retries=retries,
+            url=self._get_absolute_url(path=path, query_params=params),
+        )
+
+    def delete(
+        self,
+        path: str,
+        headers: OptionalHeaders = None,
+        retries: int = 0,
+    ) -> HttpResponse:
+        return self.request(
+            headers=self._get_headers(opt_headers=headers, authenticate=True),
+            method='DELETE',
+            retries=retries,
+            url=self._get_absolute_url(path=path, query_params=None),
+        )
+
+    def _get_headers(self, opt_headers: OptionalHeaders, authenticate: bool) -> Dict[str, str]:
+        # Only keep header keys with a value
+        headers: Dict[str, str] = {key: value for key, value in (opt_headers or {}).items() if value}
+
+        if authenticate:
+            if self._refresh_token:
+                headers['Authorization'] = f'Bearer {self._get_access_token()}'
+            else:
+                # TODO: Remove this block when deprecated api client is removed
+                deprecated_api_client = DeprecatedApiClient.get()
+                if deprecated_api_client.is_signed_in:
+                    deprecated_api_client.refresh_access_token()
+
+                if deprecated_api_client.resource_deploy_key:
+                    headers['Authorization'] = f'Token {deprecated_api_client.resource_deploy_key}'
+                else:
+                    # Adding access_token outside is_signed_in check as job_worker.py currently sets access_token
+                    # without setting refresh_token
+                    access_token = deprecated_api_client.access_token
+                    if access_token:
+                        headers['Authorization'] = f'Bearer {access_token}'
+
+        headers['client-type'] = 'biolib-python'
+        headers['client-version'] = ApiClient._biolib_package_version
+
+        return headers
+
+    def _get_absolute_url(self, path: str, query_params: Optional[Dict[str, Union[str, int]]]) -> str:
+        deprecated_api_client = DeprecatedApiClient.get()
+        base_url = self._base_url or deprecated_api_client.base_url
+        base_api_url = urljoin(base_url, '/api/')
+        url = urljoin(base_api_url, path.strip('/') + '/')
+        if query_params:
+            url = url + '?' + urlencode(query_params)
+
+        return url
+
+    def _get_access_token(self) -> str:
+        if self._access_token:
+            decoded_token = self._decode_jwt_without_checking_signature(self._access_token)
+            if datetime.now(tz=timezone.utc).timestamp() < decoded_token['payload']['exp'] - 60:  # 60 second buffer
+                # Token has not expired yet
+                return self._access_token
+
+        # TODO: Implement nicer error handling
+        try:
+            response = HttpClient.request(
+                method='POST',
+                url=f'{self._base_url}/api/user/token/refresh/',
+                data={'refresh': self._refresh_token},
+            )
+        except Exception as exception:
+            logger.error('Sign in with refresh token failed')
+            raise exception
+
+        try:
+            response_dict = response.json()
+        except JSONDecodeError as error:
+            logger.error('Could not decode response from server as JSON:')
+            raise BioLibError(response.text) from error
+
+        self._access_token = cast(str, response_dict['access'])
+        return self._access_token
+
+    @staticmethod
+    def _decode_jwt_without_checking_signature(jwt: str) -> Dict[str, Any]:
+        jwt_bytes = jwt.encode('utf-8')
+
+        try:
+            signing_input, _ = jwt_bytes.rsplit(b'.', 1)
+            header_segment, payload_segment = signing_input.split(b'.', 1)
+        except ValueError as error:
+            raise JwtDecodeError('Not enough segments') from error
+
+        try:
+            header_data = base64.urlsafe_b64decode(header_segment)
+        except (TypeError, binascii.Error) as error:
+            raise JwtDecodeError('Invalid header padding') from error
+
+        try:
+            header = json.loads(header_data)
+        except ValueError as error:
+            raise JwtDecodeError(f'Invalid header string: {error}') from error
+
+        if not isinstance(header, dict):
+            raise JwtDecodeError('Invalid header string: must be a json object')
+
+        try:
+            payload_data = base64.urlsafe_b64decode(payload_segment)
+        except (TypeError, binascii.Error) as error:
+            raise JwtDecodeError('Invalid payload padding') from error
+
+        try:
+            payload = json.loads(payload_data)
+        except ValueError as error:
+            raise JwtDecodeError(f'Invalid payload string: {error}') from error
+
+        if not isinstance(header, dict):
+            raise JwtDecodeError('Invalid payload string: must be a json object')
+
+        return dict(header=header, payload=payload)

{pybiolib-1.2.576 → pybiolib-1.2.582}/biolib/app/app.py

@@ -6,6 +6,7 @@ import string
 from pathlib import Path
 
 from biolib import utils
+from biolib.api.client import ApiClient
 from biolib.biolib_api_client import JobState
 from biolib.biolib_api_client.app_types import App, AppVersion
 from biolib.biolib_api_client.biolib_app_api import BiolibAppApi
@@ -16,13 +17,15 @@ from biolib.biolib_logging import logger
 from biolib.compute_node.job_worker.job_worker import JobWorker
 from biolib.experiments.experiment import Experiment
 from biolib.jobs import Job
-from biolib.typing_utils import Optional, Dict
+from biolib.typing_utils import Dict, Optional
 from biolib.utils.app_uri import parse_app_uri
 
 
 class BioLibApp:
-    def __init__(self, uri: str):
-        app_response = BiolibAppApi.get_by_uri(uri)
+    def __init__(self, uri: str, _api_client: Optional[ApiClient] = None):
+        self._api_client: Optional[ApiClient] = _api_client
+
+        app_response = BiolibAppApi.get_by_uri(uri=uri, api_client=self._api_client)
         self._app: App = app_response['app']
         self._app_uri = app_response['app_uri']
         self._app_version: AppVersion = app_response['app_version']
@@ -98,6 +101,7 @@ class BioLibApp:
             timeout=timeout,
             requested_machine_count=machine_count,
             temporary_client_secrets=temporary_client_secrets,
+            api_client=self._api_client,
         )
         logger.info(f'View the result in your browser at: {utils.BIOLIB_BASE_URL}/results/{job.id}/')
         if blocking:

{pybiolib-1.2.576 → pybiolib-1.2.582}/biolib/biolib_api_client/biolib_app_api.py

@@ -8,6 +8,7 @@ import urllib.parse
 import biolib.api
 from biolib import biolib_errors
 from biolib._internal.http_client import HttpError
+from biolib.api.client import ApiClient
 from biolib.biolib_api_client import AppGetResponse
 from biolib.biolib_logging import logger
 from biolib.typing_utils import Optional
@@ -84,10 +85,11 @@ def _get_app_uri_from_str(input_str: str) -> str:
 
 class BiolibAppApi:
     @staticmethod
-    def get_by_uri(uri: str) -> AppGetResponse:
+    def get_by_uri(uri: str, api_client: Optional[ApiClient] = None) -> AppGetResponse:
         uri = _get_app_uri_from_str(uri)
+        api = api_client or biolib.api.client
         try:
-            response = biolib.api.client.get(path='/app/', params={'uri': uri})
+            response = api.get(path='/app/', params={'uri': uri})
             app_response: AppGetResponse = response.json()
             return app_response
 

{pybiolib-1.2.576 → pybiolib-1.2.582}/biolib/biolib_api_client/biolib_job_api.py

@@ -5,6 +5,7 @@ import biolib.api
 
 from biolib import utils
 from biolib._internal.http_client import HttpError
+from biolib.api.client import ApiClient
 from biolib.biolib_api_client import CloudJob, JobState
 from biolib.biolib_errors import JobResultPermissionError, JobResultError, JobResultNotFound, StorageDownloadFailed
 from biolib.biolib_logging import logger
@@ -35,19 +36,19 @@ def _get_user_info() -> Optional[str]:
 
 
 class BiolibJobApi:
-
     @staticmethod
     def create(
-            app_version_id,
-            app_resource_name_prefix=None,
-            override_command=False,
-            caller_job=None,
-            machine='',
-            experiment_uuid: Optional[str] = None,
-            timeout: Optional[int] = None,
-            notify: bool = False,
-            requested_machine_count: Optional[int] = None,
-            temporary_client_secrets: Optional[Dict[str, str]] = None,
+        app_version_id,
+        app_resource_name_prefix=None,
+        override_command=False,
+        caller_job=None,
+        machine='',
+        experiment_uuid: Optional[str] = None,
+        timeout: Optional[int] = None,
+        notify: bool = False,
+        requested_machine_count: Optional[int] = None,
+        temporary_client_secrets: Optional[Dict[str, str]] = None,
+        api_client: Optional[ApiClient] = None,
     ):
         data = {
             'app_version_id': app_version_id,
@@ -58,22 +59,16 @@ class BiolibJobApi:
         }
 
         if app_resource_name_prefix:
-            data.update({
-                'app_resource_name_prefix': app_resource_name_prefix
-            })
+            data.update({'app_resource_name_prefix': app_resource_name_prefix})
 
         if override_command:
-            data.update({
-                'arguments_override_command': override_command
-            })
+            data.update({'arguments_override_command': override_command})
 
         if caller_job:
             data['caller_job'] = caller_job
 
         if machine:
-            data.update({
-                'requested_machine': machine
-            })
+            data.update({'requested_machine': machine})
 
         if requested_machine_count:
             data.update({'requested_machine_count': requested_machine_count})
@@ -87,7 +82,8 @@ class BiolibJobApi:
         if temporary_client_secrets:
             data['temporary_client_secrets'] = temporary_client_secrets
 
-        response = biolib.api.client.post(path='/jobs/', data=data)
+        api = api_client or biolib.api.client
+        response = api.post(path='/jobs/', data=data)
 
         return response.json()
 
@@ -99,20 +95,25 @@ class BiolibJobApi:
             logger.error(f'Failed to update job "{job_uuid}" to state "{state.value}" due to {error}')
 
     @staticmethod
-    def create_cloud_job(job_id: str, result_name_prefix: Optional[str]) -> CloudJob:
+    def create_cloud_job(
+        job_id: str,
+        result_name_prefix: Optional[str],
+        api_client: Optional[ApiClient] = None,
+    ) -> CloudJob:
         data = {'job_id': job_id}
         if result_name_prefix:
             data['result_name_prefix'] = result_name_prefix
 
-        response = biolib.api.client.post(path='/jobs/cloud/', data=data)
+        api = api_client or biolib.api.client
+        response = api.post(path='/jobs/cloud/', data=data)
         cloud_job: CloudJob = response.json()
         return cloud_job
 
     @staticmethod
     def get_job_storage_download_url(
-            job_uuid: str,
-            job_auth_token: str,
-            storage_type: Literal['input', 'results'],
+        job_uuid: str,
+        job_auth_token: str,
+        storage_type: Literal['input', 'results'],
     ) -> str:
         try:
             response = biolib.api.client.get(
@@ -154,19 +155,21 @@ class BiolibJobApi:
 
     @staticmethod
     def create_job_with_data(
-            app_version_uuid: str,
-            app_resource_name_prefix: Optional[str],
-            module_input_serialized: bytes,
-            arguments_override_command: bool,
-            experiment_uuid: Optional[str],
-            requested_machine: Optional[str],
-            result_name_prefix: Optional[str],
-            caller_job_uuid: Optional[str] = None,
-            requested_timeout_seconds: Optional[int] = None,
-            notify: bool = False,
-            requested_machine_count: Optional[int] = None,
+        app_version_uuid: str,
+        app_resource_name_prefix: Optional[str],
+        module_input_serialized: bytes,
+        arguments_override_command: bool,
+        experiment_uuid: Optional[str],
+        requested_machine: Optional[str],
+        result_name_prefix: Optional[str],
+        caller_job_uuid: Optional[str] = None,
+        requested_timeout_seconds: Optional[int] = None,
+        notify: bool = False,
+        requested_machine_count: Optional[int] = None,
+        api_client: Optional[ApiClient] = None,
     ) -> Dict:
-        job_dict: Dict = biolib.api.client.post(
+        api = api_client or biolib.api.client
+        job_dict: Dict = api.post(
             path='/jobs/create_job_with_data/',
             data=module_input_serialized,
             headers={
@@ -184,6 +187,6 @@ class BiolibJobApi:
                 'result-name-prefix': result_name_prefix,
                 'requested-timeout-seconds': str(requested_timeout_seconds) if requested_timeout_seconds else None,
                 'notify': 'true' if notify else 'false',
-            }
+            },
         ).json()
         return job_dict

{pybiolib-1.2.576 → pybiolib-1.2.582}/biolib/jobs/job.py

@@ -6,9 +6,11 @@ from datetime import datetime, timedelta
 from pathlib import Path
 from urllib.parse import urlparse
 
-from biolib import api, utils
+import biolib.api.client
+from biolib import utils
 from biolib._internal.http_client import HttpClient
 from biolib._internal.utils import 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
 from biolib.biolib_api_client.biolib_job_api import BiolibJobApi
@@ -39,7 +41,9 @@ class Job:
         }
     )
 
-    def __init__(self, job_dict: JobDict):
+    def __init__(self, job_dict: JobDict, _api_client: Optional[ApiClient] = None):
+        self._api_client: Optional[ApiClient] = _api_client
+
         self._uuid: str = job_dict['uuid']
         self._auth_token: str = job_dict['auth_token']
 
@@ -208,7 +212,7 @@ class Job:
 
     def cancel(self) -> None:
         try:
-            api.client.patch(
+            biolib.api.client.patch(
                 path=f'/jobs/{self._uuid}/',
                 headers={'Job-Auth-Token': self._auth_token} if self._auth_token else None,
                 data={'state': 'cancelled'},
@@ -219,7 +223,7 @@ class Job:
 
     def rename(self, name: str) -> None:
         try:
-            api.client.patch(
+            biolib.api.client.patch(
                 path=f'/jobs/{self._uuid}/main_result/',
                 headers={'Job-Auth-Token': self._auth_token} if self._auth_token else None,
                 data={'result_name_prefix': name},
@@ -325,20 +329,21 @@ class Job:
             params['state'] = status
 
         api_path = '/jobs/'
-        response = api.client.get(api_path, params=params).json()
+        response = biolib.api.client.get(api_path, params=params).json()
         jobs = [job_dict for job_dict in response['results']]
 
         for page_number in range(2, response['page_count'] + 1):
             if len(jobs) >= count:
                 break
-            page_response = api.client.get(path=api_path, params=dict(**params, page=page_number)).json()
+            page_response = biolib.api.client.get(path=api_path, params=dict(**params, page=page_number)).json()
             jobs.extend([job_dict for job_dict in page_response['results']])
 
         return jobs[:count]
 
     @staticmethod
-    def _get_job_dict(uuid: str, auth_token: Optional[str] = None) -> JobDict:
-        job_dict: JobDict = api.client.get(
+    def _get_job_dict(uuid: str, auth_token: Optional[str] = None, api_client: Optional[ApiClient] = None) -> JobDict:
+        api = api_client or biolib.api.client
+        job_dict: JobDict = api.get(
             path=f'/jobs/{uuid}/',
             headers={'Job-Auth-Token': auth_token} if auth_token else None,
         ).json()
@@ -506,6 +511,7 @@ class Job:
         notify: bool = False,
         requested_machine_count: Optional[int] = None,
         temporary_client_secrets: Optional[Dict[str, str]] = None,
+        api_client: Optional[ApiClient] = None,
     ) -> 'Job':
         if len(module_input_serialized) < 500_000 and temporary_client_secrets is None:
             _job_dict = BiolibJobApi.create_job_with_data(
@@ -519,6 +525,7 @@ class Job:
                 requested_timeout_seconds=timeout,
                 result_name_prefix=result_prefix,
                 requested_machine_count=requested_machine_count,
+                api_client=api_client,
             )
             return Job(cast(JobDict, _job_dict))
 
@@ -532,8 +539,9 @@ class Job:
             timeout=timeout,
             requested_machine_count=requested_machine_count,
             temporary_client_secrets=temporary_client_secrets,
+            api_client=api_client,
         )
         JobStorage.upload_module_input(job=job_dict, module_input_serialized=module_input_serialized)
         cloud_job = BiolibJobApi.create_cloud_job(job_id=job_dict['public_id'], result_name_prefix=result_prefix)
         logger.debug(f"Cloud: Job created with id {cloud_job['public_id']}")
-        return Job(cast(JobDict, job_dict))
+        return Job(cast(JobDict, job_dict), _api_client=api_client)

{pybiolib-1.2.576 → pybiolib-1.2.582}/biolib/sdk/__init__.py

@@ -5,12 +5,17 @@ from biolib._data_record.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._runtime.runtime import Runtime as _Runtime
+from biolib._session.session import Session as _Session
 from biolib.app import BioLibApp as _BioLibApp
 
 # Classes to expose as public API
 Runtime = _Runtime
 
 
+def get_session(refresh_token: str, base_url: Optional[str] = None) -> _Session:
+    return _Session.get_session(refresh_token=refresh_token, base_url=base_url)
+
+
 def push_app_version(uri: str, path: str) -> _BioLibApp:
     push_data = _push_application(
         app_uri=uri,

{pybiolib-1.2.576 → pybiolib-1.2.582}/pyproject.toml

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

pybiolib-1.2.576/biolib/api/client.py

@@ -1,118 +0,0 @@
-from urllib.parse import urlencode, urljoin
-
-import importlib_metadata
-
-from biolib._internal.http_client import HttpClient, HttpResponse
-from biolib.biolib_api_client import BiolibApiClient as DeprecatedApiClient
-from biolib.typing_utils import Dict, Optional, Union, cast
-
-OptionalHeaders = Union[
-    Optional[Dict[str, str]],
-    Optional[Dict[str, Union[str, None]]],
-]
-
-
-def _get_biolib_package_version() -> str:
-    # try fetching version, if it fails (usually when in dev), add default
-    try:
-        return cast(str, importlib_metadata.version('pybiolib'))
-    except importlib_metadata.PackageNotFoundError:
-        return '0.0.0'
-
-
-class ApiClient(HttpClient):
-    _biolib_package_version: str = _get_biolib_package_version()
-
-    def get(
-        self,
-        path: str,
-        params: Optional[Dict[str, Union[str, int]]] = None,
-        headers: OptionalHeaders = None,
-        authenticate: bool = True,
-        retries: int = 10,
-    ) -> HttpResponse:
-        return self.request(
-            headers=self._get_headers(opt_headers=headers, authenticate=authenticate),
-            method='GET',
-            retries=retries,
-            url=self._get_absolute_url(path=path, query_params=params),
-        )
-
-    def post(
-        self,
-        path: str,
-        data: Optional[Union[Dict, bytes]] = None,
-        headers: OptionalHeaders = None,
-        authenticate: bool = True,
-        retries: int = 50,  # TODO: reduce this back to 5 when timeout errors have been solved
-    ) -> HttpResponse:
-        return self.request(
-            data=data,
-            headers=self._get_headers(opt_headers=headers, authenticate=authenticate),
-            method='POST',
-            retries=retries,
-            url=self._get_absolute_url(path=path, query_params=None),
-        )
-
-    def patch(
-        self,
-        path: str,
-        data: Dict,
-        headers: OptionalHeaders = None,
-        retries: int = 5,
-        params: Optional[Dict[str, Union[str, int]]] = None,
-    ) -> HttpResponse:
-        return self.request(
-            data=data,
-            headers=self._get_headers(opt_headers=headers, authenticate=True),
-            method='PATCH',
-            retries=retries,
-            url=self._get_absolute_url(path=path, query_params=params),
-        )
-
-    def delete(
-        self,
-        path: str,
-        headers: OptionalHeaders = None,
-        retries: int = 0,
-    ) -> HttpResponse:
-        return self.request(
-            headers=self._get_headers(opt_headers=headers, authenticate=True),
-            method='DELETE',
-            retries=retries,
-            url=self._get_absolute_url(path=path, query_params=None),
-        )
-
-    @staticmethod
-    def _get_headers(opt_headers: OptionalHeaders, authenticate: bool) -> Dict[str, str]:
-        # Only keep header keys with a value
-        headers: Dict[str, str] = {key: value for key, value in (opt_headers or {}).items() if value}
-
-        if authenticate:
-            deprecated_api_client = DeprecatedApiClient.get()
-            if deprecated_api_client.is_signed_in:
-                deprecated_api_client.refresh_access_token()
-
-            if deprecated_api_client.resource_deploy_key:
-                headers['Authorization'] = f'Token {deprecated_api_client.resource_deploy_key}'
-            else:
-                # Adding access_token outside is_signed_in check as job_worker.py currently sets access_token
-                # without setting refresh_token
-                access_token = deprecated_api_client.access_token
-                if access_token:
-                    headers['Authorization'] = f'Bearer {access_token}'
-
-        headers['client-type'] = 'biolib-python'
-        headers['client-version'] = ApiClient._biolib_package_version
-
-        return headers
-
-    @staticmethod
-    def _get_absolute_url(path: str, query_params: Optional[Dict[str, Union[str, int]]]) -> str:
-        deprecated_api_client = DeprecatedApiClient.get()
-        base_api_url = urljoin(deprecated_api_client.base_url, '/api/')
-        url = urljoin(base_api_url, path.strip('/') + '/')
-        if query_params:
-            url = url + '?' + urlencode(query_params)
-
-        return url