pybiolib 1.1.1881__py3-none-any.whl → 1.2.7.dev0__py3-none-any.whl

biolib/experiments/experiment.py

@@ -1,30 +1,29 @@
 import time
 from collections import OrderedDict
 
-from biolib.biolib_errors import BioLibError
-from biolib.jobs.types import JobsPaginatedResponse
-from biolib.typing_utils import List, Optional
-
+import biolib._internal.types as _types
 from biolib import api
-from biolib.experiments.types import ExperimentDict
+from biolib.biolib_errors import BioLibError
 from biolib.jobs.job import Job
-from biolib.typing_utils import Dict, Union
-
+from biolib.jobs.types import JobsPaginatedResponse
 from biolib.tables import BioLibTable
+from biolib.typing_utils import Dict, List, Optional, Union
 
 
 class Experiment:
     _BIOLIB_EXPERIMENTS: List['Experiment'] = []
 
     # Columns to print in table when showing Job
-    _table_columns_to_row_map = OrderedDict({
-        'Name': {'key': 'name', 'params': {}},
-        'Job Count': {'key': 'job_count', 'params': {}},
-        'Created At': {'key': 'created_at', 'params': {}}
-    })
+    _table_columns_to_row_map = OrderedDict(
+        {
+            'Name': {'key': 'name', 'params': {}},
+            'Job Count': {'key': 'job_count', 'params': {}},
+            'Created At': {'key': 'created_at', 'params': {}},
+        }
+    )
 
-    def __init__(self, name: str):
-        self._experiment_dict: ExperimentDict = self._create_in_backend_or_get_experiment_dict(name)
+    def __init__(self, uri: str, _resource_dict: Optional[_types.ResourceDict] = None):
+        self._resource_dict: _types.ResourceDict = _resource_dict or self._get_or_create_resource_dict(uri)
 
     def __enter__(self):
         Experiment._BIOLIB_EXPERIMENTS.append(self)
@@ -33,18 +32,29 @@ class Experiment:
         Experiment._BIOLIB_EXPERIMENTS.pop()
 
     def __str__(self):
-        return f'Experiment: {self.name}'
+        return f'Experiment: {self.uri}'
 
     def __repr__(self):
-        return f'Experiment: {self.name}'
+        return f'Experiment: {self.uri}'
 
     @property
     def uuid(self) -> str:
-        return self._experiment_dict['uuid']
+        return self._resource_dict['uuid']
 
     @property
     def name(self) -> str:
-        return self._experiment_dict['name']
+        return self._resource_dict['name']
+
+    @property
+    def uri(self) -> str:
+        return self._resource_dict['uri']
+
+    @property
+    def _experiment_dict(self) -> _types.ExperimentSlimDict:
+        if not self._resource_dict['experiment']:
+            raise ValueError(f'Resource {self.uri} is not an Experiment')
+
+        return self._resource_dict['experiment']
 
     @staticmethod
     def get_experiment_in_context() -> Optional['Experiment']:
@@ -55,32 +65,46 @@ class Experiment:
     # Prints a table listing info about experiments accessible to the user
     @staticmethod
     def show_experiments(count: int = 25) -> None:
-        experiment_dicts = api.client.get(
-            path='/experiments/',
-            params={
-                'page_size': str(count)
-            }
-        ).json()['results']
+        experiment_dicts = api.client.get(path='/experiments/', params={'page_size': str(count)}).json()['results']
         BioLibTable(
             columns_to_row_map=Experiment._table_columns_to_row_map,
             rows=experiment_dicts,
-            title='Experiments'
+            title='Experiments',
         ).print_table()
 
+    @staticmethod
+    def get_by_uri(uri: str) -> 'Experiment':
+        query_param_key = 'uri' if '/' in uri else 'name'
+        resource_dict: _types.ResourceDict = api.client.get('/resource/', params={query_param_key: uri}).json()
+        if not resource_dict['experiment']:
+            raise ValueError(f'Resource {uri} is not an experiment')
+
+        return Experiment(uri=resource_dict['uri'], _resource_dict=resource_dict)
+
     def wait(self) -> None:
