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

cli/__main__.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 import click
 
-from cli import consts, data_cmds, experiment_cmds, profile_cmds, runc_cmds
+from cli import consts, data_cmds, experiment_cmds, profile_cmds, recipe_cmds, runc_cmds
 from cli.config import Config, ConfigSchema
 
 
@@ -54,6 +54,7 @@ main.add_command(profile_cmds.profile)
 main.add_command(data_cmds.data)
 main.add_command(runc_cmds.runc)
 main.add_command(experiment_cmds.experiment)
+main.add_command(recipe_cmds.recipe)
 
 if __name__ == "__main__":
     main()

cli/consts.py

@@ -8,6 +8,7 @@ ERROR_CREATE_PROFILE: str = "Failed to create profile. Profile name must be uniq
 ERROR_GET_RESOURCE: str = "Failed to get the data from platform. Verify url or api key."
 
 ERROR_EXPERIMENT_DIR: str = "Source directory does not exist"
+ERROR_RECIPE_FILE_FORMAT: str = "Recipe filename must be a '.zip' file"
 
 PROFILE_SWITCHED_SUCCESS: str = "Switched to profile:"
 PROFILE_REMOVED_SUCCESS: str = "Removed profile:"

cli/data_cmds.py

@@ -1,3 +1,4 @@
+from pathlib import Path
 from typing import Optional
 
 import click
@@ -35,20 +36,18 @@ def data_get(cfg: Config, url: str, destination: click.Path) -> None:
 @click.argument("destination", default=None, required=False)
 @click.option("--force", is_flag=True, default=False, help="Force download")
 @click.pass_obj
-def data_download(cfg: Config, dataset_name: str, destination: Optional[click.Path], force: bool) -> None:
+def data_download(cfg: Config, dataset_name: str, destination: Optional[click.Path], force: bool) -> Path:
     """Download dataset from Hafnia platform"""
 
     from hafnia.data.factory import download_or_get_dataset_path
 
     try:
-        endpoint_dataset = cfg.get_platform_endpoint("datasets")
-        api_key = cfg.api_key
-        download_or_get_dataset_path(
+        path_dataset = download_or_get_dataset_path(
             dataset_name=dataset_name,
-            endpoint=endpoint_dataset,
-            api_key=api_key,
+            cfg=cfg,
             output_dir=destination,
             force_redownload=force,
         )
     except Exception:
         raise click.ClickException(consts.ERROR_GET_RESOURCE)
+    return path_dataset

cli/experiment_cmds.py

@@ -13,32 +13,6 @@ def experiment() -> None:
     pass
 
 
-@experiment.command(name="create_recipe")
-@click.option("--source_folder", default=".", type=Path, help="Path to the source folder", show_default=True)
-@click.option(
-    "--recipe_filename",
-    default="recipe.zip",
-    type=Path,
-    help="Recipe filename. Should have a '.zip' suffix",
-    show_default=True,
-)
-def create_recipe(source_folder: str, recipe_filename: str) -> None:
-    """Build recipe from local path as image with prefix - localhost"""
-
-    from hafnia.platform.builder import validate_recipe
-    from hafnia.utils import archive_dir
-
-    path_output_zip = Path(recipe_filename)
-
-    if path_output_zip.suffix != ".zip":
-        raise click.ClickException("Recipe filename must be a '.zip' file")
-
-    path_source = Path(source_folder)
-
-    path_output_zip = archive_dir(path_source, path_output_zip)
-    validate_recipe(path_output_zip)
-
-
 @experiment.command(name="create")
 @click.argument("name")
 @click.argument("source_dir", type=Path)

cli/recipe_cmds.py

@@ -0,0 +1,49 @@
+from pathlib import Path
+
+import click
+
+import cli.consts as consts
+
+
+@click.group(name="recipe")
+def recipe() -> None:
+    """Hafnia Recipe management commands"""
+    pass
+
+
+@recipe.command(name="create")
+@click.argument("source")
+@click.option(
+    "--output", type=click.Path(writable=True), default="./recipe.zip", show_default=True, help="Output recipe path."
+)
+def create(source: str, output: str) -> None:
+    """Create HRF from local path"""
+
+    from hafnia.platform.builder import validate_recipe
+    from hafnia.utils import archive_dir
+
+    path_output_zip = Path(output)
+    if path_output_zip.suffix != ".zip":
+        raise click.ClickException(consts.ERROR_RECIPE_FILE_FORMAT)
+
+    path_source = Path(source)
+    path_output_zip = archive_dir(path_source, path_output_zip)
+    validate_recipe(path_output_zip)
+
+
+@recipe.command(name="view")
+@click.option("--path", type=str, default="./recipe.zip", show_default=True, help="Path of recipe.zip.")
+@click.option("--depth-limit", type=int, default=3, help="Limit the depth of the tree view.", show_default=True)
+def view(path: str, depth_limit: int) -> None:
+    """View the content of a recipe zip file."""
+    from hafnia.utils import view_recipe_content
+
+    path_recipe = Path(path)
+    if not path_recipe.exists():
+        raise click.ClickException(
+            f"Recipe file '{path_recipe}' does not exist. Please provide a valid path. "
+            f"To create a recipe, use the 'hafnia recipe create' command."
+        )
+
+    tree_str = view_recipe_content(path_recipe, depth_limit=depth_limit)
+    click.echo(tree_str)

cli/runc_cmds.py

@@ -1,6 +1,10 @@
+import json
+import subprocess
+import zipfile
 from hashlib import sha256
 from pathlib import Path
 from tempfile import TemporaryDirectory
+from typing import Optional
 
 import click
 
@@ -22,6 +26,72 @@ def launch(task: str) -> None:
     handle_launch(task)
 
 
+@runc.command(name="launch-local")
+@click.argument("exec_cmd", type=str)
+@click.option(
+    "--dataset",
+    type=str,
+    help="Hafnia dataset name e.g. mnist, midwest-vehicle-detection or a path to a local dataset",
+    required=True,
+)
+@click.option(
+    "--image_name",
+    type=Optional[str],
+    default=None,
+    help=(
+        "Docker image name to use for the launch. "
+        "By default, it will use image name from '.state.json' "
+        "file generated by the 'hafnia runc build-local' command"
+    ),
+)
+@click.pass_obj
+def launch_local(cfg: Config, exec_cmd: str, dataset: str, image_name: str) -> None:
+    """Launch a job within the image."""
+    from hafnia.data.factory import download_or_get_dataset_path
+
+    is_local_dataset = "/" in dataset
+    if is_local_dataset:
+        click.echo(f"Using local dataset: {dataset}")
+        path_dataset = Path(dataset)
+        if not path_dataset.exists():
+            raise click.ClickException(f"Dataset path does not exist: {path_dataset}")
+    else:
+        click.echo(f"Using Hafnia dataset: {dataset}")
+        path_dataset = download_or_get_dataset_path(dataset_name=dataset, cfg=cfg, force_redownload=False)
+
+    if image_name is None:
+        # Load image name from state.json
+        path_state_file = Path("state.json")
+        if not path_state_file.exists():
+            raise click.ClickException("State file does not exist. Please build the image first.")
+        state_dict = json.loads(path_state_file.read_text())
+        if "mdi_tag" not in state_dict:
+            raise click.ClickException("mdi_tag not found in state file. Please build the image first.")
+        image_name = state_dict["mdi_tag"]
+
+    docker_cmds = [
+        "docker",
+        "run",
+        "--rm",
+        "-v",
+        f"{path_dataset.absolute()}:/opt/ml/input/data/training",
+        "-e",
+        "HAFNIA_CLOUD=true",
+        "-e",
+        "PYTHONPATH=src",
+        "--runtime",
+        "nvidia",
+        image_name,
+    ] + exec_cmd.split(" ")
+
+    # Use the "hafnia runc launch" cmd when we have moved to the new folder structure and
+    # direct commands.
+    # Replace '+ exec_cmd.split(" ")' with '["hafnia", "runc", "launch"] + exec_cmd.split(" ")'
+
+    click.echo(f"Running command: \n\t{' '.join(docker_cmds)}")
+    subprocess.run(docker_cmds, check=True)
+
+
 @runc.command(name="build")
 @click.argument("recipe_url")
 @click.argument("state_file", default="state.json")
@@ -56,13 +126,18 @@ def build_local(recipe: str, state_file: str, image_name: str) -> None:
 
     validate_recipe(recipe_zip)
     click.echo("Recipe successfully validated")
-    image_info = {
-        "name": image_name,
-        "dockerfile": f"{recipe_zip.parent}/Dockerfile",
-        "docker_context": f"{recipe_zip.parent}",
-        "hash": sha256(recipe_zip.read_bytes()).hexdigest()[:8],
-    }
-    click.echo("Start building image")
-    build_image(image_info, "localhost", state_file=state_file)
-    if recipe_created:
-        recipe_zip.unlink()
+    with TemporaryDirectory() as temp_dir:
+        temp_dir_path = Path(temp_dir)
+        with zipfile.ZipFile(recipe_zip, "r") as zip_ref:
+            zip_ref.extractall(temp_dir_path)
+
+        image_info = {
+            "name": image_name,
+            "dockerfile": (temp_dir_path / "Dockerfile").as_posix(),
+            "docker_context": temp_dir_path.as_posix(),
+            "hash": sha256(recipe_zip.read_bytes()).hexdigest()[:8],
+        }
+        click.echo("Start building image")
+        build_image(image_info, "localhost", state_file=state_file)
+        if recipe_created:
+            recipe_zip.unlink()

hafnia/data/factory.py

@@ -21,12 +21,16 @@ def load_local(dataset_path: Path) -> Union[Dataset, DatasetDict]:
 
 def download_or_get_dataset_path(
     dataset_name: str,
-    endpoint: str,
-    api_key: str,
+    cfg: Optional[Config] = None,
     output_dir: Optional[str] = None,
     force_redownload: bool = False,
 ) -> Path:
     """Download or get the path of the dataset."""
+
+    cfg = cfg or Config()
+    endpoint_dataset = cfg.get_platform_endpoint("datasets")
+    api_key = cfg.api_key
+
     output_dir = output_dir or str(utils.PATH_DATASET)
     dataset_path_base = Path(output_dir).absolute() / dataset_name
     dataset_path_base.mkdir(exist_ok=True, parents=True)
@@ -36,8 +40,8 @@ def download_or_get_dataset_path(
         logger.info("Dataset found locally. Set 'force=True' or add `--force` flag with cli to re-download")
         return dataset_path_sample
 
-    dataset_id = get_dataset_id(dataset_name, endpoint, api_key)
-    dataset_access_info_url = f"{endpoint}/{dataset_id}/temporary-credentials"
+    dataset_id = get_dataset_id(dataset_name, endpoint_dataset, api_key)
+    dataset_access_info_url = f"{endpoint_dataset}/{dataset_id}/temporary-credentials"
 
     if force_redownload and dataset_path_sample.exists():
         # Remove old files to avoid old files conflicting with new files
@@ -48,23 +52,6 @@ def download_or_get_dataset_path(
     raise RuntimeError("Failed to download dataset")
 
 
-def load_from_platform(
-    dataset_name: str,
-    endpoint: str,
-    api_key: str,
-    output_dir: Optional[str] = None,
-    force_redownload: bool = False,
-) -> Union[Dataset, DatasetDict]:
-    path_dataset = download_or_get_dataset_path(
-        dataset_name=dataset_name,
-        endpoint=endpoint,
-        api_key=api_key,
-        output_dir=output_dir,
-        force_redownload=force_redownload,
-    )
-    return load_local(path_dataset)
-
-
 def load_dataset(dataset_name: str, force_redownload: bool = False) -> Union[Dataset, DatasetDict]:
     """Load a dataset either from a local path or from the Hafnia platform."""
 
@@ -72,15 +59,9 @@ def load_dataset(dataset_name: str, force_redownload: bool = False) -> Union[Dat
         path_dataset = Path(os.getenv("MDI_DATASET_DIR", "/opt/ml/input/data/training"))
         return load_local(path_dataset)
 
-    cfg = Config()
-    endpoint_dataset = cfg.get_platform_endpoint("datasets")
-    api_key = cfg.api_key
-    dataset = load_from_platform(
+    path_dataset = download_or_get_dataset_path(
         dataset_name=dataset_name,
-        endpoint=endpoint_dataset,
-        api_key=api_key,
-        output_dir=None,
         force_redownload=force_redownload,
     )
-
+    dataset = load_local(path_dataset)
     return dataset

hafnia/experiment/hafnia_logger.py

@@ -159,8 +159,12 @@ class HafniaLogger:
     def log_hparams(self, params: Dict, fname: str = "hparams.json"):
         file_path = self._path_artifacts() / fname
         try:
-            with open(file_path, "w") as f:
-                json.dump(params, f, indent=2)
+            if file_path.exists():  # New params are appended to existing params
+                existing_params = json.loads(file_path.read_text())
+            else:
+                existing_params = {}
+            existing_params.update(params)
+            file_path.write_text(json.dumps(existing_params, indent=2))
             logger.info(f"Saved parameters to {file_path}")
         except Exception as e:
             logger.error(f"Failed to save parameters to {file_path}: {e}")

hafnia/platform/builder.py

@@ -25,7 +25,7 @@ def validate_recipe(zip_path: Path, required_paths: Optional[set] = None) -> Non
     Raises:
         FileNotFoundError: If any required file or directory is missing.
     """
-    required_paths = {"src/lib/", "src/scripts/", "Dockerfile"} if required_paths is None else required_paths
+    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 = {
@@ -35,10 +35,10 @@ def validate_recipe(zip_path: Path, required_paths: Optional[set] = None) -> Non
         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("src/scripts/") and f.endswith(".py")]
+        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 'src/scripts/' directory.")
+            raise ValueError("No Python script files found in the 'scripts' directory.")
 
 
 def clean_up(files: List[Path], dirs: List[Path], prefix: str = "__") -> None:
@@ -82,11 +82,11 @@ def get_recipe_content(recipe_url: str, output_dir: Path, state_file: str, api_k
 
     tag = sha256(recipe_path.read_bytes()).hexdigest()[:8]
 
-    scripts_dir = output_dir / "src/scripts"
+    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 valid_commands:
-        raise ValueError("No valid Python script commands found in the 'src/scripts' directory.")
+        raise ValueError("No valid Python script commands found in the 'scripts' directory.")
 
     state = {
         "user_data": (output_dir / "src").as_posix(),

hafnia/platform/executor.py

@@ -21,22 +21,22 @@ def handle_mount(source: str) -> None:
     Mounts the Hafnia environment by adding source directories to PYTHONPATH.
 
     Args:
-        source (str): Path to the root directory containing 'lib' and 'scripts' subdirectories
+        source (str): Path to the root directory containing 'src' and 'scripts' subdirectories
 
     Raises:
         FileNotFoundError: If the required directory structure is not found
     """
     source_path = Path(source)
-    lib_dir = source_path / "lib"
+    src_dir = source_path / "src"
     scripts_dir = source_path / "scripts"
 
-    if not lib_dir.exists() and not scripts_dir.exists():
-        logger.error(f"Filestructure is not supported. Expected 'lib' and 'scripts' directories in {source_path}.")
+    if not src_dir.exists() and not scripts_dir.exists():
+        logger.error(f"Filestructure is not supported. Expected 'src' and 'scripts' directories in {source_path}.")
         exit(1)
 
-    sys.path.extend([lib_dir.as_posix(), scripts_dir.as_posix()])
+    sys.path.extend([src_dir.as_posix(), scripts_dir.as_posix()])
     python_path = os.getenv("PYTHONPATH", "")
-    os.environ["PYTHONPATH"] = f"{python_path}:{lib_dir.as_posix()}:{scripts_dir.as_posix()}"
+    os.environ["PYTHONPATH"] = f"{python_path}:{src_dir.as_posix()}:{scripts_dir.as_posix()}"
     logger.info(f"Mounted codebase from {source_path}")
 
 

hafnia/utils.py

@@ -1,18 +1,37 @@
 import functools
 import os
 import sys
+import tempfile
+import zipfile
 from datetime import datetime
 from pathlib import Path
 from typing import Any, Callable, Optional
 from zipfile import ZipFile
 
 import click
+import pathspec
+import seedir
 
 from hafnia.log import logger
 
 PATH_DATA = Path("./.data")
 PATH_DATASET = PATH_DATA / "datasets"
 PATH_RECIPES = PATH_DATA / "recipes"
+FILENAME_HAFNIAIGNORE = ".hafniaignore"
+DEFAULT_IGNORE_SPECIFICATION = [
+    "*.jpg",
+    "*.png",
+    "*.py[cod]",
+    "*_cache/",
+    ".data",
+    ".git",
+    ".venv",
+    ".vscode",
+    "__pycache__",
+    "recipe.zip",
+    "tests",
+    "wandb",
+]
 
 
 def now_as_str() -> str:
@@ -26,32 +45,40 @@ def get_recipe_path(recipe_name: str) -> Path:
     return path_recipe
 
 
-def archive_dir(recipe_path: Path, output_path: Optional[Path] = None) -> Path:
+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)
 
-    click.echo(f"Creating zip archive {recipe_path}")
+    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(
+            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."
+        )
+    else:
+        ignore_specification_lines = Path(path_ignore_file).read_text().splitlines()
+    ignore_specification = pathspec.GitIgnoreSpec.from_lines(ignore_specification_lines)
+
+    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 item in recipe_path.rglob("*"):
-            should_skip = (
-                item == recipe_zip_path
-                or item.name.endswith(".zip")
-                or any(part.startswith(".") for part in item.parts)
-                or any(part == "__pycache__" for part in item.parts)
-            )
-
-            if should_skip:
-                if item != recipe_zip_path:
-                    click.echo(f"[-] {item.relative_to(recipe_path)}")
+        for str_filepath in include_files:
+            path_file = recipe_path / str_filepath
+            if not path_file.is_file():
                 continue
 
-            if not item.is_file():
-                continue
+            relative_path = path_file.relative_to(recipe_path)
+            zip_ref.write(path_file, relative_path)
 
-            relative_path = item.relative_to(recipe_path)
-            click.echo(f"[+] {relative_path}")
-            zip_ref.write(item, relative_path)
+    recipe_dir_tree = view_recipe_content(recipe_zip_path)
+    click.echo(recipe_dir_tree)
     return recipe_zip_path
 
 
@@ -77,6 +104,31 @@ def safe(func: Callable) -> Callable:
     return wrapper
 
 
+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}"
+        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))
+
+    dir_str = dir_str + f"\n\nRecipe size: {size_str}. Max size 800MiB\n"
+    return dir_str
+
+
 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"

{hafnia-0.1.24.dist-info → hafnia-0.1.25.dist-info}/METADATA

@@ -1,18 +1,21 @@
 Metadata-Version: 2.4
 Name: hafnia
-Version: 0.1.24
-Summary: Python tools for communication with Hafnia platform.
-Author-email: Ivan Sahumbaiev <ivsa@milestone.dk>
+Version: 0.1.25
+Summary: Python SDK for communication with Hafnia platform.
+Author-email: Milestone Systems <hafniaplatform@milestone.dk>
 License-File: LICENSE
 Requires-Python: >=3.10
 Requires-Dist: boto3>=1.35.91
 Requires-Dist: click>=8.1.8
 Requires-Dist: datasets>=3.2.0
+Requires-Dist: emoji>=2.14.1
 Requires-Dist: flatten-dict>=0.4.2
+Requires-Dist: pathspec>=0.12.1
 Requires-Dist: pillow>=11.1.0
 Requires-Dist: pyarrow>=18.1.0
 Requires-Dist: pydantic>=2.10.4
 Requires-Dist: rich>=13.9.4
+Requires-Dist: seedir>=0.5.0
 Requires-Dist: tqdm>=4.67.1
 Provides-Extra: torch
 Requires-Dist: flatten-dict>=0.4.2; extra == 'torch'
@@ -167,31 +170,49 @@ and datasets available in the data library.
 By combining logging and dataset loading, we can now construct our model training recipe. 
 
 To demonstrate this, we have provided a recipe project that serves as a template for creating and structuring training recipes
-[recipe-classification](https://github.com/Data-insight-Platform/recipe-classification)
+[recipe-classification](https://github.com/milestone-hafnia/recipe-classification)
 
 The project also contains additional information on how to structure your training recipe, use the `HafniaLogger`, the `load_dataset` function and different approach for launching 
 the training recipe on the Hafnia platform.
 
+
+## Create, Build and Run `recipe.zip` locally
+In order to test recipe compatibility with Hafnia cloud use the following command to build and 
+start the job locally.
+
+```bash
+    # Create 'recipe.zip' from source folder '.'
+    hafnia recipe create .
+    
+    # Build the docker image locally from a 'recipe.zip' file
+    hafnia runc build-local recipe.zip
+
+    # Execute the docker image locally with a desired dataset
+    hafnia runc launch-local --dataset mnist  "python scripts/train.py"
+```
+
 ## Detailed Documentation
 For more information, go to our [documentation page](https://hafnia.readme.io/docs/welcome-to-hafnia) 
 or in below markdown pages. 
 
 - [CLI](docs/cli.md) - Detailed guide for the Hafnia command-line interface
-- [Script2Model Documentation](docs/s2m.md) - Detailed guide for script2model
 - [Release lifecycle](docs/release.md) - Details about package release lifecycle.
 
 ## Development
 For development, we are using an uv based virtual python environment.
 
 Install uv
-
-    curl -LsSf https://astral.sh/uv/install.sh | sh
-
+```bash 
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
 
 Install python dependencies including developer (`--dev`) and optional dependencies (`--all-extras`).
 
-    uv sync --all-extras --dev
+```bash
+uv sync --all-extras --dev
+```
 
  Run tests:
-
-    uv run pytest tests
+```bash
+uv run pytest tests
+```

hafnia-0.1.25.dist-info/RECORD

@@ -0,0 +1,29 @@
+cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cli/__main__.py,sha256=8JgZHtFpWAOUlEFvV0YWviLwesWSA-PTYH_v9COl2xw,1786
+cli/config.py,sha256=Js_dCn39l7hLhA3ovHorOyVqj-LCLzUg_figSy4jNjs,5279
+cli/consts.py,sha256=ybpWMhjkrqqevL7eVmYtdn_13a5-bV_5lCpA6_Wzcz0,964
+cli/data_cmds.py,sha256=BQiythAPwAwudgdUa68v50a345uw5flrcDiBHLGp9lo,1460
+cli/experiment_cmds.py,sha256=nJCnI0kzmFJ1_vmxIzOYWk_2eiiw1Ub0j02jXi2vW_s,2239
+cli/profile_cmds.py,sha256=Rg-5wLHSWlZhNPUZBO7LdyJS-Y-SgI6qKLoAac2gSdk,2534
+cli/recipe_cmds.py,sha256=TnUAoO643NeSio8akVUEJHs6Ttuu2JuprxyTPqzzb4k,1592
+cli/runc_cmds.py,sha256=6qvVfjxQ_1nkm7lrrIzYETdnBzfiXrmdnWo4jpbbdPk,4830
+hafnia/__init__.py,sha256=Zphq-cQoX95Z11zm4lkrU-YiAJxddR7IBfwDkxeHoDE,108
+hafnia/http.py,sha256=rID6Krn9wRGXwsJYvpffsFlt5cwxFgkcihYppqtdT-8,2974
+hafnia/log.py,sha256=ii--Q6IThsWOluRp_Br9WGhwBtKChU80BXk5pK_NU5A,819
+hafnia/torch_helpers.py,sha256=P_Jl4IwqUebKVCOXNe6iTorJZA3S-3d92HV274UHIko,7456
+hafnia/utils.py,sha256=jLq2S8n7W4HS7TsXnDgxTze463Mcatd_wC6pd54a7Os,4221
+hafnia/data/__init__.py,sha256=Pntmo_1fst8OhyrHB60jQ8mhJJ4hL38tdjLvt0YXEJo,73
+hafnia/data/factory.py,sha256=scsXrAHlBEP16AJH8RyQ1fyzhei5GxIwsmMgwEru3Pc,2536
+hafnia/experiment/__init__.py,sha256=OEFE6HqhO5zcTCLZcPcPVjIg7wMFFnvZ1uOtAVhRz7M,85
+hafnia/experiment/hafnia_logger.py,sha256=8baV6SUtCVIijypU-FfgAOIyWIf_eeJ5a62oFzQesmc,6794
+hafnia/platform/__init__.py,sha256=Oz1abs40hEKspLg6mVIokdtsp1tZJF9Pndv8uSMOgtQ,522
+hafnia/platform/api.py,sha256=aJvlQGjzqm-D3WYb2xTEYX60YoJoWN_kyYdlkvqt_MI,382
+hafnia/platform/builder.py,sha256=6xLy64a4cytMZEfqiA0kPzxiATEBbHXmDbf7igTMAiM,6595
+hafnia/platform/download.py,sha256=AWnlSYj9FD7GvZ_-9Sw5jrcxi3RyBSSUVph8U9T9ZbQ,4711
+hafnia/platform/executor.py,sha256=8E6cGmEMr5xYb3OReBuWj8ZnVXc0Es0UkfPamsmjH4g,3759
+hafnia/platform/experiment.py,sha256=951ppXdrp075pW2xGFOM0oiGYGE1I53tP9azQjjIUe8,2305
+hafnia-0.1.25.dist-info/METADATA,sha256=Q5dBhUXq-6lgaIVwR2ndWPsF7GFu4m8-G7dIjcW0iug,8660
+hafnia-0.1.25.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hafnia-0.1.25.dist-info/entry_points.txt,sha256=FCJVIQ8GP2VE9I3eeGVF5eLxVDNW_01pOJCpG_CGnMM,45
+hafnia-0.1.25.dist-info/licenses/LICENSE,sha256=wLZw1B7_mod_CO1H8LXqQgfqlWD6QceJR8--LJYRZGE,1078
+hafnia-0.1.25.dist-info/RECORD,,

{hafnia-0.1.24.dist-info → hafnia-0.1.25.dist-info}/licenses/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 Data-insight-Platform
+Copyright (c) 2025 Milestone Systems A/S
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

hafnia-0.1.24.dist-info/RECORD

@@ -1,28 +0,0 @@
-cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-cli/__main__.py,sha256=h1tOAK15us_dkoMd6Yd4SesVPisojTxOXiYxpLZnatw,1736
-cli/config.py,sha256=Js_dCn39l7hLhA3ovHorOyVqj-LCLzUg_figSy4jNjs,5279
-cli/consts.py,sha256=nd9fPTypqCJYJoOp9QifNgj7-c91J-T0dTv83c33g50,892
-cli/data_cmds.py,sha256=FYZPaeTs6WQnTf9b4a56w3SXQ1VAOMF5s8eUDHeNtd4,1538
-cli/experiment_cmds.py,sha256=d9M8008Z0Y49KIITy73qd5ViPehgMymDVAgsvZhwye0,3099
-cli/profile_cmds.py,sha256=Rg-5wLHSWlZhNPUZBO7LdyJS-Y-SgI6qKLoAac2gSdk,2534
-cli/runc_cmds.py,sha256=fNgPNURXmO4nfLyuorcpqWEeNNuTVsRBHxcIA9FCPts,2197
-hafnia/__init__.py,sha256=Zphq-cQoX95Z11zm4lkrU-YiAJxddR7IBfwDkxeHoDE,108
-hafnia/http.py,sha256=rID6Krn9wRGXwsJYvpffsFlt5cwxFgkcihYppqtdT-8,2974
-hafnia/log.py,sha256=ii--Q6IThsWOluRp_Br9WGhwBtKChU80BXk5pK_NU5A,819
-hafnia/torch_helpers.py,sha256=P_Jl4IwqUebKVCOXNe6iTorJZA3S-3d92HV274UHIko,7456
-hafnia/utils.py,sha256=WWWXZPolzncQmSb4onArT1lJyISV0D22eEejrHWePoc,2425
-hafnia/data/__init__.py,sha256=Pntmo_1fst8OhyrHB60jQ8mhJJ4hL38tdjLvt0YXEJo,73
-hafnia/data/factory.py,sha256=61oGQsm1naG_6Nd_UY2teOki8Oiu2F-gT-nGocmqAcg,2992
-hafnia/experiment/__init__.py,sha256=OEFE6HqhO5zcTCLZcPcPVjIg7wMFFnvZ1uOtAVhRz7M,85
-hafnia/experiment/hafnia_logger.py,sha256=bkSfioEaBXthUEGBjMbQaSefU30b_Gu809VcmWy_wyg,6566
-hafnia/platform/__init__.py,sha256=Oz1abs40hEKspLg6mVIokdtsp1tZJF9Pndv8uSMOgtQ,522
-hafnia/platform/api.py,sha256=aJvlQGjzqm-D3WYb2xTEYX60YoJoWN_kyYdlkvqt_MI,382
-hafnia/platform/builder.py,sha256=VqcbOPxC7HqGAqFMb6ewThBZYLEV5RBgQrVuMd2dbLY,6622
-hafnia/platform/download.py,sha256=AWnlSYj9FD7GvZ_-9Sw5jrcxi3RyBSSUVph8U9T9ZbQ,4711
-hafnia/platform/executor.py,sha256=HA8IF2ZTZ6ZiRWNjVdIdWKiUa5i8Yoz06mIUBDwzVDk,3759
-hafnia/platform/experiment.py,sha256=951ppXdrp075pW2xGFOM0oiGYGE1I53tP9azQjjIUe8,2305
-hafnia-0.1.24.dist-info/METADATA,sha256=85f5fVCG57auPMtzbF6T0o05smjq20XvZP-6jqNqEYg,8124
-hafnia-0.1.24.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-hafnia-0.1.24.dist-info/entry_points.txt,sha256=FCJVIQ8GP2VE9I3eeGVF5eLxVDNW_01pOJCpG_CGnMM,45
-hafnia-0.1.24.dist-info/licenses/LICENSE,sha256=DqQ3NOAy7Efwppv0IAVXEm3Za2SI_1OuDfG20ab8eQw,1078
-hafnia-0.1.24.dist-info/RECORD,,