eodash_catalog 0.0.6__py3-none-any.whl → 0.0.9__py3-none-any.whl

eodash_catalog/sh_endpoint.py

@@ -1,4 +1,5 @@
 import os
+
 from oauthlib.oauth2 import BackendApplicationClient
 from requests_oauthlib import OAuth2Session
 

eodash_catalog/stac_handling.py

@@ -0,0 +1,359 @@
+from datetime import datetime
+
+import requests
+import spdx_lookup as lookup
+import yaml
+from dateutil import parser
+from pystac import (
+    Asset,
+    Collection,
+    Extent,
+    Link,
+    Provider,
+    SpatialExtent,
+    TemporalExtent,
+)
+from yaml.loader import SafeLoader
+
+from eodash_catalog.utils import generateDateIsostringsFromInterval
+
+
+def get_or_create_collection_and_times(catalog, collection_id, data, config, endpoint=None):
+    # Check if collection already in catalog
+    for collection in catalog.get_collections():
+        if collection.id == collection_id:
+            return collection, []
+    # If none found create a new one
+    spatial_extent = endpoint.get("OverwriteBBox", [-180.0, -90.0, 180.0, 90.0])
+
+    spatial_extent = SpatialExtent(
+        [
+            spatial_extent,
+        ]
+    )
+    times = []
+    temporal_extent = TemporalExtent([[datetime.now(), None]])
+    if endpoint and endpoint.get("Type") == "OverwriteTimes":
+        if endpoint.get("Times"):
+            times = endpoint.get("Times")
+            times_datetimes = sorted([parser.isoparse(time) for time in times])
+            temporal_extent = TemporalExtent([[times_datetimes[0], times_datetimes[-1]]])
+        elif endpoint.get("DateTimeInterval"):
+            start = endpoint["DateTimeInterval"].get("Start", "2020-09-01T00:00:00")
+            end = endpoint["DateTimeInterval"].get("End", "2020-10-01T00:00:00")
+            timedelta_config = endpoint["DateTimeInterval"].get("Timedelta", {"days": 1})
+            times = generateDateIsostringsFromInterval(start, end, timedelta_config)
+            times_datetimes = sorted([parser.isoparse(time) for time in times])
+            temporal_extent = TemporalExtent([[times_datetimes[0], times_datetimes[-1]]])
+    extent = Extent(spatial=spatial_extent, temporal=temporal_extent)
+
+    # Check if description is link to markdown file
+    if "Description" in data:
+        description = data["Description"]
+        if description.endswith((".md", ".MD")):
+            if description.startswith("http"):
+                # if full absolute path is defined
+                response = requests.get(description)
+                if response.status_code == 200:
+                    description = response.text
+                elif "Subtitle" in data:
+                    print("WARNING: Markdown file could not be fetched")
+                    description = data["Subtitle"]
+            else:
+                # relative path to assets was given
+                response = requests.get(f"{config["assets_endpoint"]}/{description}")
+                if response.status_code == 200:
+                    description = response.text
+                elif "Subtitle" in data:
+                    print("WARNING: Markdown file could not be fetched")
+                    description = data["Subtitle"]
+    elif "Subtitle" in data:
+        # Try to use at least subtitle to fill some information
+        description = data["Subtitle"]
+
+    collection = Collection(
+        id=collection_id,
+        title=data["Title"],
+        description=description,
+        extent=extent,
+    )
+    return (collection, times)
+
+
+def create_web_map_link(layer, role):
+    extra_fields = {
+        "roles": [role],
+        "id": layer["id"],
+    }
+    if layer.get("default"):
+        extra_fields["roles"].append("default")
+    if layer.get("visible"):
+        extra_fields["roles"].append("visible")
+    if "visible" in layer and not layer["visible"]:
+        extra_fields["roles"].append("invisible")
+
+    match layer["protocol"]:
+        case "wms":
+            # handle wms special config options
+            extra_fields["wms:layers"] = layer["layers"]
+            if "styles" in layer:
+                extra_fields["wms:styles"] = layer["styles"]
+            # TODO: handle wms dimensions extra_fields["wms:dimensions"]
+        case "wmts":
+            extra_fields["wmts:layer"] = layer["layer"]
+            # TODO: handle wmts dimensions extra_fields["wmts:dimensions"]
+
+    wml = Link(
+        rel=layer["protocol"],
+        target=layer["url"],
+        media_type=layer.get("media_type", "image/png"),
+        title=layer["name"],
+        extra_fields=extra_fields,
+    )
+    return wml
+
+
+def add_example_info(stac_object, data, endpoint, config):
+    if "Services" in data:
+        for service in data["Services"]:
+            if service["Name"] == "Statistical API":
+                service_type = service.get("Type", "byoc")
+                stac_object.add_link(
+                    Link(
+                        rel="example",
+                        target="{}/{}".format(config["assets_endpoint"], service["Script"]),
+                        title="evalscript",
+                        media_type="application/javascript",
+                        extra_fields={
+                            "example:language": "JavaScript",
+                            "dataId": "{}-{}".format(service_type, service["CollectionId"]),
+                        },
+                    )
+                )
+            if service["Name"] == "VEDA Statistics":
+                stac_object.add_link(
+                    Link(
+                        rel="example",
+                        target=service["Endpoint"],
+                        title=service["Name"],
+                        media_type="application/json",
+                        extra_fields={
+                            "example:language": "JSON",
+                        },
+                    )
+                )
+            if service["Name"] == "EOxHub Notebook":
+                # TODO: we need to consider if we can improve information added
+                stac_object.add_link(
+                    Link(
+                        rel="example",
+                        target=service["Url"],
+                        title=(service["Title"] if "Title" in service else service["Name"]),
+                        media_type="application/x-ipynb+json",
+                        extra_fields={
+                            "example:language": "Jupyter Notebook",
+                            "example:container": True,
+                        },
+                    )
+                )
+    elif "Resources" in data:
+        for service in data["Resources"]:
+            if service.get("Name") == "xcube":
+                target_url = "{}/timeseries/{}/{}?aggMethods=median".format(
+                    endpoint["EndPoint"],
+                    endpoint["DatacubeId"],
+                    endpoint["Variable"],
+                )
+                stac_object.add_link(
+                    Link(
+                        rel="example",
+                        target=target_url,
+                        title=service["Name"] + " analytics",
+                        media_type="application/json",
+                        extra_fields={
+                            "example:language": "JSON",
+                            "example:method": "POST",
+                        },
+                    )
+                )
+
+
+def add_collection_information(config, collection, data):
+    # Add metadata information
+    # Check license identifier
+    if "License" in data:
+        # Check if list was provided
+        if isinstance(data["License"], list):
+            if len(data["License"]) == 1:
+                collection.license = "proprietary"
+                link = Link(
+                    rel="license",
+                    target=data["License"][0]["Url"],
+                    media_type=(data["License"][0].get("Type", "text/html")),
+                )
+                if "Title" in data["License"][0]:
+                    link.title = data["License"][0]["Title"]
+                collection.links.append(link)
+            elif len(data["License"]) > 1:
+                collection.license = "various"
+                for license_entry in data["License"]:
+                    link = Link(
+                        rel="license",
+                        target=license_entry["Url"],
+                        media_type="text/html"
+                        if "Type" in license_entry
+                        else license_entry["Type"],
+                    )
+                    if "Title" in license_entry:
+                        link.title = license_entry["Title"]
+                    collection.links.append(link)
+        else:
+            license_data = lookup.by_id(data["License"])
+            if license_data is not None:
+                collection.license = license_data.id
+                if license_data.sources:
+                    # add links to licenses
+                    for source in license_data.sources:
+                        collection.links.append(
+                            Link(
+                                rel="license",
+                                target=source,
+                                media_type="text/html",
+                            )
+                        )
+            else:
+                # fallback to proprietary
+                print("WARNING: License could not be parsed, falling back to proprietary")
+                collection.license = "proprietary"
+    else:
+        # print("WARNING: No license was provided, falling back to proprietary")
+        pass
+
+    if "Provider" in data:
+        try:
+            collection.providers = [
+                Provider(
+                    # convert information to lower case
+                    **{k.lower(): v for k, v in provider.items()}
+                )
+                for provider in data["Provider"]
+            ]
+        except Exception:
+            print(f"WARNING: Issue creating provider information for collection: {collection.id}")
+
+    if "Citation" in data:
+        if "DOI" in data["Citation"]:
+            collection.extra_fields["sci:doi"] = data["Citation"]["DOI"]
+        if "Citation" in data["Citation"]:
+            collection.extra_fields["sci:citation"] = data["Citation"]["Citation"]
+        if "Publication" in data["Citation"]:
+            collection.extra_fields["sci:publications"] = [
+                # convert keys to lower case
+                {k.lower(): v for k, v in publication.items()}
+                for publication in data["Citation"]["Publication"]
+            ]
+
+    if "Subtitle" in data:
+        collection.extra_fields["subtitle"] = data["Subtitle"]
+    if "Legend" in data:
+        collection.add_asset(
+            "legend",
+            Asset(
+                href=f"{config["assets_endpoint"]}/{data["Legend"]}",
+                media_type="image/png",
+                roles=["metadata"],
+            ),
+        )
+    if "Story" in data:
+        collection.add_asset(
+            "story",
+            Asset(
+                href=f"{config["assets_endpoint"]}/{data["Story"]}",
+                media_type="text/markdown",
+                roles=["metadata"],
+            ),
+        )
+    if "Image" in data:
+        collection.add_asset(
+            "thumbnail",
+            Asset(
+                href=f"{config["assets_endpoint"]}/{data["Image"]}",
+                media_type="image/png",
+                roles=["thumbnail"],
+            ),
+        )
+    # Add extra fields to collection if available
+    add_extra_fields(collection, data)
+
+    if "References" in data:
+        generic_counter = 1
+        for ref in data["References"]:
+            if "Key" in ref:
+                key = ref["Key"]
+            else:
+                key = f"reference_{generic_counter}"
+                generic_counter = generic_counter + 1
+            collection.add_asset(
+                key,
+                Asset(
+                    href=ref["Url"],
+                    title=ref["Name"],
+                    media_type=ref.get("MediaType", "text/html"),
+                    roles=["metadata"],
+                ),
+            )
+
+
+def add_base_overlay_info(collection, config, data):
+    # check if default base layers defined
+    if "default_base_layers" in config:
+        with open(f"{config["default_base_layers"]}.yaml") as f:
+            base_layers = yaml.load(f, Loader=SafeLoader)
+            for layer in base_layers:
+                collection.add_link(create_web_map_link(layer, role="baselayer"))
+    # check if default overlay layers defined
+    if "default_overlay_layers" in config:
+        with open("{}.yaml".format(config["default_overlay_layers"])) as f:
+            overlay_layers = yaml.load(f, Loader=SafeLoader)
+            for layer in overlay_layers:
+                collection.add_link(create_web_map_link(layer, role="overlay"))
+    if "BaseLayers" in data:
+        for layer in data["BaseLayers"]:
+            collection.add_link(create_web_map_link(layer, role="baselayer"))
+    if "OverlayLayers" in data:
+        for layer in data["OverlayLayers"]:
+            collection.add_link(create_web_map_link(layer, role="overlay"))
+    # TODO: possibility to overwrite default base and overlay layers
+
+
+def add_extra_fields(stac_object, data):
+    if "yAxis" in data:
+        stac_object.extra_fields["yAxis"] = data["yAxis"]
+    if "Themes" in data:
+        stac_object.extra_fields["themes"] = data["Themes"]
+    if "Locations" in data or "Subcollections" in data:
+        stac_object.extra_fields["locations"] = True
+    if "Tags" in data:
+        stac_object.extra_fields["tags"] = data["Tags"]
+    if "Satellite" in data:
+        stac_object.extra_fields["satellite"] = data["Satellite"]
+    if "Sensor" in data:
+        stac_object.extra_fields["sensor"] = data["Sensor"]
+    if "Agency" in data:
+        stac_object.extra_fields["agency"] = data["Agency"]
+    if "yAxis" in data:
+        stac_object.extra_fields["yAxis"] = data["yAxis"]
+    if "EodashIdentifier" in data:
+        stac_object.extra_fields["subcode"] = data["EodashIdentifier"]
+    if "DataSource" in data:
+        if "Spaceborne" in data["DataSource"]:
+            if "Sensor" in data["DataSource"]["Spaceborne"]:
+                stac_object.extra_fields["sensor"] = data["DataSource"]["Spaceborne"]["Sensor"]
+            if "Satellite" in data["DataSource"]["Spaceborne"]:
+                stac_object.extra_fields["satellite"] = data["DataSource"]["Spaceborne"][
+                    "Satellite"
+                ]
+        if "InSitu" in data["DataSource"]:
+            stac_object.extra_fields["insituSources"] = data["DataSource"]["InSitu"]
+        if "Other" in data["DataSource"]:
+            stac_object.extra_fields["otherSources"] = data["DataSource"]["Other"]

