pygeodata 0.0.1__tar.gz

pygeodata-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Jasper Roebroek
+
+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.

pygeodata-0.0.1/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: pygeodata
+Version: 0.0.1
+Summary: Lightweight framework for geospatial data access and processing
+Author-email: Jasper Roebroek <roebroek.jasper@gmail.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rioxarray
+Requires-Dist: geopandas
+Requires-Dist: dask
+Requires-Dist: zarr
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# pygeodata
+
+**Lightweight framework for geospatial data access and processing**
+
+`pygeodata` provides simple, composable tools for working with geospatial raster and vector data. It aims to make spatial data handling consistent, efficient, and compatible with large-scale and cloud-based workflows.
+
+## Features
+
+- Unified access to raster and vector datasets  
+- CRS-aware reprojection and alignment utilities
+- Clean, composable API designed for scientific workflows  
+
+## Installation
+
+```bash
+pip install pygeodata
+```

pygeodata-0.0.1/README.md

@@ -0,0 +1,17 @@
+# pygeodata
+
+**Lightweight framework for geospatial data access and processing**
+
+`pygeodata` provides simple, composable tools for working with geospatial raster and vector data. It aims to make spatial data handling consistent, efficient, and compatible with large-scale and cloud-based workflows.
+
+## Features
+
+- Unified access to raster and vector datasets  
+- CRS-aware reprojection and alignment utilities
+- Clean, composable API designed for scientific workflows  
+
+## Installation
+
+```bash
+pip install pygeodata
+```

pygeodata-0.0.1/pygeodata/config.py

@@ -0,0 +1,37 @@
+from contextlib import contextmanager
+from dataclasses import asdict, dataclass
+from pathlib import Path
+from typing import Any, Iterator, Optional
+
+from pygeodata.types import SpatialSpec
+
+
+@dataclass
+class Config:
+    path_data_processed: Path = Path('data_processed')
+    num_threads: int = 1
+    warp_mem_limit: int = 0  # GDAL default, indicates 64 MB
+    spec: Optional[SpatialSpec] = None
+
+    def update(self, **kwargs):
+        for key, value in kwargs.items():
+            if not hasattr(self, key):
+                raise ValueError(f'Invalid config key: {key}')
+            setattr(self, key, value)
+
+
+CONFIG = Config()
+
+
+def get_config() -> Config:
+    return CONFIG
+
+
+@contextmanager
+def set_config(**overrides: Any) -> Iterator[Config]:
+    old_values = asdict(CONFIG)
+    CONFIG.update(**overrides)
+    try:
+        yield CONFIG
+    finally:
+        CONFIG.update(**old_values)

pygeodata-0.0.1/pygeodata/drivers/__init__.py

@@ -0,0 +1,4 @@
+from pygeodata.drivers.xarray import RioXArrayDriver
+
+
+__all__ = ['RioXArrayDriver']

pygeodata-0.0.1/pygeodata/drivers/xarray.py

