satdatakit 0.1.0__tar.gz

satdatakit-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Rafael Cañete Vazquez
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

satdatakit-0.1.0/PKG-INFO

@@ -0,0 +1,165 @@
+Metadata-Version: 2.4
+Name: satdatakit
+Version: 0.1.0
+Summary: Unified satellite data analysis toolkit
+Author-email: Rafael Cañete Vazquez <rafael@satdatakit.dev>
+License: MIT
+Project-URL: Homepage, https://github.com/rafaelcanete/satdatakit
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.23.0
+Requires-Dist: xarray>=2023.1.0
+Requires-Dist: rioxarray>=0.14.0
+Requires-Dist: rasterio>=1.3.0
+Requires-Dist: netCDF4>=1.6.0
+Requires-Dist: h5py>=3.7.0
+Requires-Dist: pandas>=1.5.0
+Requires-Dist: pyproj>=3.4.0
+Requires-Dist: shapely>=2.0.0
+Requires-Dist: geopandas>=0.12.0
+Requires-Dist: pillow>=9.0.0
+Requires-Dist: python-dateutil>=2.8.0
+Requires-Dist: typing-extensions>=4.0.0
+Provides-Extra: dask
+Requires-Dist: dask[complete]>=2024.1.0; extra == "dask"
+Requires-Dist: distributed>=2024.1.0; extra == "dask"
+Provides-Extra: stac
+Requires-Dist: pystac>=1.9.0; extra == "stac"
+Requires-Dist: pystac-client>=0.7.0; extra == "stac"
+Requires-Dist: stackstac>=0.5.0; extra == "stac"
+Provides-Extra: zarr
+Requires-Dist: zarr>=2.16.0; extra == "zarr"
+Requires-Dist: fsspec>=2024.1.0; extra == "zarr"
+Provides-Extra: cloud
+Requires-Dist: satdatakit[stac,zarr]; extra == "cloud"
+Requires-Dist: s3fs>=2024.1.0; extra == "cloud"
+Provides-Extra: full
+Requires-Dist: satdatakit[cloud,dask]; extra == "full"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: ruff>=0.1.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Dynamic: license-file
+
+<p align="center">
+  <img src="satdatakit_banner.png" alt="SatDataKit Banner" width="100%">
+</p>
+
+<h1 align="center">SatDataKit</h1>
+
+<p align="center">
+  <strong>Unified satellite data analysis toolkit — one API for all Earth Observation formats.</strong>
+</p>
+
+<p align="center">
+  <a href="https://github.com/raicanvag/satdatakit/blob/main/LICENSE">
+    <img src="https://img.shields.io/badge/License-MIT-green.svg" alt="License: MIT">
+  </a>
+  <img src="https://img.shields.io/badge/Python-3.9%2B-blue.svg" alt="Python 3.9+">
+  <img src="https://img.shields.io/badge/EO-GeoTIFF%20%7C%20NetCDF%20%7C%20HDF%20%7C%20SAFE-orange.svg" alt="Formats">
+</p>
+
+---
+
+## What is SatDataKit?
+
+SatDataKit solves a real problem in the Earth Observation community: **every satellite data format has its own API**, forcing scientists to learn GDAL, NetCDF4, h5py, rasterio, and Sentinel-specific tools just to read a single image.
+
+SatDataKit **unifies all of that into one clean API**:
+
+| Format | Library needed without SatDataKit | With SatDataKit |
+|---|---|---|
+| GeoTIFF | `rasterio` + coordinate handling | `read("file.tif")` |
+| NetCDF | `xarray` + `netCDF4` + CF conventions | `read("file.nc")` |
+| HDF5 | `h5py` + dataset discovery logic | `read("file.h5")` |
+| Sentinel SAFE | `zipfile` + XML parsing + JP2 reader | `read("file.SAFE")` |
+
+**Built on the same stack NASA uses** (xarray, rioxarray, rasterio, netCDF4, h5py) but with a unified abstraction layer that eliminates boilerplate.
+
+---
+
+## Quick Start
+
+```python
+from satdatakit import read, compute_index, Pipeline
+
+# Read any format
+ds = read("sentinel2.tif")  # GeoTIFF, NetCDF, HDF, SAFE
+
+# Compute indices
+ds = compute_index(ds, "NDVI")
+
+# Pipeline
+result = (
+    Pipeline()
+    .read("data.tif")
+    .reproject("EPSG:4326")
+    .resample(30)
+    .compute_index("NDVI")
+    .to_geotiff("output.tif")
+)
+
+---
+## Installation
+
+# Docker (recommended)
+docker-compose up --build satdatakit
+
+# Or Conda
+conda env create -f environment.yml
+conda activate satdatakit
+pip install -e ".[dev]"
+
+## Optional Extensions
+
+SatDataKit core supports GeoTIFF, NetCDF, HDF5, and SAFE out of the box.
+
+For large-scale processing, install optional extensions:
+
+```bash
+# Parallel processing with Dask
+pip install satdatakit[dask]
+
+# Cloud catalogs (STAC) + Zarr format
+pip install satdatakit[cloud]
+
+# Everything (production servers)
+pip install satdatakit[full]
+
+| Extension | Command                         | Use Case                                 |
+| --------- | ------------------------------- | ---------------------------------------- |
+| **Dask**  | `pip install satdatakit[dask]`  | 10+ files, lazy chunks, parallel compute |
+| **STAC**  | `pip install satdatakit[stac]`  | Search cloud catalogs (AWS, Copernicus)  |
+| **Zarr**  | `pip install satdatakit[zarr]`  | Cloud-native format, chunked storage     |
+| **Cloud** | `pip install satdatakit[cloud]` | STAC + Zarr + S3 access                  |
+| **Full**  | `pip install satdatakit[full]`  | All extensions (servers, production)     |
+
+
+### Dask Example
+
+from satdatakit.extensions.dask_ext import enable_dask, read_dask
+
+enable_dask()
+
+# Lazy load with chunks
+ds = read_dask(["file1.tif", "file2.tif"], chunks={"x": 1024})
+
+# Compute when ready
+ds = ds.compute()
+
+
+## Features
+
+Unified API: One read() for GeoTIFF, NetCDF, HDF, SAFE
+Spectral Indices: NDVI, NDWI, EVI, SAVI, and more
+Pipeline API: Fluent, chainable operations
+Time Series: Stack multiple scenes automatically
+
+
+## License
+
+MIT License — see LICENSE for details.
+Author: Rafael Cañete Vazquez

satdatakit-0.1.0/README.md

@@ -0,0 +1,119 @@
+<p align="center">
+  <img src="satdatakit_banner.png" alt="SatDataKit Banner" width="100%">
+</p>
+
+<h1 align="center">SatDataKit</h1>
+
+<p align="center">
+  <strong>Unified satellite data analysis toolkit — one API for all Earth Observation formats.</strong>
+</p>
+
+<p align="center">
+  <a href="https://github.com/raicanvag/satdatakit/blob/main/LICENSE">
+    <img src="https://img.shields.io/badge/License-MIT-green.svg" alt="License: MIT">
+  </a>
+  <img src="https://img.shields.io/badge/Python-3.9%2B-blue.svg" alt="Python 3.9+">
+  <img src="https://img.shields.io/badge/EO-GeoTIFF%20%7C%20NetCDF%20%7C%20HDF%20%7C%20SAFE-orange.svg" alt="Formats">
+</p>
+
+---
+
+## What is SatDataKit?
+
+SatDataKit solves a real problem in the Earth Observation community: **every satellite data format has its own API**, forcing scientists to learn GDAL, NetCDF4, h5py, rasterio, and Sentinel-specific tools just to read a single image.
+
+SatDataKit **unifies all of that into one clean API**:
+
+| Format | Library needed without SatDataKit | With SatDataKit |
+|---|---|---|
+| GeoTIFF | `rasterio` + coordinate handling | `read("file.tif")` |
+| NetCDF | `xarray` + `netCDF4` + CF conventions | `read("file.nc")` |
+| HDF5 | `h5py` + dataset discovery logic | `read("file.h5")` |
+| Sentinel SAFE | `zipfile` + XML parsing + JP2 reader | `read("file.SAFE")` |
+
+**Built on the same stack NASA uses** (xarray, rioxarray, rasterio, netCDF4, h5py) but with a unified abstraction layer that eliminates boilerplate.
+
+---
+
+## Quick Start
+
+```python
+from satdatakit import read, compute_index, Pipeline
+
+# Read any format
+ds = read("sentinel2.tif")  # GeoTIFF, NetCDF, HDF, SAFE
+
+# Compute indices
+ds = compute_index(ds, "NDVI")
+
+# Pipeline
+result = (
+    Pipeline()
+    .read("data.tif")
+    .reproject("EPSG:4326")
+    .resample(30)
+    .compute_index("NDVI")
+    .to_geotiff("output.tif")
+)
+
+---
+## Installation
+
+# Docker (recommended)
+docker-compose up --build satdatakit
+
+# Or Conda
+conda env create -f environment.yml
+conda activate satdatakit
+pip install -e ".[dev]"
+
+## Optional Extensions
+
+SatDataKit core supports GeoTIFF, NetCDF, HDF5, and SAFE out of the box.
+
+For large-scale processing, install optional extensions:
+
+```bash
+# Parallel processing with Dask
+pip install satdatakit[dask]
+
+# Cloud catalogs (STAC) + Zarr format
+pip install satdatakit[cloud]
+
+# Everything (production servers)
+pip install satdatakit[full]
+
+| Extension | Command                         | Use Case                                 |
+| --------- | ------------------------------- | ---------------------------------------- |
+| **Dask**  | `pip install satdatakit[dask]`  | 10+ files, lazy chunks, parallel compute |
+| **STAC**  | `pip install satdatakit[stac]`  | Search cloud catalogs (AWS, Copernicus)  |
+| **Zarr**  | `pip install satdatakit[zarr]`  | Cloud-native format, chunked storage     |
+| **Cloud** | `pip install satdatakit[cloud]` | STAC + Zarr + S3 access                  |
+| **Full**  | `pip install satdatakit[full]`  | All extensions (servers, production)     |
+
+
+### Dask Example
+
+from satdatakit.extensions.dask_ext import enable_dask, read_dask
+
+enable_dask()
+
+# Lazy load with chunks
+ds = read_dask(["file1.tif", "file2.tif"], chunks={"x": 1024})
+
+# Compute when ready
+ds = ds.compute()
+
+
+## Features
+
+Unified API: One read() for GeoTIFF, NetCDF, HDF, SAFE
+Spectral Indices: NDVI, NDWI, EVI, SAVI, and more
+Pipeline API: Fluent, chainable operations
+Time Series: Stack multiple scenes automatically
+
+
+## License
+
+MIT License — see LICENSE for details.
+Author: Rafael Cañete Vazquez

