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

hafnia/utils.py

@@ -1,18 +1,60 @@
-import functools
 import os
-import sys
+import time
+import zipfile
 from datetime import datetime
+from functools import wraps
 from pathlib import Path
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Iterator, Optional
 from zipfile import ZipFile
 
-import click
+import pathspec
+import seedir
+from rich import print as rprint
 
-from hafnia.log import logger
+from hafnia.log import sys_logger, user_logger
 
 PATH_DATA = Path("./.data")
 PATH_DATASET = PATH_DATA / "datasets"
 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 timed(label: str):
+    """
+    Decorator factory that allows custom labels for timing.
+    Usage: @timed("Custom Operation")
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        def wrapper(*args, **kwargs) -> Any:
+            operation_label = label or func.__name__
+            tik = time.perf_counter()
+            try:
+                return func(*args, **kwargs)
+            except Exception as e:
+                sys_logger.error(f"{operation_label} failed: {e}")
+            finally:
+                elapsed = time.perf_counter() - tik
+                sys_logger.debug(f"{operation_label} took {elapsed:.2f} seconds.")
+
+        return wrapper
+
+    return decorator
 
 
 def now_as_str() -> str:
@@ -26,58 +68,70 @@ def get_recipe_path(recipe_name: str) -> Path:
     return path_recipe
 
 
-def archive_dir(recipe_path: Path, output_path: Optional[Path] = None) -> Path:
+def filter_recipe_files(recipe_path: Path, path_ignore_file: Optional[Path] = None) -> Iterator:
+    path_ignore_file = path_ignore_file or recipe_path / FILENAME_HAFNIAIGNORE
+    if not path_ignore_file.exists():
+        ignore_specification_lines = DEFAULT_IGNORE_SPECIFICATION
+        user_logger.info(
+            f"No '{FILENAME_HAFNIAIGNORE}' was file found. Files are excluded using the default ignore patterns.\n"
+            f"\tDefault ignore patterns: {DEFAULT_IGNORE_SPECIFICATION}\n"
+            f"Add a '{FILENAME_HAFNIAIGNORE}' file to the root folder to make custom ignore patterns."
+        )
+    else:
+        ignore_specification_lines = Path(path_ignore_file).read_text().splitlines()
+    ignore_specification = pathspec.GitIgnoreSpec.from_lines(ignore_specification_lines)
+    include_files = ignore_specification.match_tree(recipe_path, negate=True)
+    return include_files
+
+
+@timed("Wrapping recipe.")
+def archive_dir(
+    recipe_path: Path,
+    output_path: Optional[Path] = None,
+    path_ignore_file: Optional[Path] = None,
+) -> Path:
     recipe_zip_path = output_path or recipe_path / "recipe.zip"
     assert recipe_zip_path.suffix == ".zip", "Output path must be a zip file"
     recipe_zip_path.parent.mkdir(parents=True, exist_ok=True)
 
-    click.echo(f"Creating zip archive {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)}")
-                continue
-
-            if not item.is_file():
-                continue
-
-            relative_path = item.relative_to(recipe_path)
-            click.echo(f"[+] {relative_path}")
-            zip_ref.write(item, relative_path)
-    return recipe_zip_path
+    user_logger.info(f" Creating zip archive of '{recipe_path}'")
+    include_files = filter_recipe_files(recipe_path, path_ignore_file)
+    with ZipFile(recipe_zip_path, "w", compression=zipfile.ZIP_STORED, allowZip64=True) as zip_ref:
+        for str_filepath in include_files:
+            full_path = recipe_path / str_filepath
+            zip_ref.write(full_path, str_filepath)
+    show_recipe_content(recipe_zip_path)
 
+    return recipe_zip_path
 
-def safe(func: Callable) -> Callable:
-    """
-    Decorator that catches exceptions, logs them, and exits with code 1.
 
-    Args:
-        func: The function to decorate
+def size_human_readable(size_bytes: int, suffix="B") -> str:
+    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}"
 