@@ -0,0 +1,88 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Optional
+
+import numpy as np
+import rasterio as rio
+import rioxarray as rxr
+import xarray as xr
+from rioxarray.exceptions import TooManyDimensions
+
+
+@dataclass
+class RioXArrayDriver:
+    """Load a raster file using rioxarray.
+
+    Parameters
+    ----------
+    parse_coordinates : bool, optional
+        Whether to parse coordinates
+    mask_and_scale : bool, optional
+        Whether to mask and scale. By default, this parameter is None, which causes it to be inferred from the data
+        type. Floating data will default to True, integer data to False.
+    decode_times : bool, optional
+        Whether to decode times, by default False
+    cache : bool, optional
+        Whether to cache, by default False
+    open_kw : dict, optional
+        Additional keyword arguments to pass to rioxarray.open_rasterio
+    flatten : bool, optional
+        By default 2D rasters will be returned as 3D, with a band dimension of size 1. If True, which is the
+        default, this dimension is removed.
+    """
+
+    parse_coordinates: bool = True
+    mask_and_scale: Optional[bool] = None  # if None, inferred from data -> float yes, int no
+    decode_times: bool = False
+    cache: bool = False
+    open_kw: dict = field(default_factory=dict)
+    flatten: bool = True
+
+    @staticmethod
+    def _subdatasets(path: Path) -> list[str]:
+        with rio.open(path) as fp:
+            return fp.subdatasets
+
+    def _has_subdatasets(self, path: Path) -> bool:
+        return len(self._subdatasets(path)) > 0
+
+    @staticmethod
+    def _infer_mask_and_scale(path: Path) -> bool:
+        with rio.open(path) as fp:
+            return np.issubdtype(fp.dtypes[0], np.floating)
+
+    @staticmethod
+    def _assert_exists(path: Path) -> None:
+        with rio.open(path):
+            pass
+
+    def load(self, path: str | Path) -> xr.DataArray:
+        path = Path(path)
+
+        self._assert_exists(path)
+
+        if self._has_subdatasets(path):
+            subs_str = '\n'.join(self._subdatasets(path))
+            raise TooManyDimensions(f'Multiple variables found in {path}. Use one of the subdatasets:\n{subs_str}')
+
+        mask_and_scale = self.mask_and_scale if self.mask_and_scale is not None else self._infer_mask_and_scale(path)
+
+        try:
+            da = rxr.open_rasterio(
+                path,
+                parse_coordinates=self.parse_coordinates,
+                decode_times=self.decode_times,
+                cache=self.cache,
+                mask_and_scale=mask_and_scale,
+                **self.open_kw,
+            )
+        except Exception as e:
+            raise type(e)(f'Failed to load {path}: {e}') from e
+
+        if isinstance(da, xr.Dataset):
+            raise TooManyDimensions(f'Dataset found in {path}. Use one of the subdatasets.')
+
+        if self.flatten and 'band' in da.dims and da.sizes['band'] == 1:
+            da = da.isel(band=0).drop_vars('band')
+
+        return da

pygeodata-0.0.1/pygeodata/load.py

@@ -0,0 +1,12 @@
+from typing import Any, Optional
+
+from pygeodata.config import get_config
+from pygeodata.loader import DataLoader
+from pygeodata.types import SpatialSpec
+
+
+def load_data(loader: DataLoader, spec: Optional[SpatialSpec] = None) -> Any:
+    spec = spec or get_config().spec
+    if spec is None:
+        raise ValueError('No spatial specification (spec) provided or present in config')
+    return loader.load(spec)

pygeodata-0.0.1/pygeodata/loader.py

@@ -0,0 +1,68 @@
+import re
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Any
+
+from pygeodata.config import get_config
+from pygeodata.paths import generate_path
+from pygeodata.types import SpatialSpec
+
+
+class DataLoader(ABC):
+    @property
+    @abstractmethod
+    def processor(self):
+        pass
+
+    @property
+    @abstractmethod
+    def driver(self):
+        pass
+
+    @property
+    def class_name(self) -> str:
+        return self.__class__.__name__.replace('Loader', '')
+
+    @property
+    def name(self) -> str:
+        # Handle acronym → word transitions (e.g. XMLHTTPRequest → XML_Http_Request)
+        s1 = re.sub('([A-Z]+)([A-Z][a-z])', r'\1_\2', self.class_name)
+        # Handle normal camelCase → camel_Case
+        s2 = re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1)
+        return s2.lower()
+
+    def get_params(self) -> dict[str, Any]:
+        params = {}
+        for key in self.__dict__:
+            if key in ('name', 'class_name'):
+                continue
+            params.update({key: self.__dict__[key]})
+        return params
+
+    def __repr__(self) -> str:
+        params = self.get_params()
+        parts = [f'{k}={v}' for k, v in sorted(params.items())]
+        return f'{self.class_name}(' + ', '.join(parts) + ')'
+
+    def get_processed_path(self, spec: SpatialSpec) -> Path:
+        path = generate_path(
+            spec=spec,
+            name=self.class_name,
+            filename=self.name,
+            base_dir=get_config().path_data_processed,
+            **self.get_params(),
+        )
+        path.parent.mkdir(exist_ok=True, parents=True)
+        return path
+
+    def is_processed(self, spec: SpatialSpec) -> bool:
+        p = self.get_processed_path(spec)
+        return p.exists() or p.is_symlink()
+
+    def process(self, spec: SpatialSpec) -> None:
+        if not self.is_processed(spec):
+            self.processor(self.get_processed_path(spec), spec)
+
+    def load(self, spec: SpatialSpec) -> Any:
+        self.process(spec)
+        self.driver.load(self.get_processed_path(spec))