eodash_catalog/thumbnails.py

@@ -0,0 +1,49 @@
+import os
+import re
+from pathlib import Path
+
+import requests
+
+from eodash_catalog.utils import generate_veda_cog_link
+
+
+def fetch_and_save_thumbnail(data, url):
+    collection_path = "../thumbnails/{}_{}/".format(data["EodashIdentifier"], data["Name"])
+    Path(collection_path).mkdir(parents=True, exist_ok=True)
+    image_path = f"{collection_path}/thumbnail.png"
+    if not os.path.exists(image_path):
+        data = requests.get(url).content
+        with open(image_path, "wb") as f:
+            f.write(data)
+
+
+def generate_thumbnail(stac_object, data, endpoint, file_url=None, time=None, styles=None):
+    if endpoint["Name"] == "Sentinel Hub" or endpoint["Name"] == "WMS":
+        instanceId = os.getenv("SH_INSTANCE_ID")
+        if "InstanceId" in endpoint:
+            instanceId = endpoint["InstanceId"]
+        # Build example url
+        wms_config = (
+            "REQUEST=GetMap&SERVICE=WMS&VERSION=1.3.0&FORMAT=image/png&STYLES=&TRANSPARENT=true"
+        )
+        bbox_s = stac_object.bbox
+        bbox = f"{bbox_s[1]},{bbox_s[0]},{bbox_s[3]},{bbox_s[2]}"
+        output_format = f"format=image/png&WIDTH=256&HEIGHT=128&CRS=EPSG:4326&BBOX={bbox}"
+        item_datetime = stac_object.get_datetime()
+        # it is possible for datetime to be null,
+        # if it is start and end datetime have to exist
+        if item_datetime:
+            time = item_datetime.isoformat()[:-6] + "Z"
+        url = "https://services.sentinel-hub.com/ogc/wms/{}?{}&layers={}&time={}&{}".format(
+            instanceId,
+            wms_config,
+            endpoint["LayerId"],
+            time,
+            output_format,
+        )
+        fetch_and_save_thumbnail(data, url)
+    elif endpoint["Name"] == "VEDA":
+        target_url = generate_veda_cog_link(endpoint, file_url)
+        # set to get 0/0/0 tile
+        url = re.sub(r"\{.\}", "0", target_url)
+        fetch_and_save_thumbnail(data, url)

