pybiolib 1.1.1747__py3-none-any.whl → 1.1.2193__py3-none-any.whl

biolib/app/search_apps.py

@@ -7,41 +7,37 @@ from biolib.typing_utils import Optional, List
 def search_apps(
         search_query: Optional[str] = None,
         team: Optional[str] = None,
-        count: int = 100
-    ) -> List[str]:
-
+        count: int = 100,
+) -> List[str]:
     query_exceeded_page_size = False
     params = {
         'page_size': count,
     }
     if team:
-        if not team.startswith("@"):
-            team = "@biolib.com/" + team
+        if not team.startswith('@'):
+            team = '@biolib.com/' + team
         params['account_handle'] = team
 
     if search_query:
         params['search'] = search_query
 
-    apps_json = api.client.get(
-        path='/apps/',
-        params=params
-    ).json()
+    apps_json = api.client.get(path='/apps/', params=params).json()
     if apps_json['count'] > count:
         query_exceeded_page_size = True
 
     apps = [app['resource_uri'] for app in apps_json['results']]
 
-    if not utils.BASE_URL_IS_PUBLIC_BIOLIB and (not team or team.lower().startswith("@biolib.com")):
+    if not utils.BASE_URL_IS_PUBLIC_BIOLIB and (not team or team.lower().startswith('@biolib.com')):
         # Also get federated apps if running on enterprise deployment
         public_biolib_apps_json = api.client.get(
             authenticate=False,
             path='https://biolib.com/api/apps/',
-            params=params
+            params=params,
         ).json()
         if public_biolib_apps_json['count'] > count:
             query_exceeded_page_size = True
 
-        apps.extend([f'@biolib.com/{app["resource_uri"]}' for app in public_biolib_apps_json['results']])
+        apps.extend([f"@biolib.com/{app['resource_uri']}" for app in public_biolib_apps_json['results']])
 
     if query_exceeded_page_size:
         print(f'Search results exceeded {count}, use the argument "count" to increase the amount of results returned')

biolib/biolib_api_client/api_client.py

@@ -6,6 +6,7 @@ import os
 from datetime import datetime, timezone
 from json.decoder import JSONDecodeError
 
+from biolib._runtime.runtime import Runtime
 from biolib._internal.http_client import HttpClient
 from biolib.typing_utils import Optional
 from biolib.biolib_errors import BioLibError
@@ -61,16 +62,18 @@ class _ApiClient:
             return
 
         if self.access_token:
-            decoded_token = self._decode_jwt_without_checking_signature(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
 
         # 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})
+            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
@@ -111,9 +114,11 @@ class _ApiClient:
     def sign_in_with_api_token(self, api_token: str) -> None:
         logger_no_user_data.debug('ApiClient: Signing in with BIOLIB_TOKEN...')
         try:
-            response = HttpClient.request(method='POST',
-                                        url=f'{self.base_url}/api/user/api_tokens/exchange/',
-                                        data={'token': api_token})
+            response = HttpClient.request(
+                method='POST',
+                url=f'{self.base_url}/api/user/api_tokens/exchange/',
+                data={'token': api_token},
+            )
         except Exception as exception:
             logger.error('Sign in with API token failed')
             raise exception
@@ -127,7 +132,7 @@ class _ApiClient:
         self.refresh_token = json_response['refresh_token']
 
     @staticmethod
-    def _decode_jwt_without_checking_signature(jwt: str) -> Dict[str, Any]:
+    def decode_jwt_without_checking_signature(jwt: str) -> Dict[str, Any]:
         jwt_bytes = jwt.encode('utf-8')
 
         try:
@@ -187,9 +192,16 @@ class BiolibApiClient:
         api_client.refresh_access_token()
 
     @staticmethod
-    def assert_is_signed_in(authenticated_action_description: str) -> None:
+    def is_reauthentication_needed() -> bool:
         api_client = BiolibApiClient.get()
-        if not api_client.is_signed_in:
+        if not api_client.is_signed_in and not Runtime.check_is_environment_biolib_app():
+            return True
+        else:
+            return False
+
+    @staticmethod
+    def assert_is_signed_in(authenticated_action_description: str) -> None:
+        if BiolibApiClient.is_reauthentication_needed():
             raise BioLibError(
                 f'You must be signed in to {authenticated_action_description}. '
                 f'Please set the environment variable "BIOLIB_TOKEN"'

biolib/biolib_api_client/app_types.py

@@ -1,7 +1,7 @@
 from enum import Enum
 
-from biolib.typing_utils import TypedDict, List, Optional, Dict, Literal
 from biolib.biolib_api_client.common_types import SemanticVersion
+from biolib.typing_utils import Dict, List, Literal, Optional, TypedDict
 
 
 class AppVersionSlim(SemanticVersion):
@@ -16,6 +16,7 @@ class AppVersion(AppVersionSlim):
     source_code_license: str
     stdout_render_type: Literal['text', 'markdown']
     main_output_file: Optional[str]
+    app_uri: str
 
 
 class App(TypedDict):

biolib/biolib_api_client/biolib_app_api.py

@@ -35,7 +35,7 @@ def encode_multipart(data, files):
     line_array.append('')
 
     data_encoded = b'\r\n'.join([line.encode() if isinstance(line, str) else line for line in line_array])
-    return 'multipart/form-data; boundary={}'.format(boundary), data_encoded
+    return f'multipart/form-data; boundary={boundary}', data_encoded
 
 
 def _get_git_branch_name() -> str:

biolib/biolib_api_client/biolib_job_api.py

@@ -46,6 +46,7 @@ class BiolibJobApi:
             experiment_uuid: Optional[str] = None,
             timeout: Optional[int] = None,
             notify: bool = False,
+            requested_machine_count: Optional[int] = None,
     ):
         data = {
             'app_version_id': app_version_id,
@@ -73,6 +74,9 @@ class BiolibJobApi:
                 'requested_machine': machine
             })
 
