ngio 0.4.8__py3-none-any.whl → 0.5.0a1__py3-none-any.whl

ngio/ome_zarr_meta/v05/_v05_spec_utils.py

@@ -0,0 +1,518 @@
+"""Utilities for OME-Zarr v05 specs.
+
+This module provides a set of classes to internally handle the metadata
+of the OME-Zarr v05 specification.
+
+For Images and Labels implements the following functionalities:
+- A function to find if a dict view of the metadata is a valid OME-Zarr v05 metadata.
+- A function to convert a v05 image metadata to a ngio image metadata.
+- A function to convert a ngio image metadata to a v05 image metadata.
+"""
+
+from ome_zarr_models.common.omero import Channel as ChannelV05
+from ome_zarr_models.common.omero import Omero as OmeroV05
+from ome_zarr_models.common.omero import Window as WindowV05
+from ome_zarr_models.v05.axes import Axis as AxisV05
+from ome_zarr_models.v05.coordinate_transformations import VectorScale as VectorScaleV05
+from ome_zarr_models.v05.coordinate_transformations import (
+    VectorTranslation as VectorTranslationV05,
+)
+from ome_zarr_models.v05.hcs import HCSAttrs as HCSAttrsV05
+from ome_zarr_models.v05.image import ImageAttrs as ImageAttrsV05
+from ome_zarr_models.v05.image_label import ImageLabelAttrs as LabelAttrsV05
+from ome_zarr_models.v05.multiscales import Dataset as DatasetV05
+from ome_zarr_models.v05.multiscales import Multiscale as MultiscaleV05
+from ome_zarr_models.v05.multiscales import ValidTransform as ValidTransformV05
+from pydantic import BaseModel, ValidationError
+
+from ngio.ome_zarr_meta.ngio_specs import (
+    AxesHandler,
+    AxesSetup,
+    Axis,
+    AxisType,
+    Channel,
+    ChannelsMeta,
+    ChannelVisualisation,
+    Dataset,
+    ImageLabelSource,
+    NgioImageMeta,
+    NgioLabelMeta,
+    NgioPlateMeta,
+    NgioWellMeta,
+    default_channel_name,
+)
+from ngio.ome_zarr_meta.v05._custom_models import CustomWellAttrs as WellAttrsV05
+
+
+class ImageV05AttrsWithOmero(ImageAttrsV05):
+    omero: OmeroV05 | None = None
+
+
+class ImageV05WithOmero(BaseModel):
+    ome: ImageV05AttrsWithOmero
+
+
+class ImageLabelV05(BaseModel):
+    ome: LabelAttrsV05
+
+
+def _is_v05_image_meta(metadata: dict) -> ImageV05WithOmero | ValidationError:
+    """Check if the metadata is a valid OME-Zarr v05 metadata.
+
+    Args:
+        metadata (dict): The metadata to check.
+
+    Returns:
+        bool: True if the metadata is a valid OME-Zarr v05 metadata, False otherwise.
+    """
+    try:
+        return ImageV05WithOmero(**metadata)
+    except ValidationError as e:
+        return e
+
+
+def _is_v05_label_meta(metadata: dict) -> ImageLabelV05 | ValidationError:
+    """Check if the metadata is a valid OME-Zarr v05 metadata.
+
+    Args:
+        metadata (dict): The metadata to check.
+
+    Returns:
+        bool: True if the metadata is a valid OME-Zarr v05 metadata, False otherwise.
+    """
+    try:
+        return ImageLabelV05(**metadata)
+    except ValidationError as e:
+        return e
+
+
+def _v05_omero_to_channels(v05_omero: OmeroV05 | None) -> ChannelsMeta | None:
+    if v05_omero is None:
+        return None
+
+    ngio_channels = []
+    for idx, v05_channel in enumerate(v05_omero.channels):
+        channel_extra = v05_channel.model_extra
+
+        if channel_extra is None:
+            channel_extra = {}
+
+        if "label" in channel_extra:
+            label = channel_extra.pop("label")
+        else:
+            label = default_channel_name(idx)
+
+        if "wavelength_id" in channel_extra:
+            wavelength_id = channel_extra.pop("wavelength_id")
+        else:
+            wavelength_id = label
+
+        if "active" in channel_extra:
+            active = channel_extra.pop("active")
+        else:
+            active = True
+
+        channel_visualisation = ChannelVisualisation(
+            color=v05_channel.color,
+            start=v05_channel.window.start,
+            end=v05_channel.window.end,
+            min=v05_channel.window.min,
+            max=v05_channel.window.max,
+            active=active,
+            **channel_extra,
+        )
+
+        ngio_channels.append(
+            Channel(
+                label=label,
+                wavelength_id=wavelength_id,
+                channel_visualisation=channel_visualisation,
+            )
+        )
+
+    v05_omero_extra = v05_omero.model_extra if v05_omero.model_extra is not None else {}
+    return ChannelsMeta(channels=ngio_channels, **v05_omero_extra)
+
+
+def _compute_scale_translation(
+    v05_transforms: ValidTransformV05,
+    scale: list[float],
+    translation: list[float],
+) -> tuple[list[float], list[float]]:
+    for v05_transform in v05_transforms:
+        if isinstance(v05_transform, VectorScaleV05):
+            scale = [t1 * t2 for t1, t2 in zip(scale, v05_transform.scale, strict=True)]
+
+        elif isinstance(v05_transform, VectorTranslationV05):
+            translation = [
+                t1 + t2
+                for t1, t2 in zip(translation, v05_transform.translation, strict=True)
+            ]
+        else:
+            raise NotImplementedError(
+                f"Coordinate transformation {v05_transform} is not supported."
+            )
+    return scale, translation
+
+
+def _v05_to_ngio_datasets(
+    v05_multiscale: MultiscaleV05,
+    axes_setup: AxesSetup,
+    allow_non_canonical_axes: bool = False,
+    strict_canonical_order: bool = True,
+) -> list[Dataset]:
+    """Convert a v05 multiscale to a list of ngio datasets."""
+    datasets = []
+
+    global_scale = [1.0] * len(v05_multiscale.axes)
+    global_translation = [0.0] * len(v05_multiscale.axes)
+
+    if v05_multiscale.coordinateTransformations is not None:
+        global_scale, global_translation = _compute_scale_translation(
+            v05_multiscale.coordinateTransformations, global_scale, global_translation
+        )
+
+    # Prepare axes handler
+    axes = []
+    for v05_axis in v05_multiscale.axes:
+        unit = v05_axis.unit
+        if unit is not None and not isinstance(unit, str):
+            unit = str(unit)
+        axes.append(
+            Axis(
+                name=str(v05_axis.name),
+                axis_type=AxisType(v05_axis.type),
+                # (for some reason the type is a generic JsonValue,
+                # but it should be a string or None)
+                unit=v05_axis.unit,  # type: ignore
+            )
+        )
+    axes_handler = AxesHandler(
+        axes=axes,
+        axes_setup=axes_setup,
+        allow_non_canonical_axes=allow_non_canonical_axes,
+        strict_canonical_order=strict_canonical_order,
+    )
+
+    for v05_dataset in v05_multiscale.datasets:
+        _scale, _translation = _compute_scale_translation(
+            v05_dataset.coordinateTransformations, global_scale, global_translation
+        )
+        datasets.append(
+            Dataset(
+                path=v05_dataset.path,
+                axes_handler=axes_handler,
+                scale=_scale,
+                translation=_translation,
+            )
+        )
+    return datasets
+
+
+def v05_to_ngio_image_meta(
+    metadata: dict,
+    axes_setup: AxesSetup | None = None,
+    allow_non_canonical_axes: bool = False,
+    strict_canonical_order: bool = True,
+) -> tuple[bool, NgioImageMeta | ValidationError]:
+    """Convert a v05 image metadata to a ngio image metadata.
+
+    Args:
+        metadata (dict): The v05 image metadata.
+        axes_setup (AxesSetup, optional): The axes setup. This is
+            required to convert image with non-canonical axes names.
+        allow_non_canonical_axes (bool, optional): Allow non-canonical axes.
+        strict_canonical_order (bool, optional): Strict canonical order.
+
+    Returns:
+        NgioImageMeta: The ngio image metadata.
+    """
+    v05_image = _is_v05_image_meta(metadata)
+    if isinstance(v05_image, ValidationError):
+        return False, v05_image
+    v05_image = v05_image.ome
+    if len(v05_image.multiscales) > 1:
+        raise NotImplementedError(
+            "Multiple multiscales in a single image are not supported in ngio."
+        )
+
+    v05_multiscale = v05_image.multiscales[0]
+
+    channels_meta = _v05_omero_to_channels(v05_image.omero)
+    axes_setup = axes_setup if axes_setup is not None else AxesSetup()
+    datasets = _v05_to_ngio_datasets(
+        v05_multiscale,
+        axes_setup=axes_setup,
+        allow_non_canonical_axes=allow_non_canonical_axes,
+        strict_canonical_order=strict_canonical_order,
+    )
+
+    name = v05_multiscale.name
+    if name is not None and not isinstance(name, str):
+        name = str(name)
+    return True, NgioImageMeta(
+        version="0.5",
+        name=name,
+        datasets=datasets,
+        channels=channels_meta,
+    )
+
+
+def v05_to_ngio_label_meta(
+    metadata: dict,
+    axes_setup: AxesSetup | None = None,
+    allow_non_canonical_axes: bool = False,
+    strict_canonical_order: bool = True,
+) -> tuple[bool, NgioLabelMeta | ValidationError]:
+    """Convert a v05 image metadata to a ngio image metadata.
+
+    Args:
+        metadata (dict): The v05 image metadata.
+        axes_setup (AxesSetup, optional): The axes setup. This is
+            required to convert image with non-canonical axes names.
+        allow_non_canonical_axes (bool, optional): Allow non-canonical axes.
+        strict_canonical_order (bool, optional): Strict canonical order.
+
+    Returns:
+        NgioImageMeta: The ngio image metadata.
+    """
+    v05_label = _is_v05_label_meta(metadata)
+    if isinstance(v05_label, ValidationError):
+        return False, v05_label
+    v05_label = v05_label.ome
+
+    if len(v05_label.multiscales) > 1:
+        raise NotImplementedError(
+            "Multiple multiscales in a single image are not supported in ngio."
+        )
+
+    v05_multiscale = v05_label.multiscales[0]
+
+    axes_setup = axes_setup if axes_setup is not None else AxesSetup()
+    datasets = _v05_to_ngio_datasets(
+        v05_multiscale,
+        axes_setup=axes_setup,
+        allow_non_canonical_axes=allow_non_canonical_axes,
+        strict_canonical_order=strict_canonical_order,
+    )
+
+    if v05_label.image_label is not None:
+        source = v05_label.image_label.source
+        if source is None:
+            image_label_source = None
+        else:
+            source = v05_label.image_label.source
+            if source is None:
+                image_label_source = None
+            else:
+                image_label_source = source.image
+            image_label_source = ImageLabelSource(
+                version="0.5",
+                source={"image": image_label_source},
+            )
+    else:
+        image_label_source = None
+    name = v05_multiscale.name
+    if name is not None and not isinstance(name, str):
+        name = str(name)
+
+    return True, NgioLabelMeta(
+        version="0.5",
+        name=name,
+        datasets=datasets,
+        image_label=image_label_source,
+    )
+
+
+def _ngio_to_v05_multiscale(name: str | None, datasets: list[Dataset]) -> MultiscaleV05:
+    """Convert a ngio multiscale to a v05 multiscale.
+
+    Args:
+        name (str | None): The name of the multiscale.
+        datasets (list[Dataset]): The ngio datasets.
+
+    Returns:
+        MultiscaleV05: The v05 multiscale.
+    """
+    ax_mapper = datasets[0].axes_handler
+    v05_axes = []
+    for axis in ax_mapper.axes:
+        v05_axes.append(
+            AxisV05(
+                name=axis.name,
+                type=axis.axis_type.value if axis.axis_type is not None else None,
+                unit=axis.unit if axis.unit is not None else None,
+            )
+        )
+
+    v05_datasets = []
+    for dataset in datasets:
+        transform = [VectorScaleV05(type="scale", scale=list(dataset._scale))]
+        if sum(dataset._translation) > 0:
+            transform = (
+                VectorScaleV05(type="scale", scale=list(dataset._scale)),
+                VectorTranslationV05(
+                    type="translation", translation=list(dataset._translation)
+                ),
+            )
+        else:
+            transform = (VectorScaleV05(type="scale", scale=list(dataset._scale)),)
+
+        v05_datasets.append(
+            DatasetV05(path=dataset.path, coordinateTransformations=transform)
+        )
+    return MultiscaleV05(axes=v05_axes, datasets=tuple(v05_datasets), name=name)
+
+
+def _ngio_to_v05_omero(channels: ChannelsMeta | None) -> OmeroV05 | None:
+    """Convert a ngio channels to a v05 omero."""
+    if channels is None:
+        return None
+
+    v05_channels = []
+    for channel in channels.channels:
+        _model_extra = {
+            "label": channel.label,
+            "wavelength_id": channel.wavelength_id,
+            "active": channel.channel_visualisation.active,
+        }
+        if channel.channel_visualisation.model_extra is not None:
+            _model_extra.update(channel.channel_visualisation.model_extra)
+
+        v05_channels.append(
+            ChannelV05(
+                color=channel.channel_visualisation.valid_color,
+                window=WindowV05(
+                    start=channel.channel_visualisation.start,
+                    end=channel.channel_visualisation.end,
+                    min=channel.channel_visualisation.min,
+                    max=channel.channel_visualisation.max,
+                ),
+                **_model_extra,
+            )
+        )
+
+    _model_extra = channels.model_extra if channels.model_extra is not None else {}
+    return OmeroV05(channels=v05_channels, **_model_extra)
+
+
+def ngio_to_v05_image_meta(metadata: NgioImageMeta) -> dict:
+    """Convert a ngio image metadata to a v05 image metadata.
+
+    Args:
+        metadata (NgioImageMeta): The ngio image metadata.
+
+    Returns:
+        dict: The v05 image metadata.
+    """
+    v05_muliscale = _ngio_to_v05_multiscale(
+        name=metadata.name, datasets=metadata.datasets
+    )
+    v05_omero = _ngio_to_v05_omero(metadata._channels_meta)
+
+    v05_image_attrs = ImageV05AttrsWithOmero(
+        multiscales=[v05_muliscale], omero=v05_omero, version="0.5"
+    )
+    v05_image = ImageV05WithOmero(
+        ome=v05_image_attrs,
+    )
+    return v05_image.model_dump(exclude_none=True, by_alias=True)
+
+
+def ngio_to_v05_label_meta(metadata: NgioLabelMeta) -> dict:
+    """Convert a ngio image metadata to a v05 image metadata.
+
+    Args:
+        metadata (NgioImageMeta): The ngio image metadata.
+
+    Returns:
+        dict: The v05 image metadata.
+    """
+    v05_muliscale = _ngio_to_v05_multiscale(
+        name=metadata.name, datasets=metadata.datasets
+    )
+    labels_meta = {
+        "multiscales": [v05_muliscale],
+        "image-label": metadata.image_label.model_dump(),
+    }
+    v05_label = LabelAttrsV05(**labels_meta, version="0.5")
+    v05_label = ImageLabelV05(
+        ome=v05_label,
+    )
+    return v05_label.model_dump(exclude_none=True, by_alias=True)
+
+
+class WellV05(BaseModel):
+    ome: WellAttrsV05
+
+
+class HCSV05(BaseModel):
+    ome: HCSAttrsV05
+
+
+def v05_to_ngio_well_meta(
+    metadata: dict,
+) -> tuple[bool, NgioWellMeta | ValidationError]:
+    """Convert a v05 well metadata to a ngio well metadata.
+
+    Args:
+        metadata (dict): The v05 well metadata.
+
+    Returns:
+        result (bool): True if the conversion was successful, False otherwise.
+        ngio_well_meta (NgioWellMeta): The ngio well metadata.
+    """
+    try:
+        v05_well = WellV05(**metadata)
+    except ValidationError as e:
+        return False, e
+
+    return True, NgioWellMeta(**v05_well.ome.model_dump())
+
+
+def v05_to_ngio_plate_meta(
+    metadata: dict,
+) -> tuple[bool, NgioPlateMeta | ValidationError]:
+    """Convert a v05 plate metadata to a ngio plate metadata.
+
+    Args:
+        metadata (dict): The v05 plate metadata.
+
+    Returns:
+        result (bool): True if the conversion was successful, False otherwise.
+        ngio_plate_meta (NgioPlateMeta): The ngio plate metadata.
+    """
+    try:
+        v05_plate = HCSV05(**metadata)
+    except ValidationError as e:
+        return False, e
+
+    return True, NgioPlateMeta(**v05_plate.ome.model_dump())
+
+
+def ngio_to_v05_well_meta(metadata: NgioWellMeta) -> dict:
+    """Convert a ngio well metadata to a v05 well metadata.
+
+    Args:
+        metadata (NgioWellMeta): The ngio well metadata.
+
+    Returns:
+        dict: The v05 well metadata.
+    """
+    v05_well = WellAttrsV05(**metadata.model_dump())
+    v05_well = WellV05(ome=v05_well)
+    return v05_well.model_dump(exclude_none=True, by_alias=True)
+
+
+def ngio_to_v05_plate_meta(metadata: NgioPlateMeta) -> dict:
+    """Convert a ngio plate metadata to a v05 plate metadata.
+
+    Args:
+        metadata (NgioPlateMeta): The ngio plate metadata.
+
+    Returns:
+        dict: The v05 plate metadata.
+    """
+    v05_plate = HCSAttrsV05(**metadata.model_dump())
+    v05_plate = HCSV05(ome=v05_plate)
+    return v05_plate.model_dump(exclude_none=True, by_alias=True)

