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

biolib/_internal/utils/job_url.py

@@ -0,0 +1,33 @@
+import re
+from urllib.parse import urlparse
+
+import biolib.utils
+from biolib.typing_utils import Optional, Tuple
+
+
+def parse_result_id_or_url(result_id_or_url: str, default_token: Optional[str] = None) -> Tuple[str, Optional[str]]:
+    result_id_or_url = result_id_or_url.strip()
+
+    if '/' not in result_id_or_url:
+        return (result_id_or_url, default_token)
+
+    if not result_id_or_url.startswith('http://') and not result_id_or_url.startswith('https://'):
+        result_id_or_url = 'https://' + result_id_or_url
+
+    parsed_url = urlparse(result_id_or_url)
+
+    if biolib.utils.BIOLIB_BASE_URL:
+        expected_base = urlparse(biolib.utils.BIOLIB_BASE_URL)
+        if parsed_url.scheme != expected_base.scheme or parsed_url.netloc != expected_base.netloc:
+            raise ValueError(f'URL must start with {biolib.utils.BIOLIB_BASE_URL}, got: {result_id_or_url}')
+
+    pattern = r'/results?/(?P<uuid>[a-f0-9-]+)/?(?:\?token=(?P<token>[^&]+))?'
+    match = re.search(pattern, result_id_or_url, re.IGNORECASE)
+
+    if not match:
+        raise ValueError(f'URL must be in format <base_url>/results/<UUID>/?token=<token>, got: {result_id_or_url}')
+
+    uuid = match.group('uuid')
+    token = match.group('token') or default_token
+
+    return (uuid, token)

biolib/_internal/utils/multinode.py