pygeodata-0.0.1/pygeodata/options.py

@@ -0,0 +1,46 @@
+from dataclasses import asdict, dataclass
+from typing import Any, Optional
+
+
+@dataclass
+class RasterioProfile:
+    """Rasterio creation profile options.
+
+    Parameters
+    ----------
+    compress : str, optional
+        Compression algorithm ('lzw', 'deflate', 'zstd', 'lzma', 'jpeg', 'webp')
+    compress_level : int, optional
+        Compression level (1-9 for deflate, 1-12 for zstd)
+    tiled : bool, default=False
+        Whether to create a tiled raster (False for striped layout)
+    blockxsize : int, optional
+        Tile width (defaults to 256 if tiled=True, must be multiple of 16)
+    blockysize : int, optional
+        Tile height (defaults to 256 if tiled=True, must be multiple of 16)
+    interleave : str, optional
+        Band interleave ('pixel', 'band', 'line')
+    photometric : str, optional
+        Photometric interpretation ('minisblack', 'rgb', 'ycbcr')
+    predictor : int, optional
+        Predictor for compression (1=none, 2=horizontal, 3=floating point)
+    bigtiff : bool | str, optional
+        Create BigTIFF file ('yes', 'no', 'if_needed', 'if_safer')
+    sparse_ok : bool, optional
+        Allow sparse files
+    """
+
+    compress: Optional[str] = None
+    compress_level: Optional[int] = None
+    tiled: Optional[bool] = None
+    blockxsize: Optional[int] = None
+    blockysize: Optional[int] = None
+    interleave: Optional[str] = None
+    photometric: Optional[str] = None
+    predictor: Optional[int] = None
+    bigtiff: Optional[bool | str] = None
+    sparse_ok: Optional[bool] = None
+    num_threads: Optional[int | str] = None
+
+    def to_dict(self) -> dict[str, Any]:
+        return {k: v for k, v in asdict(self).items() if v is not None}

pygeodata-0.0.1/pygeodata/paths.py

@@ -0,0 +1,34 @@
+import re
+from pathlib import Path
+from typing import Optional
+
+from pygeodata.types import SpatialSpec
+from pygeodata.utils import transform_to_str
+
+
+def generate_path(
+    spec: SpatialSpec,
+    filename: str,
+    name: Optional[str] = None,
+    base_dir: str | Path = "data_processed",
+    ext: str = "tif",
+    **kwargs,
+) -> Path:
+    """Function that converts a path of the data to the processed data."""
+    base_dir = Path(base_dir)
+
+    p = []
+    if name is not None:
+        p.append(name)
+
+    for key in sorted(kwargs.keys()):
+        p.append(f"{key}={kwargs[key]}")
+
+    return Path(
+        base_dir,
+        f"{re.sub(r'[^\w\-]', '_', spec.crs.to_string())}",
+        transform_to_str(spec.transform),
+        f"{spec.shape[0]}-{spec.shape[1]}",
+        *p,
+        f"{filename}.{ext}",
+    )

pygeodata-0.0.1/pygeodata/processors/__init__.py

@@ -0,0 +1,4 @@
+from pygeodata.processors.reprojection import Reprojector
+
+
+__all__ = ['Reprojector']

pygeodata-0.0.1/pygeodata/processors/rasterizer.py