ngio/tables/_tables_container.py

@@ -359,7 +359,7 @@ ImplementedTables().add_implementation(ConditionTableV1)
 def open_tables_container(
     store: StoreOrGroup,
     cache: bool = False,
-    mode: AccessModeLiteral = "r+",
+    mode: AccessModeLiteral = "a",
     parallel_safe: bool = False,
 ) -> TablesContainer:
     """Open a table handler from a Zarr store."""
@@ -373,7 +373,7 @@ def open_table(
     store: StoreOrGroup,
     backend: TableBackend | None = None,
     cache: bool = False,
-    mode: AccessModeLiteral = "r+",
+    mode: AccessModeLiteral = "a",
     parallel_safe: bool = False,
 ) -> Table:
     """Open a table from a Zarr store."""
@@ -391,7 +391,7 @@ def open_table_as(
     table_cls: type[TableType],
     backend: TableBackend | None = None,
     cache: bool = False,
-    mode: AccessModeLiteral = "r+",
+    mode: AccessModeLiteral = "a",
     parallel_safe: bool = False,
 ) -> TableType:
     """Open a table from a Zarr store as a specific type."""

ngio/tables/backends/_abstract_backend.py

@@ -198,6 +198,13 @@ class AbstractTableBackend(ABC):
         if metadata is None:
             metadata = {}
 
