hafnia 0.1.25__tar.gz → 0.1.26__tar.gz

{hafnia-0.1.25 → hafnia-0.1.26}/.github/workflows/ci_cd.yaml

@@ -21,7 +21,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4.2.2
       - name: Run Trivy vulnerability scanner
-        uses: aquasecurity/trivy-action@0.30.0
+        uses: aquasecurity/trivy-action@0.31.0
         with:
           scan-type: 'fs'
           scan-ref: '.'

{hafnia-0.1.25 → hafnia-0.1.26}/.github/workflows/publish_docker.yaml

@@ -47,7 +47,7 @@ jobs:
             echo "aws_region=${{ secrets.STAGE_AWS_REGION }}" >> $GITHUB_OUTPUT
           fi
       - name: Configure AWS credentials
-        uses: aws-actions/configure-aws-credentials@v4.1.0
+        uses: aws-actions/configure-aws-credentials@v4.2.1
         with:
           role-to-assume: arn:aws:iam::${{ steps.env-vars.outputs.aws_account_id }}:role/${{ secrets.AWS_ROLE_NAME }}
           aws-region: ${{ steps.env-vars.outputs.aws_region }} 
@@ -60,7 +60,7 @@ jobs:
         uses: docker/setup-buildx-action@v3.10.0
 
       - name: Build and push
-        uses: docker/build-push-action@v6.16.0
+        uses: docker/build-push-action@v6.18.0
         env:
           ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
           ECR_REPOSITORY: mdi-runtime

{hafnia-0.1.25 → hafnia-0.1.26}/.github/workflows/tests.yaml

@@ -20,6 +20,6 @@ jobs:
         with:
           version: 0.6.8
       - name: Install the project
-        run: uv sync --all-extras --dev
+        run: uv sync --group dev
       - name: Run tests
         run: uv run pytest tests 

{hafnia-0.1.25 → hafnia-0.1.26}/.gitignore

@@ -163,4 +163,4 @@ cython_debug/
 /pypiprivate/
 /packaging/
 /.data/
-*.zip
+/recipe.zip

hafnia-0.1.26/.pre-commit-config.yaml

@@ -0,0 +1,32 @@
+repos:
+- repo: https://github.com/astral-sh/ruff-pre-commit
+  rev: v0.11.13
+  hooks:
+    - id: ruff-check
+      types_or: [python, pyi]
+      args: [--show-fixes]
+      files: ^(src|tests)/
+    - id: ruff-format
+      types_or: [python, pyi]
+      files: ^(src|tests)/
+- repo: https://github.com/astral-sh/uv-pre-commit
+  rev: 0.7.13
+  hooks:
+    # Update the uv lockfile
+    - id: uv-lock
+- repo: https://github.com/pre-commit/mirrors-mypy
+  rev: v1.16.0
+  hooks:
+    - id: mypy
+      args: ["src/", "tests/"]      
+      pass_filenames: false
+- repo: local
+  hooks:
+  - id: pytest
+    stages: [manual]
+    name: pytest
+    entry: pytest
+    language: system
+    types: [python]
+    pass_filenames: false
+    args: ["-m", "not slow", "--tb=short", "-q"]

