easy-eo 0.1.0__py3-none-any.whl

eeo/core/adapters/base.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any, Optional, Tuple
+
+import numpy as np
+from rasterio.coords import BoundingBox
+from rasterio.crs import CRS
+from rasterio.transform import Affine
+
+
+class BaseRasterAdapter(ABC):
+    ###########################
+    # METADATA
+    ##########################
+    @abstractmethod
+    def get_crs(self) -> CRS:
+        ...
+
+    @abstractmethod
+    def get_transform(self) -> Affine:
+        ...
+
+    @abstractmethod
+    def get_bounds(self) -> BoundingBox:
+        ...
+
+    @abstractmethod
+    def get_shape(self) -> Tuple[int, int]:
+        ...
+
+    @abstractmethod
+    def get_width(self) -> int:
+        ...
+
+    @abstractmethod
+    def get_height(self) -> int:
+        ...
+
+    @abstractmethod
+    def get_count(self) -> int:
+        ...
+
+    @abstractmethod
+    def get_nodata(self) -> Optional[float]:
+        ...
+
+    @abstractmethod
+    def get_metadata(self) -> dict[Any, Any]:
+        ...
+
+    ###########################
+    # DATA ACCESS
+    ##########################
+
+    @abstractmethod
+    def read(self, *args, **kwargs) -> np.ndarray:
+        """
+        Read the entire raster as a NumPy array
+        For multiband rasters, returns an array of shape (bands, height, width)
+        """
+        ...
+
+    @abstractmethod
+    def read_band(self, idx: int) -> np.ndarray:
+        """
+        Read a single band (1-based index).
+        """
+        ...
+
+    ###########################
+    # Persistence
+    ##########################
+    @abstractmethod
+    def write(self, path: str, driver: str = "GTiff") -> None:
+        ...
+
+
+    @abstractmethod
+    def close(self) -> None:
+        ...
+
+    ###########################
+    # BACKEND ACCESS - RETURNING THE UNDERLYING DATASET
+    ##########################
+    @property
+    @abstractmethod
+    def backend(self) -> Any:
+        """
+        Return the underlying backend object (rasterio.DatasetReader or numpy.ndarray)
+
+        WARNING: This bypasses Easy-EO abstractions
+        """
+        ...

eeo/core/adapters/numpy.py

@@ -0,0 +1,102 @@
+from typing import Optional
+
+import numpy as np
+import rasterio as rio
+from rasterio.crs import CRS
+from rasterio.transform import Affine
+
+from eeo.core.adapters import BaseRasterAdapter, RasterioAdapter
+
+
+class NumpyRasterioAdapter(BaseRasterAdapter):
+    """ Numpy backend adapter for EEORasterDataset """
+    def __init__(
+        self,
+        array: np.ndarray,
+        transform: Affine,
+        crs: CRS,
+        driver: str = "GTiff",
+        nodata: Optional[float] = None,
+    ):
+        if array.ndim == 2:
+            array = array[np.newaxis, ...]
+
+        self._array = array
+        self._transform = transform
+        self._crs = crs
+        self._nodata = nodata
+        self._driver = driver
+
+    # ========================
+    # Metadata
+    # ========================
+    def get_crs(self) -> CRS:
+        return self._crs
+
+    def get_transform(self) -> Affine:
+        return self._transform
+
+    def get_bounds(self):
+        h, w = self.get_shape()
+        return rio.transform.array_bounds(h, w, self._transform)
+
+    def get_shape(self) -> tuple[int, int]:
+        return self._array.shape[-2:]
+
+    def get_width(self) -> int:
+        return self.get_shape()[1]
+
+    def get_height(self) -> int:
+        return self.get_shape()[0]
+
+    def get_count(self) -> int:
+        return self._array.shape[0]
+
+    def get_nodata(self) -> Optional[float]:
+        return self._nodata
+
+    def get_metadata(self) -> dict:
+        return {
+            "dtype": self._array.dtype,
+            "nodata": self._nodata,
+            "transform": self._transform,
+            "crs": self._crs,
+            "driver": self._driver,
+            "count": self.get_count(),
+            "width": self.get_width(),
+            "height": self.get_height(),
+        }
+
+    # ========================
+    # Data Access
+    # ========================
+    def read(self, *args, **kwargs) -> np.ndarray:
+        return self._array
+
+    def read_band(self, idx: int) -> np.ndarray:
+        if idx < 1 or idx > self.get_count():
+            raise IndexError(f"Band index {idx} out of range")
+        return self._array[idx - 1]
+
+    # ========================
+    # Persistence
+    # ========================
+    def write(self, path: str, driver: str = "GTiff") -> None:
+        adapter = RasterioAdapter.from_array(
+            array=self._array,
+            transform=self._transform,
+            crs=self._crs,
+            nodata=self._nodata,
+        )
+        adapter.write(path, driver=driver)
+        adapter.close()
+
+    def close(self) -> None:
+        pass
+
+    # ========================
+    # Backend Access
+    # ========================
+    @property
+    def backend(self) -> np.ndarray:
+        return self._array

