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

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/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/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()
 
@@ -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

@@ -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,14 +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
-from biolib._internal.file_utils import path_to_renamed_path
+
+
+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']
@@ -33,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
@@ -71,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,
@@ -84,22 +102,18 @@ 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)
 
         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,
@@ -111,11 +125,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:
@@ -152,6 +167,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''
@@ -173,18 +190,21 @@ Example: "app.cli('--help')"
             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_path = filename.relative_to(Path.cwd())
-                            files_dict[path_to_renamed_path(str(relative_path))] = f.read()
+                            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
@@ -199,11 +219,13 @@ Example: "app.cli('--help')"
                             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:
-                                files_dict[path_to_renamed_path(str(filename))] = f.read()
+                                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
@@ -214,20 +236,22 @@ Example: "app.cli('--help')"
                             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:
-                                files_dict[path_to_renamed_path(str(filename))] = f.read()
-                    args[idx] = (
-                        arg.split('=')[0] + '=' +
-                        path_to_renamed_path(file_path, prefix_with_slash=False)
-                    )
+                                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()
@@ -246,7 +270,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)
 
@@ -271,7 +295,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/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/biolib_api_client/app_types.py

@@ -68,11 +68,6 @@ class LargeFileSystemMapping(TypedDict):
     uuid: str
 
 
-class PortMapping(TypedDict):
-    from_port: int
-    to_port: int
-
-
 class _Module(TypedDict):
     command: str
     environment: Literal['biolib-app', 'biolib-custom', 'biolib-ecr']
@@ -83,7 +78,7 @@ class _Module(TypedDict):
     large_file_systems: List[LargeFileSystemMapping]
     name: str
     output_files_mappings: List[FilesMapping]
-    port_mappings: List[PortMapping]
+    ports: List[int]
     source_files_mappings: List[FilesMapping]
     working_directory: str
 

biolib/biolib_api_client/biolib_app_api.py

@@ -57,6 +57,22 @@ def _get_git_branch_name() -> str:
         return ''
 
 
+def _get_git_commit_hash() -> str:
+    try:
+        github_actions_commit_hash = os.getenv('GITHUB_SHA')
+        if github_actions_commit_hash:
+            return github_actions_commit_hash
+
+        gitlab_ci_commit_hash = os.getenv('CI_COMMIT_SHA')
+        if gitlab_ci_commit_hash:
+            return gitlab_ci_commit_hash
+
+        result = subprocess.run(['git', 'rev-parse', 'HEAD'], check=True, stdout=subprocess.PIPE, text=True)
+        return result.stdout.strip()
+    except BaseException:
+        return ''
+
+
 def _get_git_repository_url() -> str:
     try:
         result = subprocess.run(['git', 'remote', 'get-url', 'origin'], check=True, stdout=subprocess.PIPE, text=True)
@@ -125,6 +141,7 @@ class BiolibAppApi:
                 'state': 'published',
                 'app_version_id_to_copy_images_from': app_version_id_to_copy_images_from,
                 'git_branch_name': _get_git_branch_name(),
+                'git_commit_hash': _get_git_commit_hash(),
                 'git_repository_url': _get_git_repository_url(),
             }
             if semantic_version: