pybiolib 0.2.951__py3-none-any.whl → 1.2.1890__py3-none-any.whl

biolib/_shared/types/file_node.py

@@ -0,0 +1,17 @@
+from .typing import TypedDict
+
+
+class FileZipMetadataDict(TypedDict):
+    header_start: int
+    size_on_disk: int
+
+
+class FileNodeDict(TypedDict):
+    dir_path: str
+    is_dir: bool
+    name: str
+    size: int
+
+
+class ZipFileNodeDict(FileNodeDict):
+    zip_meta: FileZipMetadataDict

biolib/_shared/types/push.py

@@ -0,0 +1,6 @@
+from typing import TypedDict
+
+
+class PushResponseDict(TypedDict):
+    app_uri: str
+    sematic_version: 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/_shared/types/resource_permission.py

@@ -0,0 +1,14 @@
+from .resource import ResourceDict
+from .typing import TypedDict
+
+
+class ResourcePermissionDict(TypedDict):
+    uuid: str
+    created_at: str
+    action: str
+    resource: ResourceDict
+    target_resource: ResourceDict
+
+
+class ResourcePermissionDetailedDict(ResourcePermissionDict):
+    pass

biolib/_shared/types/resource_version.py

@@ -0,0 +1,19 @@
+from .typing import Literal, NotRequired, Optional, TypedDict
+
+
+class ResourceVersionAssetsDict(TypedDict):
+    download_url: str
+    size_bytes: int
+
+
+class ResourceVersionDict(TypedDict):
+    uuid: str
+    semantic_version: str
+    state: Literal['published', 'unpublished']
+    created_at: str
+    git_branch_name: NotRequired[str]
+    git_commit_hash: NotRequired[str]
+
+
+class ResourceVersionDetailedDict(ResourceVersionDict):
+    assets: Optional[ResourceVersionAssetsDict]

biolib/_shared/types/result.py

@@ -0,0 +1,14 @@
+from .typing import Optional, TypedDict
+
+
+class ResultDict(TypedDict):
+    uuid: str
+    name: str
+    app_uri: str
+    created_at: str
+    state: str
+    finished_at: Optional[str]
+
+
+class ResultDetailedDict(ResultDict):
+    pass

biolib/_shared/types/typing.py

@@ -0,0 +1,10 @@
+import sys
+
+# import and expose everything from the typing module
+from typing import *  # noqa:F403 pylint: disable=wildcard-import, unused-wildcard-import
+
+if sys.version_info < (3, 8):  # noqa: UP036
+    from typing_extensions import Literal, TypedDict  # pylint: disable=unused-import
+
+if sys.version_info < (3, 11):  # noqa: UP036
+    from typing_extensions import NotRequired  # pylint: disable=unused-import

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/__init__.py

@@ -0,0 +1,6 @@
+from biolib._internal.http_client import HttpClient
+
+from .client import ApiClient as _ApiClient
+
+_client = _ApiClient()
+client = _client

biolib/api/client.py