eeo/core/adapters/rasterio.py

@@ -0,0 +1,131 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import numpy as np
+import rasterio as rio
+from rasterio.io import DatasetReader, MemoryFile
+
+from .base import BaseRasterAdapter
+
+
+class RasterioAdapter(BaseRasterAdapter):
+    """
+    Rasterio-backend adapter for EEORasterDataset
+    """
+    def __init__(
+            self,
+            dataset: DatasetReader,
+            *,
+            memory_file: MemoryFile | None = None,
+    ) -> None:
+        self._ds = dataset
+        self._memory_file = memory_file
+
+    # ========================
+    # Factories
+    # ========================
+    @classmethod
+    def from_path(cls, path: str) -> "RasterioAdapter":
+        try:
+            dataset = rio.open(path)
+        except Exception as e:
+            raise RuntimeError(f"Failed to open raster: {path}") from e
+        return cls(dataset)
+
+    @classmethod
+    def from_array(
+            cls,
+            array: np.ndarray,
+            *,
+            transform,
+            crs,
+            nodata: Optional[float] = None,
+            dtype: Optional[str] = None,
+    ) -> "RasterioAdapter":
+        """
+        Create an in-memory adapter from a NumPy array
+        """
+        if array.ndim == 2:
+            array = array[np.newaxis, ...]
+
+        count, height, width = array.shape
+        memfile = MemoryFile()
+        dataset = memfile.open(
+            driver="GTiff",
+            height=height,
+            width=width,
+            count=count,
+            transform=transform,
+            crs=crs,
+            nodata=nodata,
+            dtype=dtype or array.dtype,
+        )
+        dataset.write(array)
+        return cls(dataset, memory_file=memfile)
+
+    # ========================
+    # Metadata
+    # ========================
+    def get_crs(self):
+        return self._ds.crs
+
+    def get_transform(self):
+        return self._ds.transform
+
+    def get_bounds(self):
+        return self._ds.bounds
+
+    def get_shape(self):
+        return self._ds.shape
+
+    def get_width(self):
+        return self._ds.width
+
+    def get_height(self):
+        return self._ds.height
+
+    def get_count(self):
+        return self._ds.count
+
+    def get_nodata(self):
+        return self._ds.nodata
+
+    def get_metadata(self):
+        return self._ds.meta.copy()
+
+    # ========================
+    # Data Access
+    # ========================
+    def read(self, *args, **kwargs) -> np.ndarray:
+        return self._ds.read(*args, **kwargs)
+
+    def read_band(self, idx: int) -> np.ndarray:
+        if idx < 1 or idx > self._ds.count:
+            raise IndexError(f"Band index {idx} out of range")
+        return self._ds.read(idx)
+
+    # ========================
+    # Persistence
+    # ========================
+    def write(self, path: str, driver: str = "GTiff") -> None:
+        meta = self._ds.meta.copy()
+        meta.update(driver=driver)
+
+        with rio.open(path, "w", **meta) as dst:
+            for i in range(1, self._ds.count + 1):
+                dst.write(self._ds.read(i), i)
+
+    def close(self) -> None:
+        try:
+            self._ds.close()
+        finally:
+            if self._memory_file is not None:
+                self._memory_file.close()
+
+    # ========================
+    # Backend Access
+    # ========================
+    @property
+    def backend(self) -> DatasetReader:
+        return self._ds

eeo/core/core.py

