eodash_catalog 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

eodash_catalog/__about__.py

@@ -1,4 +1,4 @@
 # SPDX-FileCopyrightText: 2024-present Daniel Santillan <daniel.santillan@eox.at>
 #
 # SPDX-License-Identifier: MIT
-__version__ = "0.2.1"
+__version__ = "0.3.1"

eodash_catalog/duration.py

@@ -34,7 +34,7 @@ def max_days_in_month(year, month):
         return 31
     if month in (4, 6, 9, 11):
         return 30
-    if ((year % 400) == 0) or ((year % 100) != 0) and ((year % 4) == 0):
+    if ((year % 400) == 0) or (((year % 100) != 0) and ((year % 4) == 0)):
         return 29
     return 28
 
@@ -260,11 +260,10 @@ class Duration:
         the two Durations are considered equal.
         """
         if isinstance(other, Duration):
-            if (self.years * 12 + self.months) == (
-                other.years * 12 + other.months
-            ) and self.tdelta == other.tdelta:
-                return True
-            return False
+            return bool(
+                self.years * 12 + self.months == other.years * 12 + other.months
+                and self.tdelta == other.tdelta
+            )
         # check if other con be compared against timedelta object
         # will raise an AssertionError when optimisation is off
         if self.years == 0 and self.months == 0:
@@ -277,11 +276,10 @@ class Duration:
         the two Durations are considered not equal.
         """
         if isinstance(other, Duration):
-            if (self.years * 12 + self.months) != (
-                other.years * 12 + other.months
-            ) or self.tdelta != other.tdelta:
-                return True
-            return False
+            return bool(
+                self.years * 12 + self.months != other.years * 12 + other.months
+                or self.tdelta != other.tdelta
+            )
         # check if other can be compared against timedelta object
         # will raise an AssertionError when optimisation is off
         if self.years == 0 and self.months == 0:

eodash_catalog/endpoints.py