+        attrs = self._group_handler.reopen_group().attrs.asdict()
+        # This is required by anndata to identify the format
+        if "encoding-type" in attrs:
+            metadata["encoding-type"] = attrs["encoding-type"]
+        if "encoding-version" in attrs:
+            metadata["encoding-version"] = attrs["encoding-version"]
+
         backend_metadata = BackendMeta(
             backend=self.backend_name(),
             index_key=self.index_key,

ngio/tables/backends/_anndata.py

@@ -1,4 +1,5 @@
 from anndata import AnnData
+from anndata._settings import settings
 from pandas import DataFrame
 from polars import DataFrame as PolarsDataFrame
 from polars import LazyFrame
@@ -40,6 +41,7 @@ class AnnDataBackend(AbstractTableBackend):
 
     def load_as_anndata(self) -> AnnData:
         """Load the table as an AnnData object."""
+        settings.zarr_write_format = self._group_handler.zarr_format
         anndata = custom_anndata_read_zarr(self._group_handler._group)
         anndata = normalize_anndata(anndata, index_key=self.index_key)
         return anndata
@@ -58,7 +60,8 @@ class AnnDataBackend(AbstractTableBackend):
                 "Please make sure to use a compatible "
                 "store like a zarr.DirectoryStore."
             )
-        table.write_zarr(full_url)  # type: ignore (AnnData writer requires a str path)
+        settings.zarr_write_format = self._group_handler.zarr_format
+        table.write_zarr(full_url)
 
     def write_from_pandas(self, table: DataFrame) -> None:
         """Serialize the table from a pandas DataFrame."""

