hafnia 0.1.25__py3-none-any.whl → 0.1.27__py3-none-any.whl

hafnia/platform/builder.py

@@ -1,184 +1,150 @@
 import json
 import os
+import re
+import subprocess
+import zipfile
 from hashlib import sha256
 from pathlib import Path
-from shutil import rmtree
-from typing import Dict, List, Optional
-from zipfile import ZipFile
+from typing import Dict, Optional
 
 import boto3
 from botocore.exceptions import ClientError
 
-from hafnia.log import logger
+from hafnia.log import sys_logger, user_logger
 from hafnia.platform import download_resource
 
 
-def validate_recipe(zip_path: Path, required_paths: Optional[set] = None) -> None:
-    """
-    Validates the structure of a zip archive.
-    Ensures the presence of specific files and directories.
-
-    Args:
-        zip_path (Path): Path to the zip archive.
-        required_paths (set): A set of required paths relative to the archive root.
-
-    Raises:
-        FileNotFoundError: If any required file or directory is missing.
-    """
-    required_paths = {"src", "scripts", "Dockerfile"} if required_paths is None else required_paths
-    with ZipFile(zip_path, "r") as archive:
-        archive_contents = {Path(file).as_posix() for file in archive.namelist()}
-        missing_paths = {
-            path for path in required_paths if not any(entry.startswith(path) for entry in archive_contents)
-        }
+def validate_recipe_format(path: Path) -> None:
+    """Validate Hafnia Recipe Format submition"""
+    hrf = zipfile.Path(path) if path.suffix == ".zip" else path
+    required = {"src", "scripts", "Dockerfile"}
+    errors = 0
+    for rp in required:
+        if not (hrf / rp).exists():
+            user_logger.error(f"Required path {rp} not found in recipe.")
+            errors += 1
+    if errors > 0:
+        raise FileNotFoundError("Wrong recipe structure")
 
-        if missing_paths:
-            raise FileNotFoundError(f"The following required paths are missing in the zip archive: {missing_paths}")
-
-        script_files = [f for f in archive_contents if f.startswith("scripts/") and f.endswith(".py")]
-
-        if not script_files:
-            raise ValueError("No Python script files found in the 'scripts' directory.")
-
-
-def clean_up(files: List[Path], dirs: List[Path], prefix: str = "__") -> None:
-    """
-    Clean up a list of files first, and then remove all folders starting with a specific prefix.
-
-    Args:
-        paths (list[Path]): List of file and directory paths to clean up.
-        prefix (str, optional): Prefix to match for folder removal. Defaults to "__".
-    """
-    for path in files:
-        if path.exists() and path.is_file():
-            path.unlink()
-
-    for path in dirs:
-        if path.exists() and path.is_dir():
-            for sub_dir in path.glob(f"**/{prefix}*"):
-                if sub_dir.is_dir():
-                    rmtree(sub_dir)
-
-
-def get_recipe_content(recipe_url: str, output_dir: Path, state_file: str, api_key: str) -> Dict:
-    """
-    Retrieves and validates the recipe content from an S3 location and extracts it.
-
-    Args:
-        recipe_uuid (str): The unique identifier of the recipe.
-        output_dir (str): Directory to extract the recipe content.
-        state_file (str): File to save the state information.
 
-    Returns:
-        Dict: Metadata about the recipe for further processing.
-    """
-    result = download_resource(recipe_url, output_dir, api_key)
-    recipe_path = Path(result["downloaded_files"][0])
-
-    validate_recipe(recipe_path)
-
-    with ZipFile(recipe_path, "r") as zip_ref:
+def prepare_recipe(recipe_url: str, output_dir: Path, api_key: str, state_file: Optional[Path] = None) -> Dict:
+    resource = download_resource(recipe_url, output_dir.as_posix(), api_key)
+    recipe_path = Path(resource["downloaded_files"][0])
+    with zipfile.ZipFile(recipe_path, "r") as zip_ref:
         zip_ref.extractall(output_dir)
 
-    tag = sha256(recipe_path.read_bytes()).hexdigest()[:8]
+    validate_recipe_format(output_dir)
 
     scripts_dir = output_dir / "scripts"
-    valid_commands = [str(f.name)[:-3] for f in scripts_dir.iterdir() if f.is_file() and f.suffix.lower() == ".py"]
+    if not any(scripts_dir.iterdir()):
+        user_logger.warning("Scripts folder is empty")
 
-    if not valid_commands:
-        raise ValueError("No valid Python script commands found in the 'scripts' directory.")
-
-    state = {
+    metadata = {
         "user_data": (output_dir / "src").as_posix(),
-        "docker_context": output_dir.as_posix(),
         "dockerfile": (output_dir / "Dockerfile").as_posix(),
-        "docker_tag": f"runtime:{tag}",
-        "hash": tag,
-        "valid_commands": valid_commands,
+        "digest": sha256(recipe_path.read_bytes()).hexdigest()[:8],
     }
+    state_file = state_file if state_file else output_dir / "state.json"
+    with open(state_file, "w", encoding="utf-8") as f:
+        json.dump(metadata, f)
+    return metadata
 
-    try:
-        with open(state_file, "w", encoding="utf-8") as f:
-            json.dump(state, f)
-    except Exception as e:
-        raise RuntimeError(f"Failed to write state file: {e}")
 
-    clean_up([recipe_path], [output_dir])
-
-    return state
+def buildx_available() -> bool:
+    try:
+        result = subprocess.run(["docker", "buildx", "version"], capture_output=True, text=True, check=True)
+        return "buildx" in result.stdout.lower()
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return False
 
 
-def build_dockerfile(dockerfile: str, docker_context: str, docker_tag: str, secrets: Optional[Dict] = None) -> None:
+def build_dockerfile(dockerfile: str, docker_context: str, docker_tag: str) -> None:
     """
     Build a Docker image using the provided Dockerfile.
 
     Args:
-        dockerfile (Path): Path to the Dockerfile.
+        dockerfile (str): Path to the Dockerfile.
         docker_context (str): Path to the build context.
         docker_tag (str): Tag for the Docker image.
-        secrets (dict, optional): Dictionary of secrets to pass to docker build.
-            Each key-value pair will be passed as --secret id=key,env=value
+        meta_file (Optional[str]): File to store build metadata.
     """
-
-    import subprocess
-
     if not Path(dockerfile).exists():
         raise FileNotFoundError("Dockerfile not found.")
-    build_cmd = [
-        "docker",
-        "build",
-        "--platform=linux/amd64",
-        "-t",
-        docker_tag,
-        "-f",
-        dockerfile,
-    ]
-    build_cmd.append(docker_context)
-    logger.info(f"Building Docker image: {' '.join(build_cmd)}")
-    subprocess.run(build_cmd, check=True)
-
-
-def check_ecr(repository_name: str, image_tag: str) -> bool:
-    aws_region = os.getenv("AWS_REGION", None)
-    if aws_region is None:
-        logger.warning("ECR registry region is not provided can not look up in the registry.")
-        return False
-    session = boto3.Session(region_name=aws_region)
-    ecr_client = session.client("ecr")
+
+    cmd = ["docker", "build", "--platform", "linux/amd64", "-t", docker_tag, "-f", dockerfile]
+
+    remote_cache = os.getenv("EXPERIMENT_CACHE_ECR")
+    cloud_mode = os.getenv("HAFNIA_CLOUD", "false").lower() in ["true", "1", "yes"]
+
+    if buildx_available():
+        cmd.insert(1, "buildx")
+        cmd += ["--build-arg", "BUILDKIT_INLINE_CACHE=1"]
+        if cloud_mode:
+            cmd += ["--push"]
+        if remote_cache:
+            cmd += [
+                "--cache-from",
+                f"type=registry,ref={remote_cache}:buildcache",
+                "--cache-to",
+                f"type=registry,ref={remote_cache}:buildcache,mode=max",
+            ]
+    cmd.append(docker_context)
+    sys_logger.debug("Build cmd: `{}`".format(" ".join(cmd)))
+    sys_logger.info(f"Building and pushing Docker image with BuildKit (buildx); cache repo: {remote_cache or 'none'}")
+    result = None
+    output = ""
+    errors = []
     try:
-        response = ecr_client.describe_images(repositoryName=repository_name, imageIds=[{"imageTag": image_tag}])
-        if response["imageDetails"]:
-            logger.info(f"Image {image_tag} already exists in ECR.")
-            return True
-        else:
-            return False
+        result = subprocess.run(cmd, check=True, capture_output=True, text=True)
+        output = (result.stdout or "") + (result.stderr or "")
+    except subprocess.CalledProcessError as e:
+        output = (e.stdout or "") + (e.stderr or "")
+        error_pattern = r"ERROR: (.+?)(?:\n|$)"
+        errors = re.findall(error_pattern, output)
+        if not errors:
+            raise RuntimeError(f"Docker build failed: {output}")
+        if re.search(r"image tag '([^']+)' already exists", errors[-1]):
+            sys_logger.warning("Image {} already exists in the registry.".format(docker_tag.rsplit("/")[-1]))
+            return
+        raise RuntimeError(f"Docker build failed: {output}")
+    finally:
+        stage_pattern = r"^.*\[\d+/\d+\][^\n]*"
+        stages = re.findall(stage_pattern, output, re.MULTILINE)
+        user_logger.info("\n".join(stages))
+        sys_logger.debug(output)
+
+
+def check_registry(docker_image: str) -> Optional[str]:
+    """
+    Returns the remote digest for TAG if it exists, otherwise None.
+    """
+    if "localhost" in docker_image:
+        return None
+
+    region = os.getenv("AWS_REGION")
+    if not region:
+        sys_logger.warning("AWS_REGION environment variable not set. Skip image exist check.")
+        return None
+
+    repo_name, image_tag = docker_image.rsplit(":")
+    if "/" in repo_name:
+        repo_name = repo_name.rsplit("/", 1)[-1]
+    ecr = boto3.client("ecr", region_name=region)
+    try:
+        out = ecr.describe_images(repositoryName=repo_name, imageIds=[{"imageTag": image_tag}])
+        return out["imageDetails"][0]["imageDigest"]
     except ClientError as e:
-        if e.response["Error"]["Code"] == "ImageNotFoundException":
-            logger.info(f"Image {image_tag} does not exist in ECR.")
-            return False
-        else:
-            raise e
-
-
-def prepare_recipe(recipe_url: str, output_dir: Path, api_key: str) -> Dict:
-    state_file = output_dir / "state.json"
-    get_recipe_content(recipe_url, output_dir, state_file.as_posix(), api_key)
-    with open(state_file.as_posix(), "r") as f:
-        return json.loads(f.read())
-
+        error_code = e.response["Error"]["Code"]
+        sys_logger.error(f"ECR client error: {error_code}")
+        return None
 
-def build_image(image_info: Dict, ecr_prefix: str, state_file: str = "state.json") -> None:
-    hafnia_tag = f"{ecr_prefix}/{image_info['name']}:{image_info['hash']}"
-    image_exists = False
-    if "localhost" not in ecr_prefix:
-        image_exists = check_ecr(image_info["name"], image_info["hash"])
 
-    image_info.update({"mdi_tag": hafnia_tag, "image_exists": image_exists})
-    state_path = Path(state_file)
-    state_path.parent.mkdir(parents=True, exist_ok=True)
+def build_image(metadata: Dict, registry_repo: str, state_file: str = "state.json") -> None:
+    docker_image = f"{registry_repo}:{metadata['digest']}"
+    image_exists = check_registry(docker_image) is not None
     if image_exists:
-        logger.info(f"Image {hafnia_tag} already exists in ECR. Skipping build.")
+        sys_logger.info("Image {} already exists in the registry.".format(docker_image.rsplit("/")[-1]))
     else:
-        build_dockerfile(image_info["dockerfile"], image_info["docker_context"], hafnia_tag)
-    with open(state_path.as_posix(), "w") as f:
-        json.dump(image_info, f, indent=4)
+        build_dockerfile(metadata["dockerfile"], Path(metadata["dockerfile"]).parent.as_posix(), docker_image)
+    metadata.update({"image_tag": docker_image, "image_exists": image_exists})
+    Path(state_file).write_text(json.dumps(metadata, indent=2))

hafnia/platform/download.py

@@ -6,7 +6,7 @@ from botocore.exceptions import ClientError
 from tqdm import tqdm
 
 from hafnia.http import fetch
-from hafnia.log import logger
+from hafnia.log import sys_logger, user_logger
 
 
 def get_resource_creds(endpoint: str, api_key: str) -> Dict[str, Any]:
@@ -30,11 +30,11 @@ def get_resource_creds(endpoint: str, api_key: str) -> Dict[str, Any]:
         RuntimeError: If the call to fetch the credentials fails for any reason.
     """
     try:
-        creds = fetch(endpoint, headers={"X-APIKEY": api_key, "accept": "application/json"})
-        logger.debug("Successfully retrieved credentials from DIP endpoint.")
+        creds = fetch(endpoint, headers={"Authorization": api_key, "accept": "application/json"})
+        sys_logger.debug("Successfully retrieved credentials from DIP endpoint.")
         return creds
     except Exception as e:
-        logger.error(f"Failed to fetch credentials from endpoint: {e}")
+        sys_logger.error(f"Failed to fetch credentials from endpoint: {e}")
         raise RuntimeError(f"Failed to retrieve credentials: {e}") from e
 
 
@@ -99,12 +99,12 @@ def download_resource(resource_url: str, destination: str, api_key: str) -> Dict
         s3_client.head_object(Bucket=bucket_name, Key=key)
         local_file = download_single_object(s3_client, bucket_name, key, output_path)
         downloaded_files.append(str(local_file))
-        logger.info(f"Downloaded single file: {local_file}")
+        user_logger.info(f"Downloaded single file: {local_file}")
 
     except ClientError as e:
         error_code = e.response.get("Error", {}).get("Code")
         if error_code == "404":
-            logger.debug(f"Object '{key}' not found; trying as a prefix.")
+            sys_logger.debug(f"Object '{key}' not found; trying as a prefix.")
             response = s3_client.list_objects_v2(Bucket=bucket_name, Prefix=key)
             contents = response.get("Contents", [])
 
@@ -118,9 +118,9 @@ def download_resource(resource_url: str, destination: str, api_key: str) -> Dict
                 local_file = download_single_object(s3_client, bucket_name, sub_key, output_path)
                 downloaded_files.append(local_file.as_posix())
 
-            logger.info(f"Downloaded folder/prefix '{key}' with {len(downloaded_files)} object(s).")
+            user_logger.info(f"Downloaded folder/prefix '{key}' with {len(downloaded_files)} object(s).")
         else:
-            logger.error(f"Error checking object or prefix: {e}")
+            user_logger.error(f"Error checking object or prefix: {e}")
             raise RuntimeError(f"Failed to check or download S3 resource: {e}") from e
 
     return {"status": "success", "downloaded_files": downloaded_files}

hafnia/platform/experiment.py

@@ -2,45 +2,53 @@ from pathlib import Path
 from typing import Optional
 
 from hafnia.http import fetch, post
-from hafnia.platform.builder import validate_recipe
-from hafnia.utils import archive_dir, get_recipe_path
+from hafnia.log import user_logger
+from hafnia.utils import archive_dir, get_recipe_path, timed
 
 
-def get_dataset_id(dataset_name: str, endpoint: str, api_key: str) -> Optional[str]:
-    headers = {"X-APIKEY": api_key}
+@timed("Fetching dataset info.")
+def get_dataset_id(dataset_name: str, endpoint: str, api_key: str) -> str:
+    headers = {"Authorization": api_key}
     full_url = f"{endpoint}?name__iexact={dataset_name}"
     dataset_info = fetch(full_url, headers=headers)
     if not dataset_info:
         raise ValueError(f"Dataset '{dataset_name}' was not found in the dataset library.")
-    return dataset_info[0]["id"]
+    try:
+        return dataset_info[0]["id"]
+    except (IndexError, KeyError) as e:
+        raise ValueError("Dataset information is missing or invalid") from e
 
 
-def create_recipe(source_dir: Path, endpoint: str, api_key: str, organization_id: str) -> Optional[str]:
-    headers = {"X-APIKEY": api_key, "accept": "application/json"}
+@timed("Uploading recipe.")
+def create_recipe(source_dir: Path, endpoint: str, api_key: str) -> str:
     source_dir = source_dir.resolve()  # Ensure the path is absolute to handle '.' paths are given an appropriate name.
     path_recipe = get_recipe_path(recipe_name=source_dir.name)
     zip_path = archive_dir(source_dir, output_path=path_recipe)
+    user_logger.info(f"Recipe created and stored in '{path_recipe}'")
 
-    print(f"Recipe created and stored in '{path_recipe}'")
-
-    validate_recipe(zip_path)
-    with open(zip_path, "rb") as zip_file:
-        fields = {
-            "name": path_recipe.name,
-            "description": "Recipe created by Hafnia CLI",
-            "organization": organization_id,
-            "file": (zip_path.name, zip_file.read()),
-        }
-        response = post(endpoint, headers=headers, data=fields, multipart=True)
-        return response["id"]
+    headers = {"Authorization": api_key, "accept": "application/json"}
+    data = {
+        "name": path_recipe.name,
+        "description": "Recipe created by Hafnia CLI",
+        "file": (zip_path.name, Path(zip_path).read_bytes()),
+    }
+    response = post(endpoint, headers=headers, data=data, multipart=True)
+    return response["id"]
 
 
-def get_exp_environment_id(name: str, endpoint: str, api_key: str) -> Optional[str]:
-    headers = {"X-APIKEY": api_key}
+@timed("Fetching environment info.")
+def get_exp_environment_id(name: str, endpoint: str, api_key: str) -> str:
+    headers = {"Authorization": api_key}
     env_info = fetch(endpoint, headers=headers)
-    return next((env["id"] for env in env_info if env["name"] == name), None)
+
+    for env in env_info:
+        if env["name"] == name:
+            return env["id"]
+
+    raise ValueError(f"Environment '{name}' not found")
 
 
+@timed("Creating exepriment.")
 def create_experiment(
     exp_name: str,
     dataset_id: str,
@@ -49,14 +57,12 @@ def create_experiment(
     environment_id: str,
     endpoint: str,
     api_key: str,
-    organization_id: str,
 ) -> Optional[str]:
-    headers = {"X-APIKEY": api_key}
+    headers = {"Authorization": api_key}
     response = post(
         endpoint,
         headers=headers,
         data={
-            "organization": organization_id,
             "name": exp_name,
             "recipe": recipe_id,
             "dataset": dataset_id,

hafnia/utils.py

@@ -1,18 +1,17 @@
-import functools
 import os
-import sys
-import tempfile
+import time
 import zipfile
 from datetime import datetime
+from functools import wraps
 from pathlib import Path
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Iterator, Optional
 from zipfile import ZipFile
 
-import click
 import pathspec
 import seedir
+from rich import print as rprint
 
-from hafnia.log import logger
+from hafnia.log import sys_logger, user_logger
 
 PATH_DATA = Path("./.data")
 PATH_DATASET = PATH_DATA / "datasets"
@@ -34,6 +33,30 @@ DEFAULT_IGNORE_SPECIFICATION = [
 ]
 
 
+def timed(label: str):
+    """
+    Decorator factory that allows custom labels for timing.
+    Usage: @timed("Custom Operation")
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
+            operation_label = label or func.__name__
+            tik = time.perf_counter()
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                sys_logger.error(f"{operation_label} failed: {e}")
+            finally:
+                elapsed = time.perf_counter() - tik
+                sys_logger.debug(f"{operation_label} took {elapsed:.2f} seconds.")
+
+        return wrapper
+
+    return decorator
+
+
 def now_as_str() -> str:
     """Get the current date and time as a string."""
     return datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
@@ -45,19 +68,11 @@ def get_recipe_path(recipe_name: str) -> Path:
     return path_recipe
 
 
-def archive_dir(
-    recipe_path: Path,
-    output_path: Optional[Path] = None,
-    path_ignore_file: Optional[Path] = None,
-) -> Path:
-    recipe_zip_path = output_path or recipe_path / "recipe.zip"
-    assert recipe_zip_path.suffix == ".zip", "Output path must be a zip file"
-    recipe_zip_path.parent.mkdir(parents=True, exist_ok=True)
-
+def filter_recipe_files(recipe_path: Path, path_ignore_file: Optional[Path] = None) -> Iterator:
     path_ignore_file = path_ignore_file or recipe_path / FILENAME_HAFNIAIGNORE
     if not path_ignore_file.exists():
         ignore_specification_lines = DEFAULT_IGNORE_SPECIFICATION
-        click.echo(
+        user_logger.info(
             f"No '{FILENAME_HAFNIAIGNORE}' was file found. Files are excluded using the default ignore patterns.\n"
             f"\tDefault ignore patterns: {DEFAULT_IGNORE_SPECIFICATION}\n"
             f"Add a '{FILENAME_HAFNIAIGNORE}' file to the root folder to make custom ignore patterns."
@@ -65,71 +80,58 @@ def archive_dir(
     else:
         ignore_specification_lines = Path(path_ignore_file).read_text().splitlines()
     ignore_specification = pathspec.GitIgnoreSpec.from_lines(ignore_specification_lines)
+    include_files = ignore_specification.match_tree(recipe_path, negate=True)
+    return include_files
 
-    include_files = sorted(ignore_specification.match_tree(recipe_path, negate=True))
-    click.echo(f"Creating zip archive of '{recipe_path}'")
-    with ZipFile(recipe_zip_path, "w") as zip_ref:
-        for str_filepath in include_files:
-            path_file = recipe_path / str_filepath
-            if not path_file.is_file():
-                continue
-
-            relative_path = path_file.relative_to(recipe_path)
-            zip_ref.write(path_file, relative_path)
 
-    recipe_dir_tree = view_recipe_content(recipe_zip_path)
-    click.echo(recipe_dir_tree)
-    return recipe_zip_path
-
-
-def safe(func: Callable) -> Callable:
-    """
-    Decorator that catches exceptions, logs them, and exits with code 1.
-
-    Args:
-        func: The function to decorate
-
-    Returns:
-        Wrapped function that handles exceptions
-    """
+@timed("Wrapping recipe.")
+def archive_dir(
+    recipe_path: Path,
+    output_path: Optional[Path] = None,
+    path_ignore_file: Optional[Path] = None,
+) -> Path:
+    recipe_zip_path = output_path or recipe_path / "recipe.zip"
+    assert recipe_zip_path.suffix == ".zip", "Output path must be a zip file"
+    recipe_zip_path.parent.mkdir(parents=True, exist_ok=True)
 
-    @functools.wraps(func)
-    def wrapper(*args: Any, **kwargs: Any) -> Any:
-        try:
-            return func(*args, **kwargs)
-        except Exception as e:
-            logger.error(f"Error in {func.__name__}: {str(e)}")
-            sys.exit(1)
+    user_logger.info(f" Creating zip archive of '{recipe_path}'")
+    include_files = filter_recipe_files(recipe_path, path_ignore_file)
+    with ZipFile(recipe_zip_path, "w", compression=zipfile.ZIP_STORED, allowZip64=True) as zip_ref:
+        for str_filepath in include_files:
+            full_path = recipe_path / str_filepath
+            zip_ref.write(full_path, str_filepath)
+    show_recipe_content(recipe_zip_path)
 
-    return wrapper
+    return recipe_zip_path
 
 
 def size_human_readable(size_bytes: int, suffix="B") -> str:
-    # From: https://stackoverflow.com/a/1094933
     size_value = float(size_bytes)
     for unit in ("", "Ki", "Mi", "Gi", "Ti", "Pi", "Ei", "Zi"):
         if abs(size_value) < 1024.0:
-            return f"{size_value:3.1f}{unit}{suffix}"
+            return f"{size_value:3.1f} {unit}{suffix}"
         size_value /= 1024.0
     return f"{size_value:.1f}Yi{suffix}"
 
 
-def view_recipe_content(recipe_path: Path, style: str = "emoji", depth_limit: int = 3) -> str:
-    zf = zipfile.ZipFile(recipe_path)
-    with tempfile.TemporaryDirectory() as tempdir:
-        path_extract_folder = Path(tempdir) / "recipe"
-        zf.extractall(path_extract_folder)
-        dir_str = seedir.seedir(
-            path_extract_folder, sort=True, first="folders", style=style, depthlimit=depth_limit, printout=False
-        )
-
-    size_str = size_human_readable(os.path.getsize(recipe_path))
+def show_recipe_content(recipe_path: Path, style: str = "emoji", depth_limit: int = 3) -> None:
+    def scan(parent: seedir.FakeDir, path: zipfile.Path, depth: int = 0) -> None:
+        if depth >= depth_limit:
+            return
+        for child in path.iterdir():
+            if child.is_dir():
+                folder = seedir.FakeDir(child.name)
+                scan(folder, child, depth + 1)
+                folder.parent = parent
+            else:
+                parent.create_file(child.name)
 
-    dir_str = dir_str + f"\n\nRecipe size: {size_str}. Max size 800MiB\n"
-    return dir_str
+    recipe = seedir.FakeDir("recipe")
+    scan(recipe, zipfile.Path(recipe_path))
+    rprint(recipe.seedir(sort=True, first="folders", style=style, printout=False))
+    user_logger.info(f"Recipe size: {size_human_readable(os.path.getsize(recipe_path))}. Max size 800 MiB")
 
 
 def is_remote_job() -> bool:
     """Check if the current job is running in HAFNIA cloud environment."""
-    is_remote = os.getenv("HAFNIA_CLOUD", "false").lower() == "true"
-    return is_remote
+    return os.getenv("HAFNIA_CLOUD", "false").lower() == "true"