{hafnia-0.1.25 → hafnia-0.1.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hafnia
-Version: 0.1.25
+Version: 0.1.26
 Summary: Python SDK for communication with Hafnia platform.
 Author-email: Milestone Systems <hafniaplatform@milestone.dk>
 License-File: LICENSE
@@ -17,10 +17,6 @@ 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'
-Requires-Dist: torch>=2.6.0; extra == 'torch'
-Requires-Dist: torchvision>=0.21.0; extra == 'torch'
 Description-Content-Type: text/markdown
 
 # Hafnia
@@ -91,14 +87,117 @@ and explore the dataset sample with a python script:
 from hafnia.data import load_dataset
 
 dataset_splits = load_dataset("mnist")
-print(dataset_splits)
-print(dataset_splits["train"])
 ```
+
+### Dataset Format
 The returned sample dataset is a [hugging face dataset](https://huggingface.co/docs/datasets/index) 
 and contains train, validation and test splits. 
 
+```python
+print(dataset_splits)
+
+# Output:
+>>> DatasetDict({
+    train: Dataset({
+        features: ['image_id', 'image', 'height', 'width', 'objects', 'Weather', 'Surface Conditions'],
+        num_rows: 172
+    })
+    validation: Dataset({
+        features: ['image_id', 'image', 'height', 'width', 'objects', 'Weather', 'Surface Conditions'],
+        num_rows: 21
+    })
+    test: Dataset({
+        features: ['image_id', 'image', 'height', 'width', 'objects', 'Weather', 'Surface Conditions'],
+        num_rows: 21
+    })
+})
+
+```
+
+A Hugging Face dataset is a dictionary with splits, where each split is a `Dataset` object.
+Each `Dataset` is structured as a table with a set of columns (also called features) and a row for each sample.
+
+The features of the dataset can be viewed with the `features` attribute.
+```python
+# View features of the train split
+pprint.pprint(dataset["train"].features)
+{'Surface Conditions': ClassLabel(names=['Dry', 'Wet'], id=None),
+ 'Weather': ClassLabel(names=['Clear', 'Foggy'], id=None),
+ 'height': Value(dtype='int64', id=None),
+ 'image': Image(mode=None, decode=True, id=None),
+ 'image_id': Value(dtype='int64', id=None),
+ 'objects': Sequence(feature={'bbox': Sequence(feature=Value(dtype='int64',
+                                                             id=None),
+                                               length=-1,
+                                               id=None),
+                              'class_idx': ClassLabel(names=['Vehicle.Bicycle',
+                                                             'Vehicle.Motorcycle',
+                                                             'Vehicle.Car',
+                                                             'Vehicle.Van',
+                                                             'Vehicle.RV',
+                                                             'Vehicle.Single_Truck',
+                                                             'Vehicle.Combo_Truck',
+                                                             'Vehicle.Pickup_Truck',
+                                                             'Vehicle.Trailer',
+                                                             'Vehicle.Emergency_Vehicle',
+                                                             'Vehicle.Bus',
+                                                             'Vehicle.Heavy_Duty_Vehicle'],
+                                                      id=None),
+                              'class_name': Value(dtype='string', id=None),
+                              'id': Value(dtype='string', id=None)},
+                     length=-1,
+                     id=None),
+ 'width': Value(dtype='int64', id=None)}
+```
+
+View the first sample in the training set:
+```python
+# Print sample from the training set
+pprint.pprint(dataset["train"][0])
+
+{'image': <PIL.PngImagePlugin.PngImageFile image mode=RGB size=1920x1080 at 0x79D6292C5ED0>,
+ 'image_id': 4920,
+ 'height': 1080,
+ 'Weather': 0,
+ 'Surface Conditions': 0,
+ 'objects': {'bbox': [[441, 180, 121, 126],
+                      [549, 151, 131, 103],
+                      [1845, 722, 68, 130],
+                      [1810, 571, 110, 149]],
+             'class_idx': [7, 7, 2, 2],
+             'class_name': ['Vehicle.Pickup_Truck',
+                            'Vehicle.Pickup_Truck',
+                            'Vehicle.Car',
+                            'Vehicle.Car'],
+             'id': ['HW6WiLAJ', 'T/ccFpRi', 'CS0O8B6W', 'DKrJGzjp']},
+ 'width': 1920}
+
+```
+
+For hafnia based datasets, we want to standardized how a dataset and dataset tasks are represented.
+We have defined a set of features that are common across all datasets in the Hafnia data library.
+
+- `image`: The image itself, stored as a PIL image
+- `height`: The height of the image in pixels
+- `width`: The width of the image in pixels
+- `[IMAGE_CLASSIFICATION_TASK]`: [Optional] Image classification tasks are top-level `ClassLabel` feature. 
+  `ClassLabel` is a Hugging Face feature that maps class indices to class names. 
+  In above example we have two classification tasks:
+  - `Weather`: Classifies the weather conditions in the image, with possible values `Clear` and `Foggy`
+  - `Surface Conditions`: Classifies the surface conditions in the image, with possible values `Dry` and `Wet`
+- `objects`: A dictionary containing information about objects in the image, including:
+  - `bbox`: Bounding boxes for each object, represented with a list of bounding box coordinates 
+  `[xmin, ymin, bbox_width, bbox_height]`. Each bounding box is defined with a top-left corner coordinate 
+  `(xmin, ymin)` and bounding box width and height `(bbox_width, bbox_height)` in pixels.
+  - `class_idx`: Class indices for each detected object. This is a
+  `ClassLabel` feature that maps to the `class_name` feature.
+  - `class_name`: Class names for each detected object
+  - `id`: Unique identifiers for each detected object
+
+### Dataset Locally vs. Training-aaS
 An important feature of `load_dataset` is that it will return the full dataset 
-when loaded on the Hafnia platform. 
+when loaded with Training-aaS on the Hafnia platform. 
+
 This enables seamlessly switching between running/validating a training script 
 locally (on the sample dataset) and running full model trainings with Training-aaS (on the full dataset). 
 without changing code or configurations for the training script.
@@ -160,12 +259,58 @@ with a dataloader that performs data augmentations and batching of the dataset a
 To support this, we have provided a torch dataloader example script
 [example_torchvision_dataloader.py](./examples/example_torchvision_dataloader.py). 
 
-The script demonstrates how to make a dataloader with data augmentation (`torchvision.transforms.v2`)
-and a helper function for visualizing image and labels. 
+The script demonstrates how to load a dataset sample, apply data augmentations using
+`torchvision.transforms.v2`, and visualize the dataset with `torch_helpers.draw_image_and_targets`.
+
+Note also how `torch_helpers.TorchVisionCollateFn` is used in combination with the `DataLoader` from 
+`torch.utils.data` to handle the dataset's collate function.
 
 The dataloader and visualization function supports computer vision tasks 
 and datasets available in the data library. 
 
+```python
+# Load Hugging Face dataset
+dataset_splits = load_dataset("midwest-vehicle-detection")
+
+# Define transforms
+train_transforms = v2.Compose(
+    [
+        v2.RandomResizedCrop(size=(224, 224), antialias=True),
+        v2.RandomHorizontalFlip(p=0.5),
+        v2.ToDtype(torch.float32, scale=True),
+        v2.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ]
+)
+test_transforms = v2.Compose(
+    [
+        v2.Resize(size=(224, 224), antialias=True),
+        v2.ToDtype(torch.float32, scale=True),
+        v2.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ]
+)
+
+keep_metadata = True
+train_dataset = torch_helpers.TorchvisionDataset(
+    dataset_splits["train"], transforms=train_transforms, keep_metadata=keep_metadata
+)
+test_dataset = torch_helpers.TorchvisionDataset(
+    dataset_splits["test"], transforms=test_transforms, keep_metadata=keep_metadata
+)
+
+# Visualize sample
+image, targets = train_dataset[0]
+visualize_image = torch_helpers.draw_image_and_targets(image=image, targets=targets)
+pil_image = torchvision.transforms.functional.to_pil_image(visualize_image)
+pil_image.save("visualized_labels.png")
+
+# Create DataLoaders - using TorchVisionCollateFn
+collate_fn = torch_helpers.TorchVisionCollateFn(
+    skip_stacking=["objects.bbox", "objects.class_idx"]
+)
+train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True, collate_fn=collate_fn)
+```
+
+
 ## Example: Training-aaS
 By combining logging and dataset loading, we can now construct our model training recipe. 
 
@@ -206,10 +351,10 @@ Install uv
 curl -LsSf https://astral.sh/uv/install.sh | sh
 ```
 