satdatakit-0.1.0/pyproject.toml

@@ -0,0 +1,68 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "satdatakit"
+version = "0.1.0"
+description = "Unified satellite data analysis toolkit"
+readme = "README.md"
+license = {text = "MIT"}
+authors = [{name = "Rafael Cañete Vazquez", email = "rafael@satdatakit.dev"}]
+requires-python = ">=3.9"
+dependencies = [
+    "numpy>=1.23.0", "xarray>=2023.1.0", "rioxarray>=0.14.0",
+    "rasterio>=1.3.0", "netCDF4>=1.6.0", "h5py>=3.7.0",
+    "pandas>=1.5.0", "pyproj>=3.4.0", "shapely>=2.0.0",
+    "geopandas>=0.12.0", "pillow>=9.0.0",
+    "python-dateutil>=2.8.0", "typing-extensions>=4.0.0"
+]
+
+[project.optional-dependencies]
+dask = [
+    "dask[complete]>=2024.1.0",
+    "distributed>=2024.1.0",
+]
+stac = [
+    "pystac>=1.9.0",
+    "pystac-client>=0.7.0",
+    "stackstac>=0.5.0",
+]
+zarr = [
+    "zarr>=2.16.0",
+    "fsspec>=2024.1.0",
+]
+cloud = [
+    "satdatakit[stac,zarr]",
+    "s3fs>=2024.1.0",
+]
+full = [
+    "satdatakit[dask,cloud]",
+]
+
+dev = ["pytest>=7.0.0", 
+     "pytest-cov>=4.0.0", 
+     "black>=23.0.0", 
+     "ruff>=0.1.0", 
+     "mypy>=1.0.0"
+]
+
+[project.urls]
+Homepage = "https://github.com/rafaelcanete/satdatakit"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.black]
+line-length = 100
+
+[tool.ruff]
+line-length = 100
+
+[tool.mypy]
+python_version = "3.9"
+disallow_untyped_defs = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = "test_*.py"

satdatakit-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

satdatakit-0.1.0/src/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-0.1.0/src/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-0.1.0/src/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()}")