hafnia 0.4.3__py3-none-any.whl → 0.5.1__py3-none-any.whl

hafnia/platform/datasets.py

@@ -1,29 +1,74 @@
-import os
-import shutil
-import subprocess
-import sys
-import tempfile
-import uuid
-from pathlib import Path
 from typing import Any, Dict, List, Optional
 
 import rich
 from rich import print as rprint
 
 from hafnia import http, utils
-from hafnia.dataset.dataset_names import DATASET_FILENAMES_REQUIRED
-from hafnia.dataset.dataset_recipe.dataset_recipe import (
-    DatasetRecipe,
-    get_dataset_path_from_recipe,
-)
-from hafnia.dataset.hafnia_dataset import HafniaDataset
-from hafnia.http import fetch
-from hafnia.log import sys_logger, user_logger
+from hafnia.http import fetch, post
+from hafnia.log import user_logger
 from hafnia.platform.download import get_resource_credentials
-from hafnia.utils import progress_bar, timed
+from hafnia.platform.s5cmd_utils import ResourceCredentials
+from hafnia.utils import timed
 from hafnia_cli.config import Config
 
 
+@timed("Fetching dataset by name.")
+def get_dataset_by_name(dataset_name: str, cfg: Optional[Config] = None) -> Optional[Dict[str, Any]]:
+    """Get dataset details by name from the Hafnia platform."""
+    cfg = cfg or Config()
+    endpoint_dataset = cfg.get_platform_endpoint("datasets")
+    header = {"Authorization": cfg.api_key}
+    full_url = f"{endpoint_dataset}?name__iexact={dataset_name}"
+    datasets: List[Dict[str, Any]] = http.fetch(full_url, headers=header)  # type: ignore[assignment]
+    if len(datasets) == 0:
+        return None
+
+    if len(datasets) > 1:
+        raise ValueError(f"Multiple datasets found with the name '{dataset_name}'.")
+
+    return datasets[0]
+
+
+@timed("Fetching dataset by ID.")
+def get_dataset_by_id(dataset_id: str, cfg: Optional[Config] = None) -> Optional[Dict[str, Any]]:
+    """Get dataset details by ID from the Hafnia platform."""
+    cfg = cfg or Config()
+    endpoint_dataset = cfg.get_platform_endpoint("datasets")
+    header = {"Authorization": cfg.api_key}
+    full_url = f"{endpoint_dataset}/{dataset_id}"
+    dataset: Dict[str, Any] = http.fetch(full_url, headers=header)  # type: ignore[assignment]
+    if not dataset:
+        return None
+
+    return dataset
+
+
+def get_or_create_dataset(dataset_name: str = "", cfg: Optional[Config] = None) -> Dict[str, Any]:
+    """Create a new dataset on the Hafnia platform."""
+    cfg = cfg or Config()
+    dataset = get_dataset_by_name(dataset_name, cfg)
+    if dataset is not None:
+        user_logger.info(f"Dataset '{dataset_name}' already exists on the Hafnia platform.")
+        return dataset
+
+    endpoint_dataset = cfg.get_platform_endpoint("datasets")
+    header = {"Authorization": cfg.api_key}
+    dataset_title = dataset_name.replace("-", " ").title()  # convert dataset-name to title "Dataset Name"
+    payload = {
+        "title": dataset_title,
+        "name": dataset_name,
+        "overview": "No description provided.",
+    }
+
+    dataset = http.post(endpoint_dataset, headers=header, data=payload)  # type: ignore[assignment]
+
+    # TODO: Handle issue when dataset creation fails because name is taken by another user from a different organization
+    if not dataset:
+        raise ValueError("Failed to create dataset on the Hafnia platform. ")
+
+    return dataset
+
+
 @timed("Fetching dataset list.")
 def get_datasets(cfg: Optional[Config] = None) -> List[Dict[str, str]]:
     """List available datasets on the Hafnia platform."""