@@ -0,0 +1,198 @@
+"""
+Core functionalities for easy-eo
+"""
+from __future__ import annotations
+
+from typing import Union
+
+import numpy as np
+import rasterio as rio
+from rasterio import CRS
+from rasterio.transform import Affine
+
+from eeo.core.adapters import NumpyRasterioAdapter
+from eeo.core.adapters import RasterioAdapter, BaseRasterAdapter
+
+
+# IO helper
+def _save_raster(dataset: rio.DatasetReader, path: str, driver: str = "GTiff") -> None:
+    profile = dataset.profile.copy()
+    if driver != "GTiff":
+        profile.update(driver=driver)
+    with rio.open(path, mode="w", **profile) as dst:
+        dst.write(dataset.read())
+
+
+# Core class
+class EEORasterDataset:
+    def __init__(self, adapter: BaseRasterAdapter, path: str | None = None):
+        self._adapter = adapter
+        self.path = path
+
+    # ========================
+    # Constructors
+    # ========================
+    @classmethod
+    def from_path(cls, path: str) -> "EEORasterDataset":
+        adapter = RasterioAdapter.from_path(path)
+        return cls(adapter=adapter, path=path)
+
+    @classmethod
+    def from_rasterio(cls, dataset: rio.DatasetReader) -> "EEORasterDataset":
+        return cls(adapter=RasterioAdapter(dataset))
+
+    @classmethod
+    def from_array(
+            cls,
+            array: np.ndarray,
+            transform: Affine,
+            crs: Union[CRS, str, int],
+            driver: str = "GTiff",
+            nodata=None,
+    ) -> "EEORasterDataset":
+        adapter = NumpyRasterioAdapter(
+            array=array,
+            transform=transform,
+            crs=crs,
+            nodata=nodata,
+            driver=driver,
+        )
+        return cls(adapter=adapter)
+
+    # ========================
+    # Conversion between adapters
+    # ========================
+
+    def to_rasterio(self) -> "EEORasterDataset":
+        backend = self._adapter.backend
+
+        # already a rasterio backend
+        if isinstance(backend, rio.DatasetReader):
+            return self
+
+        array = self.read()
+        transform = self.get_transform()
+        crs = self.get_crs()
+        nodata = self._adapter.get_nodata()
+
+        adapter = RasterioAdapter.from_array(
+            array=array,
+            transform=transform,
+            crs=crs,
+            nodata=nodata,
+        )
+        return EEORasterDataset(adapter=adapter)
+
+    def to_array(self) -> np.ndarray:
+        return self.read()
+
+    # ========================
+    # Metadata
+    # ========================
+
+    def read(self, *args, **kwargs):
+        """Forward rasterio.read"""
+        return self._adapter.read(*args, **kwargs)
+
+    def get_crs(self):
+        return self._adapter.get_crs()
+
+    def get_transform(self):
+        return self._adapter.get_transform()
+
+    def get_shape(self):
+        return self._adapter.get_shape()
+
+    def get_bounds(self):
+        return self._adapter.get_bounds()
+
+    def get_metadata(self):
+        return self._adapter.get_metadata()
+
+    def get_width(self):
+        return self._adapter.get_width()
+
+    def get_height(self):
+        return self._adapter.get_height()
+
+    def get_count(self):
+        return self._adapter.get_count()
+
+    def get_index(self):
+        return self.ds.index
+
+    def get_band(self, idx: int) -> np.ndarray:
+        return self._adapter.read_band(idx)
+
+    # ========================
+    # Saving
+    # ========================
+    def save_raster(self, path: str, driver: str="GTiff") -> None:
+        self._adapter.write(path=path, driver=driver)
+
+    # ========================
+    # Lifecycle
+    # ========================
+    def close(self) -> None:
+        self._adapter.close()
+
+    def __del__(self):
+        try:
+            self.close()
+        except Exception:
+            pass
+
+    # ========================
+    # Constructors
+    # ========================
+    def _bind(self, func):
+        """Helper that wraps external functions as bound methods"""
+        def method(*args, **kwargs):
+            result = func(*args, **kwargs)
+            return self if result is None else result
+        return method
+
+    # ========================
+    # Adapter access
+    # ========================
+    @property
+    def ds(self):
+        return self._adapter.backend
+
+
+    # ========================
+    # Arithmetic Operators
+    # ========================
+    def __add__(self, other):
+        return self.add(other)
+
+    def __radd__(self, other):
+        return self.add(other)
+
+    def __sub__(self, other):
+        return self.subtract(other)
+
+    def __rsub__(self, other):
+        # implement for only raster - scalar
+        if isinstance(other, (int, float)):
+            return self.multiply(-1).add(other)
+        return NotImplemented
+
+    def __mul__(self, other):
+        return self.multiply(other)
+
+    def __rmul__(self, other):
+        return self.multiply(other)
+
+    def __truediv__(self, other):
+        return self.divide(other)
+
+    def __rtruediv__(self, other):
+        # implement scalar / raster
+        if isinstance(other, (int, float)):
+            return self.power(-1).multiply(other)
+        return NotImplemented
+
+    def __pow__(self, exponent):
+        return self.power(exponent)
+