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

eodash_catalog/stac_handling.py

@@ -6,6 +6,7 @@ import yaml
 from dateutil import parser
 from pystac import (
     Asset,
+    Catalog,
     Collection,
     Extent,
     Link,
@@ -18,69 +19,75 @@ 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):
+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(
         [
             spatial_extent,
         ]
     )
-    times = []
+    times: list[str] = []
     temporal_extent = TemporalExtent([[datetime.now(), None]])
-    if endpoint and endpoint.get("Type") == "OverwriteTimes":
-        if endpoint.get("Times"):
-            times = 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, role):
+def create_web_map_link(layer: dict, role: str) -> Link:
     extra_fields = {
         "roles": [role],
         "id": layer["id"],
@@ -113,15 +120,20 @@ def create_web_map_link(layer, role):
     return wml
 
 
-def add_example_info(stac_object, data, endpoint, config):
-    if "Services" in data:
-        for service in data["Services"]:
+def add_example_info(
+    stac_object: Collection | Catalog,
+    collection_config: dict,
+    endpoint_config: dict,
+    catalog_config: dict,
+) -> None:
+    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={
@@ -156,13 +168,13 @@ def add_example_info(stac_object, data, endpoint, config):
                         },
                     )
                 )
-    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(
@@ -178,25 +190,27 @@ def add_example_info(stac_object, data, endpoint, config):
                 )
 
 
-def add_collection_information(config, collection, data):
+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"],
@@ -208,7 +222,7 @@ def add_collection_information(config, collection, data):
                         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:
@@ -229,65 +243,65 @@ def add_collection_information(config, collection, data):
         # 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:
@@ -304,56 +318,73 @@ def add_collection_information(config, collection, data):
             )
 
 
-def add_base_overlay_info(collection, config, data):
+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, 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:
+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

@@ -3,31 +3,43 @@ import re
 from pathlib import Path
 
 import requests
+from pystac import (
+    Item,
+)
 
 from eodash_catalog.utils import generate_veda_cog_link
 
 
-def fetch_and_save_thumbnail(data, url):
-    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):
-        data = requests.get(url).content
+        dd = requests.get(url).content
         with open(image_path, "wb") as f:
-            f.write(data)
+            f.write(dd)
 
 
-def generate_thumbnail(stac_object, data, endpoint, file_url=None, time=None, styles=None):
-    if endpoint["Name"] == "Sentinel Hub" or endpoint["Name"] == "WMS":
+def generate_thumbnail(
+    stac_object: Item,
+    collection_config: dict,
+    endpoint_config: dict,
+    file_url: str = "",
+    time: str | None = None,
+) -> None:
+    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"
         )
-        bbox_s = stac_object.bbox
-        bbox = f"{bbox_s[1]},{bbox_s[0]},{bbox_s[3]},{bbox_s[2]}"
+        bbox = [-180, -85, 180, 85]
+        if bbox_s := stac_object.bbox:
+            bbox = f"{bbox_s[1]},{bbox_s[0]},{bbox_s[3]},{bbox_s[2]}"  # type: ignore
         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,
@@ -37,13 +49,13 @@ def generate_thumbnail(stac_object, data, endpoint, file_url=None, time=None, st
         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

@@ -1,6 +1,8 @@
 import re
 import threading
+import uuid
 from collections.abc import Iterator
+from dataclasses import dataclass
 from datetime import datetime, timedelta
 from decimal import Decimal
 from functools import reduce
@@ -9,7 +11,7 @@ from typing import Any
 from dateutil import parser
 from owslib.wms import WebMapService
 from owslib.wmts import WebMapTileService
-from pystac import Catalog
+from pystac import Catalog, Collection, Item, RelType
 from six import string_types
 
 from eodash_catalog.duration import Duration
@@ -35,7 +37,7 @@ def create_geojson_point(lon: int | float, lat: int | float) -> dict[str, Any]:
 
 def retrieveExtentFromWMSWMTS(
     capabilities_url: str, layer: str, version: str = "1.1.1", wmts: bool = False
-):
+) -> tuple[list[float], list[str]]:
     times = []
     try:
         if not wmts:
@@ -91,7 +93,9 @@ def parse_duration(datestring):
     if not isinstance(datestring, string_types):
         raise TypeError(f"Expecting a string {datestring}")
     match = ISO8601_PERIOD_REGEX.match(datestring)
-    groups = match.groupdict()
+    groups = {}
+    if match:
+        groups = match.groupdict()
     for key, val in groups.items():
         if key not in ("separator", "sign"):
             if val is None:
@@ -128,7 +132,9 @@ def parse_duration(datestring):
     return ret
 
 
-def generateDateIsostringsFromInterval(start: str, end: str, timedelta_config: dict | None = None):
+def generateDateIsostringsFromInterval(
+    start: str, end: str, timedelta_config: dict | None = None
+) -> list[str]:
     if timedelta_config is None:
         timedelta_config = {}
     start_dt = datetime.fromisoformat(start)
@@ -171,32 +177,63 @@ 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):
+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 ""
 
     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
+
+
+@dataclass
+class Options:
+    catalogspath: str
+    collectionspath: str
+    indicatorspath: str
+    outputpath: str
+    vd: bool
+    ni: bool
+    tn: bool
+    collections: list[str]
+
+
+def add_single_item_if_collection_empty(collection: Collection) -> None:
+    for link in collection.links:
+        if link.rel == RelType.ITEM:
+            break
+    else:
+        item = Item(
+            id=str(uuid.uuid4()),
+            bbox=[-180, -85, 180, 85],
+            properties={},
+            geometry=None,
+            datetime=datetime(1970, 1, 1, 0, 0, 0),
+            start_datetime=datetime(1970, 1, 1, 0, 0, 0),
+            end_datetime=datetime.now(),
+        )
+        collection.add_item(item)

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: eodash_catalog
-Version: 0.0.10
+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.10.dist-info/RECORD

@@ -1,14 +0,0 @@
-eodash_catalog/__about__.py,sha256=vzs3SY-zF_mgRKDxdhyQb7oaQQkNWxttzi_gL2wbP_c,138
-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.10.dist-info/METADATA,sha256=PKpvEeXYSO24jDVWIUUrkhR7jOK72J6mz92OUJ24sRk,3203
-eodash_catalog-0.0.10.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-eodash_catalog-0.0.10.dist-info/entry_points.txt,sha256=kuUQrDG1PtYd8kPjf5XM6H_NtQd9Ozwl0jjiGtAvZSM,87
-eodash_catalog-0.0.10.dist-info/licenses/LICENSE.txt,sha256=oJCW5zQxnFD-J0hGz6Zh5Lkpdk1oAndmWhseTmV224E,1107
-eodash_catalog-0.0.10.dist-info/RECORD,,