pybiolib 1.2.883__py3-none-any.whl → 1.2.1890__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 is_spot_machine_requested() -> 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,74 @@
+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 ResourceDetailedDict, ResourceDict, ResourceTypeLiteral, ResourceUriDict, SemanticVersionDict
+from .resource_deploy_key import ResourceDeployKeyDict, ResourceDeployKeyWithSecretDict
+from .resource_permission import ResourcePermissionDetailedDict, ResourcePermissionDict
+from .resource_version import (
+    ResourceVersionAssetsDict,
+    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',
+    'ResourceTypeLiteral',
+    'ResourcePermissionDetailedDict',
+    'ResourcePermissionDict',
+    'ResourceUriDict',
+    'ResourceVersionAssetsDict',
+    '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,37 @@
+from .experiment import DeprecatedExperimentDict
+from .resource_version import ResourceVersionDetailedDict
+from .typing import Literal, NotRequired, 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]
+
+
+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_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_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/_shared/types/user.py

@@ -0,0 +1,19 @@
+from .account import AccountDict
+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]
+
+
+class UserDict(TypedDict):
+    uuid: str
+    account: AccountDict
+
+
+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

@@ -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._internal.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()
 
@@ -65,6 +59,7 @@ class ApiClient(HttpClient):
         self,
         path: str,
         data: Optional[Union[Dict, bytes]] = None,
+        params: Optional[Dict[str, Union[str, int]]] = None,
         headers: OptionalHeaders = None,
         authenticate: bool = True,
         retries: int = 50,  # TODO: reduce this back to 5 when timeout errors have been solved
@@ -74,7 +69,7 @@ class ApiClient(HttpClient):
             headers=self._get_headers(opt_headers=headers, authenticate=authenticate),
             method='POST',
             retries=retries,
-            url=self._get_absolute_url(path=path, query_params=None),
+            url=self._get_absolute_url(path=path, query_params=params),
         )
 
     def patch(
@@ -147,7 +142,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 +166,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)