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

hafnia/dataset/operations/table_transformations.py

@@ -1,8 +1,7 @@
 from pathlib import Path
-from typing import TYPE_CHECKING, List, Optional, Tuple, Type
+from typing import List, Optional, Tuple, Type
 
 import polars as pl
-from rich.progress import track
 
 from hafnia.dataset.dataset_names import (
     FILENAME_ANNOTATIONS_JSONL,
@@ -10,14 +9,13 @@ from hafnia.dataset.dataset_names import (
     PrimitiveField,
     SampleField,
 )
+from hafnia.dataset.hafnia_dataset_types import TaskInfo
 from hafnia.dataset.operations import table_transformations
 from hafnia.dataset.primitives import PRIMITIVE_TYPES
 from hafnia.dataset.primitives.classification import Classification
 from hafnia.dataset.primitives.primitive import Primitive
 from hafnia.log import user_logger
-
-if TYPE_CHECKING:
-    from hafnia.dataset.hafnia_dataset import TaskInfo
+from hafnia.utils import progress_bar
 
 
 def create_primitive_table(
@@ -29,13 +27,11 @@ def create_primitive_table(
     """
     Returns a DataFrame with objects of the specified primitive type.
     """
-    column_name = PrimitiveType.column_name()
-    has_primitive_column = (column_name in samples_table.columns) and (
-        samples_table[column_name].dtype == pl.List(pl.Struct)
-    )
-    if not has_primitive_column:
+    if not has_primitive(samples_table, PrimitiveType):
         return None
 
+    column_name = PrimitiveType.column_name()
+
     # Remove frames without objects
     remove_no_object_frames = samples_table.filter(pl.col(column_name).list.len() > 0)
 
@@ -60,6 +56,17 @@ def create_primitive_table(
     return objects_df
 
 
+def has_primitive(samples: pl.DataFrame, PrimitiveType: Type[Primitive]) -> bool:
+    col_name = PrimitiveType.column_name()
+    if col_name not in samples.columns:
+        return False
+
+    if samples[col_name].dtype != pl.List(pl.Struct):
+        return False
+
+    return True
+
+
 def merge_samples(samples0: pl.DataFrame, samples1: pl.DataFrame) -> pl.DataFrame:
     has_same_schema = samples0.schema == samples1.schema
     if not has_same_schema:
@@ -215,7 +222,7 @@ def read_samples_from_path(path: Path) -> pl.DataFrame:
 def check_image_paths(table: pl.DataFrame) -> bool:
     missing_files = []
     org_paths = table[SampleField.FILE_PATH].to_list()
-    for org_path in track(org_paths, description="Check image paths"):
+    for org_path in progress_bar(org_paths, description="Check image paths"):
         org_path = Path(org_path)
         if not org_path.exists():
             missing_files.append(org_path)
@@ -273,7 +280,7 @@ def unnest_classification_tasks(table: pl.DataFrame, strict: bool = True) -> pl.
     return table_out
 
 
-def update_class_indices(samples: pl.DataFrame, task: "TaskInfo") -> pl.DataFrame:
+def update_class_indices(samples: pl.DataFrame, task: TaskInfo) -> pl.DataFrame:
     if task.class_names is None or len(task.class_names) == 0:
         raise ValueError(f"Task '{task.name}' does not have defined class names to update class indices.")
 
@@ -318,7 +325,7 @@ def add_sample_index(samples: pl.DataFrame) -> pl.DataFrame:
     if SampleField.SAMPLE_INDEX in samples.columns:
         samples = samples.drop(SampleField.SAMPLE_INDEX)
     samples = samples.select(
-        pl.int_range(0, pl.count(), dtype=pl.UInt64).alias(SampleField.SAMPLE_INDEX),
+        pl.int_range(0, pl.len(), dtype=pl.UInt64).alias(SampleField.SAMPLE_INDEX),
         pl.all(),
     )
     return samples

hafnia/dataset/primitives/bbox.py

@@ -30,6 +30,9 @@ class Bbox(Primitive):
     top_left_y: float = Field(
         description="Normalized y-coordinate of top-left corner (0.0=top edge, 1.0=bottom edge) as a fraction of image height"
     )
+    area: Optional[float] = Field(
+        default=None, description="Area of the bounding box as a fraction of the image area (0.0 to 1.0)"
+    )
     class_name: Optional[str] = Field(default=None, description="Class name, e.g. 'car'")
     class_idx: Optional[int] = Field(default=None, description="Class index, e.g. 0 for 'car' if it is the first class")
     object_id: Optional[str] = Field(default=None, description="Unique identifier for the object, e.g. '12345123'")
@@ -49,7 +52,8 @@ class Bbox(Primitive):
     def column_name() -> str:
         return "bboxes"
 
-    def calculate_area(self) -> float:
+    def calculate_area(self, image_height: int, image_width: int) -> float:
+        """Calculates the area of the bounding box as a fraction of the image area."""
         return self.height * self.width
 
     @staticmethod
@@ -73,7 +77,7 @@ class Bbox(Primitive):
         """
         return (self.top_left_x, self.top_left_y, self.width, self.height)
 
-    def to_coco(self, image_height: int, image_width: int) -> Tuple[int, int, int, int]:
+    def to_coco_ints(self, image_height: int, image_width: int) -> Tuple[int, int, int, int]:
         xmin = round_int_clip_value(self.top_left_x * image_width, max_value=image_width)
         bbox_width = round_int_clip_value(self.width * image_width, max_value=image_width)
 

hafnia/dataset/primitives/bitmask.py

@@ -22,11 +22,11 @@ class Bitmask(Primitive):
     left: int = Field(description="Bitmask left coordinate in pixels")
     height: int = Field(description="Bitmask height of the bounding box in pixels")
     width: int = Field(description="Bitmask width of the bounding box in pixels")
-    rleString: str = Field(
+    rle_string: str = Field(
         description="Run-length encoding (RLE) string for the bitmask region of size (height, width) at (top, left)."
     )
     area: Optional[float] = Field(
-        default=None, description="Area of the bitmask in pixels is calculated from the RLE string"
+        default=None, description="Area of the bitmask as a fraction of the image area (0.0 to 1.0)"
     )
     class_name: Optional[str] = Field(default=None, description="Class name of the object represented by the bitmask")
     class_idx: Optional[int] = Field(default=None, description="Class index of the object represented by the bitmask")
@@ -47,8 +47,9 @@ class Bitmask(Primitive):
     def column_name() -> str:
         return "bitmasks"
 
-    def calculate_area(self) -> float:
-        raise NotImplementedError()
+    def calculate_area(self, image_height: int, image_width: int) -> float:
+        area_px = coco_mask.area(self.to_coco_rle(img_height=image_height, img_width=image_width))
+        return area_px / (image_height * image_width)
 
     @staticmethod
     def from_mask(
@@ -79,60 +80,34 @@ class Bitmask(Primitive):
             height=h,
             width=w,
             area=area,
-            rleString=rle_string,
+            rle_string=rle_string,
             class_name=class_name,
             class_idx=class_idx,
             object_id=object_id,
         )
 
-    def squeeze_mask(self):
-        """
-        A mask may have large redundant areas of zeros. This function squeezes the mask to remove those areas.
-        """
-        region_mask = self.to_region_mask()
-        shift_left, last_left = np.flatnonzero(region_mask.sum(axis=0))[[0, -1]]
-        shift_top, last_top = np.flatnonzero(region_mask.sum(axis=1))[[0, -1]]
-        new_top = self.top + shift_top
-        new_left = self.left + shift_left
-        new_region_mask = region_mask[shift_top : last_top + 1, shift_left : last_left + 1]
-
-        bitmask_squeezed = Bitmask.from_mask(
-            mask=new_region_mask,
-            top=new_top,
-            left=new_left,
-            class_name=self.class_name,
-            class_idx=self.class_idx,
-            object_id=self.object_id,
-        )
-        return bitmask_squeezed
-
     def anonymize_by_blurring(self, image: np.ndarray, inplace: bool = False, max_resolution: int = 20) -> np.ndarray:
-        mask_tight = self.squeeze_mask()
-
-        mask_region = mask_tight.to_region_mask()
-        region_image = image[
-            mask_tight.top : mask_tight.top + mask_tight.height, mask_tight.left : mask_tight.left + mask_tight.width
-        ]
+        mask = self.to_mask(img_height=image.shape[0], img_width=image.shape[1])
+        region_mask = mask[self.top : self.top + self.height, self.left : self.left + self.width]
+        region_image = image[self.top : self.top + self.height, self.left : self.left + self.width]
         region_image_blurred = anonymize_by_resizing(blur_region=region_image, max_resolution=max_resolution)
-        image_mixed = np.where(mask_region[:, :, None], region_image_blurred, region_image)
-        image[
-            mask_tight.top : mask_tight.top + mask_tight.height, mask_tight.left : mask_tight.left + mask_tight.width
-        ] = image_mixed
+        image_mixed = np.where(region_mask[:, :, None], region_image_blurred, region_image)
+        image[self.top : self.top + self.height, self.left : self.left + self.width] = image_mixed
         return image
 
-    def to_region_mask(self) -> np.ndarray:
-        """Returns a binary mask from the RLE string. The masks is only the region of the object and not the full image."""
-        rle = {"counts": self.rleString.encode(), "size": [self.height, self.width]}
-        mask = coco_mask.decode(rle) > 0
-        return mask
+    def to_coco_rle(self, img_height: int, img_width: int, as_bytes: bool = True) -> Dict[str, Any]:
+        """Returns the COCO RLE dictionary from the RLE string."""
+
+        rle_string = self.rle_string
+        if as_bytes:
+            rle_string = rle_string.encode()  # type: ignore[assignment]
+        rle = {"counts": rle_string, "size": [img_height, img_width]}
+        return rle
 
     def to_mask(self, img_height: int, img_width: int) -> np.ndarray:
         """Creates a full image mask from the RLE string."""
-
-        region_mask = self.to_region_mask()
-        bitmask_np = np.zeros((img_height, img_width), dtype=bool)
-        bitmask_np[self.top : self.top + self.height, self.left : self.left + self.width] = region_mask
-        return bitmask_np
+        mask = coco_mask.decode(self.to_coco_rle(img_height=img_height, img_width=img_width)) > 0
+        return mask
 
     def draw(self, image: np.ndarray, inplace: bool = False, draw_label: bool = True) -> np.ndarray:
         if not inplace:

hafnia/dataset/primitives/classification.py

@@ -33,7 +33,7 @@ class Classification(Primitive):
     def column_name() -> str:
         return "classifications"
 
-    def calculate_area(self) -> float:
+    def calculate_area(self, image_height: int, image_width: int) -> float:
         return 1.0
 
     def draw(self, image: np.ndarray, inplace: bool = False, draw_label: bool = True) -> np.ndarray:

hafnia/dataset/primitives/polygon.py

@@ -2,6 +2,8 @@ from typing import Any, Dict, List, Optional, Sequence, Tuple
 
 import cv2
 import numpy as np
+from more_itertools import collapse
+from pycocotools import mask as coco_utils
 from pydantic import Field
 
 from hafnia.dataset.primitives.bitmask import Bitmask
@@ -13,6 +15,7 @@ from hafnia.dataset.primitives.utils import class_color_by_name, get_class_name
 class Polygon(Primitive):
     # Names should match names in FieldName
     points: List[Point] = Field(description="List of points defining the polygon")
+    area: Optional[float] = Field(default=None, description="Area of the polygon in pixels")
     class_name: Optional[str] = Field(default=None, description="Class name of the polygon")
     class_idx: Optional[int] = Field(default=None, description="Class index of the polygon")
     object_id: Optional[str] = Field(default=None, description="Object ID of the polygon")
@@ -44,7 +47,7 @@ class Polygon(Primitive):
     def column_name() -> str:
         return "polygons"
 
-    def calculate_area(self) -> float:
+    def calculate_area(self, image_height: int, image_width: int) -> float:
         raise NotImplementedError()
 
     def to_pixel_coordinates(
@@ -81,11 +84,49 @@ class Polygon(Primitive):
         points = np.array(self.to_pixel_coordinates(image_shape=image.shape[:2]))
         mask = np.zeros(image.shape[:2], dtype=np.uint8)
         mask = cv2.fillPoly(mask, [points], color=255).astype(bool)
-        bitmask = Bitmask.from_mask(mask=mask, top=0, left=0).squeeze_mask()
+        bitmask = Bitmask.from_mask(mask=mask, top=0, left=0)
         image = bitmask.anonymize_by_blurring(image=image, inplace=inplace, max_resolution=max_resolution)
 
         return image
 
+    def to_mask(self, img_height: int, img_width: int, use_coco_utils=False) -> np.ndarray:
+        if use_coco_utils:
+            points = list(collapse(self.to_pixel_coordinates(image_shape=(img_height, img_width))))
+            rles = coco_utils.frPyObjects([points], img_height, img_width)
+            rle = coco_utils.merge(rles)
+            mask = coco_utils.decode(rle).astype(bool)
+            return mask
+
+        mask = np.zeros((img_height, img_width), dtype=np.uint8)
+        points = np.array(self.to_pixel_coordinates(image_shape=(img_height, img_width)))
+        mask = cv2.fillPoly(mask, [points], color=255).astype(bool)
+        return mask
+
+    def to_bitmask(self, img_height: int, img_width: int) -> Bitmask:
+        points = list(collapse(self.to_pixel_coordinates(image_shape=(img_height, img_width))))
+        rles = coco_utils.frPyObjects([points], img_height, img_width)
+        rle = coco_utils.merge(rles)
+        top, left, height, width = coco_utils.toBbox(rle)
+
+        rle_string = rle["counts"]
+        if isinstance(rle_string, bytes):
+            rle_string = rle_string.decode("utf-8")
+
+        return Bitmask(
+            rle_string=rle_string,
+            top=int(top),
+            left=int(left),
+            width=int(width),
+            height=int(height),
+            class_name=self.class_name,
+            class_idx=self.class_idx,
+            object_id=self.object_id,
+            confidence=self.confidence,
+            ground_truth=self.ground_truth,
+            task_name=self.task_name,
+            meta=self.meta,
+        )
+
     def mask(
         self, image: np.ndarray, inplace: bool = False, color: Optional[Tuple[np.uint8, np.uint8, np.uint8]] = None
     ) -> np.ndarray:

hafnia/dataset/primitives/primitive.py

@@ -27,7 +27,7 @@ class Primitive(BaseModel, metaclass=ABCMeta):
         pass
 
     @abstractmethod
-    def calculate_area(self) -> float:
+    def calculate_area(self, image_height: int, image_width: int) -> float:
         # Calculate the area of the primitive
         pass
 

hafnia/dataset/primitives/segmentation.py

@@ -30,7 +30,7 @@ class Segmentation(Primitive):
     def column_name() -> str:
         return "segmentations"
 
-    def calculate_area(self) -> float:
+    def calculate_area(self, image_height: int, image_width: int) -> float:
         raise NotImplementedError()
 
     def draw(self, image: np.ndarray, inplace: bool = False) -> np.ndarray:

hafnia/experiment/hafnia_logger.py

@@ -85,8 +85,9 @@ class Entity(BaseModel):
 class HafniaLogger:
     EXPERIMENT_FILE = "experiment.parquet"
 
-    def __init__(self, log_dir: Union[Path, str] = "./.data"):
+    def __init__(self, project_name: str, log_dir: Union[Path, str] = "./.data"):
         self._local_experiment_path = Path(log_dir) / "experiments" / now_as_str()
+        self.project_name = project_name
         create_paths = [
             self._local_experiment_path,
             self.path_model_checkpoints(),
@@ -109,6 +110,7 @@ class HafniaLogger:
             self._init_mlflow()
 
         self.log_environment()
+        self.log_configuration({"project_name": project_name})
 
     def _init_mlflow(self):
         """Initialize MLflow tracking for remote jobs."""
@@ -125,9 +127,16 @@ class HafniaLogger:
                 mlflow.set_experiment(experiment_name)
                 user_logger.info(f"MLflow experiment set to: {experiment_name}")
 
-            # Start MLflow run
+            # Start MLflow run with tags
             run_name = os.getenv("MLFLOW_RUN_NAME", "undefined")
-            mlflow.start_run(run_name=run_name)
+            created_by = os.getenv("MLFLOW_CREATED_BY")
+            tags = {"project_name": self.project_name}
+            if experiment_name:
+                tags["organization_id"] = experiment_name
+            if created_by:
+                tags["created_by"] = created_by
+
+            mlflow.start_run(run_name=run_name, tags=tags, log_system_metrics=True)
             self._mlflow_initialized = True
             user_logger.info("MLflow run started successfully")
 
@@ -290,7 +299,7 @@ def get_instructions_how_to_store_model() -> str:
         from hafnia.experiment import HafniaLogger
 
         # Initiate Hafnia logger
-        logger = HafniaLogger()
+        logger = HafniaLogger(project_name="my_classification_project")
 
         # Folder path to store models - generated by the hafnia logger. 
         model_dir = logger.path_model()

hafnia/platform/datasets.py

@@ -9,7 +9,6 @@ from typing import Any, Dict, List, Optional
 
 import rich
 from rich import print as rprint
-from rich.progress import track
 
 from hafnia import http, utils
 from hafnia.dataset.dataset_names import DATASET_FILENAMES_REQUIRED
@@ -21,7 +20,7 @@ from hafnia.dataset.hafnia_dataset import HafniaDataset
 from hafnia.http import fetch
 from hafnia.log import sys_logger, user_logger
 from hafnia.platform.download import get_resource_credentials
-from hafnia.utils import timed
+from hafnia.utils import progress_bar, timed
 from hafnia_cli.config import Config
 
 
@@ -192,7 +191,7 @@ def execute_s5cmd_commands(
 
         error_lines = []
         lines = []
-        for line in track(process.stdout, total=len(commands), description=description):
+        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())

hafnia/torch_helpers.py

@@ -1,6 +1,8 @@
 from typing import Dict, List, Optional, Tuple, Type, Union
 
+import cv2
 import numpy as np
+import polars as pl
 import torch
 import torchvision
 from flatten_dict import flatten, unflatten
@@ -9,8 +11,9 @@ from torchvision import tv_tensors
 from torchvision import utils as tv_utils
 from torchvision.transforms import v2
 
-from hafnia.dataset.dataset_names import PrimitiveField
-from hafnia.dataset.hafnia_dataset import HafniaDataset, Sample
+from hafnia.dataset.dataset_names import PrimitiveField, SampleField
+from hafnia.dataset.hafnia_dataset import HafniaDataset
+from hafnia.dataset.hafnia_dataset_types import Sample
 from hafnia.dataset.primitives import (
     PRIMITIVE_COLUMN_NAMES,
     class_color_by_name,
@@ -18,6 +21,7 @@ from hafnia.dataset.primitives import (
 from hafnia.dataset.primitives.bbox import Bbox
 from hafnia.dataset.primitives.bitmask import Bitmask
 from hafnia.dataset.primitives.classification import Classification
+from hafnia.dataset.primitives.polygon import Polygon
 from hafnia.dataset.primitives.primitive import Primitive
 from hafnia.dataset.primitives.segmentation import Segmentation
 from hafnia.log import user_logger
@@ -50,6 +54,16 @@ class TorchvisionDataset(torch.utils.data.Dataset):
     ):
         self.dataset = dataset
 
+        self.max_points_in_polygon = 0
+
+        if self.dataset.has_primitive(Polygon):
+            self.max_points_in_polygon = (
+                self.dataset.samples[SampleField.POLYGONS]
+                .list.eval(pl.element().struct.field("points").list.len())
+                .explode()
+                .max()
+            )
+
         self.transforms = transforms
         self.keep_metadata = keep_metadata
 
@@ -74,7 +88,7 @@ class TorchvisionDataset(torch.utils.data.Dataset):
 
         bbox_tasks: Dict[str, List[Bbox]] = get_primitives_per_task_name_for_primitive(sample, Bbox)
         for task_name, bboxes in bbox_tasks.items():
-            bboxes_list = [bbox.to_coco(image_height=h, image_width=w) for bbox in bboxes]
+            bboxes_list = [bbox.to_coco_ints(image_height=h, image_width=w) for bbox in bboxes]
             bboxes_tensor = torch.as_tensor(bboxes_list).reshape(-1, 4)
             target_flat[f"{Bbox.column_name()}.{task_name}"] = {
                 PrimitiveField.CLASS_IDX: [bbox.class_idx for bbox in bboxes],
@@ -91,6 +105,22 @@ class TorchvisionDataset(torch.utils.data.Dataset):
                 "mask": tv_tensors.Mask(bitmasks_np),
             }
 
+        polygon_tasks: Dict[str, List[Polygon]] = get_primitives_per_task_name_for_primitive(sample, Polygon)
+        for task_name, polygons in polygon_tasks.items():
+            polygon_tensors = [
+                torch.tensor(pg.to_pixel_coordinates(image_shape=(h, w), as_int=False)) for pg in polygons
+            ]
+            n_polygons = len(polygons)
+            polygons_matrix = torch.full((n_polygons, self.max_points_in_polygon, 2), fill_value=torch.nan)
+
+            for i, polygon_tensor in enumerate(polygon_tensors):
+                polygons_matrix[i, : polygon_tensor.shape[0], :] = polygon_tensor
+
+            target_flat[f"{Polygon.column_name()}.{task_name}"] = {
+                PrimitiveField.CLASS_IDX: [polygon.class_idx for polygon in polygons],
+                PrimitiveField.CLASS_NAME: [polygon.class_name for polygon in polygons],
+                "polygon": tv_tensors.KeyPoints(polygons_matrix, canvas_size=(h, w)),
+            }
         if self.transforms:
             image, target_flat = self.transforms(image, target_flat)
 
@@ -181,6 +211,18 @@ def draw_image_and_targets(
                 colors=colors,
             )
 
+    if Polygon.column_name() in targets:
+        primitive_annotations = targets[Polygon.column_name()]
+        np_image = visualize_image.permute(1, 2, 0).numpy()
+        for task_name, task_annotations in primitive_annotations.items():
+            task_annotations["polygon"]
+            colors = [class_color_by_name(class_name) for class_name in task_annotations[PrimitiveField.CLASS_NAME]]
+            for color, polygon in zip(colors, task_annotations["polygon"], strict=True):
+                single_polygon = np.array(polygon[~torch.isnan(polygon[:, 0]), :][None, :, :]).astype(int)
+
+                np_image = cv2.polylines(np_image, [single_polygon], isClosed=False, color=color, thickness=2)
+        visualize_image = torch.from_numpy(np_image).permute(2, 0, 1)
+
     # Important that classification is drawn last as it will change image dimensions
     if Classification.column_name() in targets:
         primitive_annotations = targets[Classification.column_name()]
@@ -219,7 +261,7 @@ class TorchVisionCollateFn:
         images, targets = tuple(zip(*batch, strict=False))
         if "image" not in self.skip_stacking_list:
             images = torch.stack(images)
-
+        height, width = images.shape[-2:]
         keys_min = set(targets[0])
         keys_max = set(targets[0])
         for target in targets:
@@ -250,6 +292,8 @@ class TorchVisionCollateFn:
                 item_values = tv_tensors.Image(item_values)
             elif isinstance(first_element, tv_tensors.BoundingBoxes):
                 item_values = tv_tensors.BoundingBoxes(item_values)
+            elif isinstance(first_element, tv_tensors.KeyPoints):
+                item_values = tv_tensors.KeyPoints(item_values, canvas_size=(height, width))
             targets_modified[key_name] = item_values
 
         return images, targets_modified

hafnia/utils.py

@@ -2,6 +2,7 @@ import hashlib
 import os
 import time
 import zipfile
+from collections.abc import Sized
 from datetime import datetime
 from functools import wraps
 from pathlib import Path
@@ -13,6 +14,7 @@ import pathspec
 import rich
 import seedir
 from rich import print as rprint
+from rich.progress import BarColumn, MofNCompleteColumn, Progress, TextColumn, TimeElapsedColumn, TimeRemainingColumn
 
 from hafnia.log import sys_logger, user_logger
 
@@ -222,3 +224,35 @@ def remove_duplicates_preserve_order(seq: Iterable) -> List:
 def is_image_file(file_path: Path) -> bool:
     image_extensions = (".jpg", ".jpeg", ".png", ".bmp", ".tiff", ".tif", ".gif")
     return file_path.suffix.lower() in image_extensions
+
+
+def progress_bar(sequence: Iterable, total: Optional[int] = None, description: str = "Working...") -> Iterable:
+    """
+    Progress bar showing number of iterations being processed with ETA and elapsed time.
+
+    Example usage:
+
+    ```python
+    items = list(range(1000))
+    for item in progress_bar(items, description="Processing..."):
+        time.sleep(0.02)
+    ```
+    Processing... ━━━━━━━━━╸━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  245/1000 ETA: 0:00:16 | Elapsed: 0:00:05
+    """
+    progress_bar = Progress(
+        TextColumn("{task.description}"),
+        BarColumn(),
+        MofNCompleteColumn(),
+        TextColumn("ETA:"),
+        TimeRemainingColumn(),
+        TextColumn("| Elapsed:"),
+        TimeElapsedColumn(),
+    )
+
+    if total is None:
+        total = len(sequence) if isinstance(sequence, Sized) else None
+    with progress_bar as progress:
+        task = progress.add_task(description, total=total)
+        for item in sequence:
+            yield item
+            progress.update(task, advance=1)

hafnia/visualizations/image_visualizations.py

@@ -7,7 +7,7 @@ import numpy as np
 import numpy.typing as npt
 from PIL import Image
 
-from hafnia.dataset.hafnia_dataset import HafniaDataset, Sample
+from hafnia.dataset.hafnia_dataset_types import Sample
 from hafnia.dataset.primitives import (
     Bbox,
     Bitmask,
@@ -175,6 +175,8 @@ def save_dataset_sample_set_visualizations(
     draw_settings: Optional[Dict[Type[Primitive], Dict]] = None,
     anonymize_settings: Optional[Dict[Type[Primitive], Dict]] = None,
 ) -> List[Path]:
+    from hafnia.dataset.hafnia_dataset import HafniaDataset
+
     dataset = HafniaDataset.from_path(path_dataset)
     shutil.rmtree(path_output_folder, ignore_errors=True)
     path_output_folder.mkdir(parents=True)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hafnia
-Version: 0.4.2
+Version: 0.4.3
 Summary: Python SDK for communication with Hafnia platform.
 Author-email: Milestone Systems <hafniaplatform@milestone.dk>
 License-File: LICENSE
@@ -343,7 +343,7 @@ batch_size = 128
 learning_rate = 0.001
 
 # Initialize Hafnia logger
-logger = HafniaLogger()
+logger = HafniaLogger(project_name="my_classification_project")
 
 # Log experiment parameters
 logger.log_configuration({"batch_size": 128, "learning_rate": 0.001})