@@ -86,25 +86,23 @@ def fasta_batch_records(records, work_per_batch_min, work_per_residue=1, verbose
 
     batches = []
     batch = []
-    current_work_units = 0
-    total_work_units = 0
+    current_longest_seq_len = 0
     for record in records:
-        # Add to batch
-        batch.append(record)
-
-        # Calculate work units
-        seq = record.sequence
-        sequence_work_units = len(seq) * work_per_residue
+        seq_len = len(record.sequence)
+        potential_longest_seq_len = max(current_longest_seq_len, seq_len)
 
-        # Increase counters
-        current_work_units += sequence_work_units
-        total_work_units += sequence_work_units
+        # Calculate work units if we were to add this record
+        potential_work_units = potential_longest_seq_len * work_per_residue * (len(batch) + 1)
 
-        # If above limit, start a new batch
-        if current_work_units >= work_per_batch_min:
+        if potential_work_units >= work_per_batch_min and len(batch) > 0:
             batches.append(batch)
             batch = []
-            current_work_units = 0
+            current_longest_seq_len = 0
+            potential_longest_seq_len = seq_len
+
+        # Add to batch
+        batch.append(record)
+        current_longest_seq_len = potential_longest_seq_len
 
     # Append last batch if present
     if batch:

biolib/_runtime/runtime.py

@@ -30,13 +30,26 @@ class Runtime:
         return Runtime._get_job_data()['job_auth_token']
 
     @staticmethod
-    def get_job_requested_machine() -> str:
-        return Runtime._get_job_data()['job_requested_machine']
+    def get_job_requested_machine() -> Optional[str]:
+        job_data = Runtime._get_job_data()
+        job_requested_machine = job_data.get('job_requested_machine')
+        if not job_requested_machine:
+            return None
+        return job_requested_machine
+
+    @staticmethod
+    def get_job_requested_spot_machine() -> bool:
+        job_data = Runtime._get_job_data()
+        return job_data.get('job_requested_machine_spot', False)
 
     @staticmethod
     def get_app_uri() -> str:
         return Runtime._get_job_data()['app_uri']
 
+    @staticmethod
+    def get_max_workers() -> int:
+        return Runtime._get_job_data()['job_reserved_machines']
+
     @staticmethod
     def get_secret(secret_name: str) -> bytes:
         assert re.match(

biolib/_session/session.py

@@ -1,21 +1,23 @@
 from biolib import utils
-from biolib._internal.types import Optional
+from biolib.typing_utils import Optional
 from biolib.api.client import ApiClient, ApiClientInitDict
 from biolib.app import BioLibApp
 
 
 class Session:
-    def __init__(self, _init_dict: ApiClientInitDict) -> None:
+    def __init__(self, _init_dict: ApiClientInitDict, _experiment: Optional[str] = None) -> None:
         self._api = ApiClient(_init_dict=_init_dict)
+        self._experiment = _experiment
 
     @staticmethod
-    def get_session(refresh_token: str, base_url: Optional[str] = None, client_type: Optional[str] = None) -> 'Session':
+    def get_session(refresh_token: str, base_url: Optional[str] = None, client_type: Optional[str] = None, experiment: Optional[str] = None) -> 'Session':
         return Session(
             _init_dict=ApiClientInitDict(
                 refresh_token=refresh_token,
                 base_url=base_url or utils.load_base_url_from_env(),
                 client_type=client_type,
-            )
+            ),
+            _experiment=experiment,
         )
 
     def load(self, uri: str, suppress_version_warning: bool = False) -> BioLibApp:
@@ -39,4 +41,4 @@ class Session:
             >>> app = biolib.load('https://biolib.com/biolib/myapp/')
             >>> result = app.cli('--help')
         """
-        return BioLibApp(uri=uri, _api_client=self._api, suppress_version_warning=suppress_version_warning)
+        return BioLibApp(uri=uri, _api_client=self._api, suppress_version_warning=suppress_version_warning, _experiment=self._experiment)

biolib/_shared/types/__init__.py

@@ -0,0 +1,69 @@
+from .account import AccountDict, AccountDetailedDict
+from .account_member import AccountMemberDict
+from .app import AppDetailedDict, AppSlimDict
+from .data_record import (
+    DataRecordDetailedDict,
+    DataRecordSlimDict,
+    DataRecordTypeDict,
+    DataRecordValidationRuleDict,
+    SqliteV1Column,
+    SqliteV1DatabaseSchema,
+    SqliteV1ForeignKey,
+    SqliteV1Table,
+)
+from .experiment import (
+    DeprecatedExperimentDict,
+    ExperimentDetailedDict,
+    ExperimentDict,
+    ResultCounts,
+)
+from .file_node import FileNodeDict, FileZipMetadataDict, ZipFileNodeDict
+from .push import PushResponseDict
+from .resource import 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 .result import ResultDetailedDict, ResultDict
+from .typing import Optional
+from .user import EnterpriseSettingsDict, UserDetailedDict, UserDict
+
+__all__ = [
+    'AccountDetailedDict',
+    'AccountDict',
+    'AccountMemberDict',
+    'AppDetailedDict',
+    'AppSlimDict',
+    'DataRecordDetailedDict',
+    'DataRecordSlimDict',
+    'DataRecordTypeDict',
+    'DataRecordValidationRuleDict',
+    'DeprecatedExperimentDict',
+    'EnterpriseSettingsDict',
+    'ExperimentDetailedDict',
+    'ExperimentDict',
+    'FileNodeDict',
+    'FileZipMetadataDict',
+    'Optional',
+    'PushResponseDict',
+    'ResourceDeployKeyDict',
+    'ResourceDeployKeyWithSecretDict',
+    'ResourceDetailedDict',
+    'ResourceDict',
+    'ResourcePermissionDetailedDict',
+    'ResourcePermissionDict',
+    'ResourceUriDict',
+    'ResourceVersionDetailedDict',
+    'ResourceVersionDict',
+    'ResultCounts',
+    'ResultDetailedDict',
+    'ResultDict',
+    'SemanticVersionDict',
+    'SqliteV1Column',
+    'SqliteV1DatabaseSchema',
+    'SqliteV1ForeignKey',
+    'SqliteV1Table',
+    'UserDetailedDict',
+    'UserDict',
+    'ZipFileNodeDict',
+]

biolib/_shared/types/account.py

@@ -0,0 +1,12 @@
+from .typing import TypedDict
+
+
+class AccountDict(TypedDict):
+    uuid: str
+    handle: str
+    display_name: str
+    description: str
+
+
+class AccountDetailedDict(AccountDict):
+    bio: str

biolib/_shared/types/account_member.py

@@ -0,0 +1,8 @@
+from .typing import Literal, TypedDict
+from .user import UserDict
+
+
+class AccountMemberDict(TypedDict):
+    user: UserDict
+    role: Literal['member', 'admin']
+    added_at: str

biolib/{_internal → _shared}/types/experiment.py

@@ -20,6 +20,7 @@ class DeprecatedExperimentDict(TypedDict):
 class ExperimentDict(DeprecatedExperimentDict):
     uuid: Optional[str]
     name: Optional[str]
+    account_uuid: Optional[str]
     created_at: Optional[str]
     finished_at: Optional[str]
     last_created_at: Optional[str]

biolib/_shared/types/resource.py

@@ -0,0 +1,17 @@
+from .typing import Optional, TypedDict
+
+
+class SemanticVersionDict(TypedDict):
+    major: int
+    minor: int
+    patch: int
+
+
+class ResourceUriDict(TypedDict):
+    account_handle_normalized: str
+    account_handle: str
+    resource_name_normalized: Optional[str]
+    resource_name: Optional[str]
+    resource_prefix: Optional[str]
+    version: Optional[SemanticVersionDict]
+    tag: Optional[str]

biolib/_shared/types/resource_deploy_key.py

@@ -0,0 +1,11 @@
+from .typing import TypedDict
+
+
+class ResourceDeployKeyDict(TypedDict):
+    uuid: str
+    created_at: str
+    name: str
+
+
+class ResourceDeployKeyWithSecretDict(ResourceDeployKeyDict):
+    secret_key: str

biolib/{_internal → _shared}/types/resource_permission.py

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

biolib/{_internal → _shared}/types/user.py

@@ -3,6 +3,7 @@ from .typing import Optional, TypedDict
 
 
 class EnterpriseSettingsDict(TypedDict):
+    account_uuid: str
     dashboard_message: Optional[str]
     docs_message: Optional[str]
     featured_dashboard_app_version_uuid: Optional[str]
@@ -10,10 +11,9 @@ class EnterpriseSettingsDict(TypedDict):
 
 class UserDict(TypedDict):
     uuid: str
-    email: str
-    enterprise_settings: Optional[EnterpriseSettingsDict]
-    intrinsic_account: AccountDict
+    account: AccountDict
 
 
-class UserDetailedDict(TypedDict):
-    pass
+class UserDetailedDict(UserDict):
+    email: str
+    enterprise_settings: Optional[EnterpriseSettingsDict]

biolib/_shared/utils/__init__.py

@@ -0,0 +1,7 @@
+from biolib._shared.utils.resource_uri import normalize_resource_name, parse_resource_uri, parse_semantic_version
+
+__all__ = [
+    'normalize_resource_name',
+    'parse_resource_uri',
+    'parse_semantic_version',
+]

biolib/_shared/utils/resource_uri.py

@@ -0,0 +1,75 @@
+import re
+
+from biolib._shared.types import Optional
+from biolib._shared.types.resource import ResourceUriDict, SemanticVersionDict
+from biolib.biolib_errors import BioLibError
+
+URI_REGEX = re.compile(
+    r'^(@(?P<resource_prefix>[\w._-]+)/)?'
+    r'(?P<account_handle>[\w-]+)'
+    r'(/(?P<resource_name>[\w-]+))?'
+    r'(?::(?P<suffix>[^:]+))?$'
+)
+SEMVER_REGEX = re.compile(r'^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)$')
+TAG_REGEX = re.compile(r'^[a-z0-9-]{1,128}$')
+
+
+def normalize_resource_name(string: str) -> str:
+    return string.replace('-', '_').lower()
+
+
+def parse_semantic_version(semantic_version: str) -> SemanticVersionDict:
+    if match := SEMVER_REGEX.fullmatch(semantic_version):
+        return SemanticVersionDict(
+            major=int(match.group('major')),
+            minor=int(match.group('minor')),
+            patch=int(match.group('patch')),
+        )
+
+    raise ValueError('The version must be a valid semantic version in the format of major.minor.patch (1.2.3).')
+
+
+def parse_resource_uri(uri: str, use_account_as_name_default: bool = True) -> ResourceUriDict:
+    matches = URI_REGEX.match(uri)
+    if matches is None:
+        raise BioLibError(f"Could not parse resource uri '{uri}', uri did not match regex")
+
+    version: Optional[SemanticVersionDict] = None
+    tag: Optional[str] = None
+
+    suffix = matches.group('suffix')
+    if suffix and suffix != '*':
+        try:
+            version = parse_semantic_version(suffix)
+        except ValueError:
+            if TAG_REGEX.fullmatch(suffix):
+                tag = suffix
+            else:
+                raise BioLibError(
+                    f'Invalid version or tag "{suffix}". '
+                    'Versions must be semantic versions like "1.2.3". '
+                    'Tags must be lowercase alphanumeric or dashes and at most 128 characters.'
+                ) from None
+
+    resource_prefix_raw: Optional[str] = matches.group('resource_prefix')
+    resource_prefix = resource_prefix_raw.lower() if resource_prefix_raw is not None else None
+    account_handle: str = matches.group('account_handle')
+    account_handle_normalized: str = normalize_resource_name(account_handle)
+    resource_name: Optional[str] = matches.group('resource_name')
+
+    if resource_name:
+        resource_name_normalized = normalize_resource_name(resource_name)
+    elif use_account_as_name_default:
+        resource_name_normalized = account_handle_normalized
+    else:
+        resource_name_normalized = None
+
+    return ResourceUriDict(
+        resource_prefix=resource_prefix,
+        account_handle=account_handle,
+        account_handle_normalized=account_handle_normalized,
+        resource_name_normalized=resource_name_normalized,
+        resource_name=resource_name if resource_name is not None or not use_account_as_name_default else account_handle,
+        version=version,
+        tag=tag,
+    )

biolib/api/client.py

@@ -8,7 +8,7 @@ from urllib.parse import urlencode, urljoin
 import importlib_metadata
 
 from biolib._internal.http_client import HttpClient, HttpResponse
-from biolib._internal.types.typing import Any, Dict, Optional, TypedDict, Union, cast
+from biolib._shared.types.typing import Any, Dict, Optional, TypedDict, Union, cast
 from biolib.biolib_api_client import BiolibApiClient as DeprecatedApiClient
 from biolib.biolib_errors import BioLibError
 from biolib.biolib_logging import logger

biolib/app/app.py

@@ -1,11 +1,16 @@
+import copy
 import io
 import json
 import os
+import posixpath
 import random
 import string
 from pathlib import Path
 
 from biolib import utils
+from biolib._internal.file_utils import path_to_renamed_path
+from biolib._runtime.runtime import Runtime
+from biolib._shared.utils import parse_resource_uri
 from biolib.api.client import ApiClient
 from biolib.biolib_api_client import JobState
 from biolib.biolib_api_client.app_types import App, AppVersion
@@ -18,13 +23,24 @@ from biolib.compute_node.job_worker.job_worker import JobWorker
 from biolib.experiments.experiment import Experiment
 from biolib.jobs.job import Result
 from biolib.typing_utils import Dict, Optional
-from biolib.utils.app_uri import parse_app_uri
-from biolib._runtime.runtime import Runtime
+
+
+class JsonStringIO(io.StringIO):
+    pass
 
 
 class BioLibApp:
-    def __init__(self, uri: str, _api_client: Optional[ApiClient] = None, suppress_version_warning: bool = False):
+    def __init__(
+        self,
+        uri: str,
+        _api_client: Optional[ApiClient] = None,
+        suppress_version_warning: bool = False,
+        _experiment: Optional[str] = None,
+    ):
         self._api_client: Optional[ApiClient] = _api_client
+        self._experiment = _experiment
+        self._input_uri = uri
+        self._parsed_input_uri = parse_resource_uri(uri)
 
         app_response = BiolibAppApi.get_by_uri(uri=uri, api_client=self._api_client)
         self._app: App = app_response['app']
@@ -32,16 +48,19 @@ class BioLibApp:
         self._app_version: AppVersion = app_response['app_version']
 
         if not suppress_version_warning:
-            parsed_uri = parse_app_uri(uri)
-            if parsed_uri['version'] is None:
+            if self._parsed_input_uri['version'] is None:
                 if Runtime.check_is_environment_biolib_app():
                     logger.warning(
                         f"No version specified in URI '{uri}'. This will use the default version, "
-                        f"which may change behaviour over time. Consider locking down the exact version, "
+                        f'which may change behaviour over time. Consider locking down the exact version, '
                         f"e.g. '{uri}:1.2.3'"
                     )
 
-        logger.info(f'Loaded project {self._app_uri}')
+        if self._parsed_input_uri['tag']:
+            semantic_version = f"{self._app_version['major']}.{self._app_version['minor']}.{self._app_version['patch']}"
+            logger.info(f'Loaded {self._input_uri} (resolved to {semantic_version})')
+        else:
+            logger.info(f'Loaded {self._app_uri}')
 
     def __str__(self) -> str:
         return self._app_uri
@@ -70,7 +89,7 @@ class BioLibApp:
         result_prefix: Optional[str] = None,
         timeout: Optional[int] = None,
         notify: bool = False,
-        machine_count: Optional[int] = None,
+        max_workers: Optional[int] = None,
         experiment: Optional[str] = None,
         temporary_client_secrets: Optional[Dict[str, str]] = None,
         check: bool = False,
@@ -83,7 +102,12 @@ class BioLibApp:
             raise ValueError('The argument "check" cannot be True when blocking is False')
 
         if not experiment_id:
-            experiment_instance = Experiment(experiment) if experiment else Experiment.get_experiment_in_context()
+            experiment_to_use = experiment if experiment is not None else self._experiment
+            experiment_instance: Optional[Experiment]
+            if experiment_to_use:
+                experiment_instance = Experiment(experiment_to_use, _api_client=self._api_client)
+            else:
+                experiment_instance = Experiment.get_experiment_in_context()
             experiment_id = experiment_instance.uuid if experiment_instance else None
 
         module_input_serialized = self._get_serialized_module_input(args, stdin, files)
@@ -110,11 +134,12 @@ class BioLibApp:
             override_command=override_command,
             result_prefix=result_prefix,
             timeout=timeout,
-            requested_machine_count=machine_count,
+            requested_machine_count=max_workers,
             temporary_client_secrets=temporary_client_secrets,
             api_client=self._api_client,
         )
-        logger.info(f'View the result in your browser at: {utils.BIOLIB_BASE_URL}/results/{job.id}/')
+        if utils.IS_RUNNING_IN_NOTEBOOK:
+            logger.info(f'View the result in your browser at: {utils.BIOLIB_BASE_URL}/results/{job.id}/')
         if blocking:
             # TODO: Deprecate utils.STREAM_STDOUT and always stream logs by simply calling job.stream_logs()
             if utils.IS_RUNNING_IN_NOTEBOOK:
@@ -151,6 +176,8 @@ Example: "app.cli('--help')"
     def _get_serialized_module_input(args=None, stdin=None, files=None) -> bytes:
         if args is None:
             args = []
+        else:
+            args = copy.copy(args)
 
         if stdin is None:
             stdin = b''
@@ -168,21 +195,72 @@ Example: "app.cli('--help')"
             files = []
 
         files_dict = {}
+        if isinstance(files, list):
+            for file_path in files:
+                path = Path(file_path)
+                if path.is_dir():
+                    renamed_dir = path_to_renamed_path(file_path)
+                    for filename in path.rglob('*'):
+                        if filename.is_dir():
+                            continue
+                        with open(filename, 'rb') as f:
+                            relative_to_dir = filename.resolve().relative_to(path.resolve())
+                            files_dict[posixpath.join(renamed_dir, relative_to_dir.as_posix())] = f.read()
+                else:
+                    with open(path, 'rb') as f:
+                        files_dict[path_to_renamed_path(str(path))] = f.read()
+        elif isinstance(files, dict):
+            files_dict = {}
+            for key, value in files.items():
+                if '//' in key:
+                    raise BioLibError(f"File path '{key}' contains double slashes which are not allowed")
+                if not key.startswith('/'):
+                    key = '/' + key
+                files_dict[key] = value
+        else:
+            raise Exception('The given files input must be list or dict or None')
+
         for idx, arg in enumerate(args):
             if isinstance(arg, str):
                 if os.path.isfile(arg) or os.path.isdir(arg):
-                    files.append(arg)
-                    args[idx] = Path(arg).name
+                    if os.path.isfile(arg):
+                        with open(arg, 'rb') as f:
+                            files_dict[path_to_renamed_path(arg)] = f.read()
+                    elif os.path.isdir(arg):
+                        path = Path(arg)
+                        renamed_dir = path_to_renamed_path(arg)
+                        for filename in path.rglob('*'):
+                            if filename.is_dir():
+                                continue
+                            with open(filename, 'rb') as f:
+                                relative_to_dir = filename.resolve().relative_to(path.resolve())
+                                files_dict[posixpath.join(renamed_dir, relative_to_dir.as_posix())] = f.read()
+                    args[idx] = path_to_renamed_path(arg, prefix_with_slash=False)
 
                 # support --myarg=file.txt
                 elif os.path.isfile(arg.split('=')[-1]) or os.path.isdir(arg.split('=')[-1]):
-                    files.append(arg.split('=')[-1])
-                    args[idx] = arg.split('=')[0] + '=' + Path(arg.split('=')[-1]).name
+                    file_path = arg.split('=')[-1]
+                    if os.path.isfile(file_path):
+                        with open(file_path, 'rb') as f:
+                            files_dict[path_to_renamed_path(file_path)] = f.read()
+                    elif os.path.isdir(file_path):
+                        path = Path(file_path)
+                        renamed_dir = path_to_renamed_path(file_path)
+                        for filename in path.rglob('*'):
+                            if filename.is_dir():
+                                continue
+                            with open(filename, 'rb') as f:
+                                relative_to_dir = filename.resolve().relative_to(path.resolve())
+                                files_dict[posixpath.join(renamed_dir, relative_to_dir.as_posix())] = f.read()
+                    args[idx] = arg.split('=')[0] + '=' + path_to_renamed_path(file_path, prefix_with_slash=False)
                 else:
                     pass  # a normal string arg was given
             else:
                 tmp_filename = f'input_{"".join(random.choices(string.ascii_letters + string.digits, k=7))}'
-                if isinstance(arg, io.StringIO):
+                if isinstance(arg, JsonStringIO):
+                    file_data = arg.getvalue().encode()
+                    tmp_filename += '.json'
+                elif isinstance(arg, io.StringIO):
                     file_data = arg.getvalue().encode()
                 elif isinstance(arg, io.BytesIO):
                     file_data = arg.getvalue()
@@ -191,33 +269,6 @@ Example: "app.cli('--help')"
                 files_dict[f'/{tmp_filename}'] = file_data
                 args[idx] = tmp_filename
 
-        if isinstance(files, list):
-            for file in files:
-                path = Path(file).absolute()
-
-                # Recursively add data from files if dir
-                if path.is_dir():
-                    for filename in path.rglob('*'):
-                        if filename.is_dir():
-                            continue
-                        file = open(filename, 'rb')
-                        relative_path = '/' + path.name + '/' + '/'.join(filename.relative_to(path).parts)
-                        files_dict[relative_path] = file.read()
-                        file.close()
-
-                # Add file data
-                else:
-                    file = open(path, 'rb')
-                    path_short = '/' + path.name
-
-                    files_dict[path_short] = file.read()
-                    file.close()
-
-        elif isinstance(files, dict):
-            files_dict.update(files)
-        else:
-            raise Exception('The given files input must be list or dict or None')
-
         module_input_serialized: bytes = ModuleInput().serialize(
             stdin=stdin,
             arguments=args,
@@ -228,7 +279,7 @@ Example: "app.cli('--help')"
     def _run_locally(self, module_input_serialized: bytes) -> Result:
         job_dict = BiolibJobApi.create(
             app_version_id=self._app_version['public_id'],
-            app_resource_name_prefix=parse_app_uri(self._app_uri)['resource_name_prefix'],
+            app_resource_name_prefix=parse_resource_uri(self._app_uri)['resource_prefix'],
         )
         job = Result(job_dict)
 
@@ -253,7 +304,7 @@ Example: "app.cli('--help')"
                 continue
 
             if isinstance(value, dict):
-                value = io.StringIO(json.dumps(value))
+                value = JsonStringIO(json.dumps(value))
             elif isinstance(value, (int, float)):  # Cast numeric values to strings
                 value = str(value)
 

biolib/biolib_api_client/app_types.py

@@ -78,6 +78,7 @@ class _Module(TypedDict):
     large_file_systems: List[LargeFileSystemMapping]
     name: str
     output_files_mappings: List[FilesMapping]
+    ports: List[int]
     source_files_mappings: List[FilesMapping]
     working_directory: str