pybiolib 1.2.1642__py3-none-any.whl → 1.2.1727__py3-none-any.whl

biolib/_data_record/data_record.py

@@ -3,12 +3,13 @@ from collections import namedtuple
 from datetime import datetime
 from pathlib import Path
 from struct import Struct
-from typing import Callable, Dict, Iterable, List, Optional, Union, cast
+from typing import Callable, Dict, Iterable, Iterator, List, Optional, Union, cast
 
 from biolib import api
 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 (
+    _upload_from_iterator,
     push_data_path,
     validate_data_path_and_get_files_and_size_of_directory,
 )
@@ -19,7 +20,7 @@ from biolib._shared.types import ZipFileNodeDict
 from biolib._shared.utils import parse_resource_uri
 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_api_client.lfs_types import DataRecordInfo, DataRecordVersionInfo
 from biolib.biolib_binary_format import LazyLoadedFile
 from biolib.biolib_binary_format.utils import RemoteIndexableBuffer
 from biolib.biolib_logging import logger
@@ -113,30 +114,29 @@ class DataRecord:
                 else:
                     raise Exception(f"Error processing data record validation: unknown rule type {rule['type']}")
 
-        response = api.client.post(path='/lfs/versions/', data={'resource_uuid': self._state['resource_uuid']})
-        data_record_version: DataRecordVersion = response.json()
-        resource_version_uuid = data_record_version['uuid']
-
-        push_data_path(
+        new_resource_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,
+            resource_uuid=self._state['resource_uuid'],
             chunk_size_in_mb=chunk_size_in_mb,
+            publish=True,
         )
 
-        api.client.patch(
-            path=f'/resources/versions/{resource_version_uuid}/',
-            data={'state': 'published', 'set_as_active': True},
-        )
-
-        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'])
+        updated_record = DataRecord._get_by_version_uuid(new_resource_version_uuid)
+        self._state = updated_record._state  # pylint: disable=protected-access
+        logger.info(f"Successfully pushed a new Data Record version '{self.uri}'")
 
     @staticmethod
     def get_by_uri(uri: str) -> 'DataRecord':
         return DataRecord(_internal_state=get_data_record_state_from_uri(uri))
 
+    @staticmethod
+    def _get_by_version_uuid(version_uuid: str) -> 'DataRecord':
+        response = api.client.get(path=f'/lfs/versions/{version_uuid}/')
+        version_info = response.json()
+        return DataRecord.get_by_uri(version_info['uri'])
+
     @staticmethod
     def create(destination: str, data_path: Optional[str] = None, record_type: Optional[str] = None) -> 'DataRecord':
         BiolibApiClient.assert_is_signed_in(authenticated_action_description='create a Data Record')
@@ -285,6 +285,70 @@ class DataRecord:
     def _get_detailed_dict(self) -> types.DataRecordDetailedDict:
         return cast(types.DataRecordDetailedDict, api_client.get(f'/resources/data-records/{self.uuid}/').json())
 