-Install python dependencies including developer (`--dev`) and optional dependencies (`--all-extras`).
+Create virtual environment and install python dependencies
 
 ```bash
-uv sync --all-extras --dev
+uv sync
 ```
 
  Run tests:

{hafnia-0.1.25 → hafnia-0.1.26}/README.md

@@ -66,14 +66,117 @@ and explore the dataset sample with a python script:
 from hafnia.data import load_dataset
 
 dataset_splits = load_dataset("mnist")
-print(dataset_splits)
-print(dataset_splits["train"])
 ```
+
+### Dataset Format
 The returned sample dataset is a [hugging face dataset](https://huggingface.co/docs/datasets/index) 
 and contains train, validation and test splits. 
 
+```python
+print(dataset_splits)
+
+# Output:
+>>> DatasetDict({
+    train: Dataset({
+        features: ['image_id', 'image', 'height', 'width', 'objects', 'Weather', 'Surface Conditions'],
+        num_rows: 172
+    })
+    validation: Dataset({
+        features: ['image_id', 'image', 'height', 'width', 'objects', 'Weather', 'Surface Conditions'],
+        num_rows: 21
+    })
+    test: Dataset({
+        features: ['image_id', 'image', 'height', 'width', 'objects', 'Weather', 'Surface Conditions'],
+        num_rows: 21
+    })
+})
+
+```
+
+A Hugging Face dataset is a dictionary with splits, where each split is a `Dataset` object.
+Each `Dataset` is structured as a table with a set of columns (also called features) and a row for each sample.
+
+The features of the dataset can be viewed with the `features` attribute.
+```python
+# View features of the train split
+pprint.pprint(dataset["train"].features)
+{'Surface Conditions': ClassLabel(names=['Dry', 'Wet'], id=None),
+ 'Weather': ClassLabel(names=['Clear', 'Foggy'], id=None),
+ 'height': Value(dtype='int64', id=None),
+ 'image': Image(mode=None, decode=True, id=None),
+ 'image_id': Value(dtype='int64', id=None),
+ 'objects': Sequence(feature={'bbox': Sequence(feature=Value(dtype='int64',
+                                                             id=None),
+                                               length=-1,
+                                               id=None),
+                              'class_idx': ClassLabel(names=['Vehicle.Bicycle',
+                                                             'Vehicle.Motorcycle',
+                                                             'Vehicle.Car',
+                                                             'Vehicle.Van',
+                                                             'Vehicle.RV',
+                                                             'Vehicle.Single_Truck',
+                                                             'Vehicle.Combo_Truck',
+                                                             'Vehicle.Pickup_Truck',
+                                                             'Vehicle.Trailer',
+                                                             'Vehicle.Emergency_Vehicle',
+                                                             'Vehicle.Bus',
+                                                             'Vehicle.Heavy_Duty_Vehicle'],
+                                                      id=None),
+                              'class_name': Value(dtype='string', id=None),
+                              'id': Value(dtype='string', id=None)},
+                     length=-1,
+                     id=None),
+ 'width': Value(dtype='int64', id=None)}
+```
+
+View the first sample in the training set:
+```python
+# Print sample from the training set
+pprint.pprint(dataset["train"][0])
+
+{'image': <PIL.PngImagePlugin.PngImageFile image mode=RGB size=1920x1080 at 0x79D6292C5ED0>,
+ 'image_id': 4920,
+ 'height': 1080,
+ 'Weather': 0,
+ 'Surface Conditions': 0,
+ 'objects': {'bbox': [[441, 180, 121, 126],
+                      [549, 151, 131, 103],
+                      [1845, 722, 68, 130],
+                      [1810, 571, 110, 149]],
+             'class_idx': [7, 7, 2, 2],
+             'class_name': ['Vehicle.Pickup_Truck',
+                            'Vehicle.Pickup_Truck',
+                            'Vehicle.Car',
+                            'Vehicle.Car'],
+             'id': ['HW6WiLAJ', 'T/ccFpRi', 'CS0O8B6W', 'DKrJGzjp']},
+ 'width': 1920}
+
+```
+
+For hafnia based datasets, we want to standardized how a dataset and dataset tasks are represented.
+We have defined a set of features that are common across all datasets in the Hafnia data library.
+
+- `image`: The image itself, stored as a PIL image
+- `height`: The height of the image in pixels
+- `width`: The width of the image in pixels
+- `[IMAGE_CLASSIFICATION_TASK]`: [Optional] Image classification tasks are top-level `ClassLabel` feature. 
+  `ClassLabel` is a Hugging Face feature that maps class indices to class names. 
+  In above example we have two classification tasks:
+  - `Weather`: Classifies the weather conditions in the image, with possible values `Clear` and `Foggy`
+  - `Surface Conditions`: Classifies the surface conditions in the image, with possible values `Dry` and `Wet`
+- `objects`: A dictionary containing information about objects in the image, including:
+  - `bbox`: Bounding boxes for each object, represented with a list of bounding box coordinates 
+  `[xmin, ymin, bbox_width, bbox_height]`. Each bounding box is defined with a top-left corner coordinate 
+  `(xmin, ymin)` and bounding box width and height `(bbox_width, bbox_height)` in pixels.
+  - `class_idx`: Class indices for each detected object. This is a
+  `ClassLabel` feature that maps to the `class_name` feature.
+  - `class_name`: Class names for each detected object
+  - `id`: Unique identifiers for each detected object
+
+### Dataset Locally vs. Training-aaS
 An important feature of `load_dataset` is that it will return the full dataset 
-when loaded on the Hafnia platform. 
+when loaded with Training-aaS on the Hafnia platform. 
+
 This enables seamlessly switching between running/validating a training script 
 locally (on the sample dataset) and running full model trainings with Training-aaS (on the full dataset). 
 without changing code or configurations for the training script.
@@ -135,12 +238,58 @@ with a dataloader that performs data augmentations and batching of the dataset a
 To support this, we have provided a torch dataloader example script
 [example_torchvision_dataloader.py](./examples/example_torchvision_dataloader.py). 
 
-The script demonstrates how to make a dataloader with data augmentation (`torchvision.transforms.v2`)
-and a helper function for visualizing image and labels. 
+The script demonstrates how to load a dataset sample, apply data augmentations using
+`torchvision.transforms.v2`, and visualize the dataset with `torch_helpers.draw_image_and_targets`.
+
+Note also how `torch_helpers.TorchVisionCollateFn` is used in combination with the `DataLoader` from 
+`torch.utils.data` to handle the dataset's collate function.
 
 The dataloader and visualization function supports computer vision tasks 
 and datasets available in the data library. 
 
+```python
+# Load Hugging Face dataset
+dataset_splits = load_dataset("midwest-vehicle-detection")
+
+# Define transforms
+train_transforms = v2.Compose(
+    [
+        v2.RandomResizedCrop(size=(224, 224), antialias=True),
+        v2.RandomHorizontalFlip(p=0.5),
+        v2.ToDtype(torch.float32, scale=True),
+        v2.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ]
+)
+test_transforms = v2.Compose(
+    [
+        v2.Resize(size=(224, 224), antialias=True),
+        v2.ToDtype(torch.float32, scale=True),
+        v2.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ]
+)
+
+keep_metadata = True
+train_dataset = torch_helpers.TorchvisionDataset(
+    dataset_splits["train"], transforms=train_transforms, keep_metadata=keep_metadata
+)
+test_dataset = torch_helpers.TorchvisionDataset(
+    dataset_splits["test"], transforms=test_transforms, keep_metadata=keep_metadata
+)
+
+# Visualize sample
+image, targets = train_dataset[0]
+visualize_image = torch_helpers.draw_image_and_targets(image=image, targets=targets)
+pil_image = torchvision.transforms.functional.to_pil_image(visualize_image)
+pil_image.save("visualized_labels.png")
+
+# Create DataLoaders - using TorchVisionCollateFn
+collate_fn = torch_helpers.TorchVisionCollateFn(
+    skip_stacking=["objects.bbox", "objects.class_idx"]
+)
+train_loader = DataLoader(train_dataset, batch_size=8, shuffle=True, collate_fn=collate_fn)
+```
+
+
 ## Example: Training-aaS
 By combining logging and dataset loading, we can now construct our model training recipe. 
 
@@ -181,10 +330,10 @@ Install uv
 curl -LsSf https://astral.sh/uv/install.sh | sh
 ```
 