@@ -0,0 +1,168 @@
+from datetime import datetime, timezone
+from json.decoder import JSONDecodeError
+from urllib.parse import urlencode, urljoin
+
+import importlib_metadata
+
+from biolib._internal.http_client import HttpClient, HttpResponse
+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
+
+OptionalHeaders = Union[
+    Optional[Dict[str, str]],
+    Optional[Dict[str, Union[str, None]]],
+]
+
+
+def _get_biolib_package_version() -> str:
+    # try fetching version, if it fails (usually when in dev), add default
+    try:
+        return cast(str, importlib_metadata.version('pybiolib'))
+    except importlib_metadata.PackageNotFoundError:
+        return '0.0.0'
+
+
+class ApiClientInitDict(TypedDict):
+    refresh_token: str
+    base_url: str
+    client_type: Optional[str]
+
+
+class ApiClient(HttpClient):
+    _biolib_package_version: str = _get_biolib_package_version()
+
+    def __init__(self, _init_dict: Optional[ApiClientInitDict] = None) -> None:
+        self._access_token: Optional[str] = None
+        self._refresh_token: Optional[str] = _init_dict['refresh_token'] if _init_dict else None
+        self._base_url: Optional[str] = _init_dict['base_url'] if _init_dict else None
+        self._client_type: Optional[str] = _init_dict['client_type'] if _init_dict else None
+
+    def get(
+        self,
+        path: str,
+        params: Optional[Dict[str, Union[str, int]]] = None,
+        headers: OptionalHeaders = None,
+        authenticate: bool = True,
+        retries: int = 10,
+    ) -> HttpResponse:
+        return self.request(
+            headers=self._get_headers(opt_headers=headers, authenticate=authenticate),
+            method='GET',
+            retries=retries,
+            url=self._get_absolute_url(path=path, query_params=params),
+        )
+
+    def post(
+        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
+    ) -> HttpResponse:
+        return self.request(
+            data=data,
+            headers=self._get_headers(opt_headers=headers, authenticate=authenticate),
+            method='POST',
+            retries=retries,
+            url=self._get_absolute_url(path=path, query_params=params),
+        )
+
+    def patch(
+        self,
+        path: str,
+        data: Dict,
+        headers: OptionalHeaders = None,
+        retries: int = 5,
+        params: Optional[Dict[str, Union[str, int]]] = None,
+    ) -> HttpResponse:
+        return self.request(
+            data=data,
+            headers=self._get_headers(opt_headers=headers, authenticate=True),
+            method='PATCH',
+            retries=retries,
+            url=self._get_absolute_url(path=path, query_params=params),
+        )
+
+    def delete(
+        self,
+        path: str,
+        headers: OptionalHeaders = None,
+        retries: int = 0,
+    ) -> HttpResponse:
+        return self.request(
+            headers=self._get_headers(opt_headers=headers, authenticate=True),
+            method='DELETE',
+            retries=retries,
+            url=self._get_absolute_url(path=path, query_params=None),
+        )
+
+    def _get_headers(self, opt_headers: OptionalHeaders, authenticate: bool) -> Dict[str, str]:
+        # Only keep header keys with a value
+        headers: Dict[str, str] = {key: value for key, value in (opt_headers or {}).items() if value}
+
+        if authenticate:
+            if self._refresh_token:
+                headers['Authorization'] = f'Bearer {self._get_access_token()}'
+            else:
+                # TODO: Remove this block when deprecated api client is removed
+                deprecated_api_client = DeprecatedApiClient.get()
+                if deprecated_api_client.is_signed_in:
+                    deprecated_api_client.refresh_access_token()
+
+                if deprecated_api_client.resource_deploy_key:
+                    headers['Authorization'] = f'Token {deprecated_api_client.resource_deploy_key}'
+                else:
+                    # Adding access_token outside is_signed_in check as job_worker.py currently sets access_token
+                    # without setting refresh_token
+                    access_token = deprecated_api_client.access_token
+                    if access_token:
+                        headers['Authorization'] = f'Bearer {access_token}'
+
+        headers['client-type'] = 'biolib-python'
+        headers['client-version'] = ApiClient._biolib_package_version
+        if self._client_type:
+            headers['client-opt-type'] = self._client_type
+
+        return headers
+
+    def _get_absolute_url(self, path: str, query_params: Optional[Dict[str, Union[str, int]]]) -> str:
+        deprecated_api_client = DeprecatedApiClient.get()
+        base_url = self._base_url or deprecated_api_client.base_url
+        base_api_url = urljoin(base_url, '/api/')
+        url = urljoin(base_api_url, path.strip('/') + '/')
+        if query_params:
+            url = url + '?' + urlencode(query_params)
+
+        return url
+
+    def _get_access_token(self) -> str:
+        if 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
+
+        # 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},
+            )
+        except Exception as exception:
+            logger.error('Sign in with refresh token failed')
+            raise exception
+
+        try:
+            response_dict = response.json()
+        except JSONDecodeError as error:
+            logger.error('Could not decode response from server as JSON:')
+            raise BioLibError(response.text) from error
+
+        self._access_token = cast(str, response_dict['access'])
+        return self._access_token