+    def _get_zip_size_bytes(self) -> int:
+        remote_storage_endpoint = DataRecordRemoteStorageEndpoint(
+            resource_version_uuid=self._state['resource_version_uuid'],
+        )
+        presigned_url = remote_storage_endpoint.get_remote_url()
+        response = HttpClient.request(url=presigned_url, headers={'range': 'bytes=0-0'})
+        content_range = response.headers.get('Content-Range', '')
+        if not content_range or '/' not in content_range:
+            raise ValueError('Unable to determine zip size: Content-Range header missing or invalid')
+        total_size = int(content_range.split('/')[1])
+        return total_size
+
+    def _iter_zip_bytes(self, chunk_size_bytes: int) -> Iterator[bytes]:
+        remote_storage_endpoint = DataRecordRemoteStorageEndpoint(
+            resource_version_uuid=self._state['resource_version_uuid'],
+        )
+        presigned_url = remote_storage_endpoint.get_remote_url()
+        response = HttpClient.request(url=presigned_url, headers={'range': 'bytes=0-0'})
+        content_range = response.headers.get('Content-Range', '')
+        if not content_range or '/' not in content_range:
+            raise ValueError('Unable to determine zip size: Content-Range header missing or invalid')
+        total_size = int(content_range.split('/')[1])
+
+        for start in range(0, total_size, chunk_size_bytes):
+            end = min(start + chunk_size_bytes - 1, total_size - 1)
+            presigned_url = remote_storage_endpoint.get_remote_url()
+            response = HttpClient.request(
+                url=presigned_url,
+                headers={'range': f'bytes={start}-{end}'},
+                timeout_in_seconds=300,
+            )
+            yield response.content
+
+    @staticmethod
+    def clone(
+        source: 'DataRecord',
+        destination: 'DataRecord',
+        on_progress: Optional[Callable[[int, int], None]] = None,
+    ) -> 'DataRecord':
+        BiolibApiClient.assert_is_signed_in(authenticated_action_description='clone a Data Record')
+
+        # pylint: disable=protected-access
+        total_size_in_bytes = source._get_zip_size_bytes()
+
+        if total_size_in_bytes == 0:
+            raise ValueError('Source data record has no data to clone')
+
+        min_chunk_size_bytes = 10_000_000
+        chunk_size_in_bytes = max(min_chunk_size_bytes, int(total_size_in_bytes / 9_000))
+
+        zip_iterator = source._iter_zip_bytes(chunk_size_bytes=chunk_size_in_bytes)
+
+        new_resource_version_uuid = _upload_from_iterator(
+            resource_uuid=destination._state['resource_uuid'],
+            payload_iterator=zip_iterator,
+            payload_size_in_bytes=total_size_in_bytes,
+            publish=True,
+            on_progress=on_progress,
+        )
+        # pylint: enable=protected-access
+
+        logger.info(f"Successfully cloned data to '{destination.uri}'")
+        return DataRecord._get_by_version_uuid(new_resource_version_uuid)
+
     def delete(self) -> None:
         """Delete the data record.
 

biolib/_index/index.py

@@ -21,7 +21,7 @@ class Index:
 
     @property
     def id(self) -> str:
-        return f"{self._state['group_uuid']}.{self._state['resource_uuid']}".replace("-", "_")
+        return f'{self._state["group_uuid"]}.{self._state["resource_uuid"]}'.replace('-', '_')
 
     @staticmethod
     def get_by_uri(uri: str) -> 'Index':

biolib/_internal/data_record/push_data.py

@@ -1,10 +1,58 @@
+from __future__ import annotations
+
 import os
+from typing import Callable, Iterator
 
-from biolib import utils
+import biolib.api as api
 from biolib._internal.file_utils import get_files_and_size_of_directory, get_iterable_zip_stream
 from biolib.biolib_errors import BioLibError
 from biolib.biolib_logging import logger
 from biolib.typing_utils import List, Optional, Tuple
+from biolib.utils import MultiPartUploader
+
+
+def _upload_from_iterator(
+    payload_iterator: Iterator[bytes],
+    payload_size_in_bytes: int,
+    resource_uuid: Optional[str] = None,
+    resource_version_uuid: Optional[str] = None,
+    use_process_pool: bool = False,
+    publish: bool = False,
+    on_progress: Optional[Callable[[int, int], None]] = None,
+) -> str:
+    if (resource_uuid is None) == (resource_version_uuid is None):
+        raise ValueError('Must provide exactly one of resource_uuid or resource_version_uuid')
+
+    if resource_version_uuid is None:
+        response = api.client.post(
+            path='/lfs/versions/',
+            data={'resource_uuid': resource_uuid},
+        )
+        resource_version_uuid = response.json()['uuid']
+
+    multipart_uploader = MultiPartUploader(
+        use_process_pool=use_process_pool,
+        get_presigned_upload_url_request={
+            'headers': None,
+            'requires_biolib_auth': True,
+            'path': f'/lfs/versions/{resource_version_uuid}/presigned_upload_url/',
+        },
+        complete_upload_request={
+            'headers': None,
+            'requires_biolib_auth': True,
+            'path': f'/lfs/versions/{resource_version_uuid}/complete_upload/',
+        },
+        on_progress=on_progress,
+    )
+    multipart_uploader.upload(payload_iterator=payload_iterator, payload_size_in_bytes=payload_size_in_bytes)
+
+    if publish:
+        api.client.patch(
+            path=f'/resources/versions/{resource_version_uuid}/',
+            data={'state': 'published', 'set_as_active': True},
+        )
+
+    return resource_version_uuid
 
 
 def validate_data_path_and_get_files_and_size_of_directory(data_path: str) -> Tuple[List[str], int]:
@@ -28,9 +76,14 @@ def push_data_path(
     data_path: str,
     data_size_in_bytes: int,
     files_to_zip: List[str],
-    resource_version_uuid: str,
+    resource_uuid: Optional[str] = None,
+    resource_version_uuid: Optional[str] = None,
     chunk_size_in_mb: Optional[int] = None,
-) -> None:
+    publish: bool = False,
+) -> str:
+    if (resource_uuid is None) == (resource_version_uuid is None):
+        raise ValueError('Must provide exactly one of resource_uuid or resource_version_uuid')
+
     original_working_dir = os.getcwd()
     os.chdir(data_path)
 
@@ -49,19 +102,15 @@ def push_data_path(
     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(
+
+    new_resource_version_uuid = _upload_from_iterator(
+        payload_iterator=iterable_zip_stream,
+        payload_size_in_bytes=data_size_in_bytes,
+        resource_uuid=resource_uuid,
+        resource_version_uuid=resource_version_uuid,
         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/',
-        ),
+        publish=publish,
     )
 
-    multipart_uploader.upload(payload_iterator=iterable_zip_stream, payload_size_in_bytes=data_size_in_bytes)
     os.chdir(original_working_dir)
+    return new_resource_version_uuid

biolib/_internal/utils/__init__.py

@@ -1,3 +1,4 @@
+import base64
 import time
 import uuid
 from fnmatch import fnmatch
@@ -41,3 +42,17 @@ def open_browser_window_from_notebook(url_to_open: str) -> None:
     display(Javascript(f'window.open("{url_to_open}");'), display_id=display_id)
     time.sleep(1)
     update_display(Javascript(''), display_id=display_id)
+
+
+def base64_encode_string(input_str: str) -> str:
+    input_bytes = input_str.encode('utf-8')
+    base64_bytes = base64.b64encode(input_bytes)
+    base64_str = base64_bytes.decode('utf-8')
+    return base64_str
+
+
+def decode_base64_string(base64_str: str) -> str:
+    base64_bytes = base64_str.encode('utf-8')
+    input_bytes = base64.b64decode(base64_bytes)
+    input_str = input_bytes.decode('utf-8')
+    return input_str

biolib/_internal/utils/auth.py

@@ -0,0 +1,46 @@
+import base64
+import binascii
+import json
+from typing import Any, Dict
+
+
+class JwtDecodeError(Exception):
+    pass
+
+
+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(payload, dict):
+        raise JwtDecodeError('Invalid payload string: must be a json object')
+
+    return dict(header=header, payload=payload)

biolib/_runtime/runtime.py

@@ -38,7 +38,7 @@ class Runtime:
         return job_requested_machine
 
     @staticmethod
-    def get_job_requested_spot_machine() -> bool:
+    def is_spot_machine_requested() -> bool:
         job_data = Runtime._get_job_data()
         return job_data.get('job_requested_machine_spot', False)
 

biolib/_shared/types/__init__.py

@@ -19,11 +19,14 @@ from .experiment import (
 )
 from .file_node import FileNodeDict, FileZipMetadataDict, ZipFileNodeDict
 from .push import PushResponseDict
-from .resource import ResourceUriDict, SemanticVersionDict
+from .resource import ResourceDetailedDict, ResourceDict, ResourceTypeLiteral, ResourceUriDict, SemanticVersionDict
 from .resource_deploy_key import ResourceDeployKeyDict, ResourceDeployKeyWithSecretDict
 from .resource_permission import ResourcePermissionDetailedDict, ResourcePermissionDict
-from .resource_types import ResourceDetailedDict, ResourceDict
-from .resource_version import ResourceVersionDetailedDict, ResourceVersionDict
+from .resource_version import (
+    ResourceVersionAssetsDict,
+    ResourceVersionDetailedDict,
+    ResourceVersionDict,
+)
 from .result import ResultDetailedDict, ResultDict
 from .typing import Optional
 from .user import EnterpriseSettingsDict, UserDetailedDict, UserDict
@@ -50,9 +53,11 @@ __all__ = [
     'ResourceDeployKeyWithSecretDict',
     'ResourceDetailedDict',
     'ResourceDict',
+    'ResourceTypeLiteral',
     'ResourcePermissionDetailedDict',
     'ResourcePermissionDict',
     'ResourceUriDict',
+    'ResourceVersionAssetsDict',
     'ResourceVersionDetailedDict',
     'ResourceVersionDict',
     'ResultCounts',

biolib/_shared/types/resource.py

@@ -1,4 +1,6 @@
-from .typing import Optional, TypedDict
+from .experiment import DeprecatedExperimentDict
+from .resource_version import ResourceVersionDetailedDict
+from .typing import Literal, NotRequired, Optional, TypedDict
 
 
 class SemanticVersionDict(TypedDict):
@@ -15,3 +17,21 @@ class ResourceUriDict(TypedDict):
     resource_prefix: Optional[str]
     version: Optional[SemanticVersionDict]
     tag: Optional[str]
+
+
+ResourceTypeLiteral = Literal['app', 'data-record', 'experiment', 'index']
+
+
+class ResourceDict(TypedDict):
+    uuid: str
+    uri: str
+    name: str
+    created_at: str
+    description: str
+    account_uuid: str
+
+
+class ResourceDetailedDict(ResourceDict):
+    type: ResourceTypeLiteral
+    version: NotRequired[ResourceVersionDetailedDict]
+    experiment: Optional[DeprecatedExperimentDict]

biolib/_shared/types/resource_permission.py

@@ -1,4 +1,4 @@
-from .resource_types import ResourceDict
+from .resource import ResourceDict
 from .typing import TypedDict
 
 

biolib/_shared/types/resource_version.py

@@ -1,4 +1,9 @@
-from .typing import Literal, NotRequired, TypedDict
+from .typing import Literal, NotRequired, Optional, TypedDict
+
+
+class ResourceVersionAssetsDict(TypedDict):
+    download_url: str
+    size_bytes: int
 
 
 class ResourceVersionDict(TypedDict):
@@ -7,7 +12,8 @@ class ResourceVersionDict(TypedDict):
     state: Literal['published', 'unpublished']
     created_at: str
     git_branch_name: NotRequired[str]
+    git_commit_hash: NotRequired[str]
 
 
 class ResourceVersionDetailedDict(ResourceVersionDict):
-    pass
+    assets: Optional[ResourceVersionAssetsDict]

biolib/api/client.py

@@ -1,6 +1,3 @@
-import base64
-import binascii
-import json
 from datetime import datetime, timezone
 from json.decoder import JSONDecodeError
 from urllib.parse import urlencode, urljoin
@@ -8,7 +5,8 @@ from urllib.parse import urlencode, urljoin
 import importlib_metadata
 
 from biolib._internal.http_client import HttpClient, HttpResponse
-from biolib._shared.types.typing import Any, Dict, Optional, TypedDict, Union, cast
+from biolib._internal.utils.auth import decode_jwt_without_checking_signature
+from biolib._shared.types.typing import 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
@@ -33,10 +31,6 @@ class ApiClientInitDict(TypedDict):
     client_type: Optional[str]
 
 
-class JwtDecodeError(Exception):
-    pass
-
-
 class ApiClient(HttpClient):
     _biolib_package_version: str = _get_biolib_package_version()
 
@@ -147,7 +141,7 @@ class ApiClient(HttpClient):
 
     def _get_access_token(self) -> str:
         if self._access_token:
-            decoded_token = self._decode_jwt_without_checking_signature(self._access_token)
+            decoded_token = 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
@@ -171,41 +165,3 @@ class ApiClient(HttpClient):
 
         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)

biolib/app/app.py

@@ -113,16 +113,7 @@ class BioLibApp:
         module_input_serialized = self._get_serialized_module_input(args, stdin, files)
 
         if machine == 'local':
-            if not blocking:
-                raise BioLibError('The argument "blocking" cannot be False when running locally')
-
-            if experiment_id:
-                logger.warning('The argument "experiment_id" is ignored when running locally')
-
-            if result_prefix:
-                logger.warning('The argument "result_prefix" is ignored when running locally')
-
-            return self._run_locally(module_input_serialized)
+            raise BioLibError('Running applications locally with machine="local" is no longer supported.')
 
         job = Result._start_job_in_cloud(  # pylint: disable=protected-access
             app_uri=self._app_uri,

biolib/biolib_api_client/api_client.py

@@ -1,15 +1,13 @@
-import base64
-import binascii
-import json
 import os
 from datetime import datetime, timezone
 from json.decoder import JSONDecodeError
 
 from biolib._internal.http_client import HttpClient
+from biolib._internal.utils.auth import decode_jwt_without_checking_signature
 from biolib._runtime.runtime import Runtime
 from biolib.biolib_errors import BioLibError
 from biolib.biolib_logging import logger, logger_no_user_data
-from biolib.typing_utils import Any, Dict, Optional, TypedDict
+from biolib.typing_utils import Optional, TypedDict
 
 from .user_state import UserState
 
@@ -19,10 +17,6 @@ class UserTokens(TypedDict):
     refresh: str
 
 
-class JwtDecodeError(Exception):
-    pass
-
-
 class _ApiClient:
     def __init__(self, base_url: str, access_token: Optional[str] = None):
         self.base_url: str = base_url
@@ -60,7 +54,7 @@ class _ApiClient:
             return
 
         if self.access_token:
-            decoded_token = self.decode_jwt_without_checking_signature(self.access_token)
+            decoded_token = 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
@@ -132,44 +126,6 @@ class _ApiClient:
         self.access_token = json_response['access_token']
         self.refresh_token = json_response['refresh_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)
-
 
 class BiolibApiClient:
     api_client: Optional[_ApiClient] = None

biolib/cli/data_record.py

@@ -1,9 +1,11 @@
 import json
 import logging
 import os
+import sys
 from typing import Dict, List
 
 import click
+import rich.progress
 
 from biolib._data_record.data_record import DataRecord
 from biolib.biolib_api_client import BiolibApiClient
@@ -97,3 +99,66 @@ def delete(uri: str) -> None:
 
     record.delete()
     print(f'Data record {record.uri} has been deleted.')
+
+
+def _clone_data_record_with_progress(
+    source_record: DataRecord,
+    dest_record: DataRecord,
+) -> None:
+    # pylint: disable=protected-access
+    total_size_in_bytes = source_record._get_zip_size_bytes()
+    # pylint: enable=protected-access
+
+    if total_size_in_bytes == 0:
+        logger.info('Source data record has no data to clone')
+        return
+
+    if sys.stdout.isatty():
+        with rich.progress.Progress(
+            rich.progress.TextColumn('[bold blue]{task.description}'),
+            rich.progress.BarColumn(),
+            rich.progress.TaskProgressColumn(),
+            rich.progress.TimeRemainingColumn(),
+            rich.progress.TransferSpeedColumn(),
+        ) as progress:
+            task_id = progress.add_task('Cloning data record', total=total_size_in_bytes)
+
+            def on_progress(bytes_uploaded: int, _total_bytes: int) -> None:
+                progress.update(task_id, completed=bytes_uploaded)
+
+            DataRecord.clone(source=source_record, destination=dest_record, on_progress=on_progress)
+    else:
+        logger.info(f'Cloning ~{round(total_size_in_bytes / 10**6)}mb of data')
+        DataRecord.clone(source=source_record, destination=dest_record)
+
+
+def _get_or_create_destination_record(destination_uri: str) -> Optional[DataRecord]:
+    try:
+        return DataRecord.get_by_uri(uri=destination_uri)
+    except Exception:
+        print(f'Destination data record "{destination_uri}" does not exist.')
+        confirmation = input('Would you like to create it? [y/N]: ')
+        if confirmation.lower() != 'y':
+            print('Clone cancelled.')
+            return None
+
+        return DataRecord.create(destination=destination_uri)
+
+
+@data_record.command(help='Clone a Data Record to another location')
+@click.argument('source_uri', required=True)
+@click.argument('destination_uri', required=True)
+def clone(source_uri: str, destination_uri: str) -> None:
+    BiolibApiClient.assert_is_signed_in(authenticated_action_description='clone a Data Record')
+
+    logger.info(f'Fetching source data record: {source_uri}')
+    source_record = DataRecord.get_by_uri(uri=source_uri)
+
+    logger.info(f'Checking destination data record: {destination_uri}')
+    dest_record = _get_or_create_destination_record(destination_uri)
+    if dest_record is None:
+        return
+
+    logger.info(f'Cloning from {source_record.uri} to {dest_record.uri}...')
+    _clone_data_record_with_progress(source_record=source_record, dest_record=dest_record)
+    logger.info('Clone completed successfully.')