-        self._refetch_experiment_dict()
+        self._refetch()
         while self._experiment_dict['job_running_count'] > 0:
             print(f"Waiting for {self._experiment_dict['job_running_count']} jobs to finish", end='\r')
             time.sleep(5)
-            self._refetch_experiment_dict()
+            self._refetch()
 
         print(f'All jobs of experiment {self.name} have finished')
 
     def add_job(self, job_id: str) -> None:
-        api.client.patch(
-            path=f'/jobs/{job_id}/',
-            data={'experiment_uuid': self.uuid}
-        )
+        api.client.patch(path=f'/jobs/{job_id}/', data={'experiment_uuid': self.uuid})
+
+    def mount_files(self, mount_path: str) -> None:
+        try:
+            # Only attempt to import FUSE dependencies when strictly necessary
+            from biolib._internal.fuse_mount import (  # pylint: disable=import-outside-toplevel
+                ExperimentFuseMount as _ExperimentFuseMount,
+            )
+        except ImportError as error:
+            raise ImportError(
+                'Failed to import FUSE mounting utils. Please ensure FUSE is installed on your system.'
+            ) from error
+
+        _ExperimentFuseMount.mount_experiment(experiment=self, mount_path=mount_path)
 
     def export_job_list(self, export_format='dicts'):
         valid_formats = ('dicts', 'dataframe')
@@ -98,7 +122,7 @@ class Experiment:
                 raise ImportError(
                     'Pandas must be installed to use this method. '
                     'Alternatively, use .get_jobs() to get a list of job objects.'
-                 ) from error
+                ) from error
 
             jobs_df = pd.DataFrame.from_dict(job_dict_list)
             jobs_df.started_at = pd.to_datetime(jobs_df.started_at)
@@ -125,7 +149,7 @@ class Experiment:
         BioLibTable(
             columns_to_row_map=Job.table_columns_to_row_map,
             rows=[job._job_dict for job in jobs],  # pylint: disable=protected-access
-            title=f'Jobs in experiment: "{self.name}"'
+            title=f'Jobs in experiment: "{self.name}"',
         ).print_table()
 
     def get_jobs(self, status: Optional[str] = None) -> List[Job]:
@@ -147,15 +171,22 @@ class Experiment:
 
         return jobs
 
-    def _create_in_backend_or_get_experiment_dict(self, name: str) -> ExperimentDict:
-        # This endpoint returns experiment dict if already created
-        experiment_dict: ExperimentDict = api.client.post(
-            path='/experiments/',
-            data={
-                'name': name
-            }
-        ).json()
-        return experiment_dict
+    def rename(self, destination: str) -> None:
+        api.client.patch(f'/resources/{self.uuid}/', data={'uri': destination})
+        self._refetch()
+
+    @staticmethod
+    def _get_resource_dict_by_uuid(uuid: str) -> _types.ResourceDict:
+        resource_dict: _types.ResourceDict = api.client.get(f'/resources/{uuid}/').json()
+        if not resource_dict['experiment']:
+            raise ValueError('Resource from URI is not an experiment')
+
+        return resource_dict
+
+    @staticmethod
+    def _get_or_create_resource_dict(uri: str) -> _types.ResourceDict:
+        response_dict = api.client.post(path='/experiments/', data={'uri' if '/' in uri else 'name': uri}).json()
+        return Experiment._get_resource_dict_by_uuid(uuid=response_dict['uuid'])
 
-    def _refetch_experiment_dict(self) -> None:
-        self._experiment_dict = api.client.get(path=f'/experiments/{self.uuid}/').json()
+    def _refetch(self) -> None:
+        self._resource_dict = self._get_resource_dict_by_uuid(uuid=self._resource_dict['uuid'])

biolib/jobs/job.py

