hafnia 0.2.4__py3-none-any.whl → 0.3.0__py3-none-any.whl

hafnia/platform/experiment.py

@@ -1,73 +1,68 @@
-from pathlib import Path
-from typing import Optional
+from typing import Dict, List
 
-from hafnia.http import fetch, post
-from hafnia.log import user_logger
-from hafnia.utils import archive_dir, get_recipe_path, timed
+from hafnia import http
+from hafnia.utils import pretty_print_list_as_table, timed
 
 
-@timed("Fetching dataset info.")
-def get_dataset_id(dataset_name: str, endpoint: str, api_key: str) -> str:
+@timed("Creating experiment.")
+def create_experiment(
+    experiment_name: str,
+    dataset_recipe_id: str,
+    trainer_id: str,
+    exec_cmd: str,
+    environment_id: str,
+    endpoint: str,
+    api_key: str,
+) -> Dict:
     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.")
-    try:
-        return dataset_info[0]["id"]
-    except (IndexError, KeyError) as e:
-        raise ValueError("Dataset information is missing or invalid") from e
+    response = http.post(
+        endpoint,
+        headers=headers,
+        data={
+            "name": experiment_name,
+            "trainer": trainer_id,
+            "dataset_recipe": dataset_recipe_id,
+            "command": exec_cmd,
+            "environment": environment_id,
+        },
+    )
+    return response
 
 
-@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}'")
+@timed("Fetching environment info.")
+def get_environments(endpoint: str, api_key: str) -> List[Dict]:
+    headers = {"Authorization": api_key}
+    envs: List[Dict] = http.fetch(endpoint, headers=headers)  # type: ignore[assignment]
+    return envs
 
-    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()),
+
+def pretty_print_training_environments(envs: List[Dict]) -> None:
+    ENV_FIELDS = {
+        "Name": "name",
+        "Instance": "instance",
+        "GPU": "gpu",
+        "GPU Count": "gpu_count",
+        "GPU RAM": "vram",
+        "CPU": "cpu",
+        "CPU Count": "cpu_count",
+        "RAM": "ram",
     }
-    response = post(endpoint, headers=headers, data=data, multipart=True)
-    return response["id"]
+    pretty_print_list_as_table(
+        table_title="Available Training Environments",
+        dict_items=envs,
+        column_name_to_key_mapping=ENV_FIELDS,
+    )
 
 
-@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)
+    envs = get_environments(endpoint=endpoint, api_key=api_key)
 
-    for env in env_info:
+    for env in envs:
         if env["name"] == name:
             return env["id"]
 
-    raise ValueError(f"Environment '{name}' not found")
+    pretty_print_training_environments(envs)
 
+    available_envs = [env["name"] for env in envs]
 
-@timed("Creating exepriment.")
-def create_experiment(
-    exp_name: str,
-    dataset_id: str,
-    recipe_id: str,
-    exec_cmd: str,
-    environment_id: str,
-    endpoint: str,
-    api_key: str,
-) -> Optional[str]:
-    headers = {"Authorization": api_key}
-    response = post(
-        endpoint,
-        headers=headers,
-        data={
-            "name": exp_name,
-            "recipe": recipe_id,
-            "dataset": dataset_id,
-            "command": exec_cmd,
-            "environment": environment_id,
-        },
-    )
-    return response["id"]
+    raise ValueError(f"Environment '{name}' not found. Available environments are: {available_envs}")