@@ -27,15 +27,16 @@ from eodash_catalog.stac_handling import (
 from eodash_catalog.thumbnails import generate_thumbnail
 from eodash_catalog.utils import (
     Options,
-    create_geojson_from_bbox,
+    create_geometry_from_bbox,
     filter_time_entries,
     format_datetime_to_isostring_zulu,
     generate_veda_cog_link,
-    merge_bboxes,
     parse_datestring_to_tz_aware_datetime,
     replace_with_env_variables,
     retrieveExtentFromWCS,
     retrieveExtentFromWMSWMTS,
+    save_items,
+    update_extents_from_collection_children,
 )
 
 LOGGER = get_logger(__name__)
@@ -75,13 +76,18 @@ def process_WCS_rasdaman_Endpoint(
 
 
 def process_STAC_Datacube_Endpoint(
-    catalog_config: dict, endpoint_config: dict, collection_config: dict, catalog: Catalog
+    catalog_config: dict,
+    endpoint_config: dict,
+    collection_config: dict,
+    coll_path_rel_to_root_catalog: str,
+    catalog: Catalog,
+    options: Options,
 ) -> Collection:
     collection = get_or_create_collection(
         catalog, collection_config["Name"], collection_config, catalog_config, endpoint_config
     )
     add_visualization_info(collection, collection_config, endpoint_config)
-
+    coll_path_rel_to_root_catalog = f'{coll_path_rel_to_root_catalog}/{collection_config["Name"]}'
     stac_endpoint_url = endpoint_config["EndPoint"]
     if endpoint_config.get("Name") == "xcube":
         stac_endpoint_url = stac_endpoint_url + endpoint_config.get("StacEndpoint", "")
@@ -114,7 +120,7 @@ def process_STAC_Datacube_Endpoint(
     # optionally subset time results based on config
     if query := endpoint_config.get("Query"):
         datetimes = filter_time_entries(datetimes, query)
-
+    items = []
     for dt in datetimes:
         new_item = Item(
             id=format_datetime_to_isostring_zulu(dt),
@@ -122,18 +128,25 @@ def process_STAC_Datacube_Endpoint(
             properties={},
             geometry=item.geometry,
             datetime=dt,
+            assets={"dummy_asset": Asset(href="")},
         )
         add_visualization_info(new_item, collection_config, endpoint_config)
-        link = collection.add_item(new_item)
-        # bubble up information we want to the link
-        link.extra_fields["datetime"] = format_datetime_to_isostring_zulu(dt)
+        items.append(new_item)
 
+    save_items(
+        collection,
+        items,
+        options.outputpath,
+        catalog_config["id"],
+        coll_path_rel_to_root_catalog,
+        options.gp,
+    )
     unit = variables.get(endpoint_config.get("Variable")).get("unit")
     if unit and "yAxis" not in collection_config:
         collection_config["yAxis"] = unit
-    if datetimes:
+    if datetimes and not options.gp:
         collection.update_extent_from_items()
-    else:
+    elif not datetimes:
         LOGGER.warn(f"NO datetimes returned for collection: {collection_id}!")
 
     add_collection_information(catalog_config, collection, collection_config)
@@ -145,19 +158,23 @@ def handle_STAC_based_endpoint(
     catalog_config: dict,
     endpoint_config: dict,
     collection_config: dict,
+    coll_path_rel_to_root_catalog: str,
     catalog: Catalog,
     options: Options,
     headers=None,
 ) -> Collection:
+    coll_path_rel_to_root_catalog = f'{coll_path_rel_to_root_catalog}/{collection_config["Name"]}'
     if collection_config.get("Locations"):
         root_collection = get_or_create_collection(
             catalog, collection_config["Name"], collection_config, catalog_config, endpoint_config
         )
         for location in collection_config["Locations"]:
+            identifier = location.get("Identifier", uuid.uuid4())
             collection = process_STACAPI_Endpoint(
                 catalog_config=catalog_config,
                 endpoint_config=endpoint_config,
                 collection_config=collection_config,
+                coll_path_rel_to_root_catalog=f"{coll_path_rel_to_root_catalog}/{identifier}",
                 catalog=catalog,
                 options=options,
                 headers=headers,
@@ -168,7 +185,7 @@ def handle_STAC_based_endpoint(
             # Update identifier to use location as well as title
             # TODO: should we use the name as id? it provides much more
             # information in the clients
-            collection.id = location.get("Identifier", uuid.uuid4())
+            collection.id = identifier
             collection.title = location.get("Name")
             # See if description should be overwritten
             if location.get("Description"):
@@ -192,11 +209,7 @@ def handle_STAC_based_endpoint(
                         location["OverwriteBBox"],
                     ]
                 )
-        root_collection.update_extent_from_items()
-        # Add bbox extents from children
-        for c_child in root_collection.get_children():
-            if isinstance(c_child, Collection):
-                root_collection.extent.spatial.bboxes.append(c_child.extent.spatial.bboxes[0])
+        update_extents_from_collection_children(root_collection)
     else:
         bbox = None
         if endpoint_config.get("Bbox"):
@@ -205,6 +218,7 @@ def handle_STAC_based_endpoint(
             catalog_config=catalog_config,
             endpoint_config=endpoint_config,
             collection_config=collection_config,
+            coll_path_rel_to_root_catalog=coll_path_rel_to_root_catalog,
             catalog=catalog,
             options=options,
             headers=headers,
@@ -221,6 +235,7 @@ def process_STACAPI_Endpoint(
     catalog_config: dict,
     endpoint_config: dict,
     collection_config: dict,
+    coll_path_rel_to_root_catalog: str,
     catalog: Catalog,
     options: Options,
     headers: dict[str, str] | None = None,
@@ -251,9 +266,8 @@ def process_STACAPI_Endpoint(
     )
     # We keep track of potential duplicate times in this list
     added_times = {}
-    any_item_added = False
+    items = []
     for item in results.items():
-        any_item_added = True
         item_datetime = item.get_datetime()
         if item_datetime is not None:
             iso_date = item_datetime.isoformat()[:10]
@@ -263,7 +277,6 @@ def process_STACAPI_Endpoint(
             if iso_date in added_times:
                 continue
             added_times[iso_date] = True
-        link = collection.add_item(item)
         if options.tn:
             if item.assets.get("cog_default"):
                 generate_thumbnail(
@@ -274,12 +287,10 @@ def process_STACAPI_Endpoint(
         # Check if we can create visualization link
         if endpoint_config.get("Assets"):
             add_visualization_info(item, collection_config, endpoint_config, item.id)
-            link.extra_fields["item"] = item.id
         elif item.assets.get("cog_default"):
             add_visualization_info(
                 item, collection_config, endpoint_config, item.assets["cog_default"].href
             )
-            link.extra_fields["cog_href"] = item.assets["cog_default"].href
         elif item_datetime:
             add_visualization_info(
                 item, collection_config, endpoint_config, datetimes=[item_datetime]
@@ -298,23 +309,31 @@ def process_STACAPI_Endpoint(
         if root_collection:
             item.set_collection(root_collection)
 
-        # bubble up information we want to the link
-        # it is possible for datetime to be null, if it is start and end datetime have to exist
-        if item_datetime:
-            link.extra_fields["datetime"] = format_datetime_to_isostring_zulu(item_datetime)
-        else:
-            link.extra_fields["start_datetime"] = format_datetime_to_isostring_zulu(
-                parse_datestring_to_tz_aware_datetime(item.properties["start_datetime"])
-            )
-            link.extra_fields["end_datetime"] = format_datetime_to_isostring_zulu(
-                parse_datestring_to_tz_aware_datetime(item.properties["end_datetime"])
-            )
         add_projection_info(
             endpoint_config,
             item,
         )
-    if any_item_added:
-        collection.update_extent_from_items()
+        # we check if the item has any assets, if not we create a dummy asset
+        if not item.assets:
+            item.assets["dummy_asset"] = Asset(href="")
+        if "cog_default" in item.assets and item.assets["cog_default"].extra_fields.get(
+            "raster:bands"
+        ):
+            # saving via pyarrow does not work well with statistics ranges
+            # Integer value -10183824872833024 is outside of the range exactly
+            # representable by a IEEE 754 double precision value
+            item.assets["cog_default"].extra_fields.pop("raster:bands")
+        items.append(item)
+
+    if len(items) > 0:
+        save_items(
+            collection,
+            items,
+            options.outputpath,
+            catalog_config["id"],
+            coll_path_rel_to_root_catalog,
+            options.gp,
+        )
     else:
         LOGGER.warn(
             f"""NO items returned for
@@ -339,11 +358,17 @@ def handle_VEDA_endpoint(
     catalog_config: dict,
     endpoint_config: dict,
     collection_config: dict,
+    coll_path_rel_to_root_catalog: str,
     catalog: Catalog,
     options: Options,
 ) -> Collection:
     collection = handle_STAC_based_endpoint(
-        catalog_config, endpoint_config, collection_config, catalog, options
+        catalog_config,
+        endpoint_config,
+        collection_config,
+        coll_path_rel_to_root_catalog,
+        catalog,
+        options,
     )
     return collection
 
@@ -373,12 +398,18 @@ def handle_collection_only(
 
 
 def handle_SH_WMS_endpoint(
-    catalog_config: dict, endpoint_config: dict, collection_config: dict, catalog: Catalog
+    catalog_config: dict,
+    endpoint_config: dict,
+    collection_config: dict,
+    coll_path_rel_to_root_catalog: str,
+    catalog: Catalog,
+    options: Options,
 ) -> Collection:
     # create collection and subcollections (based on locations)
     root_collection = get_or_create_collection(
         catalog, collection_config["Name"], collection_config, catalog_config, endpoint_config
     )
+    coll_path_rel_to_root_catalog = f'{coll_path_rel_to_root_catalog}/{collection_config["Name"]}'
     if collection_config.get("Locations"):
         for location in collection_config["Locations"]:
             # create  and populate location collections based on times
@@ -391,23 +422,31 @@ def handle_SH_WMS_endpoint(
                 catalog, location["Identifier"], location_config, catalog_config, endpoint_config
             )
             collection.extra_fields["endpointtype"] = endpoint_config["Name"]
+            items = []
             for time_string in location["Times"]:
                 dt = parse_datestring_to_tz_aware_datetime(time_string)
                 item = Item(
                     id=format_datetime_to_isostring_zulu(dt),
                     bbox=location["Bbox"],
                     properties={},
-                    geometry=None,
+                    geometry=create_geometry_from_bbox(location["Bbox"]),
                     datetime=dt,
                     stac_extensions=[
                         "https://stac-extensions.github.io/web-map-links/v1.1.0/schema.json",
                     ],
+                    assets={"dummy_asset": Asset(href="")},
                 )
                 add_projection_info(endpoint_config, item)
                 add_visualization_info(item, collection_config, endpoint_config, datetimes=[dt])
-                item_link = collection.add_item(item)
-                item_link.extra_fields["datetime"] = format_datetime_to_isostring_zulu(dt)
-
+                items.append(item)
+            save_items(
+                collection,
+                items,
+                options.outputpath,
+                catalog_config["id"],
+                f"{coll_path_rel_to_root_catalog}/{collection.id}",
+                options.gp,
+            )
             link = root_collection.add_child(collection)
             # bubble up information we want to the link
             latlng = "{},{}".format(location["Point"][1], location["Point"][0]).strip()
@@ -415,38 +454,47 @@ def handle_SH_WMS_endpoint(
             link.extra_fields["latlng"] = latlng
             link.extra_fields["country"] = location["Country"]
             link.extra_fields["city"] = location["Name"]
-            if location["Times"]:
+            if location["Times"] and not options.gp:
                 collection.update_extent_from_items()
-            else:
+            elif not location["Times"]:
                 LOGGER.warn(f"NO datetimes configured for collection: {collection_config['Name']}!")
             add_visualization_info(collection, collection_config, endpoint_config)
             add_process_info_child_collection(collection, catalog_config, collection_config)
-
-        root_collection.update_extent_from_items()
-        # Add bbox extents from children
-        for c_child in root_collection.get_children():
-            if isinstance(c_child, Collection):
-                root_collection.extent.spatial.bboxes.append(c_child.extent.spatial.bboxes[0])
+        update_extents_from_collection_children(root_collection)
     else:
         # if locations are not provided, treat the collection as a
         # general proxy to the sentinel hub layer
         datetimes = get_collection_datetimes_from_config(endpoint_config)
         bbox = endpoint_config.get("Bbox", [-180, -85, 180, 85])
+        items = []
         for dt in datetimes:
             item = Item(
                 id=format_datetime_to_isostring_zulu(dt),
                 bbox=bbox,
                 properties={},
-                geometry=None,
+                geometry=create_geometry_from_bbox(bbox),
                 datetime=dt,
                 stac_extensions=[
                     "https://stac-extensions.github.io/web-map-links/v1.1.0/schema.json",
                 ],
+                assets={"dummy_asset": Asset(href="")},
             )
             add_projection_info(endpoint_config, item)
             add_visualization_info(item, collection_config, endpoint_config, datetimes=[dt])
-            item_link = root_collection.add_item(item)
-            item_link.extra_fields["datetime"] = format_datetime_to_isostring_zulu(dt)
+            items.append(item)
+        save_items(
+            root_collection,
+            items,
+            options.outputpath,
+            catalog_config["id"],
+            coll_path_rel_to_root_catalog,
+            options.gp,
+        )
+        # set spatial extent from config
+        root_collection.extent.spatial.bboxes = [bbox]
+        # set time extent from geodb
+        time_extent = [min(datetimes), max(datetimes)]
+        root_collection.extent.temporal = TemporalExtent([time_extent])
     # eodash v4 compatibility
     add_collection_information(catalog_config, root_collection, collection_config, True)
     add_visualization_info(root_collection, collection_config, endpoint_config)
@@ -454,13 +502,20 @@ def handle_SH_WMS_endpoint(
 
 
 def handle_xcube_endpoint(
-    catalog_config: dict, endpoint_config: dict, collection_config: dict, catalog: Catalog
+    catalog_config: dict,
+    endpoint_config: dict,
+    collection_config: dict,
+    coll_path_rel_to_root_catalog: str,
+    catalog: Catalog,
+    options: Options,
 ) -> Collection:
     collection = process_STAC_Datacube_Endpoint(
         catalog_config=catalog_config,
         endpoint_config=endpoint_config,
         collection_config=collection_config,
         catalog=catalog,
+        options=options,
+        coll_path_rel_to_root_catalog=coll_path_rel_to_root_catalog,
     )
 
     add_example_info(collection, collection_config, endpoint_config, catalog_config)
@@ -468,23 +523,33 @@ def handle_xcube_endpoint(
 
 
 def handle_rasdaman_endpoint(
-    catalog_config: dict, endpoint_config: dict, collection_config: dict, catalog: Catalog
+    catalog_config: dict,
+    endpoint_config: dict,
+    collection_config: dict,
+    coll_path_rel_to_root_catalog: str,
+    catalog: Catalog,
 ) -> Collection:
     collection = process_WCS_rasdaman_Endpoint(
-        catalog_config, endpoint_config, collection_config, catalog
+        catalog_config, endpoint_config, collection_config, coll_path_rel_to_root_catalog, catalog
     )
     # add_example_info(collection, collection_config, endpoint_config, catalog_config)
     return collection
 
 
 def handle_GeoDB_endpoint(
-    catalog_config: dict, endpoint_config: dict, collection_config: dict, catalog: Catalog
+    catalog_config: dict,
+    endpoint_config: dict,
+    collection_config: dict,
+    coll_path_rel_to_root_catalog: str,
+    catalog: Catalog,
+    options: Options,
 ) -> Collection:
     # ID of collection is data["Name"] instead of CollectionId to be able to
     # create more STAC collections from one geoDB table
     collection = get_or_create_collection(
         catalog, collection_config["Name"], collection_config, catalog_config, endpoint_config
     )
+    coll_path_rel_to_root_catalog = f'{coll_path_rel_to_root_catalog}/{collection_config["Name"]}'
     select = "?select=aoi,aoi_id,country,city,time,input_data,sub_aoi"
     url = (
         endpoint_config["EndPoint"]
@@ -538,6 +603,7 @@ def handle_GeoDB_endpoint(
             collection, key, sc_config, catalog_config, endpoint_config
         )
         if input_data:
+            items = []
             for v in values:
                 # add items based on inputData fields for each time step available in values
                 first_match = next(
@@ -548,14 +614,20 @@ def handle_GeoDB_endpoint(
                 if "sub_aoi" in v and v["sub_aoi"] != "/":
                     # create geometry from wkt
                     geometry = mapping(wkt.loads(v["sub_aoi"]))
+                    # converting multipolygon to polygon to avoid shapely throwing an exception
+                    # in collection extent from geoparquet table generation
+                    # while trying to create a multipolygon extent of all multipolygons
+                    if geometry["type"] == "MultiPolygon":
+                        geometry = {"type": "Polygon", "coordinates": geometry["coordinates"][0]}
                 else:
-                    geometry = create_geojson_from_bbox(bbox)
+                    geometry = create_geometry_from_bbox(bbox)
                 item = Item(
                     id=v["time"],
                     bbox=bbox,
                     properties={},
                     geometry=geometry,
                     datetime=time_object,
+                    assets={"dummy_asset": Asset(href="")},
                 )
                 if first_match:
                     match first_match["Type"]:
@@ -591,15 +663,15 @@ def handle_GeoDB_endpoint(
                                 extra_fields=extra_fields,
                             )
                             item.add_link(link)
-                            itemlink = locations_collection.add_item(item)
-                            itemlink.extra_fields["datetime"] = (
-                                f"{format_datetime_to_isostring_zulu(time_object)}Z"
-                            )
-
-            # add_visualization_info(
-            #     item, collection_config, endpoint_config, file_url=first_match.get("FileUrl")
-            # )
-            locations_collection.update_extent_from_items()
+                            items.append(item)
+            save_items(
+                locations_collection,
+                items,
+                options.outputpath,
+                catalog_config["id"],
+                f"{coll_path_rel_to_root_catalog}/{locations_collection.id}",
+                options.gp,
+            )
         else:
             # set spatial extent from geodb
             locations_collection.extent.spatial.bboxes = [bbox]
@@ -631,32 +703,9 @@ def handle_GeoDB_endpoint(
     add_collection_information(catalog_config, collection, collection_config)
     add_example_info(collection, collection_config, endpoint_config, catalog_config)
     collection.extra_fields["locations"] = True
-    if not input_data:
-        # we have no items, extents of collection need to be updated manually
-        merged_bbox = merge_bboxes(
-            [
-                c_child.extent.spatial.bboxes[0]
-                for c_child in collection.get_children()
-                if isinstance(c_child, Collection)
-            ]
-        )
-        collection.extent.spatial.bboxes = [merged_bbox]
-        # Add bbox extents from children
-        for c_child in collection.get_children():
-            if isinstance(c_child, Collection) and merged_bbox != c_child.extent.spatial.bboxes[0]:
-                collection.extent.spatial.bboxes.append(c_child.extent.spatial.bboxes[0])
-        # set time extent of collection
-        individual_datetimes = []
-        for c_child in collection.get_children():
-            if isinstance(c_child, Collection) and isinstance(
-                c_child.extent.temporal.intervals[0], list
-            ):
-                individual_datetimes.extend(c_child.extent.temporal.intervals[0])  # type: ignore
-        time_extent = [min(individual_datetimes), max(individual_datetimes)]
-        collection.extent.temporal = TemporalExtent([time_extent])
-    else:
-        # we can update from items
-        collection.update_extent_from_items()
+
+    update_extents_from_collection_children(collection)
+
     collection.summaries = Summaries(
         {
             "cities": cities,
@@ -670,6 +719,7 @@ def handle_SH_endpoint(
     catalog_config: dict,
     endpoint_config: dict,
     collection_config: dict,
+    coll_path_rel_to_root_catalog: str,
     catalog: Catalog,
     options: Options,
 ) -> Collection:
@@ -682,7 +732,13 @@ def handle_SH_endpoint(
             endpoint_config["Type"] + "-" + endpoint_config["CollectionId"]
         )
     collection = handle_STAC_based_endpoint(
-        catalog_config, endpoint_config, collection_config, catalog, options, headers
+        catalog_config,
+        endpoint_config,
+        collection_config,
+        coll_path_rel_to_root_catalog,
+        catalog,
+        options,
+        headers,
     )
     return collection
 
@@ -691,12 +747,15 @@ def handle_WMS_endpoint(
     catalog_config: dict,
     endpoint_config: dict,
     collection_config: dict,
+    coll_path_rel_to_root_catalog: str,
     catalog: Catalog,
+    options: Options,
     wmts: bool = False,
 ) -> Collection:
     collection = get_or_create_collection(
         catalog, collection_config["Name"], collection_config, catalog_config, endpoint_config
     )
+    coll_path_rel_to_root_catalog = f'{coll_path_rel_to_root_catalog}/{collection_config["Name"]}'
     datetimes = get_collection_datetimes_from_config(endpoint_config)
     spatial_extent = collection.extent.spatial.to_dict().get("bbox", [-180, -90, 180, 90])[0]
     if endpoint_config.get("Type") != "OverwriteTimes" or not endpoint_config.get("OverwriteBBox"):
@@ -712,6 +771,10 @@ def handle_WMS_endpoint(
     # optionally filter time results
     if query := endpoint_config.get("Query"):
         datetimes = filter_time_entries(datetimes, query)
+
+    # we first collect the items and then decide if to save as geoparquet or individual items
+    items = []
+
     # Create an item per time to allow visualization in stac clients
     if len(datetimes) > 0:
         for dt in datetimes:
@@ -719,20 +782,29 @@ def handle_WMS_endpoint(
                 id=format_datetime_to_isostring_zulu(dt),
                 bbox=spatial_extent,
                 properties={},
-                geometry=None,
+                geometry=create_geometry_from_bbox(spatial_extent),
                 datetime=dt,
                 stac_extensions=[
                     "https://stac-extensions.github.io/web-map-links/v1.1.0/schema.json",
                 ],
+                assets={"dummy_asset": Asset(href="")},
             )
             add_projection_info(endpoint_config, item)
             add_visualization_info(item, collection_config, endpoint_config, datetimes=[dt])
-            link = collection.add_item(item)
-            link.extra_fields["datetime"] = format_datetime_to_isostring_zulu(dt)
-        collection.update_extent_from_items()
+            items.append(item)
     else:
         LOGGER.warn(f"NO datetimes returned for collection: {collection_config['Name']}!")
 
+    # Save items either into collection as individual items or as geoparquet
+    save_items(
+        collection,
+        items,
+        options.outputpath,
+        catalog_config["id"],
+        coll_path_rel_to_root_catalog,
+        options.gp,
+    )
+
     # Check if we should overwrite bbox
     if endpoint_config.get("OverwriteBBox"):
         collection.extent.spatial = SpatialExtent(
@@ -758,7 +830,11 @@ def generate_veda_tiles_link(endpoint_config: dict, item: str | None) -> str:
     if endpoint_config.get("NoData"):
         no_data = "&no_data={}".format(endpoint_config["NoData"])
     item = item if item else "{item}"
-    target_url = f"https://openveda.cloud/api/raster/collections/{collection}/items/{item}/tiles/WebMercatorQuad/{{z}}/{{x}}/{{y}}?{assets}{color_formula}{no_data}"
+    target_url_base = endpoint_config["EndPoint"].replace("/stac/", "")
+    target_url = (
+        f"{target_url_base}/raster/collections/{collection}/items/{item}"
+        f"/tiles/WebMercatorQuad/{{z}}/{{x}}/{{y}}?{assets}{color_formula}{no_data}"
+    )
     return target_url
 
 
@@ -1071,12 +1147,16 @@ def handle_raw_source(
     catalog_config: dict,
     endpoint_config: dict,
     collection_config: dict,
+    coll_path_rel_to_root_catalog: str,
     catalog: Catalog,
+    options: Options,
 ) -> Collection:
     collection = get_or_create_collection(
         catalog, collection_config["Name"], collection_config, catalog_config, endpoint_config
     )
+    coll_path_rel_to_root_catalog = f'{coll_path_rel_to_root_catalog}/{collection_config["Name"]}'
     if len(endpoint_config.get("TimeEntries", [])) > 0:
+        items = []
         style_link = None
         for time_entry in endpoint_config["TimeEntries"]:
             assets = {}
@@ -1099,7 +1179,7 @@ def handle_raw_source(
                 id=format_datetime_to_isostring_zulu(dt),
                 bbox=bbox,
                 properties={},
-                geometry=create_geojson_from_bbox(bbox)["features"][0]["geometry"],
+                geometry=create_geometry_from_bbox(bbox),
                 datetime=dt,
                 assets=assets,
                 extra_fields={},
@@ -1125,13 +1205,19 @@ def handle_raw_source(
                     },
                 )
                 item.add_link(style_link)
-            link = collection.add_item(item)
-            link.extra_fields["datetime"] = format_datetime_to_isostring_zulu(dt)
-            link.extra_fields["assets"] = [a["File"] for a in time_entry["Assets"]]
+            items.append(item)
+
+        save_items(
+            collection,
+            items,
+            options.outputpath,
+            catalog_config["id"],
+            coll_path_rel_to_root_catalog,
+            options.gp,
+        )
         # eodash v4 compatibility, adding last referenced style to collection
         if style_link:
             collection.add_link(style_link)
-        collection.update_extent_from_items()
     else:
         LOGGER.warn(f"NO datetimes configured for collection: {collection_config['Name']}!")
 

eodash_catalog/generate_indicators.py

@@ -6,12 +6,11 @@ Indicator generator to harvest information from endpoints and generate catalog
 
 import os
 import time
-from datetime import datetime
 from typing import Any
 
 import click
 from dotenv import load_dotenv
-from pystac import Catalog, CatalogType, Collection, Link, Summaries, TemporalExtent
+from pystac import Catalog, CatalogType, Collection, Link, Summaries
 from pystac.layout import TemplateLayoutStrategy
 from pystac.validation import validate_all
 from structlog import get_logger
@@ -41,10 +40,10 @@ from eodash_catalog.utils import (
     RaisingThread,
     add_single_item_if_collection_empty,
     iter_len_at_least,
-    merge_bboxes,
     read_config_file,
     recursive_save,
     retry,
+    update_extents_from_collection_children,
 )
 
 # make sure we are loading the env local definition
@@ -99,10 +98,10 @@ def process_catalog_file(file_path: str, options: Options):
 
     LOGGER.info("Started creation of collection files")
     start = time.time()
-    if options.ni or options.gp:
+    if options.ni:
         catalog_self_href = f'{options.outputpath}/{catalog_config["id"]}'
         catalog.normalize_hrefs(catalog_self_href, strategy=strategy)
-        recursive_save(catalog, options.ni, options.gp)
+        recursive_save(catalog, options.ni)
     else:
         # For full catalog save with items this still seems to be faster
         catalog_self_href = catalog_config.get(
@@ -170,6 +169,7 @@ def process_indicator_file(
         catalog, indicator_config["Name"], indicator_config, catalog_config, {}
     )
     if indicator_config.get("Collections"):
+        coll_path_rel_to_root_catalog = indicator_config["Name"]
         for collection in indicator_config["Collections"]:
             process_collection_file(
                 catalog_config,
@@ -177,6 +177,7 @@ def process_indicator_file(
                 parent_indicator,
                 options,
                 "Disable" in indicator_config and collection in indicator_config["Disable"],
+                coll_path_rel_to_root_catalog,
             )
     else:
         # we assume that collection files can also be loaded directly
@@ -186,29 +187,7 @@ def process_indicator_file(
         parent_indicator.update_extent_from_items()
     # get shared extent of all of the collections
     # they might have OverwriteBBox and that would discard it for indicator
-    merged_bbox = merge_bboxes(
-        [
-            c_child.extent.spatial.bboxes[0]
-            for c_child in parent_indicator.get_children()
-            if isinstance(c_child, Collection)
-        ]
-    )
-    parent_indicator.extent.spatial.bboxes = [merged_bbox]
-    # Add bbox extents from children
-    for c_child in parent_indicator.get_children():
-        if isinstance(c_child, Collection) and merged_bbox != c_child.extent.spatial.bboxes[0]:
-            parent_indicator.extent.spatial.bboxes.append(c_child.extent.spatial.bboxes[0])
-    # aggregate all time extents from the child collections and make it a indicator extent
-    individual_datetimes: list[datetime] = []
-    for c_child in parent_indicator.get_children():
-        if isinstance(c_child, Collection) and isinstance(
-            c_child.extent.temporal.intervals[0], list
-        ):
-            individual_datetimes.extend(c_child.extent.temporal.intervals[0])  # type: ignore
-    # filter out None
-    individual_datetimes = list(filter(lambda x: x is not None, individual_datetimes))
-    time_extent = [min(individual_datetimes), max(individual_datetimes)]
-    parent_indicator.extent.temporal = TemporalExtent([time_extent])
+    update_extents_from_collection_children(parent_indicator)
     # extract collection information and add it to summary indicator level
     extract_indicator_info(parent_indicator)
     add_process_info(parent_indicator, catalog_config, indicator_config)
@@ -224,49 +203,95 @@ def process_collection_file(
     catalog: Catalog | Collection,
     options: Options,
     disable=False,
+    coll_path_rel_to_root_catalog: str = "",
 ):
     LOGGER.info(f"Processing collection: {file_path}")
     collection_config = read_config_file(file_path)
+    if not coll_path_rel_to_root_catalog:
+        # case when a single collection made the indicator
+        coll_path_rel_to_root_catalog = collection_config["Name"]
     if collection_config.get("Resources"):
         for endpoint_config in collection_config["Resources"]:
             try:
                 collection = None
                 if endpoint_config["Name"] == "Sentinel Hub":
                     collection = handle_SH_endpoint(
-                        catalog_config, endpoint_config, collection_config, catalog, options
+                        catalog_config,
+                        endpoint_config,
+                        collection_config,
+                        coll_path_rel_to_root_catalog,
+                        catalog,
+                        options,
                     )
                 elif endpoint_config["Name"] == "Sentinel Hub WMS":
                     collection = handle_SH_WMS_endpoint(
-                        catalog_config, endpoint_config, collection_config, catalog
+                        catalog_config,
+                        endpoint_config,
+                        collection_config,
+                        coll_path_rel_to_root_catalog,
+                        catalog,
+                        options,
                     )
                 elif endpoint_config["Name"] == "GeoDB":
                     collection = handle_GeoDB_endpoint(
-                        catalog_config, endpoint_config, collection_config, catalog
+                        catalog_config,
+                        endpoint_config,
+                        collection_config,
+                        coll_path_rel_to_root_catalog,
+                        catalog,
+                        options,
                     )
                 elif endpoint_config["Name"] == "VEDA":
                     collection = handle_VEDA_endpoint(
-                        catalog_config, endpoint_config, collection_config, catalog, options
+                        catalog_config,
+                        endpoint_config,
+                        collection_config,
+                        coll_path_rel_to_root_catalog,
+                        catalog,
+                        options,
                     )
                 elif endpoint_config["Name"] == "marinedatastore":
                     collection = handle_WMS_endpoint(
-                        catalog_config, endpoint_config, collection_config, catalog, wmts=True
+                        catalog_config,
+                        endpoint_config,
+                        collection_config,
+                        coll_path_rel_to_root_catalog,
+                        catalog,
+                        options,
+                        wmts=True,
                     )
                 elif endpoint_config["Name"] == "xcube":
                     collection = handle_xcube_endpoint(
-                        catalog_config, endpoint_config, collection_config, catalog
+                        catalog_config,
+                        endpoint_config,
+                        collection_config,
+                        coll_path_rel_to_root_catalog,
+                        catalog,
+                        options,
                     )
                 elif endpoint_config["Name"] == "rasdaman":
                     collection = handle_rasdaman_endpoint(
-                        catalog_config, endpoint_config, collection_config, catalog
+                        catalog_config, endpoint_config, collection_config, catalog, options
                     )
                 elif endpoint_config["Name"] == "WMS":
                     collection = handle_WMS_endpoint(
-                        catalog_config, endpoint_config, collection_config, catalog
+                        catalog_config,
+                        endpoint_config,
+                        collection_config,
+                        coll_path_rel_to_root_catalog,
+                        catalog,
+                        options,
                     )
                 elif endpoint_config["Name"] == "JAXA_WMTS_PALSAR":
                     # somewhat one off creation of individual WMTS layers as individual items
                     collection = handle_WMS_endpoint(
-                        catalog_config, endpoint_config, collection_config, catalog, wmts=True
+                        catalog_config,
+                        endpoint_config,
+                        collection_config,
+                        coll_path_rel_to_root_catalog,
+                        catalog,
+                        options,
+                        wmts=True,
                     )
                 elif endpoint_config["Name"] == "Collection-only":
                     collection = handle_collection_only(
@@ -285,12 +310,19 @@ def process_collection_file(
                     "FlatGeobuf source",
                 ]:
                     collection = handle_raw_source(
-                        catalog_config, endpoint_config, collection_config, catalog
+                        catalog_config,
+                        endpoint_config,
+                        collection_config,
+                        coll_path_rel_to_root_catalog,
+                        catalog,
+                        options,
                     )
                 else:
                     raise ValueError("Type of Resource is not supported")
                 if collection:
-                    add_single_item_if_collection_empty(endpoint_config, collection)
+                    # check if geoparquet flag is used, as these collections have no items
+                    if not options.gp:
+                        add_single_item_if_collection_empty(endpoint_config, collection)
                     add_projection_info(endpoint_config, collection)
                     add_to_catalog(collection, catalog, endpoint_config, collection_config, disable)
                 else:
@@ -304,7 +336,9 @@ def process_collection_file(
         parent_collection = get_or_create_collection(
             catalog, collection_config["Name"], collection_config, catalog_config, {}
         )
-
+        coll_path_rel_to_root_catalog = (
+            f'{coll_path_rel_to_root_catalog}/{collection_config["Name"]}'
+        )
         locations = []
         countries = []
         for sub_coll_def in collection_config["Subcollections"]:
@@ -316,11 +350,16 @@ def process_collection_file(
                     countries.extend(sub_coll_def["Country"])
                 else:
                     countries.append(sub_coll_def["Country"])
+                coll_path_rel_to_root_catalog = (
+                    f"{coll_path_rel_to_root_catalog}/{sub_coll_def['Collection']}"
+                )
                 process_collection_file(
                     catalog_config,
                     "{}/{}".format(options.collectionspath, sub_coll_def["Collection"]),
                     parent_collection,
                     options,
+                    False,
+                    coll_path_rel_to_root_catalog,
                 )
                 # find link in parent collection to update metadata
                 for link in parent_collection.links:
@@ -345,11 +384,16 @@ def process_collection_file(
             else:
                 # create temp catalog to save collection
                 tmp_catalog = Catalog(id="tmp_catalog", description="temp catalog placeholder")
+                coll_path_rel_to_root_catalog = (
+                    f"{coll_path_rel_to_root_catalog}/{sub_coll_def['Collection']}"
+                )
                 process_collection_file(
                     catalog_config,
                     "{}/{}".format(options.collectionspath, sub_coll_def["Collection"]),
                     tmp_catalog,
                     options,
+                    None,
+                    coll_path_rel_to_root_catalog,
                 )
                 links = tmp_catalog.get_child(sub_coll_def["Identifier"]).get_links()  # type: ignore
                 for link in links:
@@ -366,11 +410,7 @@ def process_collection_file(
 
         add_collection_information(catalog_config, parent_collection, collection_config, True)
         add_process_info(parent_collection, catalog_config, collection_config)
-        parent_collection.update_extent_from_items()
-        # Add bbox extents from children
-        for c_child in parent_collection.get_children():
-            if isinstance(c_child, Collection):
-                parent_collection.extent.spatial.bboxes.append(c_child.extent.spatial.bboxes[0])
+        update_extents_from_collection_children(parent_collection)
         # Fill summaries for locations
         parent_collection.summaries = Summaries(
             {

eodash_catalog/utils.py

@@ -11,14 +11,17 @@ from decimal import Decimal
 from functools import reduce, wraps
 from typing import Any
 
+import pyarrow.compute as pc
 import stac_geoparquet as stacgp
 import yaml
 from dateutil import parser
 from owslib.wcs import WebCoverageService
 from owslib.wms import WebMapService
 from owslib.wmts import WebMapTileService
-from pystac import Asset, Catalog, Collection, Item, Link, RelType
+from pystac import Asset, Catalog, Collection, Item, Link, RelType, SpatialExtent, TemporalExtent
 from pytz import timezone as pytztimezone
+from shapely import geometry as sgeom
+from shapely import wkb
 from six import string_types
 from structlog import get_logger
 
@@ -45,7 +48,15 @@ def create_geojson_point(lon: int | float, lat: int | float) -> dict[str, Any]:
     return {"type": "Feature", "geometry": point, "properties": {}}
 
 
-def create_geojson_from_bbox(bbox: list[float | int]) -> dict:
+def create_geometry_from_bbox(bbox: list[float | int]) -> dict:
+    """
+    Create a GeoJSON geometry from a bounding box.
+    Args:
+        bbox (list[float | int]): A list containing the bounding box coordinates in the format
+        [min_lon, min_lat, max_lon, max_lat].
+    Returns:
+        dict: A GeoJSON geometry object representing the bounding box.
+    """
     coordinates = [
         [bbox[0], bbox[1]],
         [bbox[2], bbox[1]],
@@ -53,11 +64,7 @@ def create_geojson_from_bbox(bbox: list[float | int]) -> dict:
         [bbox[0], bbox[3]],
         [bbox[0], bbox[1]],
     ]
-    polygon = {"type": "Polygon", "coordinates": [coordinates]}
-
-    feature = {"type": "Feature", "geometry": polygon, "properties": {}}
-    feature_collection = {"type": "FeatureCollection", "features": [feature]}
-    return feature_collection
+    return {"type": "Polygon", "coordinates": [coordinates]}
 
 
 def retrieveExtentFromWCS(
@@ -242,45 +249,11 @@ def recursive_save(stac_object: Catalog, no_items: bool = False, geo_parquet: bo
     for child in stac_object.get_children():
         recursive_save(child, no_items, geo_parquet)
     if not no_items:
-        if geo_parquet:
-            create_geoparquet_items(stac_object)
-        else:
-            for item in stac_object.get_items():
-                item.save_object()
+        for item in stac_object.get_items():
+            item.save_object()
     stac_object.save_object()
 
 
-def create_geoparquet_items(stacObject: Catalog):
-    if iter_len_at_least(stacObject.get_items(), 1):
-        stac_dir_arr = stacObject.self_href.split("/")
-        stac_dir_arr.pop()
-        stac_dir_path = "/".join(stac_dir_arr)
-        items_stacgp_path = f"{stac_dir_path}/items.parquet"
-        to_stac_geoparquet(stacObject, items_stacgp_path)
-        gp_link = Link(
-            rel="items",
-            target=items_stacgp_path,
-            media_type="application/vnd.apache.parquet",
-            title="GeoParquet Items",
-        )
-        stacObject.clear_links(rel="item")
-        stacObject.add_links([gp_link])
-
-
-def to_stac_geoparquet(stacObject: Catalog, path: str):
-    items = []
-    for item in stacObject.get_items():
-        if not item.geometry:
-            item.geometry = create_geojson_point(0, 0)["geometry"]
-        if not item.assets:
-            item.assets = {"dummy_asset": Asset(href="")}
-        items.append(item.to_dict())
-    record_batch_reader = stacgp.arrow.parse_stac_items_to_arrow(items)
-    table = record_batch_reader.read_all()
-    os.makedirs(os.path.dirname(path), exist_ok=True)
-    stacgp.arrow.to_parquet(table, path)
-
-
 def iter_len_at_least(i, n: int) -> int:
     return sum(1 for _ in zip(range(n), i, strict=False)) == n
 
@@ -317,8 +290,12 @@ def generate_veda_cog_link(endpoint_config: dict, file_url: str | None) -> str:
         )
 
     file_url = f"url={file_url}&" if file_url else ""
-
-    target_url = f"https://openveda.cloud/api/raster/cog/tiles/WebMercatorQuad/{{z}}/{{x}}/{{y}}?{file_url}resampling_method=nearest{bidx}{colormap}{colormap_name}{rescale}{Nodata}"
+    target_url_base = endpoint_config["EndPoint"].replace("/stac/", "")
+    target_url = (
+        f"{target_url_base}/raster/cog/tiles/WebMercatorQuad/{{z}}/{{x}}/{{y}}?"
+        f"{file_url}resampling_method=nearest"
+        f"{bidx}{colormap}{colormap_name}{rescale}{Nodata}"
+    )
     return target_url
 
 
@@ -439,6 +416,154 @@ def get_full_url(url: str, catalog_config) -> str:
         return f'{catalog_config["assets_endpoint"]}{url}'
 
 
+def update_extents_from_collection_children(collection: Collection):
+    # retrieve extents from children
+    c_bboxes = [
+        c_child.extent.spatial.bboxes[0]
+        for c_child in collection.get_children()
+        if isinstance(c_child, Collection)
+    ]
+    if len(c_bboxes) > 0:
+        merged_bbox = merge_bboxes(c_bboxes)
+    else:
+        LOGGER.warn(
+            "No bounding boxes found in children of collection, using default bbox",
+        )
+        merged_bbox = [-180.0, -90.0, 180.0, 90.0]
+
+    collection.extent.spatial.bboxes = [merged_bbox]
+    # Add bbox extents from children
+    for c_child in collection.get_children():
+        if isinstance(c_child, Collection) and merged_bbox != c_child.extent.spatial.bboxes[0]:
+            collection.extent.spatial.bboxes.append(c_child.extent.spatial.bboxes[0])
+    # set time extent of collection
+    individual_datetimes = []
+    for c_child in collection.get_children():
+        if isinstance(c_child, Collection) and isinstance(
+            c_child.extent.temporal.intervals[0], list
+        ):
+            individual_datetimes.extend(c_child.extent.temporal.intervals[0])  # type: ignore
+    individual_datetimes = list(filter(lambda x: x is not None, individual_datetimes))
+    time_extent = [min(individual_datetimes), max(individual_datetimes)]
+    collection.extent.temporal = TemporalExtent([time_extent])
+
+
+def save_items(
+    collection: Collection,
+    items: list[Item],
+    output_path: str,
+    catalog_id: str,
+    colpath: str,
+    use_geoparquet: bool = False,
+) -> None:
+    """
+    Save a list of items for a collection either as single geoparquet or
+    by adding them to the collection in order to be saved by pystac as individual items.
+    Args:
+        collection (Collection): The collection to which the items will be added.
+        items (list[Item]): The list of items to save.
+        output_path (str): The path where the items will be saved.
+        catalog_id (str): The ID of the catalog to which the collection belongs.
+        colpath (str): The expected path where to save the files relative to the catalog root.
+        use_geoparquet (bool): If True, save items as a single GeoParquet file.
+            If False, add items to the collection and save them individually.
+    """
+    if len(items) == 0:
+        LOGGER.info(
+            "No items to save for collection, adding placeholder extents",
+            collection_id=collection.id,
+            item_count=len(items),
+        )
+        # we need to add some generic extent to the collection
+        collection.extent.spatial = SpatialExtent([[-180.0, -90.0, 180.0, 90.0]])
+        collection.extent.temporal = TemporalExtent(
+            [
+                datetime(1970, 1, 1, 0, 0, 0, tzinfo=pytztimezone("UTC")),
+                datetime.now(tz=pytztimezone("UTC")),
+            ]
+        )
+        return
+    if use_geoparquet:
+        LOGGER.info(
+            "Saving items as GeoParquet file",
+            collection_id=collection.id,
+            item_count=len(items),
+        )
+        if colpath is None:
+            colpath = f"{collection.id}/{collection.id}"
+        buildcatpath = f"{output_path}/{catalog_id}"
+        record_batch_reader = stacgp.arrow.parse_stac_items_to_arrow(items)
+        table = record_batch_reader.read_all()
+        output_path = f"{buildcatpath}/{colpath}"
+        os.makedirs(output_path, exist_ok=True)
+        stacgp.arrow.to_parquet(table, f"{output_path}/items.parquet")
+        gp_link = Link(
+            rel="items",
+            target="./items.parquet",
+            media_type="application/vnd.apache.parquet",
+            title="GeoParquet Items",
+        )
+        collection.add_link(gp_link)
+        # add extent information to the collection
+        min_datetime = pc.min(table["datetime"]).as_py()
+        max_datetime = pc.max(table["datetime"]).as_py()
+        if not min_datetime:
+            # cases when datetime was null
+            # fallback to start_datetime
+            min_datetime = pc.min(table["start_datetime"]).as_py()
+            max_datetime = pc.max(table["start_datetime"]).as_py()
+        collection.extent.temporal = TemporalExtent([min_datetime, max_datetime])
+        geoms = [wkb.loads(g.as_py()) for g in table["geometry"] if g is not None]
+        bbox = sgeom.MultiPolygon(geoms).bounds
+        collection.extent.spatial = SpatialExtent([bbox])
+        # Make sure to also reference the geoparquet as asset
+        collection.add_asset(
+            "geoparquet",
+            Asset(
+                href="./items.parquet",
+                media_type="application/vnd.apache.parquet",
+                title="GeoParquet Items",
+                roles=["collection-mirror"],
+            ),
+        )
+    else:
+        # go over items and add them to the collection
+        LOGGER.info(
+            "Adding items to collection to be saved individually",
+            collection_id=collection.id,
+            item_count=len(items),
+        )
+        for item in items:
+            link = collection.add_item(item)
+            # bubble up information we want to the link
+            # it is possible for datetime to be null, if it is start and end datetime have to exist
+            item_datetime = item.get_datetime()
+            if item_datetime:
+                link.extra_fields["datetime"] = format_datetime_to_isostring_zulu(item_datetime)
+            else:
+                link.extra_fields["start_datetime"] = format_datetime_to_isostring_zulu(
+                    parse_datestring_to_tz_aware_datetime(item.properties["start_datetime"])
+                )
+                link.extra_fields["end_datetime"] = format_datetime_to_isostring_zulu(
+                    parse_datestring_to_tz_aware_datetime(item.properties["end_datetime"])
+                )
+
+            # bubble up data assets based on role
+            collected_assets = [
+                asset.href
+                for asset in item.assets.values()
+                if asset.roles and ("data" in asset.roles or "default" in asset.roles)
+            ]
+            if collected_assets:
+                link.extra_fields["assets"] = collected_assets
+            # also bubble up item id and cog_href if available
+            # TODO: not clear when the item id is needed in the link might be some legacy reference
+            # link.extra_fields["item"] = item.id
+            if item.assets.get("cog_default"):
+                link.extra_fields["cog_href"] = item.assets["cog_default"].href
+        collection.update_extent_from_items()
+
+
 def read_config_file(path: str) -> dict:
     # If the given path exists directly, use it
     if os.path.exists(path):

{eodash_catalog-0.2.1.dist-info → eodash_catalog-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eodash_catalog
-Version: 0.2.1
+Version: 0.3.1
 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
@@ -29,7 +29,7 @@ Requires-Dist: requests-oauthlib<1.3.2
 Requires-Dist: requests<3
 Requires-Dist: setuptools<71
 Requires-Dist: spdx-lookup<=0.3.3
-Requires-Dist: stac-geoparquet<=0.6.0
+Requires-Dist: stac-geoparquet<=0.7.0
 Requires-Dist: structlog<22.0
 Description-Content-Type: text/markdown
 

eodash_catalog-0.3.1.dist-info/RECORD

@@ -0,0 +1,14 @@
+eodash_catalog/__about__.py,sha256=l-uZOyslIByuHXe6EqfhKvRxyfPaTvVIobrJDf86Ai8,137
+eodash_catalog/__init__.py,sha256=_W_9emPYf6FUqc0P8L2SmADx6hGSd7PlQV3yRmCk5uM,115
+eodash_catalog/duration.py,sha256=TBG7v1lCpbYowADK5uJ2M8kPxsvQneFAFi1NIE26dy4,10754
+eodash_catalog/endpoints.py,sha256=Ckvg0MnaXQjTy7hd55kqnGlPmlz5UYGJ2c3HXdvLVNs,49168
+eodash_catalog/generate_indicators.py,sha256=FPeiZm9TE4PpbTyH6UMegQ7HwaARzO91IrLtzFjFSF0,21900
+eodash_catalog/sh_endpoint.py,sha256=XjZsZJ5jfJZLQenSTqUhiUZ5YAu9M9nv2KL1Qv3Be-I,1219
+eodash_catalog/stac_handling.py,sha256=waw8qRjwjdbDBRtialc4bG3WSjXAATklc-W5kLKywqE,25548
+eodash_catalog/thumbnails.py,sha256=oNbWdRC8KTLUC4PbSMlSaiOeLXfkIpa0j-sOZdn1RGU,2262
+eodash_catalog/utils.py,sha256=wEh0hvBVp20NKhdJMOQ4dmiiOrFUOTDP2sRtfe0FBpQ,22563
+eodash_catalog-0.3.1.dist-info/METADATA,sha256=OgbqxdohyQr9kO3WwjwJ3FRs5-5khvd6T7mmivVzpe8,3019
+eodash_catalog-0.3.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+eodash_catalog-0.3.1.dist-info/entry_points.txt,sha256=kuUQrDG1PtYd8kPjf5XM6H_NtQd9Ozwl0jjiGtAvZSM,87
+eodash_catalog-0.3.1.dist-info/licenses/LICENSE.txt,sha256=oJCW5zQxnFD-J0hGz6Zh5Lkpdk1oAndmWhseTmV224E,1107
+eodash_catalog-0.3.1.dist-info/RECORD,,

eodash_catalog-0.2.1.dist-info/RECORD

@@ -1,14 +0,0 @@
-eodash_catalog/__about__.py,sha256=c99Cdt5zAgv8ECLNyPwczOXULCCEQldhtr8lFnXUAQ0,137
-eodash_catalog/__init__.py,sha256=_W_9emPYf6FUqc0P8L2SmADx6hGSd7PlQV3yRmCk5uM,115
-eodash_catalog/duration.py,sha256=B6XOZfvNU7SuqpxuVtT1kNKODoOQJXDI6mocvA_U1ik,10816
-eodash_catalog/endpoints.py,sha256=3ejenyoRp3aT5YyPP_NcUy9nT1OWZydtya34qsQurk4,47521
-eodash_catalog/generate_indicators.py,sha256=8h5Xa9WZGXKsUZQbps38Jllt7KFvx7K7mZWzggtxzks,20785
-eodash_catalog/sh_endpoint.py,sha256=XjZsZJ5jfJZLQenSTqUhiUZ5YAu9M9nv2KL1Qv3Be-I,1219
-eodash_catalog/stac_handling.py,sha256=waw8qRjwjdbDBRtialc4bG3WSjXAATklc-W5kLKywqE,25548
-eodash_catalog/thumbnails.py,sha256=oNbWdRC8KTLUC4PbSMlSaiOeLXfkIpa0j-sOZdn1RGU,2262
-eodash_catalog/utils.py,sha256=BdFSiF0-M6NlnSKQGE0REI9rMPNmqqG4QjWqmaXN6g8,16946
-eodash_catalog-0.2.1.dist-info/METADATA,sha256=tif4YQQCZ5-69IteZQ9VIoOjmFW0__Y5DiphYhA_ZqI,3019
-eodash_catalog-0.2.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-eodash_catalog-0.2.1.dist-info/entry_points.txt,sha256=kuUQrDG1PtYd8kPjf5XM6H_NtQd9Ozwl0jjiGtAvZSM,87
-eodash_catalog-0.2.1.dist-info/licenses/LICENSE.txt,sha256=oJCW5zQxnFD-J0hGz6Zh5Lkpdk1oAndmWhseTmV224E,1107
-eodash_catalog-0.2.1.dist-info/RECORD,,