@@ -0,0 +1,91 @@
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Callable, Dict, Optional
+
+import geopandas as gpd
+import numpy as np
+import rasterio
+from rasterio.features import rasterize
+
+from pygeodata.options import RasterioProfile
+from pygeodata.types import SpatialSpec
+
+
+@dataclass
+class Rasterizer:
+    """
+    Rasterize a vector dataset to a single-band raster.
+
+    Parameters
+    ----------
+    path : Path
+        Path to the vector dataset (e.g., shapefile, GeoPackage).
+    column : str
+        Name of the column to use as raster values (must be numeric).
+    load_df_func : Callable[[str | Path, SpatialSpec], gpd.GeoDataFrame], optional
+        Function to load the vector data. By default, reads with geopandas and reprojects to `spec.crs`.
+    all_touched : bool, default=True
+        Whether to burn all pixels touched by geometries.
+    dtype : Optional[np.dtype]
+        Data type for raster. Defaults to the dtype of `column`.
+    fill_value : Optional[float]
+        Nodata value for raster. Defaults to `_NODATA_DTYPE_MAP` based on dtype.
+    rasterize_kw : dict
+        Additional keyword arguments passed to `rasterio.features.rasterize`.
+    profile : Optional[RasterioProfile]
+        Optional raster creation profile (compression, tiling, etc.).
+    """
+
+    path: Path
+    column: str = 'index'
+    load_df_func: Callable[[str | Path, SpatialSpec], gpd.GeoDataFrame] = field(
+        default_factory=lambda: lambda path, spec: gpd.read_file(path).to_crs(spec.crs).reset_index()
+    )
+    all_touched: bool = True
+    dtype: Optional[np.dtype] = None
+    fill_value: Optional[float] = None
+    rasterize_kw: Dict[str, Any] = field(default_factory=dict)
+    profile: Optional[RasterioProfile] = field(default_factory=RasterioProfile)
+
+    def __call__(self, dst_path: str | Path, spec: SpatialSpec) -> None:
+        df = self.load_df_func(self.path, spec)
+
+        if df.crs != spec.crs:
+            raise ValueError(f'GeoDataFrame CRS ({df.crs}) does not match target spec CRS ({spec.crs}).')
+
+        if self.column not in df.columns:
+            raise ValueError(f"Column '{self.column}' not found in GeoDataFrame.")
+
+        dtype = self.dtype or df[self.column].dtype
+
+        if not np.issubdtype(dtype, np.number):
+            raise TypeError(f"Column '{self.column}' must be numeric, got {dtype}.")
+
+        fill_value = self.fill_value or (np.nan if np.issubdtype(dtype, np.floating) else 0)
+
+        if fill_value in df[self.column]:
+            raise ValueError(f'Fill value {fill_value} is present in the data. Overwrite with a different value.')
+
+        raster = rasterize(
+            ((row.geometry, row[self.column]) for i, row in df.iterrows()),
+            out_shape=spec.shape,
+            transform=spec.transform,
+            fill=fill_value,
+            all_touched=self.all_touched,
+            dtype=dtype,
+            **self.rasterize_kw,
+        )
+
+        with rasterio.open(
+            dst_path,
+            'w',
+            driver='GTiff',
+            height=spec.shape[0],
+            width=spec.shape[1],
+            count=1,
+            dtype=dtype,
+            crs=spec.crs,
+            transform=spec.transform,
+            **self.profile.to_dict(),
+        ) as dst:
+            dst.write(raster, 1)

pygeodata-0.0.1/pygeodata/processors/reprojection.py

