satdatakit 0.1.0__py3-none-any.whl

satdatakit/__init__.py

@@ -0,0 +1,14 @@
+"""SatDataKit - Unified satellite data analysis toolkit.
+
+Author: Rafael Cañete Vazquez
+License: MIT
+"""
+__version__ = "0.1.0"
+__author__ = "Rafael Cañete Vazquez"
+
+from satdatakit.core import SatelliteDataset
+from satdatakit.io import read, read_collection
+from satdatakit.indices import compute_index
+from satdatakit.pipeline import Pipeline
+
+__all__ = ["SatelliteDataset", "read", "read_collection", "compute_index", "Pipeline"]

satdatakit/core.py

@@ -0,0 +1,233 @@
+"""Core data model: SatelliteDataset.
+
+Author: Rafael Cañete Vazquez
+License: MIT
+"""
+from __future__ import annotations
+
+import warnings
+from dataclasses import dataclass, field
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict, List, Optional, Tuple, Union
+
+import numpy as np
+import pandas as pd
+import xarray as xr
+from shapely.geometry import box
+
+
+@dataclass
+class SatelliteDataset:
+    """Universal container for Earth Observation data."""
+
+    data: xr.DataArray
+    bands: List[str]
+    crs: Optional[str] = None
+    resolution: Optional[Tuple[float, float]] = None
+    bounds: Optional[Tuple[float, float, float, float]] = None
+    datetime: Optional[Union[datetime, List[datetime]]] = None
+    sensor: Optional[str] = None
+    platform: Optional[str] = None
+    cloud_cover: Optional[float] = None
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    source_format: Optional[str] = None
+    source_path: Optional[Path] = None
+
+    def __post_init__(self) -> None:
+        self._validate_data()
+        self._normalize_bands()
+
+    def _validate_data(self) -> None:
+        dims = list(self.data.dims)
+        if "band" not in dims:
+            raise ValueError(f"DataArray must have 'band' dimension. Got: {dims}")
+        if "y" not in dims or "x" not in dims:
+            raise ValueError(f"DataArray must have 'y' and 'x' dimensions. Got: {dims}")
+        n_bands = self.data.sizes["band"]
+        if n_bands != len(self.bands):
+            warnings.warn(f"Band count mismatch: {n_bands} vs {len(self.bands)}", UserWarning)
+            self.bands = [f"band_{i}" for i in range(n_bands)]
+
+    def _normalize_bands(self) -> None:
+        self.bands = [str(b) for b in self.bands]
+        seen = set()
+        for i, name in enumerate(self.bands):
+            if name in seen:
+                self.bands[i] = f"{name}_{i}"
+            seen.add(self.bands[i])
+
+    @property
+    def shape(self) -> Tuple[int, ...]:
+        return tuple(self.data.sizes[d] for d in self.data.dims)
+
+    @property
+    def n_bands(self) -> int:
+        return self.data.sizes["band"]
+
+    @property
+    def width(self) -> int:
+        return self.data.sizes["x"]
+
+    @property
+    def height(self) -> int:
+        return self.data.sizes["y"]
+
+    @property
+    def dtype(self):
+        """Return data type."""
+        return self.data.dtype
+
+    def __getitem__(self, key: Union[str, int]) -> xr.DataArray:
+        if isinstance(key, str):
+            if key not in self.bands:
+                raise KeyError(f"Band '{key}' not found. Available: {self.bands}")
+            idx = self.bands.index(key)
+        elif isinstance(key, int):
+            idx = key
+        else:
+            raise TypeError(f"Key must be str or int, got {type(key)}")
+        return self.data.isel(band=idx)
+
+    def get_bands(self, names: List[str]) -> "SatelliteDataset":
+        indices = [self.bands.index(n) for n in names if n in self.bands]
+        new_data = self.data.isel(band=indices)
+        return SatelliteDataset(
+            data=new_data, bands=[self.bands[i] for i in indices],
+            crs=self.crs, resolution=self.resolution, bounds=self.bounds,
+            datetime=self.datetime, sensor=self.sensor, platform=self.platform,
+            cloud_cover=self.cloud_cover, metadata=self.metadata.copy(),
+            source_format=self.source_format, source_path=self.source_path)
+
+    def to_numpy(self) -> np.ndarray:
+        return self.data.values
+
+    def to_xarray(self) -> xr.DataArray:
+        return self.data
+
+    def to_dataset(self) -> xr.Dataset:
+        datasets = {b: self.data.isel(band=i).drop_vars("band")
+                    for i, b in enumerate(self.bands)}
+        ds = xr.Dataset(datasets)
+        if self.crs:
+            ds.attrs["crs"] = self.crs
+        return ds
+
+    def add_band(self, name: str, data: Union[np.ndarray, xr.DataArray]) -> "SatelliteDataset":
+        if name in self.bands:
+            raise ValueError(f"Band '{name}' already exists.")
+        if isinstance(data, np.ndarray):
+            data = xr.DataArray(data, dims=["y", "x"])
+        data = data.expand_dims(band=[name])
+        new_data = xr.concat([self.data, data], dim="band")
+        return SatelliteDataset(
+            data=new_data, bands=self.bands + [name], crs=self.crs,
+            resolution=self.resolution, bounds=self.bounds,
+            datetime=self.datetime, sensor=self.sensor, platform=self.platform,
+            cloud_cover=self.cloud_cover, metadata=self.metadata.copy(),
+            source_format=self.source_format, source_path=self.source_path)
+
+    def remove_band(self, name: str) -> "SatelliteDataset":
+        if name not in self.bands:
+            raise KeyError(f"Band '{name}' not found.")
+        idx = self.bands.index(name)
+        new_data = self.data.drop_isel(band=idx)
+        return SatelliteDataset(
+            data=new_data, bands=[b for b in self.bands if b != name],
+            crs=self.crs, resolution=self.resolution, bounds=self.bounds,
+            datetime=self.datetime, sensor=self.sensor, platform=self.platform,
+            cloud_cover=self.cloud_cover, metadata=self.metadata.copy(),
+            source_format=self.source_format, source_path=self.source_path)
+
+    def rename_bands(self, mapping: Dict[str, str]) -> "SatelliteDataset":
+        new_bands = [mapping.get(b, b) for b in self.bands]
+        new_data = self.data.copy()
+        new_data = new_data.assign_coords(band=new_bands)
+        return SatelliteDataset(
+            data=new_data, bands=new_bands, crs=self.crs,
+            resolution=self.resolution, bounds=self.bounds,
+            datetime=self.datetime, sensor=self.sensor, platform=self.platform,
+            cloud_cover=self.cloud_cover, metadata=self.metadata.copy(),
+            source_format=self.source_format, source_path=self.source_path)
+
+    def reproject(self, dst_crs: Union[str, int], **kwargs) -> "SatelliteDataset":
+        import rioxarray
+        if self.crs is None:
+            raise ValueError("Source CRS is not set. Cannot reproject.")
+        if self.data.rio.crs is None:
+            self.data = self.data.rio.write_crs(self.crs)
+        reprojected = self.data.rio.reproject(dst_crs, **kwargs)
+        new_bounds = reprojected.rio.bounds()
+        return SatelliteDataset(
+            data=reprojected, bands=self.bands.copy(), crs=str(dst_crs),
+            resolution=self.resolution, bounds=new_bounds,
+            datetime=self.datetime, sensor=self.sensor, platform=self.platform,
+            cloud_cover=self.cloud_cover, metadata=self.metadata.copy(),
+            source_format=self.source_format, source_path=self.source_path)
+
+    def resample(self, resolution: Union[float, Tuple[float, float]], **kwargs) -> "SatelliteDataset":
+        if self.crs is None:
+            raise ValueError("CRS must be set to resample.")
+        return self.reproject(dst_crs=self.crs, resolution=resolution, **kwargs)
+
+    def clip(self, geometry, crs=None, drop=True, **kwargs) -> "SatelliteDataset":
+        import rioxarray
+        if self.data.rio.crs is None and self.crs is not None:
+            self.data = self.data.rio.write_crs(self.crs)
+        clipped = self.data.rio.clip([geometry], crs=crs, drop=drop, all_touched=True, **kwargs)
+        new_bounds = clipped.rio.bounds()
+        return SatelliteDataset(
+            data=clipped, bands=self.bands.copy(), crs=self.crs,
+            resolution=self.resolution, bounds=new_bounds,
+            datetime=self.datetime, sensor=self.sensor, platform=self.platform,
+            cloud_cover=self.cloud_cover, metadata=self.metadata.copy(),
+            source_format=self.source_format, source_path=self.source_path)
+
+    def mask(self, mask_array: np.ndarray, fill_value: float = np.nan) -> "SatelliteDataset":
+        if mask_array.shape != self.data.shape[-2:]:
+            raise ValueError(f"Mask shape {mask_array.shape} does not match data spatial shape {self.data.shape[-2:]}")
+        masked_data = self.data.where(mask_array, fill_value)
+        return SatelliteDataset(
+            data=masked_data, bands=self.bands.copy(), crs=self.crs,
+            resolution=self.resolution, bounds=self.bounds,
+            datetime=self.datetime, sensor=self.sensor, platform=self.platform,
+            cloud_cover=self.cloud_cover, metadata=self.metadata.copy(),
+            source_format=self.source_format, source_path=self.source_path)
+
+    def to_geotiff(self, path: Union[str, Path], **kwargs) -> None:
+        import rioxarray
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        data = self.data
+        if data.rio.crs is None and self.crs is not None:
+            data = data.rio.write_crs(self.crs)
+        data.rio.to_raster(path, **kwargs)
+
+    def to_netcdf(self, path: Union[str, Path], **kwargs) -> None:
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        self.to_dataset().to_netcdf(path, **kwargs)
+
+    def __repr__(self) -> str:
+        return f"SatelliteDataset(shape={self.shape}, bands={self.bands}, crs={self.crs!r})"
+
+    def info(self) -> str:
+        lines = [
+            "=" * 50,
+            "SatelliteDataset Information",
+            "=" * 50,
+            f"Shape:        {self.shape}",
+            f"Bands:        {self.n_bands} ({self.bands})",
+            f"Width:        {self.width} px",
+            f"Height:       {self.height} px",
+            f"CRS:          {self.crs}",
+            f"Resolution:   {self.resolution}",
+            f"Bounds:       {self.bounds}",
+            f"Sensor:       {self.sensor}",
+            f"Platform:     {self.platform}",
+            f"Datetime:     {self.datetime}",
+            f"Cloud cover:  {self.cloud_cover}%",
+            f"Dtype:        {self.dtype}",
+            "=" * 50,
+        ]
+        return "\n".join(lines)

satdatakit/extensions/__init__.py

@@ -0,0 +1,26 @@
+"""SatDataKit extensions — optional add-ons for scalability.
+
+Extensions load on demand and do not modify core code.
+"""
+
+__version__ = "0.1.0"
+
+
+def list_extensions():
+    """Return available extensions."""
+    return ["dask", "stac", "zarr"]
+
+
+def enable(extension: str):
+    """Activate an extension by name."""
+    if extension == "dask":
+        from .dask_ext import enable_dask
+        enable_dask()
+    elif extension == "stac":
+        from .stac_ext import enable_stac
+        enable_stac()
+    elif extension == "zarr":
+        from .zarr_ext import enable_zarr
+        enable_zarr()
+    else:
+        raise ValueError(f"Unknown extension: {extension}. Available: {list_extensions()}")

satdatakit/extensions/dask_ext.py

@@ -0,0 +1,157 @@
+"""Dask extension for SatDataKit — parallel processing.
+
+Usage:
+    from satdatakit.extensions.dask_ext import enable_dask, read_dask
+    enable_dask()
+    
+    ds = read_dask(["file.tif"], chunks={"x": 1024})
+    ds = ds.to_dask(chunks={"x": 256})
+    ds = compute_index(ds, "NDVI")
+    ds = ds.compute()
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, List, Optional, Union
+
+import numpy as np
+import xarray as xr
+
+from satdatakit.core import SatelliteDataset
+
+
+def _check_dask():
+    """Verify Dask is installed."""
+    try:
+        import dask.array as da
+        from dask.distributed import Client
+    except ImportError:
+        raise ImportError(
+            "Dask not installed. Run: pip install satdatakit[dask]"
+        ) from None
+
+
+def enable_dask():
+    """Activate Dask backend. Monkey-patches SatelliteDataset safely."""
+    _check_dask()
+
+    # --- Monkey patch: SatelliteDataset.to_dask ---
+    def to_dask(self: SatelliteDataset, chunks: Optional[dict] = None) -> SatelliteDataset:
+        """Convert data to Dask lazy arrays."""
+        import dask.array as da
+        
+        if chunks is None:
+            chunks = {"x": 1024, "y": 1024}
+        if not isinstance(self.data.data, da.Array):
+            new_data = self.data.chunk(chunks)
+            return SatelliteDataset(
+                data=new_data,
+                bands=self.bands.copy(),
+                crs=self.crs,
+                resolution=self.resolution,
+                bounds=self.bounds,
+                datetime=self.datetime,
+                sensor=self.sensor,
+                platform=self.platform,
+                cloud_cover=self.cloud_cover,
+                metadata=self.metadata.copy(),
+                source_format=self.source_format,
+                source_path=self.source_path,
+            )
+        return self
+
+    SatelliteDataset.to_dask = to_dask
+
+    # --- Monkey patch: SatelliteDataset.compute ---
+    def compute(self: SatelliteDataset) -> SatelliteDataset:
+        """Trigger Dask computation and return in-memory dataset."""
+        import dask.array as da
+        
+        if isinstance(self.data.data, da.Array):
+            new_data = self.data.compute()
+            return SatelliteDataset(
+                data=new_data,
+                bands=self.bands.copy(),
+                crs=self.crs,
+                resolution=self.resolution,
+                bounds=self.bounds,
+                datetime=self.datetime,
+                sensor=self.sensor,
+                platform=self.platform,
+                cloud_cover=self.cloud_cover,
+                metadata=self.metadata.copy(),
+                source_format=self.source_format,
+                source_path=self.source_path,
+            )
+        return self
+
+    SatelliteDataset.compute = compute
+
+    print("✅ Dask extension enabled:")
+    print("   - ds.to_dask(chunks={...})")
+    print("   - ds.compute()")
+
+
+def disable_dask():
+    """Remove Dask patches."""
+    if hasattr(SatelliteDataset, "to_dask"):
+        delattr(SatelliteDataset, "to_dask")
+    if hasattr(SatelliteDataset, "compute"):
+        delattr(SatelliteDataset, "compute")
+    print("✅ Dask extension disabled")
+
+
+def read_dask(
+    paths: List[Union[str, Path]],
+    bands: Optional[List[str]] = None,
+    chunks: Optional[dict] = None,
+    concat_dim: str = "time",
+    **kwargs: Any,
+) -> SatelliteDataset:
+    """
+    Read multiple files as lazy Dask dataset.
+    
+    Usage:
+        from satdatakit.extensions.dask_ext import read_dask
+        ds = read_dask(["file1.tif", "file2.tif"], chunks={"x": 1024})
+    """
+    _check_dask()
+    
+    import dask.array as da
+    import rioxarray
+
+    if chunks is None:
+        chunks = {"x": 1024, "y": 1024}
+
+    datasets = []
+    for p in paths:
+        ds = rioxarray.open_rasterio(p, chunks=chunks)
+        datasets.append(ds)
+
+    if len(datasets) == 1:
+        stacked = datasets[0]
+    else:
+        stacked = xr.concat(datasets, dim=concat_dim)
+
+    # Extraer nombres de bandas correctamente
+    band_names = []
+    if "band" in stacked.coords:
+        band_names = [str(b) for b in stacked.coords["band"].values]
+    else:
+        band_names = [f"band_{i}" for i in range(stacked.sizes["band"])]
+
+    return SatelliteDataset(
+        data=stacked,
+        bands=band_names,
+        crs=stacked.rio.crs.to_string() if hasattr(stacked, "rio") else None,
+        resolution=None,
+        bounds=None,
+        datetime=None,
+        sensor=None,
+        platform=None,
+        cloud_cover=None,
+        metadata={},
+        source_format="dask",
+        source_path=Path(paths[0]) if paths else None,
+    )

satdatakit/extensions/stac_ext.py

@@ -0,0 +1,74 @@
+"""STAC extension for SatDataKit — cloud catalog access.
+
+Usage:
+    from satdatakit.extensions.stac_ext import enable_stac
+    enable_stac()
+    
+    ds = satdatakit.read_stac(
+        catalog_url="https://earth-search.aws.element84.com/v1",
+        collection="sentinel-2-l2a",
+        bbox=(-100, 25, -99, 26),
+        datetime_range="2024-01-01/2024-06-01"
+    )
+"""
+
+from __future__ import annotations
+
+from typing import Any, List, Optional, Tuple, Union
+
+
+def enable_stac():
+    """Activate STAC backend."""
+    try:
+        import pystac
+        import pystac_client
+        import stackstac
+    except ImportError:
+        raise ImportError(
+            "STAC dependencies not installed. Run: pip install satdatakit[stac]"
+        ) from None
+
+    from satdatakit.core import SatelliteDataset
+
+    def read_stac(
+        catalog_url: str,
+        collection: str,
+        bbox: Tuple[float, float, float, float],
+        datetime_range: str,
+        bands: Optional[List[str]] = None,
+        **kwargs: Any,
+    ) -> SatelliteDataset:
+        """Search and read from STAC catalog."""
+        catalog = pystac_client.Client.open(catalog_url)
+        search = catalog.search(
+            collections=[collection],
+            bbox=bbox,
+            datetime=datetime_range,
+        )
+        items = list(search.get_items())
+        
+        if not items:
+            raise ValueError("No items found for query")
+
+        data = stackstac.stack(items, assets=bands, **kwargs)
+
+        return SatelliteDataset(
+            data=data,
+            bands=bands or list(data.coords["band"].values),
+            crs="EPSG:4326",
+            source_format="stac",
+        )
+
+    import satdatakit
+    satdatakit.read_stac = read_stac
+
+    print("✅ STAC extension enabled:")
+    print("   - satdatakit.read_stac(catalog_url=..., collection=...)")
+
+
+def disable_stac():
+    """Remove STAC patches."""
+    import satdatakit
+    if hasattr(satdatakit, "read_stac"):
+        delattr(satdatakit, "read_stac")
+    print("✅ STAC extension disabled")

satdatakit/extensions/zarr_ext.py

@@ -0,0 +1,89 @@
+"""Zarr extension for SatDataKit — cloud-native format.
+
+Usage:
+    from satdatakit.extensions.zarr_ext import enable_zarr
+    enable_zarr()
+    
+    ds = satdatakit.read_zarr("s3://bucket/dataset.zarr")
+    ds.to_zarr("/local/output.zarr")
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Optional, Union
+
+
+def enable_zarr():
+    """Activate Zarr backend."""
+    try:
+        import zarr
+    except ImportError:
+        raise ImportError(
+            "Zarr not installed. Run: pip install satdatakit[zarr]"
+        ) from None
+
+    from satdatakit.core import SatelliteDataset
+
+    # --- Monkey patch: SatelliteDataset.to_zarr ---
+    def to_zarr(self: SatelliteDataset, path: Union[str, Path], **kwargs: Any) -> None:
+        """Export dataset to Zarr format."""
+        ds = self.to_dataset()
+        ds.to_zarr(path, **kwargs)
+
+    SatelliteDataset.to_zarr = to_zarr
+
+    # --- Global function: read_zarr ---
+    def read_zarr(path: Union[str, Path], **kwargs: Any) -> SatelliteDataset:
+        """Read Zarr store into SatelliteDataset."""
+        import xarray as xr
+
+        ds = xr.open_zarr(path, **kwargs)
+        
+        # Detectar variables espaciales
+        spatial_vars = []
+        for name, var in ds.data_vars.items():
+            if any(d in var.dims for d in ["x", "y", "lon", "lat"]):
+                spatial_vars.append(name)
+
+        if not spatial_vars:
+            raise ValueError("No spatial variables found in Zarr store")
+
+        # Convertir a DataArray con dimensión band
+        data_arrays = []
+        for var in spatial_vars:
+            da = ds[var]
+            if "band" not in da.dims:
+                da = da.expand_dims(band=[var])
+            data_arrays.append(da)
+
+        if len(data_arrays) == 1:
+            data = data_arrays[0]
+        else:
+            data = xr.concat(data_arrays, dim="band")
+
+        return SatelliteDataset(
+            data=data,
+            bands=spatial_vars,
+            crs=ds.attrs.get("crs"),
+            source_format="zarr",
+            source_path=Path(path),
+        )
+
+    import satdatakit
+    satdatakit.read_zarr = read_zarr
+
+    print("✅ Zarr extension enabled:")
+    print("   - satdatakit.read_zarr(path)")
+    print("   - ds.to_zarr(path)")
+
+
+def disable_zarr():
+    """Remove Zarr patches."""
+    from satdatakit.core import SatelliteDataset
+    if hasattr(SatelliteDataset, "to_zarr"):
+        delattr(SatelliteDataset, "to_zarr")
+    import satdatakit
+    if hasattr(satdatakit, "read_zarr"):
+        delattr(satdatakit, "read_zarr")
+    print("✅ Zarr extension disabled")

satdatakit/indices.py

@@ -0,0 +1,100 @@
+"""Spectral indices computation.
+
+Author: Rafael Cañete Vazquez
+License: MIT
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Union
+
+import numpy as np
+import xarray as xr
+
+from satdatakit.core import SatelliteDataset
+
+INDEX_DEFINITIONS: Dict[str, Dict[str, Any]] = {
+    "NDVI": {
+        "name": "Normalized Difference Vegetation Index",
+        "formula": "(nir - red) / (nir + red)",
+        "bands": {"red": ["red", "B04"], "nir": ["nir", "B08"]},
+        "range": (-1, 1),
+    },
+    "NDWI": {
+        "name": "Normalized Difference Water Index",
+        "formula": "(green - nir) / (green + nir)",
+        "bands": {"green": ["green", "B03"], "nir": ["nir", "B08"]},
+        "range": (-1, 1),
+    },
+    "EVI": {
+        "name": "Enhanced Vegetation Index",
+        "formula": "2.5 * (nir - red) / (nir + 6*red - 7.5*blue + 1)",
+        "bands": {"red": ["red", "B04"], "nir": ["nir", "B08"], "blue": ["blue", "B02"]},
+        "range": (-1, 1),
+    },
+    "SAVI": {
+        "name": "Soil Adjusted Vegetation Index",
+        "formula": "(1 + L) * (nir - red) / (nir + red + L)",
+        "bands": {"red": ["red", "B04"], "nir": ["nir", "B08"]},
+        "params": {"L": 0.5},
+        "range": (-1, 1),
+    },
+}
+
+def _resolve_band_name(dataset: SatelliteDataset, candidates: List[str]) -> Optional[str]:
+    for candidate in candidates:
+        if candidate in dataset.bands:
+            return candidate
+    return None
+
+def compute_index(dataset: SatelliteDataset, index: str,
+                  band_mapping: Optional[Dict[str, str]] = None,
+                  params: Optional[Dict[str, float]] = None,
+                  add_to_dataset: bool = True, clip_range: bool = True
+                  ) -> Union[SatelliteDataset, xr.DataArray]:
+    index = index.upper()
+    if index not in INDEX_DEFINITIONS:
+        raise ValueError(f"Index '{index}' not supported.")
+    definition = INDEX_DEFINITIONS[index]
+    resolved_bands = {}
+    for canonical_name, candidates in definition["bands"].items():
+        if band_mapping and canonical_name in band_mapping:
+            actual_name = band_mapping[canonical_name]
+        else:
+            actual_name = _resolve_band_name(dataset, candidates)
+        if actual_name is None:
+            raise KeyError(f"Cannot resolve band for '{canonical_name}'.")
+        resolved_bands[canonical_name] = actual_name
+    band_data = {name: dataset[actual] for name, actual in resolved_bands.items()}
+    formula_params = definition.get("params", {}).copy()
+    if params:
+        formula_params.update(params)
+    result = _compute_formula(index, band_data, formula_params)
+    if clip_range:
+        valid_min, valid_max = definition.get("range", (-float("inf"), float("inf")))
+        result = result.clip(min=valid_min, max=valid_max)
+    result = result.where(np.isfinite(result))
+    if add_to_dataset:
+        return dataset.add_band(index, result)
+    return result
+
+def _compute_formula(index: str, bands: Dict[str, xr.DataArray], params: Dict[str, float]) -> xr.DataArray:
+    if index == "NDVI":
+        return (bands["nir"] - bands["red"]) / (bands["nir"] + bands["red"])
+    elif index == "NDWI":
+        return (bands["green"] - bands["nir"]) / (bands["green"] + bands["nir"])
+    elif index == "EVI":
+        return 2.5 * (bands["nir"] - bands["red"]) / (bands["nir"] + 6 * bands["red"] - 7.5 * bands["blue"] + 1)
+    elif index == "SAVI":
+        L = params.get("L", 0.5)
+        return (1 + L) * (bands["nir"] - bands["red"]) / (bands["nir"] + bands["red"] + L)
+    else:
+        raise ValueError(f"Formula not implemented for index: {index}")
+
+def list_indices() -> List[str]:
+    return list(INDEX_DEFINITIONS.keys())
+
+def index_info(index: str) -> Dict[str, Any]:
+    index = index.upper()
+    if index not in INDEX_DEFINITIONS:
+        raise ValueError(f"Index '{index}' not found.")
+    return INDEX_DEFINITIONS[index].copy()