pybiolib 1.2.7.dev0__py3-none-any.whl → 1.2.105.dev1__py3-none-any.whl

biolib/__init__.py

@@ -41,8 +41,8 @@ def search(
     return apps
 
 
-def get_job(job_id: str) -> _Job:
-    return _Job.create_from_uuid(uuid=job_id)
+def get_job(job_id: str, job_token: Optional[str] = None) -> _Job:
+    return _Job.create_from_uuid(uuid=job_id, auth_token=job_token)
 
 
 def get_data_record(uri: str) -> _DataRecord:

biolib/_data_record/data_record.py

@@ -6,19 +6,21 @@ from pathlib import Path
 from struct import Struct
 from typing import Callable, Dict, List, Optional, Union, cast
 
-from biolib import api, utils
+from biolib import api
 from biolib._internal import types
 from biolib._internal.data_record import get_data_record_state_from_uri
 from biolib._internal.data_record.data_record import validate_sqlite_v1
+from biolib._internal.data_record.push_data import (
+    push_data_path,
+    validate_data_path_and_get_files_and_size_of_directory,
+)
 from biolib._internal.data_record.remote_storage_endpoint import DataRecordRemoteStorageEndpoint
-from biolib._internal.file_utils import get_files_and_size_of_directory, get_iterable_zip_stream
 from biolib._internal.http_client import HttpClient
 from biolib.api import client as api_client
 from biolib.biolib_api_client import BiolibApiClient
 from biolib.biolib_api_client.lfs_types import DataRecordInfo, DataRecordVersion, DataRecordVersionInfo
 from biolib.biolib_binary_format import LazyLoadedFile
 from biolib.biolib_binary_format.utils import RemoteIndexableBuffer
-from biolib.biolib_errors import BioLibError
 from biolib.biolib_logging import logger
 from biolib.utils.app_uri import parse_app_uri
 from biolib.utils.zip.remote_zip import RemoteZip
@@ -85,18 +87,8 @@ class DataRecord:
         self.download_files(output_dir=output_dir, path_filter=path_filter)
 
     def update(self, data_path: str, chunk_size_in_mb: Optional[int] = None) -> None:
-        assert os.path.isdir(data_path), f'The path "{data_path}" is not a directory.'
         BiolibApiClient.assert_is_signed_in(authenticated_action_description='push data to a Data Record')
-
-        if os.path.realpath(data_path) == '/':
-            raise BioLibError('Pushing your root directory is not possible')
-
-        original_working_dir = os.getcwd()
-        os.chdir(data_path)
-        files_to_zip, data_size_in_bytes = get_files_and_size_of_directory(directory=os.getcwd())
-
-        if data_size_in_bytes > 4_500_000_000_000:
-            raise BioLibError('Attempted to push directory with a size larger than the limit of 4.5 TB')
+        files_to_zip, data_size_in_bytes = validate_data_path_and_get_files_and_size_of_directory(data_path)
 
         # validate data record
         detailed_dict: types.DataRecordDetailedDict = self._get_detailed_dict()
@@ -114,40 +106,23 @@ class DataRecord:
                 else:
                     raise Exception(f"Error processing data record validation: unknown rule type {rule['type']}")
 
-        min_chunk_size_bytes = 10_000_000
-        chunk_size_in_bytes: int
-        if chunk_size_in_mb:
-            chunk_size_in_bytes = chunk_size_in_mb * 1_000_000  # Convert megabytes to bytes
-            if chunk_size_in_bytes < min_chunk_size_bytes:
-                logger.warning('Specified chunk size is too small, using minimum of 10 MB instead.')
-                chunk_size_in_bytes = min_chunk_size_bytes
-        else:
-            # Calculate chunk size based on max chunk count of 10_000, using 9_000 to be on the safe side
-            chunk_size_in_bytes = max(min_chunk_size_bytes, int(data_size_in_bytes / 9_000))
-
-        data_size_in_mb = round(data_size_in_bytes / 10**6)
-        logger.info(f'Zipping {len(files_to_zip)} files, in total ~{data_size_in_mb}mb of data')
-
         response = api.client.post(path='/lfs/versions/', data={'resource_uuid': self._state['resource_uuid']})
         data_record_version: DataRecordVersion = response.json()
-        iterable_zip_stream = get_iterable_zip_stream(files=files_to_zip, chunk_size=chunk_size_in_bytes)
-
-        multipart_uploader = utils.MultiPartUploader(
-            use_process_pool=True,
-            get_presigned_upload_url_request=dict(
-                headers=None,
-                requires_biolib_auth=True,
-                path=f"/lfs/versions/{data_record_version['uuid']}/presigned_upload_url/",
-            ),
-            complete_upload_request=dict(
-                headers=None,
-                requires_biolib_auth=True,
-                path=f"/lfs/versions/{data_record_version['uuid']}/complete_upload/",
-            ),
+        resource_version_uuid = data_record_version['uuid']
+
+        push_data_path(
+            data_path=data_path,
+            data_size_in_bytes=data_size_in_bytes,
+            files_to_zip=files_to_zip,
+            resource_version_uuid=resource_version_uuid,
+            chunk_size_in_mb=chunk_size_in_mb,
+        )
+
+        api.client.patch(
+            path=f'/resources/versions/{resource_version_uuid}/',
+            data={'state': 'published', 'set_as_active': True},
         )
 
-        multipart_uploader.upload(payload_iterator=iterable_zip_stream, payload_size_in_bytes=data_size_in_bytes)
-        os.chdir(original_working_dir)
         logger.info(f"Successfully pushed a new Data Record version '{data_record_version['uri']}'")
         self._state = get_data_record_state_from_uri(data_record_version['uri'])
 
@@ -177,12 +152,11 @@ class DataRecord:
         data_record_info: DataRecordInfo = response.json()
         logger.info(f"Successfully created new Data Record '{data_record_info['uri']}'")
 
+        data_record = DataRecord.get_by_uri(uri=data_record_info['uri'])
         if data_path is not None:
-            data_record = DataRecord.get_by_uri(uri=data_record_info['uri'])
             data_record.update(data_path=data_path)
-            return data_record
-        else:
-            return DataRecord.get_by_uri(uri=data_record_info['uri'])
+
+        return data_record
 
     @staticmethod
     def fetch(uri: Optional[str] = None, count: Optional[int] = None) -> List['DataRecord']:

biolib/_internal/data_record/push_data.py

@@ -0,0 +1,67 @@
+import os
+
+from biolib import utils
+from biolib._internal.file_utils import get_files_and_size_of_directory, get_iterable_zip_stream
+from biolib._internal.types.typing import List, Optional, Tuple
+from biolib.biolib_errors import BioLibError
+from biolib.biolib_logging import logger
+
+
+def validate_data_path_and_get_files_and_size_of_directory(data_path: str) -> Tuple[List[str], int]:
+    assert os.path.isdir(data_path), f'The path "{data_path}" is not a directory.'
+
+    if os.path.realpath(data_path) == '/':
+        raise BioLibError('Pushing your root directory is not possible')
+
+    original_working_dir = os.getcwd()
+    os.chdir(data_path)
+    files_to_zip, data_size_in_bytes = get_files_and_size_of_directory(directory=os.getcwd())
+    os.chdir(original_working_dir)
+
+    if data_size_in_bytes > 4_500_000_000_000:
+        raise BioLibError('Attempted to push directory with a size larger than the limit of 4.5 TB')
+
+    return files_to_zip, data_size_in_bytes
+
+
+def push_data_path(
+    data_path: str,
+    data_size_in_bytes: int,
+    files_to_zip: List[str],
+    resource_version_uuid: str,
+    chunk_size_in_mb: Optional[int] = None,
+) -> None:
+    original_working_dir = os.getcwd()
+    os.chdir(data_path)
+
+    min_chunk_size_bytes = 10_000_000
+    chunk_size_in_bytes: int
+    if chunk_size_in_mb:
+        chunk_size_in_bytes = chunk_size_in_mb * 1_000_000  # Convert megabytes to bytes
+        if chunk_size_in_bytes < min_chunk_size_bytes:
+            logger.warning('Specified chunk size is too small, using minimum of 10 MB instead.')
+            chunk_size_in_bytes = min_chunk_size_bytes
+    else:
+        # Calculate chunk size based on max chunk count of 10_000, using 9_000 to be on the safe side
+        chunk_size_in_bytes = max(min_chunk_size_bytes, int(data_size_in_bytes / 9_000))
+
+    data_size_in_mb = round(data_size_in_bytes / 10**6)
+    logger.info(f'Zipping {len(files_to_zip)} files, in total ~{data_size_in_mb}mb of data')
+
+    iterable_zip_stream = get_iterable_zip_stream(files=files_to_zip, chunk_size=chunk_size_in_bytes)
+    multipart_uploader = utils.MultiPartUploader(
+        use_process_pool=True,
+        get_presigned_upload_url_request=dict(
+            headers=None,
+            requires_biolib_auth=True,
+            path=f'/lfs/versions/{resource_version_uuid}/presigned_upload_url/',
+        ),
+        complete_upload_request=dict(
+            headers=None,
+            requires_biolib_auth=True,
+            path=f'/lfs/versions/{resource_version_uuid}/complete_upload/',
+        ),
+    )
+
+    multipart_uploader.upload(payload_iterator=iterable_zip_stream, payload_size_in_bytes=data_size_in_bytes)
+    os.chdir(original_working_dir)

biolib/_internal/push_application.py

@@ -6,6 +6,10 @@ import rich.progress
 import yaml
 
 from biolib import api, utils
+from biolib._internal.data_record.push_data import (
+    push_data_path,
+    validate_data_path_and_get_files_and_size_of_directory,
+)
 from biolib._internal.file_utils import get_files_and_size_of_directory, get_iterable_zip_stream
 from biolib.biolib_api_client import BiolibApiClient
 from biolib.biolib_api_client.biolib_app_api import BiolibAppApi
@@ -94,10 +98,25 @@ def push_application(
     zip_filters.add('.biolib/config.yml')
 
     input_files_maps_to_root = False
+    app_data_path: Optional[Path] = None
     try:
         with open(config_yml_path) as config_yml_file:
             config = yaml.safe_load(config_yml_file.read())
 
+        app_data = config.get('app_data')
+        if app_data:
+            if not isinstance(app_data, str):
+                raise BioLibError(
+                    f'In .biolib/config.yml the value of "app_data" must be a string but got {type(app_data)}'
+                )
+
+            app_data_path = app_path_absolute.joinpath(app_data).resolve()
+            if not app_data_path.is_dir():
+                raise BioLibError(
+                    'In .biolib/config.yml the value of "app_data" must be a path to a directory '
+                    'in the application directory'
+                )
+
         license_file_relative_path = config.get('license_file', 'LICENSE')
         if app_path_absolute.joinpath(license_file_relative_path).is_file():
             zip_filters.add(license_file_relative_path)
@@ -118,11 +137,14 @@ def push_application(
             if module.get('source_files'):
                 zip_filters.add('*')
 
-            for mapping in module['input_files']:
+            for mapping in module.get('input_files', []):
                 mapping_parts = mapping.split(' ')
                 if len(mapping_parts) == 3 and mapping_parts[2] == '/':
                     input_files_maps_to_root = True
 
+    except BioLibError as error:
+        raise error from None
+
     except Exception as error:
         raise BioLibError('Failed to parse the .biolib/config.yml file') from error
 
@@ -175,6 +197,17 @@ def push_application(
         else None,
     )
 
+    if app_data_path:
+        app_data_files_to_zip, app_data_size_in_bytes = validate_data_path_and_get_files_and_size_of_directory(
+            data_path=str(app_data_path),
+        )
+        push_data_path(
+            resource_version_uuid=new_app_version_json['public_id'],
+            data_path=str(app_data_path),
+            data_size_in_bytes=app_data_size_in_bytes,
+            files_to_zip=app_data_files_to_zip,
+        )
+
     #  Don't push docker images if copying from another app version
     docker_tags = new_app_version_json.get('docker_tags', {})
     if not app_version_to_copy_images_from and docker_tags:

biolib/_internal/types/__init__.py

@@ -2,3 +2,4 @@ from .app import *  # noqa: F403
 from .data_record import *  # noqa: F403
 from .experiment import *  # noqa: F403
 from .resource import *  # noqa: F403
+from .resource_version import *  # noqa: F403

biolib/_internal/types/data_record.py

@@ -7,7 +7,7 @@ class SqliteV1ForeignKey(TypedDict):
 
 
 class SqliteV1Column(TypedDict):
-    type: Literal['INTEGER', 'REAL', 'TEXT', 'JSON']  # noqa:F821
+    type: Literal['INTEGER', 'REAL', 'TEXT', 'JSON']
     nullable: Optional[bool]
     foreign_key: Optional[SqliteV1ForeignKey]
     json_schema: Optional[Dict]

biolib/_internal/types/resource_version.py

@@ -0,0 +1,7 @@
+from .typing import Literal, TypedDict
+
+
+class ResourceVersionDetailedDict(TypedDict):
+    semantic_version: str
+    state: Literal['published', 'unpublished']
+    uuid: str

biolib/_internal/utils/multinode.py

@@ -118,7 +118,9 @@ def fasta_batch_records(fasta_file, work_per_batch_min, work_per_residue=1, verb
     return batches
 
 
-def fasta_send_batches_biolib(app_url, batches, args, args_fasta='fasta', verbose=1):
+def fasta_send_batches_biolib(
+    app_url, batches, args, args_fasta='fasta', machine='cpu.large', stream_all_jobs=True, verbose=1
+):
     """
     Send jobs through pybiolib interface
     """
@@ -128,7 +130,6 @@ def fasta_send_batches_biolib(app_url, batches, args, args_fasta='fasta', verbos
 
     # Login to biolib, prepare app
     # current_app = biolib.load(Runtime.get_app_uri())
-    biolib.login()
     current_app = biolib.load(app_url)  # Nb: uses "_" not "-"
 
     # Compute results
@@ -149,7 +150,7 @@ def fasta_send_batches_biolib(app_url, batches, args, args_fasta='fasta', verbos
             new_args_list = _args_dict_to_args_list(new_args)
 
             # Send job
-            job = current_app.cli(args=new_args_list, blocking=False)
+            job = current_app.cli(args=new_args_list, blocking=False, machine=machine)
             job_list.append(job)
 
             # Job stats
@@ -161,7 +162,9 @@ def fasta_send_batches_biolib(app_url, batches, args, args_fasta='fasta', verbos
     # Stream job output at a time
     print('Streaming job outputs ...')
     for i, job in enumerate(job_list):
-        job.stream_logs()
+        # Try to print if verbose. Always on first job, otherwise only if stream_all_jobs set
+        if (i == 0 and verbose) or (stream_all_jobs and verbose):
+            job.stream_logs()
 
         # Check if job succeeded
         assert job.get_exit_code() == 0, f'Job failed with exit code {job.get_exit_code()}'

biolib/compute_node/remote_host_proxy.py

@@ -291,6 +291,15 @@ http {{
             proxy_ssl_server_name    on;
         }}
 
+        location /api/resources/data-records/ {{
+            proxy_pass               https://$upstream_hostname$request_uri;
+            proxy_set_header         authorization "";
+            proxy_set_header         compute-node-auth-token "{compute_node_auth_token}";
+            proxy_set_header         job-uuid "{self._job_uuid}";
+            proxy_set_header         cookie "";
+            proxy_ssl_server_name    on;
+        }}
+
         location /api/ {{
             proxy_pass               https://$upstream_hostname$request_uri;
             proxy_set_header         authorization "";

biolib/utils/seq_util.py

@@ -1,7 +1,7 @@
 import re
-from io import BufferedIOBase
+from io import BufferedIOBase, TextIOBase
 
-from biolib.typing_utils import Dict, List, Optional, Union
+from biolib.typing_utils import Dict, List, Optional, Union, Iterator
 
 
 class SeqUtilRecord:
@@ -37,67 +37,77 @@ class SeqUtil:
         allow_any_sequence_characters: bool = False,
         allow_empty_sequence: bool = True,
         file_name: Optional[str] = None,
-    ) -> List[SeqUtilRecord]:
+) -> Iterator[SeqUtilRecord]:
+        def process_and_yield_record(header: str, sequence_lines: List[str]):
+            sequence = ''.join(sequence_lines)
+            sequence_id = header.split()[0]
+            if not allow_any_sequence_characters:
+                invalid_sequence_characters = SeqUtil._find_invalid_sequence_characters(sequence)
+                if invalid_sequence_characters:
+                    raise Exception(
+                        f'Error: Invalid character ("{invalid_sequence_characters[0]}") found in sequence {sequence_id}'
+                    )
+            if not allow_empty_sequence and not sequence:
+                raise Exception(f'Error: No sequence found for fasta entry {sequence_id}')
+            yield SeqUtilRecord(
+                sequence=sequence,
+                sequence_id=sequence_id,
+                description=header[len(sequence_id):].strip()
+            )
+
+        def line_generator_from_buffered_io_base(file_handle: BufferedIOBase) -> Iterator[str]:
+            for line in file_handle:
+                yield line.decode('utf-8')
+
+        def line_generator_from_text_io_base(file_handle: TextIOBase) -> Iterator[str]:
+            for line in file_handle:
+                yield line
+
         if input_file is None:
             if file_name:
                 input_file = file_name
             else:
                 raise ValueError('input_file must be a file name (str) or a BufferedIOBase object')
+
+        file_handle = None
         if isinstance(input_file, str):
-            with open(input_file) as file_handle:
-                data = file_handle.read().strip()
+            file_handle = open(input_file, "rb")
+            line_iterator = line_generator_from_buffered_io_base(file_handle)
         elif isinstance(input_file, BufferedIOBase):
-            data = input_file.read().decode('utf-8')
+            line_iterator = line_generator_from_buffered_io_base(input_file)
+        elif isinstance(input_file, TextIOBase):
+            line_iterator = line_generator_from_text_io_base(input_file)
         else:
             raise ValueError('input_file must be a file name (str) or a BufferedIOBase object')
-        if not data:
-            return []
-
-        if '>' not in data:
-            if default_header:
-                lines_with_header = []
-                for index, line in enumerate(data.split('\n')):
-                    index_string = str(index + 1) if index > 0 else ''
-                    lines_with_header.append(f'>{default_header}{index_string}\n{line}')
-
-                data = '\n'.join(lines_with_header)
-            else:
-                raise Exception(f'No header line found in FASTA file "{file_name}"')
-
-        splitted = []
-        tmp_data = ''
-        for line in data.splitlines():
-            if line.startswith('>'):
-                if tmp_data:
-                    splitted.append(tmp_data)
-                tmp_data = line[1:].strip() + '\n'
-            else:
-                if line.strip():
-                    tmp_data += line.strip() + '\n'
-
-        if tmp_data:
-            splitted.append(tmp_data)
-
-        parsed_sequences = []
-        for sequence_data in splitted:
-            sequence_data_splitted = sequence_data.strip().split('\n')
-            header_line = sequence_data_splitted[0].split()
-            sequence_id = header_line[0]
-            description = sequence_data_splitted[0][len(sequence_id) :].strip()
-            sequence = ''.join([seq.strip() for seq in sequence_data_splitted[1:]])
-
-            if not allow_any_sequence_characters:
-                invalid_sequence_characters = SeqUtil._find_invalid_sequence_characters(sequence)
-                if len(invalid_sequence_characters) > 0:
-                    raise Exception(
-                        f'Error: Invalid character ("{invalid_sequence_characters[0]}") found in sequence {sequence_id}'
-                    )
-            if not allow_empty_sequence and len(sequence) == 0:
-                raise Exception(f'Error: No sequence found for fasta entry {sequence_id}')
-
-            parsed_sequences.append(SeqUtilRecord(sequence=sequence, sequence_id=sequence_id, description=description))
 
-        return parsed_sequences
+        header = None
+        sequence_lines: List[str] = []
+
+        try:
+            for line_number, line in enumerate(line_iterator):
+                line = line.strip()
+                if not line:
+                    continue # skip empty lines
+                if line.startswith('>'):
+                    if header is not None:
+                        yield from process_and_yield_record(header, sequence_lines)
+
+                    header = line[1:].strip()
+                    sequence_lines = []
+                else:
+                    if header is None:
+                        if default_header:
+                            yield from process_and_yield_record(f"{default_header}{line_number}", [line])
+                        else:
+                            raise Exception(f'No header line found in FASTA file "{file_name}"')
+                    else:
+                        sequence_lines.append(line)
+
+            if header is not None:
+                yield from process_and_yield_record(header, sequence_lines)
+        finally:
+            if file_handle:
+                file_handle.close()
 
     @staticmethod
     def write_records_to_fasta(file_name: str, records: List[SeqUtilRecord]) -> None:

{pybiolib-1.2.7.dev0.dist-info → pybiolib-1.2.105.dev1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pybiolib
-Version: 1.2.7.dev0
+Version: 1.2.105.dev1
 Summary: BioLib Python Client
 Home-page: https://github.com/biolib
 License: MIT

{pybiolib-1.2.7.dev0.dist-info → pybiolib-1.2.105.dev1.dist-info}/RECORD

@@ -1,10 +1,11 @@
 LICENSE,sha256=F2h7gf8i0agDIeWoBPXDMYScvQOz02pAWkKhTGOHaaw,1067
-README.md,sha256=_IH7pxFiqy2bIAmaVeA-iVTyUwWRjMIlfgtUbYTtmls,368
-biolib/__init__.py,sha256=_tThyzISH81yS9KXP_X3qEiKXmsIp5XOBcJIODfLVnc,4338
-biolib/_data_record/data_record.py,sha256=CoyYRse5VdUBhQzzPfR9BkytgOsM-IZxkfMX1kyRnPk,12589
+PYPI_README.md,sha256=_IH7pxFiqy2bIAmaVeA-iVTyUwWRjMIlfgtUbYTtmls,368
+biolib/__init__.py,sha256=q_YhAYw51Vq16IKtSk8_MJclDAa4CfCmPhvWDYmrSIg,4393
+biolib/_data_record/data_record.py,sha256=zVAhFU1RLI1-ptoQ_l639RNwrMANXV9j75yXHvB7dtA,10950
 biolib/_internal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 biolib/_internal/data_record/__init__.py,sha256=fGdME6JGRU_2VxpJbYpGXYndjN-feUkmKY4fuMyq3cg,76
 biolib/_internal/data_record/data_record.py,sha256=g_-jdy5-Zem3dthwxJj2OuQqkDGTyc-iGqN1rtYYD1A,4418
+biolib/_internal/data_record/push_data.py,sha256=-L3a_7zZzDCXabBu3O4lWPMAMeBbeRPTrBlEM-_5SCI,2693
 biolib/_internal/data_record/remote_storage_endpoint.py,sha256=eCptuZ4DMAPnaNCVDvpWXwXGI6Jac9U1N5dqU8Cj95Q,1732
 biolib/_internal/file_utils.py,sha256=4jT6j7bB21c0JNn5BfnyWQib_zt0CVtJ_TiOFOStRcE,2604
 biolib/_internal/fuse_mount/__init__.py,sha256=B_tM6RM2dBw-vbpoHJC4X3tOAaN1H2RDvqYJOw3xFwg,55
@@ -14,16 +15,17 @@ biolib/_internal/lfs/__init__.py,sha256=gSWo_xg61UniYgD7yNYxeT4I9uaXBCBSi3_nmZjn
 biolib/_internal/lfs/cache.py,sha256=pQS2np21rdJ6I3DpoOutnzPHpLOZgUIS8TMltUJk_k4,2226
 biolib/_internal/libs/__init__.py,sha256=Jdf4tNPqe_oIIf6zYml6TiqhL_02Vyqwge6IELrAFhw,98
 biolib/_internal/libs/fusepy/__init__.py,sha256=AWDzNFS-XV_5yKb0Qx7kggIhPzq1nj_BZS5y2Nso08k,41944
-biolib/_internal/push_application.py,sha256=b1WvlijJYOLp7f43AoAzjINKkALM9DVB8yfSetEP4Z4,10381
+biolib/_internal/push_application.py,sha256=mKs3kIKW-ZYfz3Cy6LIyFBwsWkbcGZ9zgMk-xn5NDyg,11660
 biolib/_internal/runtime.py,sha256=BiHl4klUHr36MCpqKaUso4idHeBZfPAahLYRQrabFqA,486
-biolib/_internal/types/__init__.py,sha256=11ZucS8jKeLGAAswXyKI7FH2KLHd6T9Sh8ZK2Ar3jlk,152
+biolib/_internal/types/__init__.py,sha256=xLgOQJFh3GRtiqIJq7MaqHReZx4pp34_zcaFQ_JjuJ4,198
 biolib/_internal/types/app.py,sha256=Mz2QGD_jESX-K9JYnLWPo4YA__Q_1FQQTk9pvidCohU,118
-biolib/_internal/types/data_record.py,sha256=AHoIiwVqeHj0HozQxFRAyxk-d3XJgLWno4ic1z9eTrQ,865
+biolib/_internal/types/data_record.py,sha256=9r_vdhVs60YTnzU4XQFXfDrfS2P2MqD3BH2xa7lk6ck,852
 biolib/_internal/types/experiment.py,sha256=D94iBdn2nS92lRW-TOs1a2WKXJD5ZtmzL4ypggKX2ys,176
 biolib/_internal/types/resource.py,sha256=G-vPkZoe4Um6FPxsQZtRzAlbSW5sDW4NFkbjn21I3V4,372
+biolib/_internal/types/resource_version.py,sha256=sLxViYXloDDUhTDFgjegiQCj097OM1Ih1-uqlC_4ULA,174
 biolib/_internal/types/typing.py,sha256=D4EKKEe7kDx0K6lJi-H_XLtk-8w6nu2fdqn9bvzI-Xo,288
 biolib/_internal/utils/__init__.py,sha256=p5vsIFyu-zYqBgdSMfwW9NC_jk7rXvvCbV4Bzd3As7c,630
-biolib/_internal/utils/multinode.py,sha256=UnM08GXc8U-p0eoSleer4BIgngIsn_fgh9FxRQJkIiI,8068
+biolib/_internal/utils/multinode.py,sha256=zWrQhcVK5u_xdWX2oIM-D_2fINqNPlqF_h71fu4K8LY,8279
 biolib/_runtime/runtime.py,sha256=oVgTnDDJv9L4BUP1_sd0oAj4LLyyiPSQdhp7ixWARvw,2923
 biolib/api/__init__.py,sha256=mQ4u8FijqyLzjYMezMUUbbBGNB3iFmkNdjXnWPZ7Jlw,138
 biolib/api/client.py,sha256=FRpdH5aI187b_I_4HUNi680v4iOP65z5f2RcUo8D8MA,3559
@@ -87,7 +89,7 @@ biolib/compute_node/job_worker/large_file_system.py,sha256=XXqRlVtYhs-Ji9zQGIk5K
 biolib/compute_node/job_worker/mappings.py,sha256=Z48Kg4nbcOvsT2-9o3RRikBkqflgO4XeaWxTGz-CNvI,2499
 biolib/compute_node/job_worker/utilization_reporter_thread.py,sha256=7tm5Yk9coqJ9VbEdnO86tSXI0iM0omwIyKENxdxiVXk,8575
 biolib/compute_node/job_worker/utils.py,sha256=wgxcIA8yAhUPdCwyvuuJ0JmreyWmmUoBO33vWtG60xg,1282
-biolib/compute_node/remote_host_proxy.py,sha256=ibkWqvLJJHwOM7GzYqJV613QPacU5392vjnDK8BNJIU,15213
+biolib/compute_node/remote_host_proxy.py,sha256=eTT7x7ht_cxXMQ-0yXCvhKZW6mKeYM4KrfBf75KTbc8,15651
 biolib/compute_node/socker_listener_thread.py,sha256=T5_UikA3MB9bD5W_dckYLPTgixh72vKUlgbBvj9dbM0,1601
 biolib/compute_node/socket_sender_thread.py,sha256=YgamPHeUm2GjMFGx8qk-99WlZhEs-kAb3q_2O6qByig,971
 biolib/compute_node/utils.py,sha256=M7i_WTyxbFM3Lri9RWZ_8FeQNYrQIWpKGLfp2I55oeY,4677
@@ -115,10 +117,10 @@ biolib/utils/__init__.py,sha256=fwjciJyJicvYyZcVTzfDBgD0SKY13DeXqvTeG4qZIy8,5548
 biolib/utils/app_uri.py,sha256=Yq_-_VGugQhMMo6mM5f0G9yNlLkr0WK4j0Nrf3FE4xQ,2171
 biolib/utils/cache_state.py,sha256=u256F37QSRIVwqKlbnCyzAX4EMI-kl6Dwu6qwj-Qmag,3100
 biolib/utils/multipart_uploader.py,sha256=XvGP1I8tQuKhAH-QugPRoEsCi9qvbRk-DVBs5PNwwJo,8452
-biolib/utils/seq_util.py,sha256=ZQFcaE37B2dtucN2zDjOmdya_X0ITc1zBFZJNQY13XA,5183
+biolib/utils/seq_util.py,sha256=WJnU9vZdwY8RHXvzATyV80OXzyJ7w9EkG33Tna9Nr6A,5698
 biolib/utils/zip/remote_zip.py,sha256=0wErYlxir5921agfFeV1xVjf29l9VNgGQvNlWOlj2Yc,23232
-pybiolib-1.2.7.dev0.dist-info/LICENSE,sha256=F2h7gf8i0agDIeWoBPXDMYScvQOz02pAWkKhTGOHaaw,1067
-pybiolib-1.2.7.dev0.dist-info/METADATA,sha256=O1duMBotGWLsk_tKeihafeOizbCNQVWjCVT7SbzVTZ4,1510
-pybiolib-1.2.7.dev0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-pybiolib-1.2.7.dev0.dist-info/entry_points.txt,sha256=p6DyaP_2kctxegTX23WBznnrDi4mz6gx04O5uKtRDXg,42
-pybiolib-1.2.7.dev0.dist-info/RECORD,,
+pybiolib-1.2.105.dev1.dist-info/LICENSE,sha256=F2h7gf8i0agDIeWoBPXDMYScvQOz02pAWkKhTGOHaaw,1067
+pybiolib-1.2.105.dev1.dist-info/METADATA,sha256=8gXSVU8uvqONlUb6KfFDPrrnjV4z9abxHxZ1FL4EtTo,1512
+pybiolib-1.2.105.dev1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+pybiolib-1.2.105.dev1.dist-info/entry_points.txt,sha256=p6DyaP_2kctxegTX23WBznnrDi4mz6gx04O5uKtRDXg,42
+pybiolib-1.2.105.dev1.dist-info/RECORD,,