@@ -0,0 +1,124 @@
+import shutil
+import tempfile
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any, Optional, Sequence
+
+import numpy as np
+import rasterio as rio
+import rasterio.warp
+from numpy.typing import DTypeLike
+from rasterio import CRS, RasterioIOError
+from rasterio.enums import Resampling
+
+from pygeodata.config import get_config
+from pygeodata.options import RasterioProfile
+from pygeodata.types import SpatialSpec
+
+
+@dataclass
+class Reprojector:
+    """Reprojects raster data to GeoTIFF format.
+
+    Parameters
+    ----------
+    src_path : str | Path
+        Path to source raster file
+    bands : int | Sequence[int], optional
+        Band indices to reproject (1-indexed). If None, reprojects all bands
+    src_crs : CRS, optional
+        Override source CRS if not defined in file
+    resampling : Resampling, default=Resampling.nearest
+        Resampling method
+    dst_dtype : DTypeLike, optional
+        Output data type. If None, uses source dtype
+    dst_nodata : float, optional
+        Output nodata value. If None, uses source nodata
+    profile : RasterioProfile, optional
+        GeoTIFF creation profile options. If None, uses defaults
+    warp_kw : dict, optional
+        Additional keyword arguments for rasterio.warp.reproject
+    """
+
+    src_path: str | Path
+    src_crs: Optional[CRS] = None
+    bands: Optional[int | Sequence[int]] = None
+    resampling: Resampling = Resampling.nearest
+    dst_dtype: Optional[DTypeLike] = None
+    dst_nodata: Optional[float] = None
+    warp_kw: dict[str, Any] = field(default_factory=dict)
+    warp_mem_limit: Optional[int] = None
+    num_threads: Optional[int] = None
+    profile: RasterioProfile = field(default_factory=RasterioProfile)
+
+    def __call__(self, dst_path: str | Path, spec: SpatialSpec) -> None:
+        """Reproject raster to specified spatial configuration.
+
+        Parameters
+        ----------
+        dst_path : str | Path
+            Destination file path
+        spec : SpatialSpec
+            Target spatial specification (CRS, transform, shape)
+        """
+        dst_path = Path(dst_path)
+
+        if dst_path.exists():
+            raise FileExistsError(f'Destination already exists: {dst_path}')
+
+        print(f'Reprojecting: {self.src_path} -> {dst_path}')
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            temp_path = Path(tmpdir) / f'~{"_".join(dst_path.parts[1:])}'
+
+            with rio.open(self.src_path) as src:
+                if len(src.subdatasets) > 1:
+                    sub_str = '\n'.join(src.subdatasets)
+                    raise RasterioIOError(
+                        f'Cannot reproject multi-variable dataset: {self.src_path}\nSubdatasets:\n{sub_str}'
+                    )
+
+                src_crs = src.crs if src.crs is not None else self.src_crs
+
+                if src_crs is None:
+                    raise ValueError(f'Cannot determine CRS for {self.src_path}. Provide src_crs parameter.')
+
+                src_dtype = src.dtypes[0]
+                src_transform = src.transform
+
+                src_nodata = src.nodata or (np.nan if np.issubdtype(src_dtype, np.floating) else 0)
+
+                src_bands = src.indexes if self.bands is None else self.bands
+
+                dst_dtype = src_dtype if self.dst_dtype is None else self.dst_dtype
+                dst_nodata = src_nodata if self.dst_nodata is None else self.dst_nodata
+
+                rio_profile = {
+                    'driver': 'GTiff',
+                    'height': spec.shape[0],
+                    'width': spec.shape[1],
+                    'dtype': dst_dtype,
+                    'nodata': dst_nodata,
+                    'count': len(src_bands),
+                    'crs': spec.crs,
+                    'transform': spec.transform,
+                    **self.profile.to_dict(),
+                }
+
+                with rio.open(temp_path, 'w', **rio_profile) as dst:
+                    rasterio.warp.reproject(
+                        source=rio.band(src, src_bands),
+                        destination=rio.band(dst, dst.indexes),
+                        src_crs=src_crs,
+                        dst_crs=spec.crs,
+                        src_transform=src_transform,
+                        dst_transform=spec.transform,
+                        src_nodata=src_nodata,
+                        dst_nodata=dst_nodata,
+                        resampling=self.resampling,
+                        warp_mem_limit=self.warp_mem_limit or get_config().warp_mem_limit,
+                        num_threads=self.num_threads or get_config().num_threads,
+                        **self.warp_kw,
+                    )
+
+            shutil.move(temp_path, dst_path)

