eodash_catalog 0.0.11__py3-none-any.whl → 0.0.12__py3-none-any.whl

eodash_catalog/stac_handling.py

@@ -19,15 +19,19 @@ from yaml.loader import SafeLoader
 from eodash_catalog.utils import generateDateIsostringsFromInterval
 
 
-def get_or_create_collection_and_times(
-    catalog: Catalog, collection_id: str, data: dict, config: dict, endpoint: dict
-) -> tuple[Collection, list[str]]:
+def get_or_create_collection(
+    catalog: Catalog,
+    collection_id: str,
+    collection_config: dict,
+    catalog_config: dict,
+    endpoint_config: dict,
+) -> Collection:
     # Check if collection already in catalog
     for collection in catalog.get_collections():
         if collection.id == collection_id:
-            return collection, []
+            return collection
     # If none found create a new one
-    spatial_extent = endpoint.get("OverwriteBBox", [-180.0, -90.0, 180.0, 90.0])
+    spatial_extent = endpoint_config.get("OverwriteBBox", [-180.0, -90.0, 180.0, 90.0])
 
     spatial_extent = SpatialExtent(
         [
@@ -36,51 +40,51 @@ def get_or_create_collection_and_times(
     )
     times: list[str] = []
     temporal_extent = TemporalExtent([[datetime.now(), None]])
-    if endpoint and endpoint.get("Type") == "OverwriteTimes":
-        if endpoint.get("Times"):
-            times = list(endpoint.get("Times", []))
+    if endpoint_config and endpoint_config.get("Type") == "OverwriteTimes":
+        if endpoint_config.get("Times"):
+            times = list(endpoint_config.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})
+        elif endpoint_config.get("DateTimeInterval"):
+            start = endpoint_config["DateTimeInterval"].get("Start", "2020-09-01T00:00:00")
+            end = endpoint_config["DateTimeInterval"].get("End", "2020-10-01T00:00:00")
+            timedelta_config = endpoint_config["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" in collection_config:
+        description = collection_config["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:
+                elif "Subtitle" in collection_config:
                     print("WARNING: Markdown file could not be fetched")
-                    description = data["Subtitle"]
+                    description = collection_config["Subtitle"]
             else:
                 # relative path to assets was given
-                response = requests.get(f"{config["assets_endpoint"]}/{description}")
+                response = requests.get(f"{catalog_config["assets_endpoint"]}/{description}")
                 if response.status_code == 200:
                     description = response.text
-                elif "Subtitle" in data:
+                elif "Subtitle" in collection_config:
                     print("WARNING: Markdown file could not be fetched")
-                    description = data["Subtitle"]
-    elif "Subtitle" in data:
+                    description = collection_config["Subtitle"]
+    elif "Subtitle" in collection_config:
         # Try to use at least subtitle to fill some information
-        description = data["Subtitle"]
+        description = collection_config["Subtitle"]
 
     collection = Collection(
         id=collection_id,
-        title=data["Title"],
+        title=collection_config["Title"],
         description=description,
         extent=extent,
     )
-    return (collection, times)
+    return collection
 
 
 def create_web_map_link(layer: dict, role: str) -> Link:
@@ -117,16 +121,19 @@ def create_web_map_link(layer: dict, role: str) -> Link:
 
 
 def add_example_info(
-    stac_object: Collection | Catalog, data: dict, endpoint: dict, config: dict
+    stac_object: Collection | Catalog,
+    collection_config: dict,
+    endpoint_config: dict,
+    catalog_config: dict,
 ) -> None:
-    if "Services" in data:
-        for service in data["Services"]:
+    if "Services" in collection_config:
+        for service in collection_config["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"]),
+                        target="{}/{}".format(catalog_config["assets_endpoint"], service["Script"]),
                         title="evalscript",
                         media_type="application/javascript",
                         extra_fields={
@@ -161,13 +168,13 @@ def add_example_info(
                         },
                     )
                 )
-    elif "Resources" in data:
-        for service in data["Resources"]:
+    elif "Resources" in collection_config:
+        for service in collection_config["Resources"]:
             if service.get("Name") == "xcube":
                 target_url = "{}/timeseries/{}/{}?aggMethods=median".format(
-                    endpoint["EndPoint"],
-                    endpoint["DatacubeId"],
-                    endpoint["Variable"],
+                    endpoint_config["EndPoint"],
+                    endpoint_config["DatacubeId"],
+                    endpoint_config["Variable"],
                 )
                 stac_object.add_link(
                     Link(
@@ -183,25 +190,27 @@ def add_example_info(
                 )
 
 
-def add_collection_information(config: dict, collection: Collection, data: dict) -> None:
+def add_collection_information(
+    catalog_config: dict, collection: Collection, collection_config: dict
+) -> None:
     # Add metadata information
     # Check license identifier
-    if "License" in data:
+    if "License" in collection_config:
         # Check if list was provided
-        if isinstance(data["License"], list):
-            if len(data["License"]) == 1:
+        if isinstance(collection_config["License"], list):
+            if len(collection_config["License"]) == 1:
                 collection.license = "proprietary"
                 link = Link(
                     rel="license",
-                    target=data["License"][0]["Url"],
-                    media_type=(data["License"][0].get("Type", "text/html")),
+                    target=collection_config["License"][0]["Url"],
+                    media_type=(collection_config["License"][0].get("Type", "text/html")),
                 )
-                if "Title" in data["License"][0]:
-                    link.title = data["License"][0]["Title"]
+                if "Title" in collection_config["License"][0]:
+                    link.title = collection_config["License"][0]["Title"]
                 collection.links.append(link)
-            elif len(data["License"]) > 1:
+            elif len(collection_config["License"]) > 1:
                 collection.license = "various"
-                for license_entry in data["License"]:
+                for license_entry in collection_config["License"]:
                     link = Link(
                         rel="license",
                         target=license_entry["Url"],
@@ -213,7 +222,7 @@ def add_collection_information(config: dict, collection: Collection, data: dict)
                         link.title = license_entry["Title"]
                     collection.links.append(link)
         else:
-            license_data = lookup.by_id(data["License"])
+            license_data = lookup.by_id(collection_config["License"])
             if license_data is not None:
                 collection.license = license_data.id
                 if license_data.sources:
@@ -234,65 +243,65 @@ def add_collection_information(config: dict, collection: Collection, data: dict)
         # print("WARNING: No license was provided, falling back to proprietary")
         pass
 
-    if "Provider" in data:
+    if "Provider" in collection_config:
         try:
             collection.providers = [
                 Provider(
                     # convert information to lower case
                     **{k.lower(): v for k, v in provider.items()}
                 )
-                for provider in data["Provider"]
+                for provider in collection_config["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"]:
+    if "Citation" in collection_config:
+        if "DOI" in collection_config["Citation"]:
+            collection.extra_fields["sci:doi"] = collection_config["Citation"]["DOI"]
+        if "Citation" in collection_config["Citation"]:
+            collection.extra_fields["sci:citation"] = collection_config["Citation"]["Citation"]
+        if "Publication" in collection_config["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"]
+                for publication in collection_config["Citation"]["Publication"]
             ]
 
-    if "Subtitle" in data:
-        collection.extra_fields["subtitle"] = data["Subtitle"]
-    if "Legend" in data:
+    if "Subtitle" in collection_config:
+        collection.extra_fields["subtitle"] = collection_config["Subtitle"]
+    if "Legend" in collection_config:
         collection.add_asset(
             "legend",
             Asset(
-                href=f"{config["assets_endpoint"]}/{data["Legend"]}",
+                href=f"{catalog_config["assets_endpoint"]}/{collection_config["Legend"]}",
                 media_type="image/png",
                 roles=["metadata"],
             ),
         )
-    if "Story" in data:
+    if "Story" in collection_config:
         collection.add_asset(
             "story",
             Asset(
-                href=f"{config["assets_endpoint"]}/{data["Story"]}",
+                href=f"{catalog_config["assets_endpoint"]}/{collection_config["Story"]}",
                 media_type="text/markdown",
                 roles=["metadata"],
             ),
         )
-    if "Image" in data:
+    if "Image" in collection_config:
         collection.add_asset(
             "thumbnail",
             Asset(
-                href=f"{config["assets_endpoint"]}/{data["Image"]}",
+                href=f"{catalog_config["assets_endpoint"]}/{collection_config["Image"]}",
                 media_type="image/png",
                 roles=["thumbnail"],
             ),
         )
     # Add extra fields to collection if available
-    add_extra_fields(collection, data)
+    add_extra_fields(collection, collection_config)
 
-    if "References" in data:
+    if "References" in collection_config:
         generic_counter = 1
-        for ref in data["References"]:
+        for ref in collection_config["References"]:
             if "Key" in ref:
                 key = ref["Key"]
             else:
@@ -309,56 +318,73 @@ def add_collection_information(config: dict, collection: Collection, data: dict)
             )
 
 
-def add_base_overlay_info(collection: Collection, config: dict, data: dict) -> None:
+def add_base_overlay_info(
+    collection: Collection, catalog_config: dict, collection_config: dict
+) -> None:
     # check if default base layers defined
-    if "default_base_layers" in config:
-        with open(f"{config["default_base_layers"]}.yaml") as f:
+    if "default_base_layers" in catalog_config:
+        with open(f"{catalog_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:
+    if "default_overlay_layers" in catalog_config:
+        with open("{}.yaml".format(catalog_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"]:
+    if "BaseLayers" in collection_config:
+        for layer in collection_config["BaseLayers"]:
             collection.add_link(create_web_map_link(layer, role="baselayer"))
-    if "OverlayLayers" in data:
-        for layer in data["OverlayLayers"]:
+    if "OverlayLayers" in collection_config:
+        for layer in collection_config["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: Collection | Catalog | Link, data: dict) -> None:
-    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:
+def add_extra_fields(stac_object: Collection | Catalog | Link, collection_config: dict) -> None:
+    if "yAxis" in collection_config:
+        stac_object.extra_fields["yAxis"] = collection_config["yAxis"]
+    if "Themes" in collection_config:
+        stac_object.extra_fields["themes"] = collection_config["Themes"]
+    if "Locations" in collection_config or "Subcollections" in collection_config:
         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 "Tags" in collection_config:
+        stac_object.extra_fields["tags"] = collection_config["Tags"]
+    if "Satellite" in collection_config:
+        stac_object.extra_fields["satellite"] = collection_config["Satellite"]
+    if "Sensor" in collection_config:
+        stac_object.extra_fields["sensor"] = collection_config["Sensor"]
+    if "Agency" in collection_config:
+        stac_object.extra_fields["agency"] = collection_config["Agency"]
+    if "yAxis" in collection_config:
+        stac_object.extra_fields["yAxis"] = collection_config["yAxis"]
+    if "EodashIdentifier" in collection_config:
+        stac_object.extra_fields["subcode"] = collection_config["EodashIdentifier"]
+    if "DataSource" in collection_config:
+        if "Spaceborne" in collection_config["DataSource"]:
+            if "Sensor" in collection_config["DataSource"]["Spaceborne"]:
+                stac_object.extra_fields["sensor"] = collection_config["DataSource"]["Spaceborne"][
+                    "Sensor"
                 ]
-        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"]
+            if "Satellite" in collection_config["DataSource"]["Spaceborne"]:
+                stac_object.extra_fields["satellite"] = collection_config["DataSource"][
+                    "Spaceborne"
+                ]["Satellite"]
+        if "InSitu" in collection_config["DataSource"]:
+            stac_object.extra_fields["insituSources"] = collection_config["DataSource"]["InSitu"]
+        if "Other" in collection_config["DataSource"]:
+            stac_object.extra_fields["otherSources"] = collection_config["DataSource"]["Other"]
+
+
+def get_collection_times_from_config(endpoint_config: dict) -> list[str]:
+    times: list[str] = []
+    if endpoint_config and endpoint_config.get("Type") == "OverwriteTimes":
+        if endpoint_config.get("Times"):
+            times = list(endpoint_config.get("Times", []))
+        elif endpoint_config.get("DateTimeInterval"):
+            start = endpoint_config["DateTimeInterval"].get("Start", "2020-09-01T00:00:00")
+            end = endpoint_config["DateTimeInterval"].get("End", "2020-10-01T00:00:00")
+            timedelta_config = endpoint_config["DateTimeInterval"].get("Timedelta", {"days": 1})
+            times = generateDateIsostringsFromInterval(start, end, timedelta_config)
+    return times

eodash_catalog/thumbnails.py

@@ -10,8 +10,10 @@ from pystac import (
 from eodash_catalog.utils import generate_veda_cog_link
 
 
-def fetch_and_save_thumbnail(data: dict, url: str) -> None:
-    collection_path = "../thumbnails/{}_{}/".format(data["EodashIdentifier"], data["Name"])
+def fetch_and_save_thumbnail(collection_config: dict, url: str) -> None:
+    collection_path = "../thumbnails/{}_{}/".format(
+        collection_config["EodashIdentifier"], collection_config["Name"]
+    )
     Path(collection_path).mkdir(parents=True, exist_ok=True)
     image_path = f"{collection_path}/thumbnail.png"
     if not os.path.exists(image_path):
@@ -22,15 +24,15 @@ def fetch_and_save_thumbnail(data: dict, url: str) -> None:
 
 def generate_thumbnail(
     stac_object: Item,
-    data: dict,
-    endpoint: dict,
+    collection_config: dict,
+    endpoint_config: dict,
     file_url: str = "",
     time: str | None = None,
 ) -> None:
-    if endpoint["Name"] == "Sentinel Hub" or endpoint["Name"] == "WMS":
+    if endpoint_config["Name"] == "Sentinel Hub" or endpoint_config["Name"] == "WMS":
         instanceId = os.getenv("SH_INSTANCE_ID")
-        if "InstanceId" in endpoint:
-            instanceId = endpoint["InstanceId"]
+        if "InstanceId" in endpoint_config:
+            instanceId = endpoint_config["InstanceId"]
         # Build example url
         wms_config = (
             "REQUEST=GetMap&SERVICE=WMS&VERSION=1.3.0&FORMAT=image/png&STYLES=&TRANSPARENT=true"
@@ -47,13 +49,13 @@ def generate_thumbnail(
         url = "https://services.sentinel-hub.com/ogc/wms/{}?{}&layers={}&time={}&{}".format(
             instanceId,
             wms_config,
-            endpoint["LayerId"],
+            endpoint_config["LayerId"],
             time,
             output_format,
         )
-        fetch_and_save_thumbnail(data, url)
-    elif endpoint["Name"] == "VEDA":
-        target_url = generate_veda_cog_link(endpoint, file_url)
+        fetch_and_save_thumbnail(collection_config, url)
+    elif endpoint_config["Name"] == "VEDA":
+        target_url = generate_veda_cog_link(endpoint_config, file_url)
         # set to get 0/0/0 tile
         url = re.sub(r"\{.\}", "0", target_url)
-        fetch_and_save_thumbnail(data, url)
+        fetch_and_save_thumbnail(collection_config, url)

eodash_catalog/utils.py

@@ -177,30 +177,32 @@ 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: dict, file_url: str | None) -> str:
+def generate_veda_cog_link(endpoint_config: dict, file_url: str | None) -> str:
     bidx = ""
-    if "Bidx" in endpoint:
+    if "Bidx" in endpoint_config:
         # Check if an array was provided
-        if hasattr(endpoint["Bidx"], "__len__"):
-            for band in endpoint["Bidx"]:
+        if hasattr(endpoint_config["Bidx"], "__len__"):
+            for band in endpoint_config["Bidx"]:
                 bidx = bidx + f"&bidx={band}"
         else:
-            bidx = "&bidx={}".format(endpoint["Bidx"])
+            bidx = "&bidx={}".format(endpoint_config["Bidx"])
 
     colormap = ""
-    if "Colormap" in endpoint:
-        colormap = "&colormap={}".format(endpoint["Colormap"])
+    if "Colormap" in endpoint_config:
+        colormap = "&colormap={}".format(endpoint_config["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 = "&colormap=%s"%(urllib.parse.quote(str(endpoint_config["Colormap"])))
 
     colormap_name = ""
-    if "ColormapName" in endpoint:
-        colormap_name = "&colormap_name={}".format(endpoint["ColormapName"])
+    if "ColormapName" in endpoint_config:
+        colormap_name = "&colormap_name={}".format(endpoint_config["ColormapName"])
 
     rescale = ""
-    if "Rescale" in endpoint:
-        rescale = "&rescale={},{}".format(endpoint["Rescale"][0], endpoint["Rescale"][1])
+    if "Rescale" in endpoint_config:
+        rescale = "&rescale={},{}".format(
+            endpoint_config["Rescale"][0], endpoint_config["Rescale"][1]
+        )
 
     file_url = f"url={file_url}&" if file_url else ""
 

{eodash_catalog-0.0.11.dist-info → eodash_catalog-0.0.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: eodash_catalog
-Version: 0.0.11
+Version: 0.0.12
 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

eodash_catalog-0.0.12.dist-info/RECORD

@@ -0,0 +1,14 @@
+eodash_catalog/__about__.py,sha256=yEv4frNTeX9AbT5lO3thIJjP9R5pEQJ0AzODE6sN9tI,138
+eodash_catalog/__init__.py,sha256=_W_9emPYf6FUqc0P8L2SmADx6hGSd7PlQV3yRmCk5uM,115
+eodash_catalog/duration.py,sha256=B6XOZfvNU7SuqpxuVtT1kNKODoOQJXDI6mocvA_U1ik,10816
+eodash_catalog/endpoints.py,sha256=o0m0dMmfvZ2ybRnHW-am4g4vjoQhFMNbnQ_xI2kE_D8,30658
+eodash_catalog/generate_indicators.py,sha256=aTh7RHhUVfDjaWNH4GYiLuzC7Z8fQEfJGfckdkjwFOs,18454
+eodash_catalog/sh_endpoint.py,sha256=vELooJwk269v1DNnOzb32vil96vL_SRCio8UBlx10N0,618
+eodash_catalog/stac_handling.py,sha256=uHsAR-H3Js2pDOcIw2ApTUWAuSApnLkpjf0OUBHQ7_Q,16637
+eodash_catalog/thumbnails.py,sha256=31Wk38oNQDxfhSUbMLBpHuZFhsR8v_7luYr65XQtDf0,2213
+eodash_catalog/utils.py,sha256=JnXrXtq3bOmECPlSn86Mz35sDTOkgptz87lrISfE1Uo,7968
+eodash_catalog-0.0.12.dist-info/METADATA,sha256=1kYgr6SXzhIj2nE-EsoRwpw-bMJVYdz_sVLLCaZzT08,3203
+eodash_catalog-0.0.12.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+eodash_catalog-0.0.12.dist-info/entry_points.txt,sha256=kuUQrDG1PtYd8kPjf5XM6H_NtQd9Ozwl0jjiGtAvZSM,87
+eodash_catalog-0.0.12.dist-info/licenses/LICENSE.txt,sha256=oJCW5zQxnFD-J0hGz6Zh5Lkpdk1oAndmWhseTmV224E,1107
+eodash_catalog-0.0.12.dist-info/RECORD,,

eodash_catalog-0.0.11.dist-info/RECORD

@@ -1,14 +0,0 @@
-eodash_catalog/__about__.py,sha256=Zuvv0AbtNybzWIAcoTcWpq2fDAxHl6M_njE7M-xUEzM,138
-eodash_catalog/__init__.py,sha256=_W_9emPYf6FUqc0P8L2SmADx6hGSd7PlQV3yRmCk5uM,115
-eodash_catalog/duration.py,sha256=B6XOZfvNU7SuqpxuVtT1kNKODoOQJXDI6mocvA_U1ik,10816
-eodash_catalog/endpoints.py,sha256=VMs7A7gN9S9brb7k8RAmzS0DCYLzRC65If4xMg60bK8,26886
-eodash_catalog/generate_indicators.py,sha256=-otR-RzlJQPyi6M7CkuTF39dm6ZHIpb-BRUeZ1GK_vQ,17132
-eodash_catalog/sh_endpoint.py,sha256=41Tcnvq6-S8mLZaauW0RdA4kZB8ay4Zsa40euRg_IRM,589
-eodash_catalog/stac_handling.py,sha256=_kBr9ES9XgmsONW2Q7PoL9k0QcmwZC5lhFl6l6AUwXk,14645
-eodash_catalog/thumbnails.py,sha256=SliAEgch7_LjgZcto30Ae39sWZ9T8DoNznwDsGoSolg,2065
-eodash_catalog/utils.py,sha256=KSsKvSQ5vxhMYPFFt_d7KYkC5YclzI2M6K1Vw0Lnkes,7855
-eodash_catalog-0.0.11.dist-info/METADATA,sha256=ShVpKo7eFOCIJ4tMBPY96-Ve4OmzXwn25JPV9PrSrbw,3203
-eodash_catalog-0.0.11.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-eodash_catalog-0.0.11.dist-info/entry_points.txt,sha256=kuUQrDG1PtYd8kPjf5XM6H_NtQd9Ozwl0jjiGtAvZSM,87
-eodash_catalog-0.0.11.dist-info/licenses/LICENSE.txt,sha256=oJCW5zQxnFD-J0hGz6Zh5Lkpdk1oAndmWhseTmV224E,1107
-eodash_catalog-0.0.11.dist-info/RECORD,,