@@ -1,26 +1,30 @@
 import base64
-from datetime import datetime, timedelta
 import sys
 import time
-from pathlib import Path
 from collections import OrderedDict
+from datetime import datetime, timedelta
+from pathlib import Path
 from urllib.parse import urlparse
 
 from biolib import api, utils
 from biolib._internal.http_client import HttpClient
 from biolib._internal.utils import open_browser_window_from_notebook
-from biolib.biolib_api_client import BiolibApiClient
+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
-from biolib.biolib_binary_format import LazyLoadedFile, ModuleOutputV2, ModuleInput, ModuleInputDict
+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_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
-from biolib.jobs.types import JobDict, CloudJobStartedDict, CloudJobDict
+from biolib.jobs.types import CloudJobDict, CloudJobStartedDict, JobDict
 from biolib.tables import BioLibTable
-from biolib.typing_utils import Optional, List, cast, Dict
+from biolib.typing_utils import Dict, List, Optional, cast
 from biolib.utils import IS_RUNNING_IN_NOTEBOOK
+from biolib.utils.app_uri import parse_app_uri
 
 
 class Job:
@@ -56,26 +60,23 @@ class Job:
     @property
     def result(self) -> JobResult:
         if not self._result:
-            if self.get_status() == "completed":
-                self._result = JobResult(job_uuid=self._uuid, job_auth_token=self._auth_token)
-            else:
-                raise BioLibError(f"Result is not available for {self._uuid}: status is {self._job_dict['state']}.")
+            self._result = JobResult(job_uuid=self._uuid, job_auth_token=self._auth_token)
 
         return self._result
 
     @property
     def stdout(self) -> bytes:
-        logger.warning("The property .stdout is deprecated, please use .get_stdout()")
+        logger.warning('The property .stdout is deprecated, please use .get_stdout()')
         return self.result.get_stdout()
 
     @property
     def stderr(self) -> bytes:
-        logger.warning("The property .stderr is deprecated, please use .get_stderr()")
+        logger.warning('The property .stderr is deprecated, please use .get_stderr()')
         return self.result.get_stderr()
 
     @property
     def exitcode(self) -> int:
-        logger.warning("The property .exitcode is deprecated, please use .get_exit_code()")
+        logger.warning('The property .exitcode is deprecated, please use .get_exit_code()')
         return self.result.get_exit_code()
 
     def is_finished(self) -> bool:
@@ -109,8 +110,8 @@ class Job:
     def load_file_as_numpy(self, *args, **kwargs):
         try:
             import numpy  # type: ignore # pylint: disable=import-outside-toplevel,import-error
-        except:  # pylint: disable=raise-missing-from
-            raise Exception("Failed to import numpy, please make sure it is installed.")
+        except ImportError:  # pylint: disable=raise-missing-from
+            raise Exception('Failed to import numpy, please make sure it is installed.') from None
         file_handle = self.result.get_output_file(*args, **kwargs).get_file_handle()
         return numpy.load(file_handle, allow_pickle=False)  # type: ignore
 
@@ -187,6 +188,39 @@ class Job:
             print('Please copy and paste the following link into your browser:')
             print(results_url_to_open)
 
+    def cancel(self) -> None:
+        try:
+            api.client.patch(
+                path=f'/jobs/{self._uuid}/',
+                headers={'Job-Auth-Token': self._auth_token} if self._auth_token else None,
+                data={'state': 'cancelled'},
+            )
+            logger.info(f'Job {self._uuid} canceled')
+        except Exception as error:
+            logger.error(f'Failed to cancel job {self._uuid} due to: {error}')
+
+    def recompute(self, app_uri: Optional[str] = None, machine: Optional[str] = None, blocking: bool = True) -> 'Job':
+        app_response = BiolibAppApi.get_by_uri(uri=app_uri or self._job_dict['app_uri'])
+
+        job_storage_input = RemoteJobStorageEndpoint(
+            job_auth_token=self._auth_token,
+            job_uuid=self._uuid,
+            storage_type='input',
+        )
+        http_response = HttpClient.request(url=job_storage_input.get_remote_url())
+        module_input_serialized = http_response.content
+
+        job = self._start_job_in_cloud(
+            app_uri=app_response['app_uri'],
+            app_version_uuid=app_response['app_version']['public_id'],
+            module_input_serialized=module_input_serialized,
+            machine=machine,
+        )
+        if blocking:
+            job.stream_logs()
+
+        return job
+
     def _get_cloud_job(self) -> CloudJobDict:
         self._refetch_job_dict(force_refetch=True)
         if self._job_dict['cloud_job'] is None:
@@ -278,7 +312,7 @@ class Job:
             status_json = self._get_job_status_from_compute_node(compute_node_url)
             if not status_json:
                 # this can happen if the job is finished but already removed from the compute node
-                logger.warning("WARN: We were unable to retrieve the full log of the job, please try again")
+                logger.warning('WARN: We were unable to retrieve the full log of the job, please try again')
                 break
             job_is_completed = status_json['is_completed']
             for status_update in status_json['status_updates']:
@@ -320,7 +354,10 @@ class Job:
         self.print_logs_packages(response_json['streamed_logs_packages_b64'])
 
     def _get_cloud_job_awaiting_started(self) -> CloudJobStartedDict:
+        retry_count = 0
         while True:
+            retry_count += 1
+            time.sleep(min(10, retry_count))
             cloud_job = self._get_cloud_job()
 
             if cloud_job['finished_at']:
@@ -333,7 +370,6 @@ class Job:
                 return cast(CloudJobStartedDict, cloud_job)
 
             logger.info('Cloud: The job has been queued. Please wait...')
-            time.sleep(10)
 
     def _get_job_status_from_compute_node(self, compute_node_url):
         for _ in range(15):
@@ -341,9 +377,9 @@ class Job:
                 return HttpClient.request(url=f'{compute_node_url}/v1/job/{self._uuid}/status/').json()
             except Exception:  # pylint: disable=broad-except
                 cloud_job = self._get_cloud_job()
-                logger.debug("Failed to get status from compute node, retrying...")
+                logger.debug('Failed to get status from compute node, retrying...')
                 if cloud_job['finished_at']:
-                    logger.debug("Job no longer exists on compute node, checking for error...")
+                    logger.debug('Job no longer exists on compute node, checking for error...')
                     if cloud_job['error_code'] != SystemExceptionCodes.COMPLETED_SUCCESSFULLY.value:
                         error_message = SystemExceptionCodeMap.get(
                             cloud_job['error_code'], f'Unknown error code {cloud_job["error_code"]}'
@@ -366,3 +402,46 @@ class Job:
 
         self._job_dict = self._get_job_dict(self._uuid, self._auth_token)
         self._job_dict_last_fetched_at = datetime.utcnow()
+
+    @staticmethod
+    def _start_job_in_cloud(
+        app_uri: str,
+        app_version_uuid: str,
+        module_input_serialized: bytes,
+        override_command: bool = False,
+        machine: Optional[str] = None,
+        experiment_id: Optional[str] = None,
+        result_prefix: Optional[str] = None,
+        timeout: Optional[int] = None,
+        notify: bool = False,
+        requested_machine_count: Optional[int] = None,
+    ) -> 'Job':
+        if len(module_input_serialized) < 500_000:
+            _job_dict = BiolibJobApi.create_job_with_data(
+                app_resource_name_prefix=parse_app_uri(app_uri)['resource_name_prefix'],
+                app_version_uuid=app_version_uuid,
+                arguments_override_command=override_command,
+                experiment_uuid=experiment_id,
+                module_input_serialized=module_input_serialized,
+                notify=notify,
+                requested_machine=machine,
+                requested_timeout_seconds=timeout,
+                result_name_prefix=result_prefix,
+                requested_machine_count=requested_machine_count,
+            )
+            return Job(cast(JobDict, _job_dict))
+
+        job_dict: CreatedJobDict = BiolibJobApi.create(
+            app_resource_name_prefix=parse_app_uri(app_uri)['resource_name_prefix'],
+            app_version_id=app_version_uuid,
+            experiment_uuid=experiment_id,
+            machine=machine,
+            notify=notify,
+            override_command=override_command,
+            timeout=timeout,
+            requested_machine_count=requested_machine_count,
+        )
+        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))