-Install python dependencies including developer (`--dev`) and optional dependencies (`--all-extras`).
+Create virtual environment and install python dependencies
 
 ```bash
-uv sync --all-extras --dev
+uv sync
 ```
 
  Run tests:

{hafnia-0.1.25 → hafnia-0.1.26}/docs/cli.md

@@ -28,8 +28,8 @@ A command-line interface tool for managing data science experiments and resource
 ### Experiment Management
 
 - `hafnia runc launch <task>` - Launch a job within the image
-- `hafnia runc build <recipe_url> [state_file] [ecr_repository] [image_name]` - Build docker image with a given recipe
-- `hafnia runc build-local <recipe> [state_file] [image_name]` - Build recipe from local path as image with prefix - localhost
+- `hafnia runc build <recipe_url> --st [state_file] --repo [registry/repo]` - Build docker image with a given recipe
+- `hafnia runc build-local <recipe> --st [state_file] --repo [registry/repo | localhost]` - Build recipe from local path as image with prefix - localhost
 
 ## Configuration
 
@@ -96,4 +96,5 @@ Available environment variables:
 - `MDI_API_KEY_SECRET_NAME` - Name of the AWS Secrets Manager secret containing the API key
 - `AWS_REGION` - AWS region for ECR and Secrets Manager operations
 - `RECIPE_DIR` - Directory containing recipe code (used by the `runc launch` command
-- `HAFNIA_CLOUD` – Allow emulate cloud behaviour
+- `HAFNIA_CLOUD` – Allow emulate cloud behaviour
+- `HAFNIA_LOG` – Allow changing log level for messages 

{hafnia-0.1.25 → hafnia-0.1.26}/examples/dataset_builder.py

@@ -10,9 +10,8 @@ from pathlib import Path
 from typing import Any, Callable, Dict, Iterable, List, Optional, Tuple
 
 import datasets
-from datasets import ClassLabel, DatasetDict
-
 import mdi
+from datasets import ClassLabel, DatasetDict
 
 # dataset = mdi.load_dataset("mnist")
 # dataset = mdi.load_dataset("[ADD SOME CUSTOM DATASET SPECIFICATION]")

hafnia-0.1.26/examples/example_load_dataset.py

@@ -0,0 +1,14 @@
+import pprint
+
+from hafnia.data import load_dataset
+
+dataset = load_dataset("midwest-vehicle-detection")
+
+# Print information on each dataset split
+print(dataset)
+
+# View features of the train split
+pprint.pprint(dataset["train"].features)
+
+# Print sample from the training set
+pprint.pprint(dataset["train"][0])

{hafnia-0.1.25 → hafnia-0.1.26}/pyproject.toml

@@ -1,10 +1,13 @@
 [project]
 name = "hafnia"
-version = "0.1.25"
+version = "0.1.26"
 description = "Python SDK for communication with Hafnia platform."
 readme = "README.md"
-authors = [{ name = "Milestone Systems", email = "hafniaplatform@milestone.dk" }]
+authors = [
+    { name = "Milestone Systems", email = "hafniaplatform@milestone.dk" },
+]
 requires-python = ">=3.10"
+
 dependencies = [
     "boto3>=1.35.91",
     "click>=8.1.8",
@@ -24,38 +27,41 @@ dependencies = [
 dev = [
     "ipykernel>=6.29.5",
     "lark>=1.2.2",
-    "pytest>=8.3.4",
-]
-lint = [
-    "pre-commit>=4.2.0",
-    "ruff>=0.9.1",
+    "torch>=2.6.0",
+    "torchvision>=0.21.0",
+    "flatten-dict>=0.4.2",
 ]
 
-[tool.uv]
-default-groups = "all"
+test = ["pytest>=8.3.4", "pre-commit>=4.2.0", "ruff>=0.9.1"]
 
 [project.scripts]
 hafnia = 'cli.__main__:main'
 
-[project.optional-dependencies]
-# Use "uv sync --extra torch" to install torch dependencies
-torch = [
-    "torch>=2.6.0",
-    "torchvision>=0.21.0",
-    "flatten-dict>=0.4.2",
-]
-
 [build-system]
 requires = ["hatchling"]
 build-backend = "hatchling.build"
 
+[tool.hatch.build.targets.wheel]
+packages = ["src/cli", "src/hafnia"]
+
+[tool.uv]
+default-groups = ["test"]
+
 [tool.ruff]
-select = ["I", "E", "F"]
-ignore = ["E501"]
+lint.select = ["I", "E", "F"]
+lint.ignore = ["E501"]
 line-length = 120
 
-[tool.ruff.isort]
+[tool.ruff.lint.isort]
 relative-imports-order = "closest-to-furthest"
 
-[tool.hatch.build.targets.wheel]
-packages = ["src/cli", "src/hafnia"]
+[tool.mypy]
+ignore_missing_imports = true
+check_untyped_defs = false
+disallow_untyped_defs = false
+disallow_incomplete_defs = false
+disallow_untyped_calls = false
+warn_unused_ignores = false
+
+[tool.pytest.ini_options]
+markers = ["slow: marks tests as slow (deselect with '-m \"not slow\"')"]

{hafnia-0.1.25 → hafnia-0.1.26}/src/cli/__main__.py

@@ -10,6 +10,7 @@ from cli.config import Config, ConfigSchema
 def main(ctx: click.Context) -> None:
     """Hafnia CLI."""
     ctx.obj = Config()
+    ctx.max_content_width = 120
 
 
 @main.command("configure")
@@ -17,9 +18,7 @@ def main(ctx: click.Context) -> None:
 def configure(cfg: Config) -> None:
     """Configure Hafnia CLI settings."""
 
-    from hafnia.platform.api import get_organization_id
-
-    profile_name = click.prompt("Profile Name", type=str, default="default")
+    profile_name = click.prompt("Profile Name", type=str, default=consts.DEFAULT_PROFILE_NAME)
     profile_name = profile_name.strip()
     try:
         cfg.add_profile(profile_name, ConfigSchema(), set_active=True)
@@ -32,12 +31,8 @@ def configure(cfg: Config) -> None:
     except ValueError as e:
         click.echo(f"Error: {str(e)}", err=True)
         return
-    platform_url = click.prompt("Hafnia Platform URL", type=str, default="https://api.mdi.milestonesys.com")
+    platform_url = click.prompt("Hafnia Platform URL", type=str, default=consts.DEFAULT_API_URL)
     cfg.platform_url = platform_url.strip()
-    try:
-        cfg.organization_id = get_organization_id(cfg.get_platform_endpoint("organizations"), cfg.api_key)
-    except Exception:
-        raise click.ClickException(consts.ERROR_ORG_ID)
     cfg.save_config()
     profile_cmds.profile_show(cfg)
 
@@ -57,4 +52,4 @@ main.add_command(experiment_cmds.experiment)
 main.add_command(recipe_cmds.recipe)
 
 if __name__ == "__main__":
-    main()
+    main(max_content_width=120)