+        if requested_machine_count:
+            data.update({'requested_machine_count': requested_machine_count})
+
         if experiment_uuid:
             data['experiment_uuid'] = experiment_uuid
 
@@ -156,6 +160,7 @@ class BiolibJobApi:
             caller_job_uuid: Optional[str] = None,
             requested_timeout_seconds: Optional[int] = None,
             notify: bool = False,
+            requested_machine_count: Optional[int] = None,
     ) -> Dict:
         job_dict: Dict = biolib.api.client.post(
             path='/jobs/create_job_with_data/',
@@ -171,6 +176,7 @@ class BiolibJobApi:
                 'client-version': BIOLIB_PACKAGE_VERSION,
                 'experiment-uuid': experiment_uuid,
                 'requested-machine': requested_machine,
+                'requested-machine-count': str(requested_machine_count) if requested_machine_count else None,
                 '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',

biolib/biolib_api_client/job_types.py

@@ -1,9 +1,8 @@
 from enum import Enum
 
-from biolib.compute_node.webserver.webserver_types import ComputeNodeInfo
-from biolib.typing_utils import TypedDict, Optional, List
-
 from biolib.biolib_api_client.app_types import AppVersionOnJob, RemoteHost
+from biolib.compute_node.webserver.webserver_types import ComputeNodeInfo
+from biolib.typing_utils import List, Optional, TypedDict
 
 
 class JobState(Enum):
@@ -15,6 +14,7 @@ class JobState(Enum):
 
 
 class _Job(TypedDict):
+    app_uri: str
     app_version: AppVersionOnJob
     arguments_override_command: bool
     auth_token: str
@@ -22,10 +22,10 @@ class _Job(TypedDict):
     created_at: str
     federated_job_uuid: Optional[str]
     public_id: str
-    uuid: str
     remote_hosts_with_warning: List[RemoteHost]
     state: str
     user_id: Optional[str]
+    uuid: str
 
 
 # type optional keys with total=False

biolib/biolib_api_client/lfs_types.py

@@ -1,13 +1,19 @@
 from biolib.typing_utils import TypedDict
 
 
-class LargeFileSystemVersion(TypedDict):
+class DataRecordVersion(TypedDict):
     presigned_download_url: str
     size_bytes: int
     uri: str
     uuid: str
 
 
-class LargeFileSystem(TypedDict):
+class DataRecordInfo(TypedDict):
     uri: str
     uuid: str
+
+
+class DataRecordVersionInfo(TypedDict):
+    resource_uri: str
+    resource_uuid: str
+    resource_version_uuid: str

biolib/biolib_binary_format/remote_endpoints.py

@@ -1,25 +1,27 @@
 from datetime import datetime, timedelta
-# from urllib.parse import urlparse, parse_qs
-
-from biolib.biolib_logging import logger
 
 from biolib.biolib_api_client.biolib_job_api import BiolibJobApi
 from biolib.biolib_binary_format.utils import RemoteEndpoint
 
+# from urllib.parse import urlparse, parse_qs
+from biolib.biolib_logging import logger
+from biolib.typing_utils import Literal
+
 
-class RemoteJobStorageResultEndpoint(RemoteEndpoint):
-    def __init__(self, job_id: str, job_auth_token: str):
-        self._job_id = job_id
-        self._job_auth_token = job_auth_token
+class RemoteJobStorageEndpoint(RemoteEndpoint):
+    def __init__(self, job_uuid: str, job_auth_token: str, storage_type: Literal['input', 'output']):
         self._expires_at = None
+        self._job_auth_token = job_auth_token
+        self._job_uuid = job_uuid
         self._presigned_url = None
+        self._storage_type: Literal['input', 'output'] = storage_type
 
     def get_remote_url(self):
         if not self._presigned_url or datetime.utcnow() > self._expires_at:
             self._presigned_url = BiolibJobApi.get_job_storage_download_url(
                 job_auth_token=self._job_auth_token,
-                job_uuid=self._job_id,
-                storage_type='results'
+                job_uuid=self._job_uuid,
+                storage_type='results' if self._storage_type == 'output' else 'input',
             )
             self._expires_at = datetime.utcnow() + timedelta(minutes=8)
             # TODO: Use expires at from url
@@ -27,6 +29,6 @@ class RemoteJobStorageResultEndpoint(RemoteEndpoint):
             # query_params = parse_qs(parsed_url.query)
             # time_at_generation = datetime.datetime.strptime(query_params['X-Amz-Date'][0], '%Y%m%dT%H%M%SZ')
             # self._expires_at = time_at_generation + timedelta(seconds=int(query_params['X-Amz-Expires'][0]))
-            logger.debug(f'Job "{self._job_id}" fetched presigned URL with expiry at {self._expires_at.isoformat()}')
+            logger.debug(f'Job "{self._job_uuid}" fetched presigned URL with expiry at {self._expires_at.isoformat()}')
 
         return self._presigned_url

biolib/biolib_binary_format/utils.py

@@ -1,6 +1,8 @@
 from abc import ABC, abstractmethod
 import io
-
+import math
+from typing import Optional, Callable
+from biolib.typing_utils import Iterator
 from biolib._internal.http_client import HttpClient
 
 
@@ -106,10 +108,18 @@ class InMemoryIndexableBuffer(IndexableBuffer):
 
 class LazyLoadedFile:
 
-    def __init__(self, path: str, buffer: IndexableBuffer, start: int, length: int):
+    def __init__(
+            self,
+            path: str,
+            buffer: IndexableBuffer,
+            start: Optional[int],
+            length: int,
+            start_func: Optional[Callable[[], int]] = None,
+    ):
         self._path = path
         self._buffer = buffer
         self._start = start
+        self._start_func = start_func
         self._length = length
 
     def __repr__(self) -> str:
@@ -119,8 +129,16 @@ class LazyLoadedFile:
     def path(self) -> str:
         return self._path
 
+    @property
+    def name(self) -> str:
+        return self._path.split('/')[-1]
+
     @property
     def start(self) -> int:
+        if self._start is None:
+            assert self._start_func is not None, 'No start function or start value'
+            self._start = self._start_func()
+
         return self._start
 
     @property
@@ -130,5 +148,24 @@ class LazyLoadedFile:
     def get_file_handle(self) -> io.BufferedIOBase:
         return io.BytesIO(self.get_data())
 
-    def get_data(self) -> bytes:
-        return self._buffer.get_data(start=self._start, length=self._length)
+    def get_data(self, start=0, length=None) -> bytes:
+        start_offset = start + self.start
+        # make sure length doesn't go outside file boundaries
+        length_to_end_of_file = max(self._length - start, 0)
+        if length is None:
+            length_to_request = length_to_end_of_file
+        else:
+            length_to_request = min(length, length_to_end_of_file)
+        return self._buffer.get_data(start=start_offset, length=length_to_request)
+
+    def get_data_iterator(self) -> Iterator[bytes]:
+        if self._length == 0:
+            yield b''
+        else:
+            chunk_size = 10_000_000
+            chunks_to_yield = math.ceil(self._length / chunk_size)
+            for chunk_idx in range(chunks_to_yield - 1):
+                yield self._buffer.get_data(start=self.start+chunk_idx*chunk_size, length=chunk_size)
+            data_already_yielded = (chunks_to_yield - 1)*chunk_size
+            yield self._buffer.get_data(start=self.start+data_already_yielded,
+                                        length=self._length - data_already_yielded)

biolib/cli/__init__.py

@@ -5,7 +5,7 @@ import click
 
 from biolib import utils
 from biolib.biolib_logging import logger, logger_no_user_data
-from biolib.cli import init, lfs, push, run, start, runtime, download_container
+from biolib.cli import auth, data_record, download_container, init, lfs, push, run, runtime, start
 
 
 @click.version_option(version=utils.BIOLIB_PACKAGE_VERSION, prog_name='pybiolib')
@@ -20,13 +20,17 @@ def cli() -> None:
     logger_no_user_data.configure(default_log_level=logging.WARNING)
 
 
+cli.add_command(auth.login)
+cli.add_command(auth.logout)
+cli.add_command(auth.whoami)
+cli.add_command(download_container.download_container)
 cli.add_command(init.init)
 cli.add_command(lfs.lfs)
 cli.add_command(push.push)
 cli.add_command(run.run)
 cli.add_command(runtime.runtime)
 cli.add_command(start.start)
-cli.add_command(download_container.download_container)
+cli.add_command(data_record.data_record)
 
 # allow this script to be called without poetry in dev e.g. by an IDE debugger
 if utils.IS_DEV and __name__ == '__main__':

biolib/cli/auth.py

@@ -0,0 +1,58 @@
+import logging
+import sys
+
+import click
+
+from biolib import api, biolib_errors
+from biolib.biolib_api_client.api_client import BiolibApiClient
+from biolib.biolib_logging import logger, logger_no_user_data
+from biolib.user import sign_in, sign_out
+
+
+@click.command(help='Login your to BioLib account with web browser')
+@click.option(
+    '-w',
+    is_flag=True,
+    default=False,
+    required=False,
+    type=bool,
+    help='Automatically open the login page in the default web browser',
+)
+def login(w: bool) -> None:  # pylint: disable=invalid-name
+    logger.configure(default_log_level=logging.INFO)
+    logger_no_user_data.configure(default_log_level=logging.INFO)
+    sign_in(open_in_default_browser=w)
+
+
+@click.command(help='Logout of your BioLib account')
+def logout() -> None:
+    logger.configure(default_log_level=logging.INFO)
+    logger_no_user_data.configure(default_log_level=logging.INFO)
+    sign_out()
+
+
+@click.command(help='Prints out the full name of the user logged in')
+def whoami() -> None:
+    client = BiolibApiClient.get()
+    if client.is_signed_in:
+        user_uuid = None
+        if client.access_token is None:
+            print('Unable to fetch user credentials. Please try logging out and logging in again.')
+            exit(1)
+        try:
+            user_uuid = client.decode_jwt_without_checking_signature(jwt=client.access_token)['payload']['public_id']
+        except biolib_errors.BioLibError as error:
+            print(
+                f'Unable to reference user public_id in access token:\n {error.message}',
+                file=sys.stderr,
+            )
+            exit(1)
+        response = api.client.get(path=f'/user/{user_uuid}/')
+        user_dict = response.json()
+        email = user_dict['email']
+        intrinsic_account = [account for account in user_dict['accounts'] if account['role'] == 'intrinsic'][0]
+        display_name = intrinsic_account['display_name']
+        print(f'Name: {display_name}\nEmail: {email}\nLogged into: {client.base_url}')
+    else:
+        print('Not logged in', file=sys.stderr)
+        exit(1)

biolib/cli/data_record.py

@@ -0,0 +1,80 @@
+import json
+import logging
+import os
+from typing import Dict, List
+
+import click
+
+from biolib._data_record.data_record import DataRecord
+from biolib.biolib_logging import logger, logger_no_user_data
+from biolib.typing_utils import Optional
+
+
+@click.group(help='Data Records')
+def data_record() -> None:
+    logger.configure(default_log_level=logging.INFO)
+    logger_no_user_data.configure(default_log_level=logging.INFO)
+
+
+@data_record.command(help='Create a Data Record')
+@click.argument('uri', required=True)
+@click.option('--data-path', required=True, type=click.Path(exists=True))
+@click.option('--record-type', required=False, type=str, default=None)
+def create(uri: str, data_path: str, record_type: Optional[str]) -> None:
+    DataRecord.create(destination=uri, data_path=data_path, record_type=record_type)
+
+
+@data_record.command(help='Update a Data Record')
+@click.argument('uri', required=True)
+@click.option('--data-path', required=True, type=click.Path(exists=True))
+@click.option('--chunk-size', default=None, required=False, type=click.INT, help='The size of each chunk (In MB)')
+def update(uri: str, data_path: str, chunk_size: Optional[int]) -> None:
+    DataRecord.get_by_uri(uri=uri).update(data_path=data_path, chunk_size_in_mb=chunk_size)
+
+
+@data_record.command(help='Download files from a Data Record')
+@click.argument('uri', required=True)
+@click.option('--file', required=False, type=str)
+@click.option('--path-filter', required=False, type=str, hide_input=True)
+def download(uri: str, file: Optional[str], path_filter: Optional[str]) -> None:
+    record = DataRecord.get_by_uri(uri=uri)
+    if file is not None:
+        try:
+            file_obj = [file_obj for file_obj in record.list_files() if file_obj.path == file][0]
+        except IndexError:
+            raise Exception('File not found in data record') from None
+
+        assert not os.path.exists(file_obj.name), 'File already exists in current directory'
+        with open(file_obj.name, 'wb') as file_handle:
+            file_handle.write(file_obj.get_data())
+
+    else:
+        assert not os.path.exists(record.name), f'Directory with name {record.name} already exists in current directory'
+        record.save_files(output_dir=record.name, path_filter=path_filter)
+
+
+@data_record.command(help='Describe a Data Record')
+@click.argument('uri', required=True)
+@click.option('--json', 'output_as_json', is_flag=True, default=False, required=False, help='Format output as JSON')
+def describe(uri: str, output_as_json: bool) -> None:
+    record = DataRecord.get_by_uri(uri)
+    files_info: List[Dict] = []
+    total_size_in_bytes = 0
+    for file in record.list_files():
+        files_info.append({'path': file.path, 'size_bytes': file.length})
+        total_size_in_bytes += file.length
+
+    if output_as_json:
+        print(
+            json.dumps(
+                obj={'uri': record.uri, 'size_bytes': total_size_in_bytes, 'files': files_info},
+                indent=4,
+            )
+        )
+    else:
+        print(f'Data Record {record.uri}\ntotal {total_size_in_bytes} bytes\n')
+        print('size bytes    path')
+        for file_info in files_info:
+            size_string = str(file_info['size_bytes'])
+            leading_space_string = ' ' * (10 - len(size_string))
+            print(f"{leading_space_string}{size_string}    {file_info['path']}")

biolib/cli/download_container.py

@@ -1,10 +1,12 @@
 import logging
+
 import click
+
 from biolib.biolib_download_container import download_container_from_uri
 from biolib.biolib_logging import logger, logger_no_user_data
 
 
-@click.command(help='Push an application to BioLib', name='download-container')
+@click.command(help='Pull an application from BioLib', name='download-container', hidden=True)
 @click.argument('uri')
 def download_container(uri: str) -> None:
     logger.configure(default_log_level=logging.INFO)

biolib/cli/init.py

@@ -2,6 +2,7 @@ import os
 import sys
 
 import click
+
 from biolib import templates
 
 

biolib/cli/lfs.py

@@ -1,12 +1,15 @@
+import json
 import logging
+import os
 import sys
+from typing import Dict, List
 
 import click
 
-import biolib.lfs
 from biolib import biolib_errors
-from biolib.biolib_logging import logger_no_user_data, logger
-from biolib.lfs import push_large_file_system, create_large_file_system, describe_large_file_system, prune_lfs_cache
+from biolib._data_record.data_record import DataRecord
+from biolib._internal.lfs import prune_lfs_cache
+from biolib.biolib_logging import logger, logger_no_user_data
 from biolib.typing_utils import Optional
 
 
@@ -18,9 +21,10 @@ def lfs() -> None:
 @lfs.command(help='Create a Large File System')
 @click.argument('uri', required=True)
 def create(uri: str) -> None:
+    logger.warning('This is command deprecated, please use "biolib data-record create" instead.')
     logger.configure(default_log_level=logging.INFO)
     logger_no_user_data.configure(default_log_level=logging.INFO)
-    create_large_file_system(lfs_uri=uri)
+    DataRecord.create(destination=uri)
 
 
 @lfs.command(help='Push a new version of a Large File System')
@@ -28,10 +32,11 @@ def create(uri: str) -> None:
 @click.option('--path', required=True, type=click.Path(exists=True))
 @click.option('--chunk-size', default=None, required=False, type=click.INT, help='The size of each chunk (In MB)')
 def push(uri: str, path: str, chunk_size: Optional[int]) -> None:
+    logger.warning('This is command deprecated, please use "biolib data-record update" instead.')
     logger.configure(default_log_level=logging.INFO)
     logger_no_user_data.configure(default_log_level=logging.INFO)
     try:
-        push_large_file_system(lfs_uri=uri, input_dir=path, chunk_size_in_mb=chunk_size)
+        DataRecord.get_by_uri(uri=uri).update(data_path=path, chunk_size_in_mb=chunk_size)
     except biolib_errors.BioLibError as error:
         print(f'An error occurred:\n{error.message}', file=sys.stderr)
         exit(1)
@@ -41,12 +46,20 @@ def push(uri: str, path: str, chunk_size: Optional[int]) -> None:
 @click.argument('uri', required=True)
 @click.option('--file-path', required=True, type=str)
 def download_file(uri: str, file_path: str) -> None:
+    logger.warning('This is command deprecated, please use "biolib data-record download" instead.')
     logger.configure(default_log_level=logging.INFO)
     logger_no_user_data.configure(default_log_level=logging.INFO)
     try:
-        data = biolib.lfs.get_file_data_from_large_file_system(lfs_uri=uri, file_path=file_path)
-        with open(file_path, mode='wb') as file:
-            file.write(data)
+        record = DataRecord.get_by_uri(uri=uri)
+        try:
+            file_obj = [file_obj for file_obj in record.list_files() if file_obj.path == file_path][0]
+        except IndexError:
+            raise Exception('File not found in data record') from None
+
+        assert not os.path.exists(file_obj.name), 'File already exists in current directory'
+        with open(file_obj.name, 'wb') as file_handle:
+            file_handle.write(file_obj.get_data())
+
     except biolib_errors.BioLibError as error:
         print(f'An error occurred:\n{error.message}', file=sys.stderr)
         exit(1)
@@ -54,9 +67,30 @@ def download_file(uri: str, file_path: str) -> None:
 
 @lfs.command(help='Describe a Large File System')
 @click.argument('uri', required=True)
-@click.option('--json', is_flag=True, default=False, required=False, help='Format output as JSON')
-def describe(uri: str, json: bool) -> None:
-    describe_large_file_system(lfs_uri=uri, output_as_json=json)
+@click.option('--json', 'output_as_json', is_flag=True, default=False, required=False, help='Format output as JSON')
+def describe(uri: str, output_as_json: bool) -> None:
+    logger.warning('This is command deprecated, please use "biolib data-record describe" instead.')
+    data_record = DataRecord.get_by_uri(uri)
+    files_info: List[Dict] = []
+    total_size_in_bytes = 0
+    for file in data_record.list_files():
+        files_info.append({'path': file.path, 'size_bytes': file.length})
+        total_size_in_bytes += file.length
+
+    if output_as_json:
+        print(
+            json.dumps(
+                obj={'uri': data_record.uri, 'size_bytes': total_size_in_bytes, 'files': files_info},
+                indent=4,
+            )
+        )
+    else:
+        print(f'Large File System {data_record.uri}\ntotal {total_size_in_bytes} bytes\n')
+        print('size bytes    path')
+        for file_info in files_info:
+            size_string = str(file_info['size_bytes'])
+            leading_space_string = ' ' * (10 - len(size_string))
+            print(f"{leading_space_string}{size_string}    {file_info['path']}")
 
 
 @lfs.command(help='Prune LFS cache', hidden=True)

biolib/cli/push.py

@@ -3,8 +3,8 @@ from typing import Optional
 
 import click
 
-from biolib.biolib_logging import logger, logger_no_user_data
 from biolib._internal.push_application import push_application
+from biolib.biolib_logging import logger, logger_no_user_data
 
 
 @click.command(help='Push an application to BioLib')