pygeodata-0.0.1/pygeodata/types.py

@@ -0,0 +1,45 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Protocol
+
+from affine import Affine
+from pyproj import CRS
+from rasterio.coords import BoundingBox
+
+type RasterShape = tuple[int, int]
+
+
+@dataclass
+class SpatialSpec:
+    crs: CRS
+    transform: Affine
+    shape: RasterShape
+
+    def resolution(self) -> tuple[int, int]:
+        return (abs(self.transform.a), abs(self.transform.e))
+
+    def bounds(self) -> BoundingBox:
+        height, width = self.shape
+        x0, y0 = self.transform * (0, 0)
+        x1, y1 = self.transform * (width, height)
+        return BoundingBox(min(x0, x1), min(y0, y1), max(x0, x1), max(y0, y1))
+
+    def __repr__(self):
+        transform_str = (
+            f'Affine('
+            f'{self.transform.a:.2f}, '
+            f'{self.transform.b:.2f}, '
+            f'{self.transform.c:.2f}, '
+            f'{self.transform.d:.2f}, '
+            f'{self.transform.e:.2f}, '
+            f'{self.transform.f:.2f})'
+        )
+        return f'SpatialSpec(crs={self.crs.to_string()}, transform={transform_str}, shape={self.shape})'
+
+
+class Processor(Protocol):
+    def __call__(self, dst_path: str | Path, spec: SpatialSpec) -> None: ...
+
+
+class Driver(Protocol):
+    def load(self, path: str | Path) -> Any: ...

pygeodata-0.0.1/pygeodata/utils.py

@@ -0,0 +1,5 @@
+from affine import Affine
+
+
+def transform_to_str(t: Affine) -> str:
+    return f'affine_{t.a:.4f}_{t.b:.4f}_{t.c:.4f}_{t.d:.4f}_{t.e:.4f}_{t.f:.4f}'

pygeodata-0.0.1/pygeodata.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: pygeodata
+Version: 0.0.1
+Summary: Lightweight framework for geospatial data access and processing
+Author-email: Jasper Roebroek <roebroek.jasper@gmail.com>
+License: MIT
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rioxarray
+Requires-Dist: geopandas
+Requires-Dist: dask
+Requires-Dist: zarr
+Provides-Extra: test
+Requires-Dist: pytest; extra == "test"
+Dynamic: license-file
+
+# pygeodata
+
+**Lightweight framework for geospatial data access and processing**
+
+`pygeodata` provides simple, composable tools for working with geospatial raster and vector data. It aims to make spatial data handling consistent, efficient, and compatible with large-scale and cloud-based workflows.
+
+## Features
+
+- Unified access to raster and vector datasets  
+- CRS-aware reprojection and alignment utilities
+- Clean, composable API designed for scientific workflows  
+
+## Installation
+
+```bash
+pip install pygeodata
+```

pygeodata-0.0.1/pygeodata.egg-info/SOURCES.txt

@@ -0,0 +1,23 @@
+LICENSE
+README.md
+pyproject.toml
+pygeodata/__init__.py
+pygeodata/config.py
+pygeodata/load.py
+pygeodata/loader.py
+pygeodata/options.py
+pygeodata/paths.py
+pygeodata/types.py
+pygeodata/utils.py
+pygeodata.egg-info/PKG-INFO
+pygeodata.egg-info/SOURCES.txt
+pygeodata.egg-info/dependency_links.txt
+pygeodata.egg-info/requires.txt
+pygeodata.egg-info/top_level.txt
+pygeodata/drivers/__init__.py
+pygeodata/drivers/xarray.py
+pygeodata/processors/__init__.py
+pygeodata/processors/rasterizer.py
+pygeodata/processors/reprojection.py
+tests/test_config.py
+tests/test_loader.py

pygeodata-0.0.1/pygeodata.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pygeodata-0.0.1/pygeodata.egg-info/requires.txt

