mapchete-eo 2025.7.0__py2.py3-none-any.whl → 2025.8.1__py2.py3-none-any.whl

mapchete_eo/__init__.py

@@ -1 +1 @@
-__version__ = "2025.7.0"
+__version__ = "2025.8.1"

mapchete_eo/base.py

@@ -91,6 +91,9 @@ class EODataCube(base.InputTile):
                     if not isinstance(item, CorruptedProductMetadata)
                 ],
                 crs=self.tile.crs,
+                # by not using rtree, we avoid an edge case where products outside of process CRS bounds
+                # cause rtree to fail when indexing the products.
+                index=None,
             )
 
         # just return the prouducts as is
@@ -101,6 +104,9 @@ class EODataCube(base.InputTile):
                 if not isinstance(item, CorruptedProductMetadata)
             ],
             crs=self.tile.crs,
+            # by not using rtree, we avoid an edge case where products outside of process CRS bounds
+            # cause rtree to fail when indexing the products.
+            index=None,
         )
 
     def read(

mapchete_eo/image_operations/blend_modes/blending_functions.py

@@ -0,0 +1,198 @@
+"""
+
+Original LICENSE:
+
+MIT License
+
+Copyright (c) 2016 Florian Roscheck
+
+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.
+
+Overview
+--------
+
+.. currentmodule:: blend_modes.blending_functions
+
+.. autosummary::
+    :nosignatures:
+
+    addition
+    darken_only
+    difference
+    divide
+    dodge
+    grain_extract
+    grain_merge
+    hard_light
+    lighten_only
+    multiply
+    normal
+    overlay
+    screen
+    soft_light
+    subtract
+"""
+
+import numpy as np
+from typing import Callable
+from mapchete_eo.image_operations.blend_modes.type_checks import (
+    assert_image_format,
+    assert_opacity,
+)
+
+
+class BlendBase:
+    def __init__(
+        self,
+        opacity=1.0,
+        disable_type_checks=False,
+        dtype=np.float16,
+        fcn_name="BlendBase",
+    ):
+        self.opacity = opacity
+        self.disable_type_checks = disable_type_checks
+        self.dtype = dtype
+        self.fcn_name = fcn_name
+
+    def _prepare(self, src: np.ndarray, dst: np.ndarray):
+        if not self.disable_type_checks:
+            assert_image_format(src, fcn_name=self.fcn_name, arg_name="src")
+            assert_image_format(dst, fcn_name=self.fcn_name, arg_name="dst")
+            assert_opacity(self.opacity, fcn_name=self.fcn_name)
+        if src.dtype != self.dtype:
+            src = src.astype(self.dtype)
+        if dst.dtype != self.dtype:
+            dst = dst.astype(self.dtype)
+        return src, dst
+
+    def blend(self, src: np.ndarray, dst: np.ndarray, blend_func: Callable):
+        src, dst = self._prepare(src, dst)
+        blended = blend_func(src, dst)
+        result = (blended * self.opacity) + (dst * (1 - self.opacity))
+        return np.clip(result, 0, 1).astype(self.dtype)
+
+
+def make_blend_function(blend_func: Callable):
+    # This function returns a wrapper that uses a shared BlendBase instance
+    base = BlendBase()
+
+    def func(
+        src: np.ndarray,
+        dst: np.ndarray,
+        opacity: float = 1.0,
+        disable_type_checks: bool = False,
+        dtype: np.dtype = np.float16,
+    ) -> np.ndarray:
+        # If parameters differ from base, create new BlendBase (rare)
+        if (
+            opacity != base.opacity
+            or disable_type_checks != base.disable_type_checks
+            or dtype != base.dtype
+        ):
+            base_local = BlendBase(opacity, disable_type_checks, dtype)
+            return base_local.blend(src, dst, blend_func)
+        return base.blend(src, dst, blend_func)
+
+    return func
+
+
+normal = make_blend_function(lambda s, d: s)
+multiply = make_blend_function(lambda s, d: s * d)
+screen = make_blend_function(lambda s, d: 1 - (1 - s) * (1 - d))
+darken_only = make_blend_function(lambda s, d: np.minimum(s, d))
+lighten_only = make_blend_function(lambda s, d: np.maximum(s, d))
+difference = make_blend_function(lambda s, d: np.abs(d - s))
+subtract = make_blend_function(lambda s, d: np.clip(d - s, 0, 1))
+
+
+def divide_blend(s: np.ndarray, d: np.ndarray) -> np.ndarray:
+    with np.errstate(divide="ignore", invalid="ignore"):
+        res = np.true_divide(d, s)
+        res[~np.isfinite(res)] = 0
+        return np.clip(res, 0, 1)
+
+
+divide = make_blend_function(divide_blend)
+
+
+def grain_extract_blend(s: np.ndarray, d: np.ndarray) -> np.ndarray:
+    return np.clip(d - s + 0.5, 0, 1)
+
+
+grain_extract = make_blend_function(grain_extract_blend)
+
+
+def grain_merge_blend(s: np.ndarray, d: np.ndarray) -> np.ndarray:
+    return np.clip(d + s - 0.5, 0, 1)
+
+
+grain_merge = make_blend_function(grain_merge_blend)
+
+
+def overlay_blend(s: np.ndarray, d: np.ndarray) -> np.ndarray:
+    mask = d <= 0.5
+    result = np.empty_like(d)
+    result[mask] = 2 * s[mask] * d[mask]
+    result[~mask] = 1 - 2 * (1 - s[~mask]) * (1 - d[~mask])
+    return np.clip(result, 0, 1)
+
+
+overlay = make_blend_function(overlay_blend)
+
+
+def hard_light_blend(s: np.ndarray, d: np.ndarray) -> np.ndarray:
+    mask = s <= 0.5
+    result = np.empty_like(d)
+    result[mask] = 2 * s[mask] * d[mask]
+    result[~mask] = 1 - 2 * (1 - s[~mask]) * (1 - d[~mask])
+    return np.clip(result, 0, 1)
+
+
+hard_light = make_blend_function(hard_light_blend)
+
+
+def soft_light_blend(s: np.ndarray, d: np.ndarray) -> np.ndarray:
+    result = (1 - 2 * s) * d**2 + 2 * s * d
+    return np.clip(result, 0, 1)
+
+
+soft_light = make_blend_function(soft_light_blend)
+
+
+def dodge_blend(s: np.ndarray, d: np.ndarray) -> np.ndarray:
+    with np.errstate(divide="ignore", invalid="ignore"):
+        res = np.true_divide(d, 1 - s)
+        res[~np.isfinite(res)] = 1
+        return np.clip(res, 0, 1)
+
+
+dodge = make_blend_function(dodge_blend)
+
+
+def burn_blend(s: np.ndarray, d: np.ndarray) -> np.ndarray:
+    with np.errstate(divide="ignore", invalid="ignore"):
+        res = 1 - np.true_divide(1 - d, s)
+        res[~np.isfinite(res)] = 0
+        return np.clip(res, 0, 1)
+
+
+burn = make_blend_function(burn_blend)
+
+
+def addition_blend(s: np.ndarray, d: np.ndarray) -> np.ndarray:
+    return np.clip(s + d, 0, 1)
+
+
+addition = make_blend_function(addition_blend)

mapchete_eo/image_operations/blend_modes/type_checks.py

@@ -0,0 +1,99 @@
+"""This module includes functions to check if variable types match expected formats."""
+
+import numpy as np
+
+
+def assert_image_format(image, fcn_name: str, arg_name: str, force_alpha: bool = True):
+    """Assert if image arguments have the expected format.
+
+    Checks:
+        - Image is a numpy array
+        - Array is of floating-point type
+        - Array is 3D (height x width x channels)
+        - Array has the correct number of layers (3 or 4)
+
+    Args:
+        image: The image to be checked.
+        fcn_name (str): Calling function name for display in error messages.
+        arg_name (str): Relevant argument name for display in error messages.
+        force_alpha (bool): Whether the image must include an alpha layer.
+
+    Raises:
+        TypeError: If type or shape are incorrect.
+    """
+    if not isinstance(image, np.ndarray):
+        raise TypeError(
+            f"\n[Invalid Type]\n"
+            f"Function: {fcn_name}\n"
+            f"Argument: {arg_name}\n"
+            f"Expected: numpy.ndarray\n"
+            f"Got: {type(image).__name__}\n"
+            f'Hint: Pass a numpy.ndarray for "{arg_name}".'
+        )
+
+    if image.dtype.kind != "f":
+        raise TypeError(
+            f"\n[Invalid Data Type]\n"
+            f"Function: {fcn_name}\n"
+            f"Argument: {arg_name}\n"
+            f'Expected dtype kind: "f" (floating-point)\n'
+            f'Got dtype kind: "{image.dtype.kind}"\n'
+            f"Hint: Convert the array to float, e.g., image.astype(float)."
+        )
+
+    if len(image.shape) != 3:
+        raise TypeError(
+            f"\n[Invalid Dimensions]\n"
+            f"Function: {fcn_name}\n"
+            f"Argument: {arg_name}\n"
+            f"Expected: 3D array (height x width x channels)\n"
+            f"Got: {len(image.shape)}D array\n"
+            f"Hint: Ensure the array has three dimensions."
+        )
+
+    if force_alpha and image.shape[2] != 4:
+        raise TypeError(
+            f"\n[Invalid Channel Count]\n"
+            f"Function: {fcn_name}\n"
+            f"Argument: {arg_name}\n"
+            f"Expected: 4 layers (R, G, B, Alpha)\n"
+            f"Got: {image.shape[2]} layers\n"
+            f"Hint: Include all four channels if force_alpha=True."
+        )
+
+
+def assert_opacity(opacity, fcn_name: str, arg_name: str = "opacity"):
+    """Assert if opacity has the expected format.
+
+    Checks:
+        - Opacity is float or int
+        - Opacity is within 0.0 <= x <= 1.0
+
+    Args:
+        opacity: The opacity value to be checked.
+        fcn_name (str): Calling function name for display in error messages.
+        arg_name (str): Argument name for display in error messages.
+
+    Raises:
+        TypeError: If type is not float or int.
+        ValueError: If opacity is out of range.
+    """
+    if not isinstance(opacity, (float, int)):
+        raise TypeError(
+            f"\n[Invalid Type]\n"
+            f"Function: {fcn_name}\n"
+            f"Argument: {arg_name}\n"
+            f"Expected: float (or int)\n"
+            f"Got: {type(opacity).__name__}\n"
+            f"Hint: Pass a float between 0.0 and 1.0."
+        )
+
+    if not 0.0 <= opacity <= 1.0:
+        raise ValueError(
+            f"\n[Out of Range]\n"
+            f"Function: {fcn_name}\n"
+            f"Argument: {arg_name}\n"
+            f"Expected: value in range 0.0 <= x <= 1.0\n"
+            f"Got: {opacity}\n"
+            f"Hint: Clamp or normalize the value to the valid range."
+        )

mapchete_eo/image_operations/compositing.py

@@ -2,13 +2,15 @@ import logging
 from enum import Enum
 from typing import Callable, Optional
 
-import blend_modes
 import cv2
 import numpy as np
 import numpy.ma as ma
 from mapchete import Timer
 from rasterio.plot import reshape_as_image, reshape_as_raster
 
+from mapchete_eo.image_operations.blend_modes import blending_functions
+
+
 logger = logging.getLogger(__name__)
 
 
@@ -68,63 +70,63 @@ def _blend_base(
 
 
 def normal(bg: np.ndarray, fg: np.ndarray, opacity: float = 1) -> ma.MaskedArray:
-    return _blend_base(bg, fg, opacity, blend_modes.normal)
+    return _blend_base(bg, fg, opacity, blending_functions.normal)
 
 
 def soft_light(bg: np.ndarray, fg: np.ndarray, opacity: float = 1) -> ma.MaskedArray:
-    return _blend_base(bg, fg, opacity, blend_modes.soft_light)
+    return _blend_base(bg, fg, opacity, blending_functions.soft_light)
 
 
 def lighten_only(bg: np.ndarray, fg: np.ndarray, opacity: float = 1) -> ma.MaskedArray:
-    return _blend_base(bg, fg, opacity, blend_modes.lighten_only)
+    return _blend_base(bg, fg, opacity, blending_functions.lighten_only)
 
 
 def screen(bg: np.ndarray, fg: np.ndarray, opacity: float = 1) -> ma.MaskedArray:
-    return _blend_base(bg, fg, opacity, blend_modes.screen)
+    return _blend_base(bg, fg, opacity, blending_functions.screen)
 
 
 def dodge(bg: np.ndarray, fg: np.ndarray, opacity: float = 1) -> ma.MaskedArray:
-    return _blend_base(bg, fg, opacity, blend_modes.dodge)
+    return _blend_base(bg, fg, opacity, blending_functions.dodge)
 
 
 def addition(bg: np.ndarray, fg: np.ndarray, opacity: float = 1) -> ma.MaskedArray:
-    return _blend_base(bg, fg, opacity, blend_modes.addition)
+    return _blend_base(bg, fg, opacity, blending_functions.addition)
 
 
 def darken_only(bg: np.ndarray, fg: np.ndarray, opacity: float = 1) -> ma.MaskedArray:
-    return _blend_base(bg, fg, opacity, blend_modes.darken_only)
+    return _blend_base(bg, fg, opacity, blending_functions.darken_only)
 
 
 def multiply(bg: np.ndarray, fg: np.ndarray, opacity: float = 1) -> ma.MaskedArray:
-    return _blend_base(bg, fg, opacity, blend_modes.multiply)
+    return _blend_base(bg, fg, opacity, blending_functions.multiply)
 
 
 def hard_light(bg: np.ndarray, fg: np.ndarray, opacity: float = 1) -> ma.MaskedArray:
-    return _blend_base(bg, fg, opacity, blend_modes.hard_light)
+    return _blend_base(bg, fg, opacity, blending_functions.hard_light)
 
 
 def difference(bg: np.ndarray, fg: np.ndarray, opacity: float = 1) -> ma.MaskedArray:
-    return _blend_base(bg, fg, opacity, blend_modes.difference)
+    return _blend_base(bg, fg, opacity, blending_functions.difference)
 
 
 def subtract(bg: np.ndarray, fg: np.ndarray, opacity: float = 1) -> ma.MaskedArray:
-    return _blend_base(bg, fg, opacity, blend_modes.subtract)
+    return _blend_base(bg, fg, opacity, blending_functions.subtract)
 
 
 def grain_extract(bg: np.ndarray, fg: np.ndarray, opacity: float = 1) -> ma.MaskedArray:
-    return _blend_base(bg, fg, opacity, blend_modes.grain_extract)
+    return _blend_base(bg, fg, opacity, blending_functions.grain_extract)
 
 
 def grain_merge(bg: np.ndarray, fg: np.ndarray, opacity: float = 1) -> ma.MaskedArray:
-    return _blend_base(bg, fg, opacity, blend_modes.grain_merge)
+    return _blend_base(bg, fg, opacity, blending_functions.grain_merge)
 
 
 def divide(bg: np.ndarray, fg: np.ndarray, opacity: float = 1) -> ma.MaskedArray:
-    return _blend_base(bg, fg, opacity, blend_modes.divide)
+    return _blend_base(bg, fg, opacity, blending_functions.divide)
 
 
 def overlay(bg: np.ndarray, fg: np.ndarray, opacity: float = 1) -> ma.MaskedArray:
-    return _blend_base(bg, fg, opacity, blend_modes.overlay)
+    return _blend_base(bg, fg, opacity, blending_functions.overlay)
 
 
 METHODS = {

mapchete_eo-2025.8.1.dist-info/METADATA

@@ -0,0 +1,84 @@
+Metadata-Version: 2.4
+Name: mapchete-eo
+Version: 2025.8.1
+Summary: mapchete EO data reader
+Project-URL: Homepage, https://gitlab.eox.at/maps/mapchete_eo
+Author-email: Joachim Ungar <joachim.ungar@eox.at>, Petr Sevcik <petr.sevcik@eox.at>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: GIS
+Requires-Dist: click
+Requires-Dist: croniter
+Requires-Dist: lxml
+Requires-Dist: mapchete[complete]>=2025.6.0
+Requires-Dist: opencv-python
+Requires-Dist: pillow
+Requires-Dist: pydantic
+Requires-Dist: pystac-client>=0.7.5
+Requires-Dist: pystac[urllib3]>=1.12.2
+Requires-Dist: retry
+Requires-Dist: rtree
+Requires-Dist: scipy
+Requires-Dist: tqdm
+Requires-Dist: xarray
+Provides-Extra: docs
+Requires-Dist: sphinx; extra == 'docs'
+Requires-Dist: sphinx-rtd-theme; extra == 'docs'
+Provides-Extra: test
+Requires-Dist: pytest-coverage; extra == 'test'
+Requires-Dist: pytest-lazy-fixture; extra == 'test'
+Requires-Dist: pytest<8; extra == 'test'
+Description-Content-Type: text/x-rst
+
+.. image:: logo/mapchete_eo.svg
+
+Earth Observation–specific driver extensions for `Mapchete <https://github.com/ungarj/mapchete>`_.
+
+.. image:: https://img.shields.io/pypi/v/mapchete-eo.svg
+  :target: https://pypi.org/project/mapchete-eo/
+
+.. image:: https://img.shields.io/pypi/l/mapchete-eo.svg
+  :target: https://github.com/mapchete/mapchete-eo/blob/main/LICENSE
+
+.. image:: https://img.shields.io/github/actions/workflow/status/mapchete/mapchete-eo/python-package.yml?label=tests
+  :target: https://github.com/mapchete/mapchete-eo/actions
+
+.. image:: https://codecov.io/gh/mapchete/mapchete-eo/graph/badge.svg?token=VD1YOF3QA2
+  :target: https://codecov.io/gh/mapchete/mapchete-eo
+
+.. image:: https://img.shields.io/github/repo-size/mapchete/mapchete-eo
+  :target: https://github.com/mapchete/mapchete-eo
+
+This package provides custom input and output drivers tailored for common EO data formats and workflows, enabling seamless integration of satellite data sources into the Mapchete tile-based geoprocessing framework.
+
+What is this?
+-------------
+
+**mapchete-eo** extends Mapchete by adding support for:
+
+- Custom **input drivers** to read EO datasets, from STAC search or metadata (catalogs, collections, items)
+- Metadata extraction and band management for optical satellite products
+- Reading data from sources via **STAC assets**
+
+This package is intended for advanced users or developers who are working with remote sensing workflows using Mapchete.
+
+Installation
+------------
+
+You must have ``mapchete`` with ``s3`` installed, so let's grab the ``complete`` dependencies in this case for convenience:
+
+.. code-block:: bash
+
+    pip install mapchete[complete]
+
+Then install mapchete-eo:
+
+.. code-block:: bash
+
+    pip install mapchete-eo

{mapchete_eo-2025.7.0.dist-info → mapchete_eo-2025.8.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
-mapchete_eo/__init__.py,sha256=qw5_HlGyySslqdhiMQcXKzB5W5dNKrjSnWHIzQ07tqg,25
-mapchete_eo/base.py,sha256=0jqaVt45-Ltjhl38g3hHBM-nKe3g8Trf7tzkRIHfqX8,18521
+mapchete_eo/__init__.py,sha256=-GyZPz1gngongzScwy1OJuFT4VYhnDbiBYLDsakhq4g,25
+mapchete_eo/base.py,sha256=-bwBYkKCthr7Q48Y10KbExw7i9sXY8lc0UGo-fe08WA,18907
 mapchete_eo/blacklist.txt,sha256=6KhBY0jNjXgRpKRvKJoOTswvNUoP56IrIcNeCYnd2qo,17471
 mapchete_eo/eostac.py,sha256=5K08Mr4wm-VOXTEvTB6DQHX7rbFLYw8mjW1wlpPltC0,574
 mapchete_eo/exceptions.py,sha256=ul7_9o6_SfJXQPsDOQqRBhh09xv2t4AwHl6YJ7yWN5s,2150
@@ -31,12 +31,14 @@ mapchete_eo/cli/s2_verify.py,sha256=atfJA5luHZjDSqiM2udaufmnQ2B4uW2Tur_OgtYLa2g,
 mapchete_eo/cli/static_catalog.py,sha256=zq20fc0phjfjWMjSao-L6VVI-o2DPrMapvDmy6i30YQ,4291
 mapchete_eo/image_operations/__init__.py,sha256=c36Vs53mT5UQR9Iwd2Ln_vnT4K_Ni8g-K7J9Fl6UsJo,432
 mapchete_eo/image_operations/color_correction.py,sha256=vMXxcdyH3qOJDSKcXGU3FgXWIcgQxMy-QVe2fGQTbdk,4447
-mapchete_eo/image_operations/compositing.py,sha256=eWnyF2Iv3mZD6thAiNW1M0MmqwsRwO9hNWxDN9jTrQY,8146
+mapchete_eo/image_operations/compositing.py,sha256=LhTx6K7TY7KwiAY7vBznbno5B7w5TEUvkRn1YFEA16U,8306
 mapchete_eo/image_operations/dtype_scale.py,sha256=_CCdTBkMLDkZdjV_PsVEkqLWT6jWuTJPeMzCcRwBOns,1243
 mapchete_eo/image_operations/fillnodata.py,sha256=IYCQkPlH-K6ri0G_-Xp8JJzvWz6HhBiA1DolWeGJVyc,4864
 mapchete_eo/image_operations/filters.py,sha256=sa_Igv0zMIANHLEALVi8mxohZMoSrdQc6XVjXDYwzy8,7201
 mapchete_eo/image_operations/linear_normalization.py,sha256=-eQX3WLCUYWUv-um3s1u33rgjAwCz84Ht8gcPsMWtJE,2468
 mapchete_eo/image_operations/sigmoidal.py,sha256=IKU8F89HhQJWGUVmIrnkuhqzn_ztlGrTf8xXZaVQWzU,3575
+mapchete_eo/image_operations/blend_modes/blending_functions.py,sha256=hv3oWFwzha0aAfG0X9CTKc1Y4rfIC6J4v_xVSGu4XAE,5955
+mapchete_eo/image_operations/blend_modes/type_checks.py,sha256=KVJyE1jLsZ4qDMlylWMh40X9POcJy_e5aZYhhqgXH88,3445
 mapchete_eo/io/__init__.py,sha256=1-1g4cESZZREvyumEUABZhDwgVuSxtxdqbNlLuVKlow,950
 mapchete_eo/io/assets.py,sha256=8OrqvrCzJOY0pExh_vKRL7Bz_RGk6M_LfayQqxHo8ag,17014
 mapchete_eo/io/items.py,sha256=FDDMRtFvNNL3Iwf0xiaSI8G3s-54vhqfYKo7xzCQq-w,5657
@@ -80,8 +82,8 @@ mapchete_eo/search/s2_mgrs.py,sha256=5LWl9c7WzFvXODr9f8m37cv-8yyf-LvnN0-TSSPcXKM
 mapchete_eo/search/stac_search.py,sha256=YnISHpdvMJfrY_wfM1dHOtHYqgsbXsYLMYrRdJlAZTo,9551
 mapchete_eo/search/stac_static.py,sha256=P1C2OC33UopV80xIvFeL-HbOuaxxe7qsPDdnkU8IXcA,8613
 mapchete_eo/search/utm_search.py,sha256=wKrG2KwqL2fjSrkDUTZuRayiVAR27BtWpX-PFab0Dng,9646
-mapchete_eo-2025.7.0.dist-info/METADATA,sha256=Yb9rTjokNJNKksLVg9Q0XBZMwtGKdbNFJQ7-BCI_bCk,1243
-mapchete_eo-2025.7.0.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
-mapchete_eo-2025.7.0.dist-info/entry_points.txt,sha256=ewk6R4FGdAclOnUpikhlPZGWI40MWeksVIIwu4jVebk,324
-mapchete_eo-2025.7.0.dist-info/licenses/LICENSE,sha256=TC5JwvBnFrUgsSQSCDFPc3cqlbth2N0q8MWrhY1EVd0,1089
-mapchete_eo-2025.7.0.dist-info/RECORD,,
+mapchete_eo-2025.8.1.dist-info/METADATA,sha256=Hx-501oDWvs2saCQF_NHSHg1LxrK_R4EY0bZy5wl9EA,3052
+mapchete_eo-2025.8.1.dist-info/WHEEL,sha256=tkmg4JIqwd9H8mL30xA7crRmoStyCtGp0VWshokd1Jc,105
+mapchete_eo-2025.8.1.dist-info/entry_points.txt,sha256=ewk6R4FGdAclOnUpikhlPZGWI40MWeksVIIwu4jVebk,324
+mapchete_eo-2025.8.1.dist-info/licenses/LICENSE,sha256=TC5JwvBnFrUgsSQSCDFPc3cqlbth2N0q8MWrhY1EVd0,1089
+mapchete_eo-2025.8.1.dist-info/RECORD,,

mapchete_eo-2025.7.0.dist-info/METADATA

@@ -1,38 +0,0 @@
-Metadata-Version: 2.4
-Name: mapchete-eo
-Version: 2025.7.0
-Summary: mapchete EO data reader
-Project-URL: Homepage, https://gitlab.eox.at/maps/mapchete_eo
-Author-email: Joachim Ungar <joachim.ungar@eox.at>, Petr Sevcik <petr.sevcik@eox.at>
-License-Expression: MIT
-License-File: LICENSE
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Topic :: Scientific/Engineering :: GIS
-Requires-Dist: blend-modes
-Requires-Dist: click
-Requires-Dist: croniter
-Requires-Dist: lxml
-Requires-Dist: mapchete[complete]>=2025.6.0
-Requires-Dist: opencv-python
-Requires-Dist: pillow
-Requires-Dist: pydantic
-Requires-Dist: pystac-client>=0.7.5
-Requires-Dist: pystac[urllib3]>=1.12.2
-Requires-Dist: retry
-Requires-Dist: rtree
-Requires-Dist: scipy
-Requires-Dist: tqdm
-Requires-Dist: xarray
-Provides-Extra: test
-Requires-Dist: pytest-coverage; extra == 'test'
-Requires-Dist: pytest-lazy-fixture; extra == 'test'
-Requires-Dist: pytest<8; extra == 'test'
-Description-Content-Type: text/markdown
-
-# Mapchete EO driver
-