@@ -50,161 +95,107 @@ def get_dataset_id(dataset_name: str, endpoint: str, api_key: str) -> str:
         raise ValueError("Dataset information is missing or invalid") from e
 
 
-def download_or_get_dataset_path(
-    dataset_name: str,
-    cfg: Optional[Config] = None,
-    path_datasets_folder: Optional[str] = None,
-    force_redownload: bool = False,
-    download_files: bool = True,
-) -> Path:
-    """Download or get the path of the dataset."""
-    recipe_explicit = DatasetRecipe.from_implicit_form(dataset_name)
-    path_dataset = get_dataset_path_from_recipe(recipe_explicit, path_datasets=path_datasets_folder)
-
-    is_dataset_valid = HafniaDataset.check_dataset_path(path_dataset, raise_error=False)
-    if is_dataset_valid and not force_redownload:
-        user_logger.info("Dataset found locally. Set 'force=True' or add `--force` flag with cli to re-download")
-        return path_dataset
-
+@timed("Get upload access credentials")
+def get_upload_credentials(dataset_name: str, cfg: Optional[Config] = None) -> Optional[ResourceCredentials]:
+    """Get dataset details by name from the Hafnia platform."""
     cfg = cfg or Config()
-    api_key = cfg.api_key
+    dataset_response = get_dataset_by_name(dataset_name=dataset_name, cfg=cfg)
+    if dataset_response is None:
+        return None
+
+    return get_upload_credentials_by_id(dataset_response["id"], cfg=cfg)
 
-    shutil.rmtree(path_dataset, ignore_errors=True)
+
+@timed("Get upload access credentials by ID")
+def get_upload_credentials_by_id(dataset_id: str, cfg: Optional[Config] = None) -> Optional[ResourceCredentials]:
+    """Get dataset details by ID from the Hafnia platform."""
+    cfg = cfg or Config()
 
     endpoint_dataset = cfg.get_platform_endpoint("datasets")
-    dataset_id = get_dataset_id(dataset_name=dataset_name, endpoint=endpoint_dataset, api_key=api_key)
-    if dataset_id is None:
-        sys_logger.error(f"Dataset '{dataset_name}' not found on the Hafnia platform.")
+    header = {"Authorization": cfg.api_key}
+    full_url = f"{endpoint_dataset}/{dataset_id}/temporary-credentials-upload"
+    credentials_response: Dict = http.fetch(full_url, headers=header)  # type: ignore[assignment]
 
+    return ResourceCredentials.fix_naming(credentials_response)
+
+
+@timed("Get read access credentials by ID")
+def get_read_credentials_by_id(dataset_id: str, cfg: Optional[Config] = None) -> Optional[ResourceCredentials]:
+    """Get dataset read access credentials by ID from the Hafnia platform."""
+    cfg = cfg or Config()
+    endpoint_dataset = cfg.get_platform_endpoint("datasets")
     if utils.is_hafnia_cloud_job():
         credentials_endpoint_suffix = "temporary-credentials-hidden"  # Access to hidden datasets
     else:
         credentials_endpoint_suffix = "temporary-credentials"  # Access to sample dataset
     access_dataset_endpoint = f"{endpoint_dataset}/{dataset_id}/{credentials_endpoint_suffix}"
+    resource_credentials = get_resource_credentials(access_dataset_endpoint, cfg.api_key)
+    return resource_credentials
+
+
+@timed("Get read access credentials by name")
+def get_read_credentials_by_name(dataset_name: str, cfg: Optional[Config] = None) -> Optional[ResourceCredentials]:
+    """Get dataset read access credentials by name from the Hafnia platform."""
+    cfg = cfg or Config()
+    dataset_response = get_dataset_by_name(dataset_name=dataset_name, cfg=cfg)
+    if dataset_response is None:
+        return None
+
+    return get_read_credentials_by_id(dataset_response["id"], cfg=cfg)
+
+
+@timed("Delete dataset by id")
+def delete_dataset_by_id(dataset_id: str, cfg: Optional[Config] = None) -> Dict:
+    cfg = cfg or Config()
+    endpoint_dataset = cfg.get_platform_endpoint("datasets")
+    header = {"Authorization": cfg.api_key}
+    full_url = f"{endpoint_dataset}/{dataset_id}"
+    return http.delete(full_url, headers=header)  # type: ignore
 
-    download_dataset_from_access_endpoint(
-        endpoint=access_dataset_endpoint,
-        api_key=api_key,
-        path_dataset=path_dataset,
-        download_files=download_files,
-    )
-    return path_dataset
 
+@timed("Delete dataset by name")
+def delete_dataset_by_name(dataset_name: str, cfg: Optional[Config] = None) -> Dict:
+    cfg = cfg or Config()
+    dataset_response = get_dataset_by_name(dataset_name=dataset_name, cfg=cfg)
+    if dataset_response is None:
+        raise ValueError(f"Dataset '{dataset_name}' not found on the Hafnia platform.")
+
+    dataset_id = dataset_response["id"]  # type: ignore[union-attr]
+    response = delete_dataset_by_id(dataset_id=dataset_id, cfg=cfg)
+    user_logger.info(f"Dataset '{dataset_name}' has been deleted from the Hafnia platform.")
+    return response
 
-def download_dataset_from_access_endpoint(
-    endpoint: str,
-    api_key: str,
-    path_dataset: Path,
-    download_files: bool = True,
+
+def delete_dataset_completely_by_name(
+    dataset_name: str,
+    interactive: bool = True,
+    cfg: Optional[Config] = None,
 ) -> None:
-    resource_credentials = get_resource_credentials(endpoint, api_key)
+    from hafnia.dataset.operations.dataset_s3_storage import delete_hafnia_dataset_files_on_platform
 
-    local_dataset_paths = [(path_dataset / filename).as_posix() for filename in DATASET_FILENAMES_REQUIRED]
-    s3_uri = resource_credentials.s3_uri()
-    s3_dataset_files = [f"{s3_uri}/{filename}" for filename in DATASET_FILENAMES_REQUIRED]
+    cfg = cfg or Config()
 
-    envs = resource_credentials.aws_credentials()
-    try:
-        fast_copy_files_s3(
-            src_paths=s3_dataset_files,
-            dst_paths=local_dataset_paths,
-            append_envs=envs,
-            description="Downloading annotations",
-        )
-    except ValueError as e:
-        user_logger.error(f"Failed to download annotations: {e}")
+    is_deleted = delete_hafnia_dataset_files_on_platform(
+        dataset_name=dataset_name,
+        interactive=interactive,
+        cfg=cfg,
+    )
+    if not is_deleted:
         return
+    delete_dataset_by_name(dataset_name, cfg=cfg)
 
-    if not download_files:
-        return
-    dataset = HafniaDataset.from_path(path_dataset, check_for_images=False)
-    try:
-        dataset = dataset.download_files_aws(path_dataset, aws_credentials=resource_credentials, force_redownload=True)
-    except ValueError as e:
-        user_logger.error(f"Failed to download images: {e}")
-        return
-    dataset.write_annotations(path_folder=path_dataset)  # Overwrite annotations as files have been re-downloaded
-
-
-def fast_copy_files_s3(
-    src_paths: List[str],
-    dst_paths: List[str],
-    append_envs: Optional[Dict[str, str]] = None,
-    description: str = "Copying files",
-) -> List[str]:
-    if len(src_paths) != len(dst_paths):
-        raise ValueError("Source and destination paths must have the same length.")
-    cmds = [f"cp {src} {dst}" for src, dst in zip(src_paths, dst_paths)]
-    lines = execute_s5cmd_commands(cmds, append_envs=append_envs, description=description)
-    return lines
-
-
-def find_s5cmd() -> Optional[str]:
-    """Locate the s5cmd executable across different installation methods.
-
-    Searches for s5cmd in:
-    1. System PATH (via shutil.which)
-    2. Python bin directory (Unix-like systems)
-    3. Python executable directory (direct installs)
-
-    Returns:
-        str: Absolute path to s5cmd executable if found, None otherwise.
-    """
-    result = shutil.which("s5cmd")
-    if result:
-        return result
-    python_dir = Path(sys.executable).parent
-    locations = (python_dir / "Scripts" / "s5cmd.exe", python_dir / "bin" / "s5cmd", python_dir / "s5cmd")
-    for loc in locations:
-        if loc.exists():
-            return str(loc)
-    return None
-
-
-def execute_s5cmd_commands(
-    commands: List[str],
-    append_envs: Optional[Dict[str, str]] = None,
-    description: str = "Executing s5cmd commands",
-) -> List[str]:
-    append_envs = append_envs or {}
-    # In Windows default "Temp" directory can not be deleted that is why we need to create a
-    # temporary directory.
-    with tempfile.TemporaryDirectory() as temp_dir:
-        tmp_file_path = Path(temp_dir, f"{uuid.uuid4().hex}.txt")
-        tmp_file_path.write_text("\n".join(commands))
-
-        s5cmd_bin = find_s5cmd()
-        if s5cmd_bin is None:
-            raise ValueError("Can not find s5cmd executable.")
-        run_cmds = [s5cmd_bin, "run", str(tmp_file_path)]
-        sys_logger.debug(run_cmds)
-        envs = os.environ.copy()
-        envs.update(append_envs)
-
-        process = subprocess.Popen(
-            run_cmds,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.STDOUT,
-            universal_newlines=True,
-            env=envs,
-        )
-
-        error_lines = []
-        lines = []
-        for line in progress_bar(process.stdout, total=len(commands), description=description):  # type: ignore[arg-type]
-            if "ERROR" in line or "error" in line:
-                error_lines.append(line.strip())
-            lines.append(line.strip())
-
-        if len(error_lines) > 0:
-            show_n_lines = min(5, len(error_lines))
-            str_error_lines = "\n".join(error_lines[:show_n_lines])
-            user_logger.error(
-                f"Detected {len(error_lines)} errors occurred while executing a total of {len(commands)} "
-                f" commands with s5cmd. The first {show_n_lines} is printed below:\n{str_error_lines}"
-            )
-            raise RuntimeError("Errors occurred during s5cmd execution.")
-    return lines
+
+@timed("Import dataset details to platform")
+def upload_dataset_details(cfg: Config, data: dict, dataset_name: str) -> dict:
+    dataset_endpoint = cfg.get_platform_endpoint("datasets")
+    dataset_id = get_dataset_id(dataset_name, dataset_endpoint, cfg.api_key)
+
+    import_endpoint = f"{dataset_endpoint}/{dataset_id}/import"
+    headers = {"Authorization": cfg.api_key}
+
+    user_logger.info("Exporting dataset details to platform. This may take up to 30 seconds...")
+    response = post(endpoint=import_endpoint, headers=headers, data=data)  # type: ignore[assignment]
+    return response  # type: ignore[return-value]
 
 
 TABLE_FIELDS = {

hafnia/platform/download.py

@@ -5,9 +5,9 @@ import boto3
 from botocore.exceptions import ClientError
 from rich.progress import Progress
 
-from hafnia.dataset.dataset_names import ResourceCredentials
 from hafnia.http import fetch
 from hafnia.log import sys_logger, user_logger
+from hafnia.platform.s5cmd_utils import ResourceCredentials
 
 
 def get_resource_credentials(endpoint: str, api_key: str) -> ResourceCredentials:

hafnia/platform/s5cmd_utils.py

@@ -0,0 +1,266 @@
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import uuid
+from pathlib import Path
+from typing import Dict, List, Optional
+
+import boto3
+from botocore.exceptions import UnauthorizedSSOTokenError
+from pydantic import BaseModel, field_validator
+
+from hafnia.log import sys_logger, user_logger
+from hafnia.utils import progress_bar
+
+
+def find_s5cmd() -> Optional[str]:
+    """Locate the s5cmd executable across different installation methods.
+
+    Searches for s5cmd in:
+    1. System PATH (via shutil.which)
+    2. Python bin directory (Unix-like systems)
+    3. Python executable directory (direct installs)
+
+    Returns:
+        str: Absolute path to s5cmd executable if found, None otherwise.
+    """
+    result = shutil.which("s5cmd")
+    if result:
+        return result
+    python_dir = Path(sys.executable).parent
+    locations = (
+        python_dir / "Scripts" / "s5cmd.exe",
+        python_dir / "bin" / "s5cmd",
+        python_dir / "s5cmd",
+    )
+    for loc in locations:
+        if loc.exists():
+            return str(loc)
+    return None
+
+
+def execute_command(args: List[str], append_envs: Optional[Dict[str, str]] = None) -> subprocess.CompletedProcess:
+    s5cmd_bin = find_s5cmd()
+    cmds = [s5cmd_bin] + args
+    envs = os.environ.copy()
+    if append_envs:
+        envs.update(append_envs)
+
+    result = subprocess.run(
+        cmds,  # type: ignore[arg-type]
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        universal_newlines=True,
+        env=envs,
+    )
+    return result
+
+
+def execute_commands(
+    commands: List[str],
+    append_envs: Optional[Dict[str, str]] = None,
+    description: str = "Executing s5cmd commands",
+) -> List[str]:
+    append_envs = append_envs or {}
+
+    with tempfile.TemporaryDirectory() as temp_dir:
+        tmp_file_path = Path(temp_dir, f"{uuid.uuid4().hex}.txt")
+        tmp_file_path.write_text("\n".join(commands))
+
+        s5cmd_bin = find_s5cmd()
+        if s5cmd_bin is None:
+            raise ValueError("Can not find s5cmd executable.")
+        run_cmds = [s5cmd_bin, "run", str(tmp_file_path)]
+        sys_logger.debug(run_cmds)
+        envs = os.environ.copy()
+        envs.update(append_envs)
+
+        process = subprocess.Popen(
+            run_cmds,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            universal_newlines=True,
+            env=envs,
+        )
+
+        error_lines = []
+        lines = []
+        for line in progress_bar(process.stdout, total=len(commands), description=description):  # type: ignore[arg-type]
+            if "ERROR" in line or "error" in line:
+                error_lines.append(line.strip())
+            lines.append(line.strip())
+
+        if len(error_lines) > 0:
+            show_n_lines = min(5, len(error_lines))
+            str_error_lines = "\n".join(error_lines[:show_n_lines])
+            user_logger.error(
+                f"Detected {len(error_lines)} errors occurred while executing a total of {len(commands)} "
+                f" commands with s5cmd. The first {show_n_lines} is printed below:\n{str_error_lines}"
+            )
+            raise RuntimeError("Errors occurred during s5cmd execution.")
+    return lines
+
+
+def delete_bucket_content(
+    bucket_prefix: str,
+    remove_bucket: bool = True,
+    append_envs: Optional[Dict[str, str]] = None,
+) -> None:
+    # Remove all files in the bucket
+    returns = execute_command(["rm", f"{bucket_prefix}/*"], append_envs=append_envs)
+
+    if returns.returncode != 0:
+        bucket_content_is_already_deleted = "no object found" in returns.stderr.strip()
+        bucket_is_already_deleted = "NoSuchBucket" in returns.stderr.strip()
+        if bucket_content_is_already_deleted:
+            user_logger.info(f"No action was taken. S3 bucket '{bucket_prefix}' is already empty.")
+        elif bucket_is_already_deleted:
+            user_logger.info(f"No action was taken. S3 bucket '{bucket_prefix}' does not exist.")
+            return
+        else:
+            user_logger.error("Error during s5cmd rm command:")
+            user_logger.error(returns.stdout)
+            user_logger.error(returns.stderr)
+            raise RuntimeError(f"Failed to delete all files in S3 bucket '{bucket_prefix}'.")
+
+    if remove_bucket:
+        # Remove the bucket itself
+        returns = execute_command(["rb", bucket_prefix], append_envs=append_envs)
+        if returns.returncode != 0:
+            user_logger.error("Error during s5cmd rb command:")
+            user_logger.error(returns.stdout)
+            user_logger.error(returns.stderr)
+            raise RuntimeError(f"Failed to delete S3 bucket '{bucket_prefix}'.")
+    user_logger.info(f"S3 bucket '{bucket_prefix}' has been deleted.")
+
+
+def list_bucket(bucket_prefix: str, append_envs: Optional[Dict[str, str]] = None) -> List[str]:
+    output = execute_command(["ls", f"{bucket_prefix}/*"], append_envs=append_envs)
+    has_missing_folder = "no object found" in output.stderr.strip()
+    if output.returncode != 0 and not has_missing_folder:
+        user_logger.error("Error during s5cmd ls command:")
+        user_logger.error(output.stderr)
+        raise RuntimeError(f"Failed to list dataset in S3 bucket '{bucket_prefix}'.")
+
+    files_in_s3 = [f"{bucket_prefix}/{line.split(' ')[-1]}" for line in output.stdout.splitlines()]
+    return files_in_s3
+
+
+def fast_copy_files(
+    src_paths: List[str],
+    dst_paths: List[str],
+    append_envs: Optional[Dict[str, str]] = None,
+    description: str = "Copying files",
+) -> List[str]:
+    if len(src_paths) != len(dst_paths):
+        raise ValueError("Source and destination paths must have the same length.")
+    cmds = [f"cp {src} {dst}" for src, dst in zip(src_paths, dst_paths)]
+    lines = execute_commands(cmds, append_envs=append_envs, description=description)
+    return lines
+
+
+ARN_PREFIX = "arn:aws:s3:::"
+
+
+class AwsCredentials(BaseModel):
+    access_key: str
+    secret_key: str
+    session_token: str
+    region: Optional[str]
+
+    def aws_credentials(self) -> Dict[str, str]:
+        """
+        Returns the AWS credentials as a dictionary.
+        """
+        environment_vars = {
+            "AWS_ACCESS_KEY_ID": self.access_key,
+            "AWS_SECRET_ACCESS_KEY": self.secret_key,
+            "AWS_SESSION_TOKEN": self.session_token,
+        }
+        if self.region:
+            environment_vars["AWS_REGION"] = self.region
+
+        return environment_vars
+
+    @staticmethod
+    def from_session(session: boto3.Session) -> "AwsCredentials":
+        """
+        Creates AwsCredentials from a Boto3 session.
+        """
+        try:
+            frozen_credentials = session.get_credentials().get_frozen_credentials()
+        except UnauthorizedSSOTokenError as e:
+            raise RuntimeError(
+                f"Failed to get AWS credentials from the session for profile '{session.profile_name}'.\n"
+                f"Ensure the profile exists in your AWS config in '~/.aws/config' and that you are logged in via AWS SSO.\n"
+                f"\tUse 'aws sso login --profile {session.profile_name}' to log in."
+            ) from e
+        return AwsCredentials(
+            access_key=frozen_credentials.access_key,
+            secret_key=frozen_credentials.secret_key,
+            session_token=frozen_credentials.token,
+            region=session.region_name,
+        )
+
+    def to_resource_credentials(self, bucket_name: str) -> "ResourceCredentials":
+        """
+        Converts AwsCredentials to ResourceCredentials by adding the S3 ARN.
+        """
+        payload = self.model_dump()
+        payload["s3_arn"] = f"{ARN_PREFIX}{bucket_name}"
+        return ResourceCredentials(**payload)
+
+
+class ResourceCredentials(AwsCredentials):
+    s3_arn: str
+
+    @staticmethod
+    def fix_naming(payload: Dict[str, str]) -> "ResourceCredentials":
+        """
+        The endpoint returns a payload with a key called 's3_path', but it
+        is actually an ARN path (starts with arn:aws:s3::). This method renames it to 's3_arn' for consistency.
+        """
+        if "s3_path" in payload and payload["s3_path"].startswith(ARN_PREFIX):
+            payload["s3_arn"] = payload.pop("s3_path")
+
+        if "region" not in payload:
+            payload["region"] = "eu-west-1"
+        return ResourceCredentials(**payload)
+
+    @field_validator("s3_arn")
+    @classmethod
+    def validate_s3_arn(cls, value: str) -> str:
+        """Validate s3_arn to ensure it starts with 'arn:aws:s3:::'"""
+        if not value.startswith("arn:aws:s3:::"):
+            raise ValueError(f"Invalid S3 ARN: {value}. It should start with 'arn:aws:s3:::'")
+        return value
+
+    def s3_path(self) -> str:
+        """
+        Extracts the S3 path from the ARN.
+        Example: arn:aws:s3:::my-bucket/my-prefix -> my-bucket/my-prefix
+        """
+        return self.s3_arn[len(ARN_PREFIX) :]
+
+    def s3_uri(self) -> str:
+        """
+        Converts the S3 ARN to a URI format.
+        Example: arn:aws:s3:::my-bucket/my-prefix -> s3://my-bucket/my-prefix
+        """
+        return f"s3://{self.s3_path()}"
+
+    def bucket_name(self) -> str:
+        """
+        Extracts the bucket name from the S3 ARN.
+        Example: arn:aws:s3:::my-bucket/my-prefix -> my-bucket
+        """
+        return self.s3_path().split("/")[0]
+
+    def object_key(self) -> str:
+        """
+        Extracts the object key from the S3 ARN.
+        Example: arn:aws:s3:::my-bucket/my-prefix -> my-prefix
+        """
+        return "/".join(self.s3_path().split("/")[1:])

hafnia/utils.py

@@ -65,6 +65,10 @@ def timed(label: str):
     return decorator
 
 
+def get_path_dataset_gallery_images(dataset_name: str) -> Path:
+    return PATH_DATASETS / dataset_name / "gallery_images"
+
+
 def get_path_hafnia_cache() -> Path:
     return Path.home() / "hafnia"
 

{hafnia-0.4.3.dist-info → hafnia-0.5.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hafnia
-Version: 0.4.3
+Version: 0.5.1
 Summary: Python SDK for communication with Hafnia platform.
 Author-email: Milestone Systems <hafniaplatform@milestone.dk>
 License-File: LICENSE
@@ -10,7 +10,7 @@ Requires-Dist: click>=8.1.8
 Requires-Dist: emoji>=2.14.1
 Requires-Dist: flatten-dict>=0.4.2
 Requires-Dist: keyring>=25.6.0
-Requires-Dist: mcp==1.16.0
+Requires-Dist: mcp>=1.23.0
 Requires-Dist: mlflow>=3.4.0
 Requires-Dist: more-itertools>=10.7.0
 Requires-Dist: opencv-python-headless>=4.11.0.86
@@ -209,7 +209,7 @@ DatasetInfo(
 ```
 
 You can iterate and access samples in the dataset using the `HafniaDataset` object.
-Each sample contain image and annotations information. 
+Each sample contain image and annotations information.
 
 ```python
 from hafnia.dataset.hafnia_dataset import HafniaDataset, Sample