hafnia/platform/trainer_package.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+from typing import Dict, List, Optional
+
+from hafnia import http
+from hafnia.log import user_logger
+from hafnia.utils import archive_dir, get_trainer_package_path, pretty_print_list_as_table, timed
+
+
+@timed("Uploading trainer package.")
+def create_trainer_package(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_trainer = get_trainer_package_path(trainer_name=source_dir.name)
+    zip_path = archive_dir(source_dir, output_path=path_trainer)
+    user_logger.info(f"Trainer package created and stored in '{path_trainer}'")
+
+    headers = {"Authorization": api_key, "accept": "application/json"}
+    data = {
+        "name": path_trainer.name,
+        "description": "Trainer package created by Hafnia CLI",
+        "file": (zip_path.name, Path(zip_path).read_bytes()),
+    }
+    response = http.post(endpoint, headers=headers, data=data, multipart=True)
+    return response["id"]
+
+
+@timed("Get trainer package.")
+def get_trainer_package_by_id(id: str, endpoint: str, api_key: str) -> Dict:
+    full_url = f"{endpoint}/{id}"
+    headers = {"Authorization": api_key}
+    response: Dict = http.fetch(full_url, headers=headers)  # type: ignore[assignment]
+    return response
+
+
+@timed("Get trainer packages")
+def get_trainer_packages(endpoint: str, api_key: str) -> List[Dict]:
+    headers = {"Authorization": api_key}
+    trainers: List[Dict] = http.fetch(endpoint, headers=headers)  # type: ignore[assignment]
+    return trainers
+
+
+def pretty_print_trainer_packages(trainers: List[Dict[str, str]], limit: Optional[int]) -> None:
+    # Sort trainer packages to have the most recent first
+    trainers = sorted(trainers, key=lambda x: x["created_at"], reverse=True)
+    if limit is not None:
+        trainers = trainers[:limit]
+
+    mapping = {
+        "ID": "id",
+        "Name": "name",
+        "Description": "description",
+        "Created At": "created_at",
+    }
+    pretty_print_list_as_table(
+        table_title="Available Trainer Packages (most recent first)",
+        dict_items=trainers,
+        column_name_to_key_mapping=mapping,
+    )

hafnia/utils.py

@@ -5,10 +5,12 @@ import zipfile
 from datetime import datetime
 from functools import wraps
 from pathlib import Path
-from typing import Any, Callable, Iterator, Optional
+from typing import Any, Callable, Dict, Iterable, Iterator, List, Optional
 from zipfile import ZipFile
 
+import more_itertools
 import pathspec
+import rich
 import seedir
 from rich import print as rprint
 
@@ -16,19 +18,21 @@ from hafnia.log import sys_logger, user_logger
 
 PATH_DATA = Path("./.data")
 PATH_DATASETS = PATH_DATA / "datasets"
-PATH_RECIPES = PATH_DATA / "recipes"
+PATH_DATASET_RECIPES = PATH_DATA / "dataset_recipes"
+PATH_TRAINER_PACKAGES = PATH_DATA / "trainers"
 FILENAME_HAFNIAIGNORE = ".hafniaignore"
 DEFAULT_IGNORE_SPECIFICATION = [
     "*.jpg",
     "*.png",
     "*.py[cod]",
     "*_cache/",
+    "**.egg-info/",
     ".data",
     ".git",
     ".venv",
     ".vscode",
     "__pycache__",
-    "recipe.zip",
+    "trainer.zip",
     "tests",
     "wandb",
 ]
@@ -49,6 +53,7 @@ def timed(label: str):
                 return func(*args, **kwargs)
             except Exception as e:
                 sys_logger.error(f"{operation_label} failed: {e}")
+                raise  # Re-raise the exception after logging
             finally:
                 elapsed = time.perf_counter() - tik
                 sys_logger.debug(f"{operation_label} took {elapsed:.2f} seconds.")
@@ -63,14 +68,14 @@ def now_as_str() -> str:
     return datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
 
 
-def get_recipe_path(recipe_name: str) -> Path:
+def get_trainer_package_path(trainer_name: str) -> Path:
     now = now_as_str()
-    path_recipe = PATH_RECIPES / f"{recipe_name}_{now}.zip"
-    return path_recipe
+    path_trainer = PATH_TRAINER_PACKAGES / f"{trainer_name}_{now}.zip"
+    return path_trainer
 
 
-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
+def filter_trainer_package_files(trainer_path: Path, path_ignore_file: Optional[Path] = None) -> Iterator:
+    path_ignore_file = path_ignore_file or trainer_path / FILENAME_HAFNIAIGNORE
     if not path_ignore_file.exists():
         ignore_specification_lines = DEFAULT_IGNORE_SPECIFICATION
         user_logger.info(
@@ -81,7 +86,7 @@ def filter_recipe_files(recipe_path: Path, path_ignore_file: Optional[Path] = No
     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)
+    include_files = ignore_specification.match_tree(trainer_path, negate=True)
     return include_files
 
 
@@ -91,17 +96,17 @@ def archive_dir(
     output_path: Optional[Path] = None,
     path_ignore_file: Optional[Path] = None,
 ) -> Path:
-    recipe_zip_path = output_path or recipe_path / "recipe.zip"
+    recipe_zip_path = output_path or recipe_path / "trainer.zip"
     assert recipe_zip_path.suffix == ".zip", "Output path must be a zip file"
     recipe_zip_path.parent.mkdir(parents=True, exist_ok=True)
 
     user_logger.info(f" Creating zip archive of '{recipe_path}'")
-    include_files = filter_recipe_files(recipe_path, path_ignore_file)
+    include_files = filter_trainer_package_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)
+    show_trainer_package_content(recipe_zip_path)
 
     return recipe_zip_path
 
@@ -115,7 +120,7 @@ def size_human_readable(size_bytes: int, suffix="B") -> str:
     return f"{size_value:.1f}Yi{suffix}"
 
 
-def show_recipe_content(recipe_path: Path, style: str = "emoji", depth_limit: int = 3) -> None:
+def show_trainer_package_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
@@ -133,6 +138,16 @@ def show_recipe_content(recipe_path: Path, style: str = "emoji", depth_limit: in
     user_logger.info(f"Recipe size: {size_human_readable(os.path.getsize(recipe_path))}. Max size 800 MiB")
 
 
+def get_dataset_path_in_hafnia_cloud() -> Path:
+    if not is_hafnia_cloud_job():
+        user_logger.error(
+            f"The function '{get_dataset_path_in_hafnia_cloud.__name__}' should only be called, when "
+            "running in HAFNIA cloud environment (HAFNIA_CLOUD-environment variable have been defined)"
+        )
+
+    return Path(os.getenv("MDI_DATASET_DIR", "/opt/ml/input/data/training"))
+
+
 def is_hafnia_cloud_job() -> bool:
     """Check if the current job is running in HAFNIA cloud environment."""
     return os.getenv("HAFNIA_CLOUD", "false").lower() == "true"
@@ -154,3 +169,39 @@ def snake_to_pascal_case(name: str) -> str:
 
 def hash_from_string(s: str) -> str:
     return hashlib.md5(s.encode("utf-8")).hexdigest()
+
+
+def pretty_print_list_as_table(
+    table_title: str,
+    dict_items: List[Dict],
+    column_name_to_key_mapping: Dict,
+) -> None:
+    """
+    Pretty print a list of dictionary elements as a table.
+    """
+
+    table = rich.table.Table(title=table_title)
+    for i_dict, dictionary in enumerate(dict_items):
+        if i_dict == 0:
+            for column_name, _ in column_name_to_key_mapping.items():
+                table.add_column(column_name, justify="left", style="cyan", no_wrap=True)
+        row = [str(dictionary.get(field, "")) for field in column_name_to_key_mapping.values()]
+        table.add_row(*row)
+
+    rich.print(table)
+
+
+def is_hafnia_configured() -> bool:
+    """
+    Check if Hafnia is configured by verifying if the API key is set.
+    """
+    from cli.config import Config
+
+    return Config().is_configured()
+
+
+def remove_duplicates_preserve_order(seq: Iterable) -> List:
+    """
+    Remove duplicates from a list while preserving the order of elements.
+    """
+    return list(more_itertools.unique_everseen(seq))

hafnia/visualizations/image_visualizations.py

@@ -102,10 +102,10 @@ def resize_width_by_padding(img0: np.ndarray, new_width: int) -> np.ndarray:
     return img0_padded
 
 
-def append_text_below_frame(frame: np.ndarray, text: str) -> np.ndarray:
-    font_size_px = int(frame.shape[0] * 0.1)  # 10% of the frame height
+def append_text_below_frame(frame: np.ndarray, text: str, text_size_ratio: float = 0.1) -> np.ndarray:
+    font_size_px = int(frame.shape[0] * text_size_ratio)  # 10% of the frame height
     font_size_px = max(font_size_px, 7)  # Ensure a minimum font size
-    font_size_px = min(font_size_px, 50)  # Ensure a maximum font size
+    font_size_px = min(font_size_px, 25)  # Ensure a maximum font size
 
     text_region = create_text_img(text, font_size_px=font_size_px)
     frame_with_text = concatenate_below_resize_by_padding(frame, text_region)

{hafnia-0.2.4.dist-info → hafnia-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hafnia
-Version: 0.2.4
+Version: 0.3.0
 Summary: Python SDK for communication with Hafnia platform.
 Author-email: Milestone Systems <hafniaplatform@milestone.dk>
 License-File: LICENSE
@@ -9,6 +9,7 @@ Requires-Dist: boto3>=1.35.91
 Requires-Dist: click>=8.1.8
 Requires-Dist: emoji>=2.14.1
 Requires-Dist: flatten-dict>=0.4.2
+Requires-Dist: mlflow>=3.2.0
 Requires-Dist: more-itertools>=10.7.0
 Requires-Dist: opencv-python-headless>=4.11.0.86
 Requires-Dist: pathspec>=0.12.1
@@ -19,6 +20,7 @@ Requires-Dist: pycocotools>=2.0.10
 Requires-Dist: pydantic>=2.10.4
 Requires-Dist: rich>=13.9.4
 Requires-Dist: s5cmd>=0.2.0
+Requires-Dist: sagemaker-mlflow>=0.1.0
 Requires-Dist: seedir>=0.5.0
 Requires-Dist: tqdm>=4.67.1
 Requires-Dist: xxhash>=3.5.0
@@ -26,13 +28,13 @@ Description-Content-Type: text/markdown
 
 # Hafnia
 
-The `hafnia` python package is a collection of tools to create and run model training recipes on
+The `hafnia` python sdk and cli is a collection of tools to create and run model trainer packages on
 the [Hafnia Platform](https://hafnia.milestonesys.com/). 
 
 The package includes the following interfaces: 
 
 - `cli`: A Command Line Interface (CLI) to 1) configure/connect to Hafnia's [Training-aaS](https://hafnia.readme.io/docs/training-as-a-service) and 2) create and 
-launch recipe scripts.
+launch trainer packages.
 - `hafnia`: A python package including `HafniaDataset` to manage datasets and `HafniaLogger` to do 
 experiment tracking.
 
@@ -42,19 +44,19 @@ experiment tracking.
 and *hidden* datasets. Hidden datasets refers to datasets that can be used for 
 training, but are not available for download or direct access. 
 
-This is a key feature of the Hafnia platform, as a hidden dataset ensures data 
+This is a key for the Hafnia platform, as a hidden dataset ensures data 
 privacy, and allow models to be trained compliantly and ethically by third parties (you).
 
 The `script2model` approach is a Training-aaS concept, where you package your custom training 
-script as a *training recipe* and use the recipe to train models on the hidden datasets.
+project or script as a *trainer package* and use the package to train models on the hidden datasets.
 
-To support local development of a training recipe, we have introduced a **sample dataset** 
+To support local development of a trainer package, we have introduced a **sample dataset** 
 for each dataset available in the Hafnia [data library](https://hafnia.milestonesys.com/training-aas/datasets). The sample dataset is a small 
-and anonymized subset of the full dataset and available for download. 
+and an anonymized subset of the full dataset and available for download. 
 
 With the sample dataset, you can seamlessly switch between local development and Training-aaS. 
-Locally, you can create, validate and debug your training recipe. The recipe is then 
-launched with Training-aaS, where the recipe runs on the full dataset and can be scaled to run on
+Locally, you can create, validate and debug your trainer package. The trainer package is then 
+launched with Training-aaS, where the package runs on the full dataset and can be scaled to run on
 multiple GPUs and instances if needed. 
 
 ## Getting started: Configuration
@@ -122,19 +124,19 @@ midwest-vehicle-detection
 You can interact with data as you want, but we also provide `HafniaDataset`
 for loading/saving, managing and interacting with the dataset.
 
-We recommend to visit and potentially execute the example script [examples/example_hafnia_dataset.py](examples/example_hafnia_dataset.py) 
-to see how to use the `HafniaDataset` class and its methods.
+We recommend the example script [examples/example_hafnia_dataset.py](examples/example_hafnia_dataset.py) 
+for a short introduction on the `HafniaDataset`.
 
 Below is a short introduction to the `HafniaDataset` class.
 
 ```python
 from hafnia.dataset.hafnia_dataset import HafniaDataset, Sample
 
-# Load dataset
+# Load dataset from path
 dataset = HafniaDataset.read_from_path(path_dataset)
 
-# Alternatively, you can use the 'load_dataset' function to download and load dataset in one go.
-# dataset = load_dataset("midwest-vehicle-detection")
+# Or get dataset directly by name
+dataset = HafniaDataset.from_name("midwest-vehicle-detection")
 
 # Print dataset information
 dataset.print_stats()
@@ -199,6 +201,8 @@ DatasetInfo(
         'duration_average': 120.0,
         ...
     }
+    "format_version": "0.0.2",
+    "updated_at": "2025-09-24T21:50:20.231263"
 )
 ```
 
@@ -238,7 +242,7 @@ Sample(
     height=1080,
     width=1920,
     split='train',
-    is_sample=True,
+    tags=["sample"],
     collection_index=None,
     collection_id=None,
     remote_path='s3://mdi-production-midwest-vehicle-detection/sample/data/343403325f27e390.png',
@@ -302,10 +306,10 @@ Sample(
 )
 ```
 
-To learn more, view and potentially execute the example script [examples/example_hafnia_dataset.py](examples/example_hafnia_dataset.py). 
+To learn more, we recommend the `HafniaDataset` example script [examples/example_hafnia_dataset.py](examples/example_hafnia_dataset.py). 
 
 ### Dataset Locally vs. Training-aaS
-An important feature of `load_dataset` is that it will return the full dataset 
+An important feature of `HafniaDataset.from_name` is that it will return the full dataset 
 when loaded with Training-aaS on the Hafnia platform. 
 
 This enables seamlessly switching between running/validating a training script 
@@ -316,7 +320,7 @@ Available datasets with corresponding sample datasets can be found in [data libr
 
 
 ## Getting started: Experiment Tracking with HafniaLogger
-The `HafniaLogger` is an important part of the recipe script and enables you to track, log and
+The `HafniaLogger` is an important part of the trainer and enables you to track, log and
 reproduce your experiments.
 
 When integrated into your training script, the `HafniaLogger` is responsible for collecting:
@@ -422,25 +426,25 @@ train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True, collate_fn=
 
 
 ## Example: Training-aaS
-By combining logging and dataset loading, we can now construct our model training recipe. 
+By combining logging and dataset loading, we can now construct our model trainer package. 
 
-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/milestone-hafnia/recipe-classification)
+To demonstrate this, we have provided a trainer package project that serves as a template for creating and structuring trainers. The example repo is called
+[trainer-classification](https://github.com/milestone-hafnia/trainer-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.
+The project also contains additional information on how to structure your trainer package, use the `HafniaLogger`, loading a dataset and different approach for launching 
+the trainer 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 
+## Create, Build and Run `trainer.zip` locally
+In order to test trainer package 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
+    # Create 'trainer.zip' in the root folder of your training trainer project '../trainer/classification'
+    hafnia trainer create-zip ../trainer-classification
+
+    # Build the docker image locally from a 'trainer.zip' file
+    hafnia runc build-local trainer.zip
 
     # Execute the docker image locally with a desired dataset
     hafnia runc launch-local --dataset mnist  "python scripts/train.py"

hafnia-0.3.0.dist-info/RECORD

@@ -0,0 +1,53 @@
+cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cli/__main__.py,sha256=04iqem4UAw6zSVujBt8ER0HQbEhno6rgmARmECUwRPA,1634
+cli/config.py,sha256=m9jrka0Rnh8_mnxnU4S_JgoYA7l1pvp2o2a7KgkYInY,6115
+cli/consts.py,sha256=uCpYX44NCu_Zvte0QwChunxOo-qqhcaJRSYDAIsoJ8A,972
+cli/dataset_cmds.py,sha256=KOPYdAJ1SyzTMlEi_J-70vSGIJ5acHPGIPOCKVIdlQ4,1418
+cli/dataset_recipe_cmds.py,sha256=O1Pd-VvFFsmZ-nE1Mh6sCC9x45ztCJEpPCZK93qz_HQ,2887
+cli/experiment_cmds.py,sha256=vc7J9JJog4EvRdgkpoMvr0kceb0QF_Rk7mn6H2KNvFE,7963
+cli/profile_cmds.py,sha256=eRo4FtPvXPG5LK2fINVFMsBd_HpkNygY468essBb57o,3285
+cli/runc_cmds.py,sha256=qV-LOwbFlbegH8XSELOo4h_2ajFAzdB5LtuVKKoRq8Y,5009
+cli/trainer_package_cmds.py,sha256=nL7yTtR41BKzo1DWZdBdpRXGPZZIbmBe0byHAi6_n2c,2312
+hafnia/__init__.py,sha256=xXUwwQ18P1YqmsZkvlkavaDqq8DbrrHf38pv5_JyV_M,179
+hafnia/http.py,sha256=bjXbV_3uKbBdudqMdYtnsMttUAsNRMsetYZ4F2xXlEs,3635
+hafnia/log.py,sha256=sWF8tz78yBtwZ9ddzm19L1MBSBJ3L4G704IGeT1_OEU,784
+hafnia/torch_helpers.py,sha256=ho65B0WIu_SjbaKPRL4wabDNrnVumWH8QSXVH4r7NAY,11605
+hafnia/utils.py,sha256=x2dPsiO0EPP6YnpQX4HBtbl29UN9hV4zHvOnDa9xYTg,6850
+hafnia/data/__init__.py,sha256=o9QjiGbEcNa6r-qDmwwmxPXf-1UitNl5-WxFNcujqsg,111
+hafnia/data/factory.py,sha256=kHkvOtBUbwaShZBGf1kZzocDJBn_1dHHLrQxnUpJmfY,778
+hafnia/dataset/dataset_helpers.py,sha256=HHm4KG_-upIEmxHWeSJO4m8RmrCUxKgseRNs4WD6kUQ,4781
+hafnia/dataset/dataset_names.py,sha256=wdLoH48ph1PjVpUYPEDnAfQYVDCvYGQCyqFmR0-ixDU,2286
+hafnia/dataset/dataset_upload_helper.py,sha256=QdJl92aKm3czpkgXt3G_AgwBjyOV9R4iKn4bjjlPyXA,28007
+hafnia/dataset/hafnia_dataset.py,sha256=XiCHv-ZSzjA4CImpyMevJ2qIJlFcKBLzwNB_HMuQGHo,36841
+hafnia/dataset/license_types.py,sha256=xpanTfui1pGG76mGQ9r6EywcUe1scI_zullEpmCO4GI,2190
+hafnia/dataset/dataset_recipe/dataset_recipe.py,sha256=A54N5qEPcM0Yswg26qaOvnr-uj3xUq-KbOInJayzbEI,19269
+hafnia/dataset/dataset_recipe/recipe_transforms.py,sha256=6tY4jG1Bzx15-BXp5RavjtVRWcms3o9svzfUO9-m9Ps,2154
+hafnia/dataset/dataset_recipe/recipe_types.py,sha256=AcrG6gpRt3Igl-CCJ60uyh-WkfI1NCnQ55M8yClSI9Q,5328
+hafnia/dataset/operations/dataset_stats.py,sha256=V2lCmTfIbJ-LeAyu1fZf0_1jSa4MMfP0psuXi77gOYk,11630
+hafnia/dataset/operations/dataset_transformations.py,sha256=JVxfw4fV51eGB7ekYfLB5FKQql6l1whTqRY_BwfX0Us,16593
+hafnia/dataset/operations/table_transformations.py,sha256=6LFQfFRAb1B25cS3QeliRzj26EgVyub5kE-6Sab5Ymo,9250
+hafnia/dataset/primitives/__init__.py,sha256=xFLJ3R7gpbuQnNJuFhuu836L3nicwoaY5aHkqk7Bbr8,927
+hafnia/dataset/primitives/bbox.py,sha256=HXYYy5BLNZwh-bO7aiAWg3z0OurUev8ISa-vYey8b8A,6055
+hafnia/dataset/primitives/bitmask.py,sha256=mq_wchMqGupJDc-a-mJh9uBO_mjHcXpLH49g591doAM,7619
+hafnia/dataset/primitives/classification.py,sha256=ri4lTtS5gBQX13vF07YbeN11rKl1CJaKeTIzCmoT9Iw,2363
+hafnia/dataset/primitives/point.py,sha256=JCRwb-E4sDafodkg6wqyuAS1Yj-yaJbwiD8aB69_Ros,635
+hafnia/dataset/primitives/polygon.py,sha256=vhPrYHv6TqQZMTAyv9r3NV8Hu6YRSSD0srB0wOCIwQ4,4289
+hafnia/dataset/primitives/primitive.py,sha256=7jxcyFADVGf95pjeQHEOqAnR9eucLpxA2h8Blz3ppXI,1253
+hafnia/dataset/primitives/segmentation.py,sha256=jUMjOmYr9j4An3YSCw5CJC1W8ihXAbus3CXaTOpc7Xw,1905
+hafnia/dataset/primitives/utils.py,sha256=3gT1as-xXEj8CamoIuBb9gQwUN9Ae9qnqtqF_uEe0zo,1993
+hafnia/experiment/__init__.py,sha256=OEFE6HqhO5zcTCLZcPcPVjIg7wMFFnvZ1uOtAVhRz7M,85
+hafnia/experiment/hafnia_logger.py,sha256=k8UIK3mXNyxpmfFndTD_u8pFA6TKbjmR-9EJ6JjvY-U,10729
+hafnia/platform/__init__.py,sha256=L_Q7CNpsJ0HMNPy_rLlLK5RhmuCU7IF4BchxKv6amYc,782
+hafnia/platform/builder.py,sha256=kUEuj5-qtL1uk5v2tUvOCREn5yV-G4Fr6F31haIAb5E,5808
+hafnia/platform/dataset_recipe.py,sha256=-scelPECr1eLn5tB_jFm5bJdygw_guktrWfoVquSu2A,3790
+hafnia/platform/datasets.py,sha256=orWdZUwrNk7BTJFJP_8TLhf0CB5PYopZug4u36w08FQ,9018
+hafnia/platform/download.py,sha256=Tzycmb6I6LmwACDHmJmR1zsrOX6OLgYWRbfkCXKEAdQ,6903
+hafnia/platform/experiment.py,sha256=SrEH0nuwwBXf1Iu4diB1BEPqL-TxW3aQkZWBbM1-tY0,1846
+hafnia/platform/trainer_package.py,sha256=w6JC7o-279ujcwtNTbUaQ9AnPcYRPPbD8EACa6XyUHA,2206
+hafnia/visualizations/colors.py,sha256=003eAJVnBal4abaYIIpsrT7erIOIjTUHHYVJ1Tj1CDc,5226
+hafnia/visualizations/image_visualizations.py,sha256=6mPnRAc0dMPZCUCTqnHjgtAhQdVL_QrtyToXUuJjwxQ,7355
+hafnia-0.3.0.dist-info/METADATA,sha256=nP2mgz_AtfOAq2OX5NgLq6lJG3fTLOog8AbKLGWYSyM,19235
+hafnia-0.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hafnia-0.3.0.dist-info/entry_points.txt,sha256=FCJVIQ8GP2VE9I3eeGVF5eLxVDNW_01pOJCpG_CGnMM,45
+hafnia-0.3.0.dist-info/licenses/LICENSE,sha256=wLZw1B7_mod_CO1H8LXqQgfqlWD6QceJR8--LJYRZGE,1078
+hafnia-0.3.0.dist-info/RECORD,,

cli/recipe_cmds.py

@@ -1,45 +0,0 @@
-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.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)
-
-
-@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 show_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."
-        )
-    show_recipe_content(path_recipe, depth_limit=depth_limit)