biolib/jobs/job_result.py

@@ -1,25 +1,24 @@
-from pathlib import Path
-from fnmatch import fnmatch
 import time
+from fnmatch import fnmatch
+from pathlib import Path
 
 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 RemoteIndexableBuffer, LazyLoadedFile
-from biolib.biolib_binary_format.remote_endpoints import RemoteJobStorageResultEndpoint
+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 Optional, List, cast, Union, Callable
+from biolib.typing_utils import Callable, List, Optional, Union, cast
 
 PathFilter = Union[str, Callable[[str], bool]]
 
 
 class JobResult:
-
     def __init__(
-            self,
-            job_uuid: str,
-            job_auth_token: str,
-            module_output: Optional[ModuleOutputV2] = None,
+        self,
+        job_uuid: str,
+        job_auth_token: str,
+        module_output: Optional[ModuleOutputV2] = None,
     ):
         self._job_uuid: str = job_uuid
         self._job_auth_token: str = job_auth_token
@@ -35,7 +34,12 @@ class JobResult:
     def get_exit_code(self) -> int:
         return self._get_module_output().get_exit_code()
 
-    def save_files(self, output_dir: str, path_filter: Optional[PathFilter] = None) -> None:
+    def save_files(
+        self,
+        output_dir: str,
+        path_filter: Optional[PathFilter] = None,
+        skip_file_if_exists: Optional[bool] = None,
+    ) -> 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
@@ -61,24 +65,44 @@ class JobResult:
             # Remove leading slash of file_path
             destination_file_path = Path(output_dir) / Path(file.path.lstrip('/'))
             if destination_file_path.exists():
-                destination_file_path.rename(f'{destination_file_path}.biolib-renamed.{time.strftime("%Y%m%d%H%M%S")}')
+                if skip_file_if_exists:
+                    print(f'Skipping {destination_file_path} as a file with that name already exists locally.')
+                    continue
+                else:
+                    destination_file_path.rename(
+                        f'{destination_file_path}.biolib-renamed.{time.strftime("%Y%m%d%H%M%S")}'
+                    )
 
             dir_path = destination_file_path.parent
             if dir_path:
                 dir_path.mkdir(parents=True, exist_ok=True)
 
-            with open(destination_file_path, mode='wb') as destination_file:
-                for chunk in stream_seeker.seek_and_read(file_start=file.start, file_length=file.length):
-                    destination_file.write(chunk)
+            # write content to temporary (partial) file
+            partial_path = destination_file_path.with_suffix(
+                destination_file_path.suffix + f'.{self._job_uuid}.partial_biolib_download'
+            )
+            file_start = file.start
+            data_to_download = file.length
+            if partial_path.exists():
+                data_already_downloaded = partial_path.stat().st_size
+                file_start += data_already_downloaded
+                data_to_download -= data_already_downloaded
+
+            with open(partial_path, mode='ab') as partial_file:
+                for chunk in stream_seeker.seek_and_read(file_start=file_start, file_length=data_to_download):
+                    partial_file.write(chunk)
+
+            # rename partial file to actual file name
+            partial_path.rename(destination_file_path)
 
     def get_output_file(self, filename) -> LazyLoadedFile:
         files = self._get_module_output().get_files()
         filtered_files = self._get_filtered_files(files, path_filter=filename)
         if not filtered_files:
-            raise BioLibError(f"File {filename} not found in results.")
+            raise BioLibError(f'File {filename} not found in results.')
 
         if len(filtered_files) != 1:
-            raise BioLibError(f"Found multiple results for filename {filename}.")
+            raise BioLibError(f'Found multiple results for filename {filename}.')
 
         return filtered_files[0]
 
@@ -100,8 +124,8 @@ class JobResult:
         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
+        if not glob_filter.startswith('/'):
+            glob_filter = '/' + glob_filter
 
         def _filter_function(file: LazyLoadedFile) -> bool:
             return fnmatch(file.path, glob_filter)
@@ -110,9 +134,10 @@ class JobResult:
 
     def _get_module_output(self) -> ModuleOutputV2:
         if self._module_output is None:
-            remote_job_storage_endpoint = RemoteJobStorageResultEndpoint(
-                job_id=self._job_uuid,
+            remote_job_storage_endpoint = RemoteJobStorageEndpoint(
                 job_auth_token=self._job_auth_token,
+                job_uuid=self._job_uuid,
+                storage_type='output',
             )
             buffer = RemoteIndexableBuffer(endpoint=remote_job_storage_endpoint)
             self._module_output = ModuleOutputV2(buffer)

biolib/jobs/types.py

@@ -1,4 +1,4 @@
-from biolib.typing_utils import TypedDict, Optional, Literal, List
+from biolib.typing_utils import List, Literal, Optional, TypedDict
 
 JobState = Literal['in_progress', 'completed', 'failed', 'cancelled']
 

biolib/runtime/__init__.py

@@ -1,5 +1,6 @@
 import warnings
-from biolib.sdk import Runtime as _Runtime
+
+from biolib._runtime.runtime import Runtime as _Runtime
 
 
 def set_main_result_prefix(result_prefix: str) -> None:

biolib/sdk/__init__.py

@@ -1,12 +1,14 @@
+from typing import Optional
+
 # Imports to hide and use as private internal utils
-from biolib._internal.data_record import DataRecord as _DataRecord
+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.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
+# Classes to expose as public API
+Runtime = _Runtime
 
 
 def push_app_version(uri: str, path: str) -> _BioLibApp:
@@ -31,7 +33,7 @@ def get_app_version_pytest_plugin(app_version: _BioLibApp):
     except BaseException:
         raise Exception('Failed to import pytest; please make sure it is installed') from None
 
-    class AppVersionFixturePlugin(object):
+    class AppVersionFixturePlugin:
         def __init__(self, app_version_ref):
             self.app_version_ref = app_version_ref
 
@@ -42,5 +44,14 @@ def get_app_version_pytest_plugin(app_version: _BioLibApp):
     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)
+def create_data_record(
+    destination: str,
+    data_path: str,
+    name: Optional[str] = None,
+    record_type: Optional[str] = None,
+) -> _DataRecord:
+    return _DataRecord.create(
+        destination=f'{destination}/{name}' if name else destination,
+        data_path=data_path,
+        record_type=record_type,
+    )

biolib/typing_utils.py

@@ -1,7 +1,2 @@
-import sys
-
-# import and expose everything from the typing module
-from typing import *  # pylint: disable=wildcard-import, unused-wildcard-import
-
-if sys.version_info < (3, 8):
-    from typing_extensions import TypedDict, Literal  # pylint: disable=unused-import
+# TODO: Deprecate and later remove this file
+from biolib._internal.types.typing import *  # pylint: disable=wildcard-import, unused-wildcard-import

biolib/user/sign_in.py

@@ -14,11 +14,11 @@ def sign_out() -> None:
 
 
 def sign_in(open_in_default_browser: bool = False) -> None:
-    api_client = BiolibApiClient.get()
-    if api_client.is_signed_in:
+    if not BiolibApiClient.is_reauthentication_needed():
         logger_no_user_data.info('Already signed in')
         return
 
+    api_client = BiolibApiClient.get()
     auth_challenge = BiolibAuthChallengeApi.create_auth_challenge()
     auth_challenge_token = auth_challenge['token']