ngio/tables/backends/_anndata_utils.py

@@ -9,6 +9,7 @@ from anndata._io.utils import _read_legacy_raw
 from anndata._io.zarr import read_dataframe
 from anndata.compat import _clean_uns
 from anndata.experimental import read_dispatched
+from zarr.storage import LocalStore
 
 from ngio.utils import (
     NgioValueError,
@@ -35,7 +36,7 @@ def custom_anndata_read_zarr(
     """
     group = open_group_wrapper(store=store, mode="r")
 
-    if not isinstance(group.store, zarr.DirectoryStore):
+    if not isinstance(group.store, LocalStore):
         elem_to_read = ["X", "obs", "var"]
 
     if elem_to_read is None:
@@ -87,6 +88,8 @@ def custom_anndata_read_zarr(
     if isinstance(group["obs"], zarr.Array):
         _clean_uns(adata)
 
+    if isinstance(adata, dict):
+        adata = AnnData(**adata)
     if not isinstance(adata, AnnData):
         raise NgioValueError(f"Expected an AnnData object, but got {type(adata)}")
     return adata

ngio/tables/backends/_non_zarr_backends.py

@@ -5,7 +5,7 @@ from typing import Any
 from pandas import DataFrame
 from polars import DataFrame as PolarsDataFrame
 from polars import LazyFrame
-from zarr.storage import DirectoryStore, FSStore
+from zarr.storage import FsspecStore, LocalStore
 
 from ngio.tables.backends._abstract_backend import AbstractTableBackend
 from ngio.tables.backends._utils import normalize_pandas_df, normalize_polars_lf
@@ -88,9 +88,9 @@ class NonZarrBaseBackend(AbstractTableBackend):
     def load_as_pandas_df(self) -> DataFrame:
         """Load the table as a pandas DataFrame."""
         store = self._group_handler.store
-        if isinstance(store, DirectoryStore):
+        if isinstance(store, LocalStore):
             dataframe = self._load_from_directory_store(reader=self.df_reader)
-        elif isinstance(store, FSStore):
+        elif isinstance(store, FsspecStore):
             dataframe = self._load_from_fs_store_df(reader=self.df_reader)
         else:
             ext = self.table_name.split(".")[-1]
@@ -117,9 +117,9 @@ class NonZarrBaseBackend(AbstractTableBackend):
     def load_as_polars_lf(self) -> LazyFrame:
         """Load the table as a polars LazyFrame."""
         store = self._group_handler.store
-        if isinstance(store, DirectoryStore):
+        if isinstance(store, LocalStore):
             lazy_frame = self._load_from_directory_store(reader=self.lf_reader)
-        elif isinstance(store, FSStore):
+        elif isinstance(store, FsspecStore):
             lazy_frame = self._load_from_fs_store_lf(reader=self.lf_reader)
         else:
             ext = self.table_name.split(".")[-1]
@@ -146,7 +146,7 @@ class NonZarrBaseBackend(AbstractTableBackend):
     def _get_store_url(self) -> str:
         """Get the store URL."""
         store = self._group_handler.store
-        if isinstance(store, DirectoryStore):
+        if isinstance(store, LocalStore):
             full_url = self._group_handler.full_url
         else:
             ext = self.table_name.split(".")[-1]

ngio/tables/backends/_utils.py

@@ -403,7 +403,7 @@ def convert_anndata_to_pandas(
         DataFrame: Converted and normalized pandas DataFrame.
     """
     pandas_df = anndata.to_df()
-    pandas_df[anndata.obs_keys()] = anndata.obs
+    pandas_df[anndata.obs.columns.to_list()] = anndata.obs
     pandas_df = normalize_pandas_df(
         pandas_df,
         index_key=index_key,

ngio/tables/v1/_roi_table.py

@@ -86,10 +86,10 @@ def _dataframe_to_rois(
 ) -> dict[str, Roi]:
     """Convert a DataFrame to a WorldCooROI object."""
     # Validate the columns of the DataFrame
-    _missing_columns = set(required_columns).difference(set(dataframe.columns))
-    if len(_missing_columns) != 0:
+    _required_columns = set(dataframe.columns).intersection(set(required_columns))
+    if len(_required_columns) != len(required_columns):
         raise NgioTableValidationError(
-            f"Could not find required columns: {_missing_columns} in the table."
+            f"Could not find required columns: {_required_columns} in the table."
         )
 
     extra_columns = set(dataframe.columns).difference(

ngio/utils/_datasets.py

@@ -155,11 +155,5 @@ def download_ome_zarr_dataset(
         path=download_dir,
         processor=processor,
         progressbar=progressbar,
-        # Add User-Agent to avoid 403 errors from Zenodo
-        downloader=pooch.HTTPDownloader(
-            headers={
-                "User-Agent": f"pooch/{pooch.__version__} (https://github.com/BioVisionCenter/ngio)"
-            }
-        ),
     )
     return processor.output_file()