-    Returns:
-        Wrapped function that handles exceptions
-    """
 
-    @functools.wraps(func)
-    def wrapper(*args: Any, **kwargs: Any) -> Any:
-        try:
-            return func(*args, **kwargs)
-        except Exception as e:
-            logger.error(f"Error in {func.__name__}: {str(e)}")
-            sys.exit(1)
+def show_recipe_content(recipe_path: Path, style: str = "emoji", depth_limit: int = 3) -> None:
+    def scan(parent: seedir.FakeDir, path: zipfile.Path, depth: int = 0) -> None:
+        if depth >= depth_limit:
+            return
+        for child in path.iterdir():
+            if child.is_dir():
+                folder = seedir.FakeDir(child.name)
+                scan(folder, child, depth + 1)
+                folder.parent = parent
+            else:
+                parent.create_file(child.name)
 
-    return wrapper
+    recipe = seedir.FakeDir("recipe")
+    scan(recipe, zipfile.Path(recipe_path))
+    rprint(recipe.seedir(sort=True, first="folders", style=style, printout=False))
+    user_logger.info(f"Recipe size: {size_human_readable(os.path.getsize(recipe_path))}. Max size 800 MiB")
 
 
 def is_remote_job() -> bool:
     """Check if the current job is running in HAFNIA cloud environment."""
-    is_remote = os.getenv("HAFNIA_CLOUD", "false").lower() == "true"
-    return is_remote
+    return os.getenv("HAFNIA_CLOUD", "false").lower() == "true"

hafnia-0.1.26.dist-info/METADATA

@@ -0,0 +1,363 @@
+Metadata-Version: 2.4
+Name: hafnia
+Version: 0.1.26
+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
+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 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.
+- `hafnia`: A python package with helper functions to load and interact with sample datasets and an experiment
+ tracker (`HafniaLogger`). 
+
+
+## The Concept: Training as a Service (Training-aaS)
+`Training-aaS` is the concept of training models on the Hafnia platform on large 
+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 
+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.
+
+To support local development of a training recipe, 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. 
+
+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
+multiple GPUs and instances if needed. 
+
+## Getting started: Configuration
+To get started with Hafnia: 
+
+1. Install `hafnia` with your favorite python package manager. With pip do this:
+
+    `pip install hafnia`
+1. Sign in to the [Hafnia Platform](https://hafnia.milestonesys.com/). 
+1. Create an API KEY for Training aaS. For more instructions, follow this 
+[guide](https://hafnia.readme.io/docs/create-an-api-key). 
+Copy the key and save it for later use.
+1. From terminal, configure your machine to access Hafnia: 
+
+    ```
+    # Start configuration with
+    hafnia configure
+
+    # You are then prompted: 
+    Profile Name [default]:   # Press [Enter] or select an optional name
+    Hafnia API Key:  # Pass your HAFNIA API key
+    Hafnia Platform URL [https://api.mdi.milestonesys.com]:  # Press [Enter]
+    ```
+1. Download `mnist` from terminal to verify that your configuration is working.  
+
+    ```bash
+    hafnia data download mnist --force
+    ```
+
+## Getting started: Loading datasets samples
+With Hafnia configured on your local machine, it is now possible to download 
+and explore the dataset sample with a python script:
+
+```python
+from hafnia.data import load_dataset
+
+dataset_splits = load_dataset("mnist")
+```
+
+### 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 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.
+
+Available datasets with corresponding sample datasets can be found in [data library](https://hafnia.milestonesys.com/training-aas/datasets) including metadata and description for each dataset. 
+
+
+## Getting started: Experiment Tracking with HafniaLogger
+The `HafniaLogger` is an important part of the recipe script and enables you to track, log and
+reproduce your experiments.
+
+When integrated into your training script, the `HafniaLogger` is responsible for collecting:
+
+- **Trained Model**: The model trained during the experiment
+- **Model Checkpoints**: Intermediate model states saved during training
+- **Experiment Configurations**: Hyperparameters and other settings used in your experiment
+- **Training/Evaluation Metrics**: Performance data such as loss values, accuracy, and custom metrics
+
+### Basic Implementation Example
+
+Here's how to integrate the `HafniaLogger` into your training script:
+
+```python
+from hafnia.experiment import HafniaLogger
+
+batch_size = 128
+learning_rate = 0.001
+
+# Initialize Hafnia logger
+logger = HafniaLogger()
+
+# Log experiment parameters
+logger.log_configuration({"batch_size": 128, "learning_rate": 0.001})
+
+# Store checkpoints in this path
+ckpt_dir = logger.path_model_checkpoints()
+
+# Store the trained model in this path
+model_dir = logger.path_model()
+
+# Log scalar and metric values during training and validation
+logger.log_scalar("train/loss", value=0.1, step=100)
+logger.log_metric("train/accuracy", value=0.98, step=100)
+
+logger.log_scalar("validation/loss", value=0.1, step=100)
+logger.log_metric("validation/accuracy", value=0.95, step=100)
+```
+
+Similar to `load_dataset`, the tracker behaves differently when running locally or in the cloud. 
+Locally, experiment data is stored in a local folder `.data/experiments/{DATE_TIME}`. 
+
+In the cloud, the experiment data will be available in the Hafnia platform under 
+[experiments](https://hafnia.milestonesys.com/training-aas/experiments). 
+
+## Example: Torch Dataloader
+Commonly for `torch`-based training scripts, a dataset is used in combination 
+with a dataloader that performs data augmentations and batching of the dataset as torch tensors.
+
+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 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. 
+
+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)
+
+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
+- [Release lifecycle](docs/release.md) - Details about package release lifecycle.
+
+## Development
+For development, we are using an uv based virtual python environment.
+
+Install uv
+```bash 
+curl -LsSf https://astral.sh/uv/install.sh | sh
+```
+
+Create virtual environment and install python dependencies
+
+```bash
+uv sync
+```
+
+ Run tests:
+```bash
+uv run pytest tests
+```

hafnia-0.1.26.dist-info/RECORD

@@ -0,0 +1,27 @@
+cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cli/__main__.py,sha256=MX0RT1BP3t59rzCvdUqfw39Kw05HOF4OEtjDTwIU9h8,1594
+cli/config.py,sha256=R9w0NKIOtIxRKNs7ieeUrIKwRkrTlK5PqOVjc5VYljE,4923
+cli/consts.py,sha256=sj0MRwbbCT2Yl77FPddck1VWkFxp7QY6I9l1o75j_aE,963
+cli/data_cmds.py,sha256=BQiythAPwAwudgdUa68v50a345uw5flrcDiBHLGp9lo,1460
+cli/experiment_cmds.py,sha256=L-k_ZJ4B7I4cA8OvHcheSwXM6nx9aTF9G7eKBzAcOzQ,1961
+cli/profile_cmds.py,sha256=-HQcFgYI6Rqaefi0Nj-91KhiqPKUj7zOaiJWbHx_bac,3196
+cli/recipe_cmds.py,sha256=qnMfF-te47HXNkgyA0hm9X3etDQsqMnrVEGDCrzVjZU,1462
+cli/runc_cmds.py,sha256=6fHMi_dEd8g3Cx9PEfU4gJMZf5-G0IUPDcZh6DNq8Mw,4953
+hafnia/__init__.py,sha256=Zphq-cQoX95Z11zm4lkrU-YiAJxddR7IBfwDkxeHoDE,108
+hafnia/http.py,sha256=psCWdNKfKYiBrYD6bezat1AeHh77JJtJrPePiUAjTIk,2948
+hafnia/log.py,sha256=sWF8tz78yBtwZ9ddzm19L1MBSBJ3L4G704IGeT1_OEU,784
+hafnia/torch_helpers.py,sha256=P_Jl4IwqUebKVCOXNe6iTorJZA3S-3d92HV274UHIko,7456
+hafnia/utils.py,sha256=mJ5aOjSVSOrrQnpmaKLK71ld5jYpmtd3HciTIk_Wk88,4659
+hafnia/data/__init__.py,sha256=Pntmo_1fst8OhyrHB60jQ8mhJJ4hL38tdjLvt0YXEJo,73
+hafnia/data/factory.py,sha256=4fZDkWNyOK1QNCmsxsXfSztPJkJW_HBIa_PTdGCYHCM,2551
+hafnia/experiment/__init__.py,sha256=OEFE6HqhO5zcTCLZcPcPVjIg7wMFFnvZ1uOtAVhRz7M,85
+hafnia/experiment/hafnia_logger.py,sha256=usL5pl7XLJP-g1vZrwvbky5YiD6Bg-rOODYYAX5z43I,6830
+hafnia/platform/__init__.py,sha256=I-VIVXDxwBAUzxx8Zx0g_wykyDdFGTsjb_mYLmvxk2Y,443
+hafnia/platform/builder.py,sha256=OFPnOjE3bAbWjUgYErXtffDKTiW_9ol95eVzKqL27WM,5433
+hafnia/platform/download.py,sha256=t055axPNHlXTYCQgZHOS2YMQt1I2_bc4G8dltsOKttY,4760
+hafnia/platform/experiment.py,sha256=-nAfTmn1c8sE6pHDCTNZvWDTopkXndarJAPIGvsnk60,2389
+hafnia-0.1.26.dist-info/METADATA,sha256=Lds8gx_ffd8_l9kByvK_e-HPFehSSUv8E_85d8ZelSE,14990
+hafnia-0.1.26.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+hafnia-0.1.26.dist-info/entry_points.txt,sha256=FCJVIQ8GP2VE9I3eeGVF5eLxVDNW_01pOJCpG_CGnMM,45
+hafnia-0.1.26.dist-info/licenses/LICENSE,sha256=wLZw1B7_mod_CO1H8LXqQgfqlWD6QceJR8--LJYRZGE,1078
+hafnia-0.1.26.dist-info/RECORD,,

{hafnia-0.1.24.dist-info → hafnia-0.1.26.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/platform/api.py

@@ -1,12 +0,0 @@
-import urllib3
-
-from hafnia.http import fetch
-
-
-def get_organization_id(endpoint: str, api_key: str) -> str:
-    headers = {"X-APIKEY": api_key}
-    try:
-        org_info = fetch(endpoint, headers=headers)
-    except urllib3.exceptions.HTTPError as e:
-        raise ValueError("Failed to fetch organization ID. Verify platform URL and API key.") from e
-    return org_info[0]["id"]