@@ -0,0 +1,7 @@
+rioxarray
+geopandas
+dask
+zarr
+
+[test]
+pytest

pygeodata-0.0.1/pygeodata.egg-info/top_level.txt

@@ -0,0 +1 @@
+pygeodata

pygeodata-0.0.1/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pygeodata"
+version = "0.0.1"
+description = "Lightweight framework for geospatial data access and processing"
+authors = [
+    { name = "Jasper Roebroek", email = "roebroek.jasper@gmail.com" }
+]
+license = { text = "MIT" }
+readme = "README.md"
+requires-python = ">=3.12"
+keywords = []
+classifiers = [
+    "Programming Language :: Python :: 3"
+]
+dependencies = [
+    "rioxarray",
+    "geopandas",
+    "dask",
+    "zarr"
+]
+
+[tool.setuptools.packages.find]
+include = ["pygeodata*"]
+
+[project.optional-dependencies]
+test = ["pytest"]

pygeodata-0.0.1/setup.cfg

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

pygeodata-0.0.1/tests/test_config.py

@@ -0,0 +1,29 @@
+from pathlib import Path
+
+import pytest
+
+from pygeodata.config import Config, get_config, set_config
+
+
+def test_default_config():
+    cfg = get_config()
+    assert cfg.path_data_processed == Path('data_processed')
+
+
+def test_temporary_override():
+    original = get_config().path_data_processed
+    with set_config(path_data_processed=Path('/tmp')) as cfg:
+        assert cfg.path_data_processed == Path('/tmp')
+    assert get_config().path_data_processed == original
+
+
+def test_multiple_overrides():
+    with set_config(path_data_processed=Path('/tmp')) as cfg:
+        assert isinstance(cfg, Config)
+        assert cfg.path_data_processed == Path('/tmp')
+
+
+def test_config_invalid_key():
+    with pytest.raises(ValueError):
+        with set_config(invalid_key='value'):
+            pass

pygeodata-0.0.1/tests/test_loader.py

@@ -0,0 +1,52 @@
+from pygeodata.config import set_config
+
+
+def test_data_entry_initialization(sample_loader_class):
+    """Test DataEntry initialization with default values."""
+    loader = sample_loader_class()
+    assert loader.name == 'sample'
+    assert hasattr(loader, 'processor')
+    assert hasattr(loader, 'driver')
+    assert loader.class_name == 'Sample'
+    assert loader.get_params() == {}
+
+
+def test_get_processed_path(sample_loader_class, sample_spatial_spec, tmp_path):
+    loader = sample_loader_class()
+    with set_config(path_data_processed=tmp_path):
+        path = loader.get_processed_path(sample_spatial_spec)
+
+        assert path.parent.exists()
+        assert path.suffix == '.tif'
+        assert str(tmp_path) in str(path)
+
+
+def test_is_processed_false(sample_loader_class, sample_spatial_spec, tmp_path):
+    """Test is_processed when file doesn't exist."""
+    with set_config(path_data_processed=tmp_path):
+        assert not sample_loader_class().is_processed(sample_spatial_spec)
+
+
+def test_is_processed_true(sample_loader_class, sample_spatial_spec, tmp_path):
+    """Test is_processed when file exists."""
+    loader = sample_loader_class()
+    with set_config(path_data_processed=tmp_path):
+        path = loader.get_processed_path(sample_spatial_spec)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.touch()
+
+        assert loader.is_processed(sample_spatial_spec)
+
+
+def test_process_creates_file(sample_loader_class, sample_spatial_spec, tmp_path):
+    """Test that process creates the expected output file."""
+    loader = sample_loader_class()
+    with set_config(path_data_processed=tmp_path):
+        loader.process(sample_spatial_spec)
+        path = loader.get_processed_path(sample_spatial_spec)
+        assert path.exists()
+
+
+def test_load_with_params(sample_loader_class_complex, sample_spatial_spec):
+    """Test that parameters are included in the generated path."""
+    assert set(sample_loader_class_complex(10, 10).get_params()) == {'time', 'resolution'}