eodash_catalog/utils.py

@@ -1,15 +1,18 @@
-import json
 import re
-from functools import reduce
-from eodash_catalog.duration import Duration
-from decimal import Decimal
+import threading
+from collections.abc import Iterator
 from datetime import datetime, timedelta
-from typing import Iterator
-from six import string_types
+from decimal import Decimal
+from functools import reduce
+from typing import Any
+
+from dateutil import parser
 from owslib.wms import WebMapService
 from owslib.wmts import WebMapTileService
-from dateutil import parser
-import threading
+from pystac import Catalog
+from six import string_types
+
+from eodash_catalog.duration import Duration
 
 ISO8601_PERIOD_REGEX = re.compile(
     r"^(?P<sign>[+-])?"
@@ -25,26 +28,28 @@ ISO8601_PERIOD_REGEX = re.compile(
 # regular expression to parse ISO duartion strings.
 
 
-def create_geojson_point(lon, lat):
+def create_geojson_point(lon: int | float, lat: int | float) -> dict[str, Any]:
     point = {"type": "Point", "coordinates": [lon, lat]}
     return {"type": "Feature", "geometry": point, "properties": {}}
 
 
-def retrieveExtentFromWMSWMTS(capabilties_url, layer, wmts=False):
+def retrieveExtentFromWMSWMTS(
+    capabilities_url: str, layer: str, version: str = "1.1.1", wmts: bool = False
+):
     times = []
-    service = None
     try:
         if not wmts:
-            service = WebMapService(capabilties_url, version="1.1.1")
+            service = WebMapService(capabilities_url, version=version)
         else:
-            service = WebMapTileService(capabilties_url)
+            service = WebMapTileService(capabilities_url)
         if layer in list(service.contents):
             tps = []
-            if not wmts and service[layer].timepositions != None:
+            if not wmts and service[layer].timepositions is not None:
                 tps = service[layer].timepositions
             elif wmts:
+                time_dimension = service[layer].dimensions.get("time")
                 # specifically taking 'time' dimension
-                if time_dimension := service[layer].dimensions.get("time"):
+                if time_dimension:
                     tps = time_dimension["values"]
             for tp in tps:
                 tp_def = tp.split("/")
@@ -59,14 +64,14 @@ def retrieveExtentFromWMSWMTS(capabilties_url, layer, wmts=False):
                     times.append(tp)
             times = [time.replace("\n", "").strip() for time in times]
             # get unique times
-            times = reduce(lambda re, x: re + [x] if x not in re else re, times, [])
+            times = reduce(lambda re, x: [*re, x] if x not in re else re, times, [])
     except Exception as e:
         print("Issue extracting information from service capabilities")
         template = "An exception of type {0} occurred. Arguments:\n{1!r}"
         message = template.format(type(e).__name__, e.args)
         print(message)
 
-    bbox = [-180, -90, 180, 90]
+    bbox = [-180.0, -90.0, 180.0, 90.0]
     if service and service[layer].boundingBoxWGS84:
         bbox = [float(x) for x in service[layer].boundingBoxWGS84]
     return bbox, times
@@ -84,34 +89,8 @@ def parse_duration(datestring):
     Parses an ISO 8601 durations into datetime.timedelta
     """
     if not isinstance(datestring, string_types):
-        raise TypeError("Expecting a string %r" % datestring)
+        raise TypeError(f"Expecting a string {datestring}")
     match = ISO8601_PERIOD_REGEX.match(datestring)
-    if not match:
-        # try alternative format:
-        if datestring.startswith("P"):
-            durdt = parse_datetime(datestring[1:])
-            if durdt.year != 0 or durdt.month != 0:
-                # create Duration
-                ret = Duration(
-                    days=durdt.day,
-                    seconds=durdt.second,
-                    microseconds=durdt.microsecond,
-                    minutes=durdt.minute,
-                    hours=durdt.hour,
-                    months=durdt.month,
-                    years=durdt.year,
-                )
-            else:  # FIXME: currently not possible in alternative format
-                # create timedelta
-                ret = timedelta(
-                    days=durdt.day,
-                    seconds=durdt.second,
-                    microseconds=durdt.microsecond,
-                    minutes=durdt.minute,
-                    hours=durdt.hour,
-                )
-            return ret
-        raise ISO8601Error("Unable to parse duration string %r" % datestring)
     groups = match.groupdict()
     for key, val in groups.items():
         if key not in ("separator", "sign"):
@@ -149,7 +128,9 @@ def parse_duration(datestring):
     return ret
 
 
-def generateDateIsostringsFromInterval(start, end, timedelta_config={}):
+def generateDateIsostringsFromInterval(start: str, end: str, timedelta_config: dict | None = None):
+    if timedelta_config is None:
+        timedelta_config = {}
     start_dt = datetime.fromisoformat(start)
     if end == "today":
         end = datetime.now().isoformat()
@@ -174,3 +155,48 @@ class RaisingThread(threading.Thread):
         super().join(timeout=timeout)
         if self._exc:
             raise self._exc
+
+
+def recursive_save(stac_object: Catalog, no_items: bool = False) -> None:
+    stac_object.save_object()
+    for child in stac_object.get_children():
+        recursive_save(child, no_items)
+    if not no_items:
+        # try to save items if available
+        for item in stac_object.get_items():
+            item.save_object()
+
+
+def iter_len_at_least(i, n: int) -> int:
+    return sum(1 for _ in zip(range(n), i, strict=False)) == n
+
+
+def generate_veda_cog_link(endpoint, file_url):
+    bidx = ""
+    if "Bidx" in endpoint:
+        # Check if an array was provided
+        if hasattr(endpoint["Bidx"], "__len__"):
+            for band in endpoint["Bidx"]:
+                bidx = bidx + f"&bidx={band}"
+        else:
+            bidx = "&bidx={}".format(endpoint["Bidx"])
+
+    colormap = ""
+    if "Colormap" in endpoint:
+        colormap = "&colormap={}".format(endpoint["Colormap"])
+        # TODO: For now we assume a already urlparsed colormap definition
+        # it could be nice to allow a json and better convert it on the fly
+        # colormap = "&colormap=%s"%(urllib.parse.quote(str(endpoint["Colormap"])))
+
+    colormap_name = ""
+    if "ColormapName" in endpoint:
+        colormap_name = "&colormap_name={}".format(endpoint["ColormapName"])
+
+    rescale = ""
+    if "Rescale" in endpoint:
+        rescale = "&rescale={},{}".format(endpoint["Rescale"][0], endpoint["Rescale"][1])
+
+    file_url = f"url={file_url}&" if file_url else ""
+
+    target_url = f"https://staging-raster.delta-backend.com/cog/tiles/WebMercatorQuad/{{z}}/{{x}}/{{y}}?{file_url}resampling_method=nearest{bidx}{colormap}{colormap_name}{rescale}"
+    return target_url

{eodash_catalog-0.0.6.dist-info → eodash_catalog-0.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: eodash_catalog
-Version: 0.0.6
+Version: 0.0.9
 Summary: This package is intended to help create a compatible STAC catalog for the eodash dashboard client. It supports configuration of multiple endpoint types for information extraction.
 Project-URL: Documentation, https://github.com/eodash/eodash_catalog#readme
 Project-URL: Issues, https://github.com/eodash/eodash_catalog/issues
@@ -57,6 +57,49 @@ Description-Content-Type: text/markdown
 pip install eodash_catalog
 ```
 
+## Testing
+
+Project uses pytest and runs it as part of CI:
+
+```bash
+python -m pytest
+```
+
+## Testing
+
+Project uses ruff to perform checks on code style and formatting
+
+```bash
+ruff check .
+```
+
+## Versioning and branches
+
+eodash_catalog adheres to [Semantic Versioning](https://semver.org/) and follows these rules:
+
+Given a version number `MAJOR.MINOR.PATCH`, we increment the:
+
+- `MAJOR` version when we make incompatible API changes
+- `MINOR` version when we add functionality in a backward compatible manner
+- `PATCH` version when we make backward compatible bug fixes
+
+Active development is followed by the `main` branch.
+`
+New features or maintenance commits should be done against this branch in the form of a Merge Request of a Feature branch.
+
+## Tagging
+
+This repository uses bump2version for managing tags. To bump a version use
+
+```bash
+bump2version <major|minor|patch> # or bump2version --new-version <new_version>
+git push && git push --tags
+```
+
+Pushing a tag in the repository automatically creates:
+
+- versioned package on pypi
+
 ## License
 
 `eodash_catalog` is distributed under the terms of the [MIT](https://spdx.org/licenses/MIT.html) license.

eodash_catalog-0.0.9.dist-info/RECORD

@@ -0,0 +1,14 @@
+eodash_catalog/__about__.py,sha256=3LUM-OiYdbFCeovLVNBJ4p0kHdKQnUAE8vPJdtdpHhA,137
+eodash_catalog/__init__.py,sha256=_W_9emPYf6FUqc0P8L2SmADx6hGSd7PlQV3yRmCk5uM,115
+eodash_catalog/duration.py,sha256=B6XOZfvNU7SuqpxuVtT1kNKODoOQJXDI6mocvA_U1ik,10816
+eodash_catalog/endpoints.py,sha256=HrUjXNf6Eikd7uGmCnaZS31cHuZP_nYIgbGtAvSN4Q8,25942
+eodash_catalog/generate_indicators.py,sha256=1k__jFWChnFb7We3E5_wE3_gQN56eslAm1EcFB4MBNw,17227
+eodash_catalog/sh_endpoint.py,sha256=vHCqUnjXH4xB9T7L8UKd36TtUyqsyJLE84QBSXaONaA,582
+eodash_catalog/stac_handling.py,sha256=6ollozeJZbB7_FKKewG1P6qRyBCtt6bPrTSQhOedc04,14366
+eodash_catalog/thumbnails.py,sha256=yqjxJoZbTl2l2eyrRAnR13cU9fDHC0NSVT6ZnITSruw,1901
+eodash_catalog/utils.py,sha256=-uOspvzGNUeGpr1tjeySyBVV13kQYEMsC6Njw6JvhDc,6969
+eodash_catalog-0.0.9.dist-info/METADATA,sha256=ZcHAcKfXa6YY8BcMB2U56HCk8ti9c0LF55v9OyqM6Pk,3202
+eodash_catalog-0.0.9.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+eodash_catalog-0.0.9.dist-info/entry_points.txt,sha256=kuUQrDG1PtYd8kPjf5XM6H_NtQd9Ozwl0jjiGtAvZSM,87
+eodash_catalog-0.0.9.dist-info/licenses/LICENSE.txt,sha256=oJCW5zQxnFD-J0hGz6Zh5Lkpdk1oAndmWhseTmV224E,1107
+eodash_catalog-0.0.9.dist-info/RECORD,,

{eodash_catalog-0.0.6.dist-info → eodash_catalog-0.0.9.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.21.1
+Generator: hatchling 1.25.0
 Root-Is-Purelib: true
 Tag: py3-none-any