eodash_catalog 0.0.29__tar.gz → 0.0.31__tar.gz

{eodash_catalog-0.0.29 → eodash_catalog-0.0.31}/.bumpversion.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 0.0.29
+current_version = 0.0.31
 commit = True
 tag = True
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(\-(?P<release>[a-z]+)\.(?P<build>\d+))?

{eodash_catalog-0.0.29 → eodash_catalog-0.0.31}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: eodash_catalog
-Version: 0.0.29
+Version: 0.0.31
 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.29 → eodash_catalog-0.0.31}/src/eodash_catalog/__about__.py

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

{eodash_catalog-0.0.29 → eodash_catalog-0.0.31}/src/eodash_catalog/endpoints.py

@@ -9,7 +9,6 @@ from itertools import groupby
 from operator import itemgetter
 
 import requests
-from dateutil import parser
 from pystac import Asset, Catalog, Collection, Item, Link, SpatialExtent, Summaries
 from pystac_client import Client
 from structlog import get_logger
@@ -19,7 +18,7 @@ from eodash_catalog.stac_handling import (
     add_collection_information,
     add_example_info,
     add_projection_info,
-    get_collection_times_from_config,
+    get_collection_datetimes_from_config,
     get_or_create_collection,
 )
 from eodash_catalog.thumbnails import generate_thumbnail
@@ -28,7 +27,9 @@ from eodash_catalog.utils import (
     create_geojson_from_bbox,
     create_geojson_point,
     filter_time_entries,
+    format_datetime_to_isostring_zulu,
     generate_veda_cog_link,
+    parse_datestring_to_tz_aware_datetime,
     replace_with_env_variables,
     retrieveExtentFromWMSWMTS,
 )
@@ -69,29 +70,26 @@ def process_STAC_Datacube_Endpoint(
         if v.get("type") == "temporal":
             time_dimension = k
             break
-    time_entries = dimensions.get(time_dimension).get("values")
+    datetimes = [
+        parse_datestring_to_tz_aware_datetime(time_string)
+        for time_string in dimensions.get(time_dimension).get("values")
+    ]
     # optionally subset time results based on config
     if query := endpoint_config.get("Query"):
-        time_entries = filter_time_entries(time_entries, query)
+        datetimes = filter_time_entries(datetimes, query)
 
-    for t in time_entries:
-        item = Item(
-            id=t,
+    for dt in datetimes:
+        new_item = Item(
+            id=format_datetime_to_isostring_zulu(dt),
             bbox=item.bbox,
             properties={},
             geometry=item.geometry,
-            datetime=parser.isoparse(t),
+            datetime=dt,
         )
-        link = collection.add_item(item)
-        link.extra_fields["datetime"] = t
+        link = collection.add_item(new_item)
         # bubble up information we want to the link
-        item_datetime = item.get_datetime()
-        # 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"] = item_datetime.isoformat()[:-6] + "Z"
-        else:
-            link.extra_fields["start_datetime"] = item.properties["start_datetime"]
-            link.extra_fields["end_datetime"] = item.properties["end_datetime"]
+        link.extra_fields["datetime"] = format_datetime_to_isostring_zulu(dt)
+
     unit = variables.get(endpoint_config.get("Variable")).get("unit")
     if unit and "yAxis" not in collection_config:
         collection_config["yAxis"] = unit
@@ -238,16 +236,15 @@ def process_STACAPI_Endpoint(
             )
             link.extra_fields["cog_href"] = item.assets["cog_default"].href
         elif item_datetime:
-            time_string = item_datetime.isoformat()[:-6] + "Z"
-            add_visualization_info(item, collection_config, endpoint_config, time=time_string)
+            add_visualization_info(
+                item, collection_config, endpoint_config, datetimes=[item_datetime]
+            )
         elif "start_datetime" in item.properties and "end_datetime" in item.properties:
             add_visualization_info(
                 item,
                 collection_config,
                 endpoint_config,
-                time="{}/{}".format(
-                    item.properties["start_datetime"], item.properties["end_datetime"]
-                ),
+                datetimes=[item.properties["start_datetime"], item.properties["end_datetime"]],
             )
         # If a root collection exists we point back to it from the item
         if root_collection:
@@ -256,12 +253,8 @@ def process_STACAPI_Endpoint(
         # 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:
-            iso_time = item_datetime.isoformat()[:-6] + "Z"
-            if endpoint_config["Name"] == "Sentinel Hub":
-                # for SH WMS we only save the date (no time)
-                link.extra_fields["datetime"] = iso_date
-            else:
-                link.extra_fields["datetime"] = iso_time
+            iso_time = format_datetime_to_isostring_zulu(item_datetime)
+            link.extra_fields["datetime"] = iso_time
         else:
             link.extra_fields["start_datetime"] = item.properties["start_datetime"]
             link.extra_fields["end_datetime"] = item.properties["end_datetime"]
@@ -305,18 +298,18 @@ def handle_collection_only(
     collection = get_or_create_collection(
         catalog, collection_config["Name"], collection_config, catalog_config, endpoint_config
     )
-    times = get_collection_times_from_config(endpoint_config)
-    if len(times) > 0:
-        for t in times:
+    datetimes = get_collection_datetimes_from_config(endpoint_config)
+    if len(datetimes) > 0:
+        for dt in datetimes:
             item = Item(
-                id=t,
+                id=format_datetime_to_isostring_zulu(dt),
                 bbox=endpoint_config.get("OverwriteBBox"),
                 properties={},
                 geometry=None,
-                datetime=parser.isoparse(t),
+                datetime=dt,
             )
             link = collection.add_item(item)
-            link.extra_fields["datetime"] = t
+            link.extra_fields["datetime"] = format_datetime_to_isostring_zulu(dt)
     add_collection_information(catalog_config, collection, collection_config)
     # eodash v4 compatibility
     add_visualization_info(collection, collection_config, endpoint_config)
@@ -327,10 +320,10 @@ def handle_SH_WMS_endpoint(
     catalog_config: dict, endpoint_config: dict, collection_config: dict, catalog: Catalog
 ) -> Collection:
     # create collection and subcollections (based on locations)
+    root_collection = get_or_create_collection(
+        catalog, collection_config["Name"], collection_config, catalog_config, endpoint_config
+    )
     if "Locations" in collection_config:
-        root_collection = get_or_create_collection(
-            catalog, collection_config["Name"], collection_config, catalog_config, endpoint_config
-        )
         for location in collection_config["Locations"]:
             # create  and populate location collections based on times
             # TODO: Should we add some new description per location?
@@ -342,21 +335,22 @@ def handle_SH_WMS_endpoint(
                 catalog, location["Identifier"], location_config, catalog_config, endpoint_config
             )
             collection.extra_fields["endpointtype"] = endpoint_config["Name"]
-            for time in location["Times"]:
+            for time_string in location["Times"]:
+                dt = parse_datestring_to_tz_aware_datetime(time_string)
                 item = Item(
-                    id=time,
+                    id=format_datetime_to_isostring_zulu(dt),
                     bbox=location["Bbox"],
                     properties={},
                     geometry=None,
-                    datetime=parser.isoparse(time),
+                    datetime=dt,
                     stac_extensions=[
                         "https://stac-extensions.github.io/web-map-links/v1.1.0/schema.json",
                     ],
                 )
                 add_projection_info(endpoint_config, item)
-                add_visualization_info(item, collection_config, endpoint_config, time=time)
+                add_visualization_info(item, collection_config, endpoint_config, datetimes=[dt])
                 item_link = collection.add_item(item)
-                item_link.extra_fields["datetime"] = time
+                item_link.extra_fields["datetime"] = format_datetime_to_isostring_zulu(dt)
 
             link = root_collection.add_child(collection)
             # bubble up information we want to the link
@@ -373,6 +367,26 @@ def handle_SH_WMS_endpoint(
         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])
+    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])
+        for dt in datetimes:
+            item = Item(
+                id=format_datetime_to_isostring_zulu(dt),
+                bbox=bbox,
+                properties={},
+                geometry=None,
+                datetime=dt,
+                stac_extensions=[
+                    "https://stac-extensions.github.io/web-map-links/v1.1.0/schema.json",
+                ],
+            )
+            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)
     # eodash v4 compatibility
     add_collection_information(catalog_config, root_collection, collection_config)
     add_visualization_info(root_collection, collection_config, endpoint_config)
@@ -518,13 +532,13 @@ def handle_WMS_endpoint(
     collection = get_or_create_collection(
         catalog, collection_config["Name"], collection_config, catalog_config, endpoint_config
     )
-    times = get_collection_times_from_config(endpoint_config)
+    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"):
         # some endpoints allow "narrowed-down" capabilities per-layer, which we utilize to not
         # have to process full service capabilities XML
         capabilities_url = endpoint_config["EndPoint"]
-        spatial_extent, times = retrieveExtentFromWMSWMTS(
+        spatial_extent, datetimes = retrieveExtentFromWMSWMTS(
             capabilities_url,
             endpoint_config["LayerId"],
             version=endpoint_config.get("Version", "1.1.1"),
@@ -532,24 +546,24 @@ def handle_WMS_endpoint(
         )
     # optionally filter time results
     if query := endpoint_config.get("Query"):
-        times = filter_time_entries(times, query)
+        datetimes = filter_time_entries(datetimes, query)
     # Create an item per time to allow visualization in stac clients
-    if len(times) > 0:
-        for t in times:
+    if len(datetimes) > 0:
+        for dt in datetimes:
             item = Item(
-                id=t,
+                id=format_datetime_to_isostring_zulu(dt),
                 bbox=spatial_extent,
                 properties={},
                 geometry=None,
-                datetime=parser.isoparse(t),
+                datetime=dt,
                 stac_extensions=[
                     "https://stac-extensions.github.io/web-map-links/v1.1.0/schema.json",
                 ],
             )
             add_projection_info(endpoint_config, item)
-            add_visualization_info(item, collection_config, endpoint_config, time=t)
+            add_visualization_info(item, collection_config, endpoint_config, datetimes=[dt])
             link = collection.add_item(item)
-            link.extra_fields["datetime"] = t
+            link.extra_fields["datetime"] = format_datetime_to_isostring_zulu(dt)
         collection.update_extent_from_items()
 
     # Check if we should overwrite bbox
@@ -586,7 +600,7 @@ def add_visualization_info(
     collection_config: dict,
     endpoint_config: dict,
     file_url: str | None = None,
-    time: str | None = None,
+    datetimes: list[datetime] | None = None,
 ) -> None:
     extra_fields: dict[str, list[str] | dict[str, str]] = {}
     if "Attribution" in endpoint_config:
@@ -606,25 +620,36 @@ def add_visualization_info(
                 "role": ["data"],
             }
         )
-        if time is not None:
-            if endpoint_config["Name"] == "Sentinel Hub WMS":
-                # SH WMS for public collections needs time interval, we use full day here
-                datetime_object = datetime.strptime(time, "%Y-%m-%d")
-                start = datetime_object.isoformat()
-                end = (datetime_object + timedelta(days=1) - timedelta(milliseconds=1)).isoformat()
-                time_interval = f"{start}/{end}"
-                extra_fields["wms:dimensions"] = {"TIME": time_interval}
-            if endpoint_config["Name"] == "Sentinel Hub":
-                extra_fields["wms:dimensions"] = {"TIME": time}
-        stac_object.add_link(
-            Link(
-                rel="wms",
-                target=f"https://services.sentinel-hub.com/ogc/wms/{instanceId}",
-                media_type=(endpoint_config.get("MimeType", "image/png")),
-                title=collection_config["Name"],
-                extra_fields=extra_fields,
-            )
+        dimensions = {}
+        if dimensions_config := endpoint_config.get("Dimensions", {}):
+            for key, value in dimensions_config.items():
+                dimensions[key] = value
+        if datetimes is not None:
+            dt = datetimes[0]
+            start_isostring = format_datetime_to_isostring_zulu(dt)
+            # SH WMS for public collections needs time interval, we use full day here
+            end = dt + timedelta(days=1) - timedelta(milliseconds=1)
+            # we have start_datetime and end_datetime
+            if len(datetimes) == 2:
+                end = datetimes[1]
+            end_isostring = format_datetime_to_isostring_zulu(end)
+            time_interval = f"{start_isostring}/{end_isostring}"
+            dimensions["TIME"] = time_interval
+
+        if dimensions != {}:
+            extra_fields["wms:dimensions"] = dimensions
+        link = Link(
+            rel="wms",
+            target=f"https://services.sentinel-hub.com/ogc/wms/{instanceId}",
+            media_type=(endpoint_config.get("MimeType", "image/png")),
+            title=collection_config["Name"],
+            extra_fields=extra_fields,
         )
+        add_projection_info(
+            endpoint_config,
+            link,
+        )
+        stac_object.add_link(link)
     elif endpoint_config["Name"] == "WMS":
         extra_fields.update(
             {
@@ -632,30 +657,44 @@ def add_visualization_info(
                 "role": ["data"],
             }
         )
-        if time is not None:
-            extra_fields["wms:dimensions"] = {
-                "TIME": time,
-            }
+        dimensions = {}
+        if dimensions_config := endpoint_config.get("Dimensions", {}):
+            for key, value in dimensions_config.items():
+                dimensions[key] = value
+        if datetimes is not None:
+            dimensions["TIME"] = format_datetime_to_isostring_zulu(datetimes[0])
+        if dimensions != {}:
+            extra_fields["wms:dimensions"] = dimensions
         if "Styles" in endpoint_config:
             extra_fields["wms:styles"] = endpoint_config["Styles"]
         media_type = endpoint_config.get("MediaType", "image/jpeg")
         endpoint_url = endpoint_config["EndPoint"]
         # custom replacing of all ENV VARS present as template in URL as {VAR}
         endpoint_url = replace_with_env_variables(endpoint_url)
-        stac_object.add_link(
-            Link(
-                rel="wms",
-                target=endpoint_url,
-                media_type=media_type,
-                title=collection_config["Name"],
-                extra_fields=extra_fields,
-            )
+        link = Link(
+            rel="wms",
+            target=endpoint_url,
+            media_type=media_type,
+            title=collection_config["Name"],
+            extra_fields=extra_fields,
+        )
+        add_projection_info(
+            endpoint_config,
+            link,
         )
+        stac_object.add_link(link)
     elif endpoint_config["Name"] == "JAXA_WMTS_PALSAR":
         target_url = "{}".format(endpoint_config.get("EndPoint"))
         # custom time just for this special case as a default for collection wmts
+        time = None
+        if datetimes is not None:
+            time = datetimes[0]
         extra_fields.update(
-            {"wmts:layer": endpoint_config.get("LayerId", "").replace("{time}", time or "2017")}
+            {
+                "wmts:layer": endpoint_config.get("LayerId", "").replace(
+                    "{time}", (time and str(time.year)) or "2017"
+                )
+            }
         )
         stac_object.add_link(
             Link(
@@ -709,8 +748,8 @@ def add_visualization_info(
             }
         )
         dimensions = {}
-        if time is not None:
-            dimensions["time"] = time
+        if datetimes is not None:
+            dimensions["time"] = format_datetime_to_isostring_zulu(datetimes[0])
         if dimensions_config := endpoint_config.get("Dimensions", {}):
             for key, value in dimensions_config.items():
                 dimensions[key] = value
@@ -731,15 +770,18 @@ def add_visualization_info(
         elif endpoint_config["Type"] == "tiles":
             target_url = generate_veda_tiles_link(endpoint_config, file_url)
         if target_url:
-            stac_object.add_link(
-                Link(
-                    rel="xyz",
-                    target=target_url,
-                    media_type="image/png",
-                    title=collection_config["Name"],
-                    extra_fields=extra_fields,
-                )
+            link = Link(
+                rel="xyz",
+                target=target_url,
+                media_type="image/png",
+                title=collection_config["Name"],
+                extra_fields=extra_fields,
+            )
+            add_projection_info(
+                endpoint_config,
+                link,
             )
+            stac_object.add_link(link)
     elif endpoint_config["Name"] == "GeoDB Vector Tiles":
         # `${geoserverUrl}${config.layerName}@EPSG%3A${projString}@pbf/{z}/{x}/{-y}.pbf`,
         # 'geodb_debd884d-92f9-4979-87b6-eadef1139394:GTIF_AT_Gemeinden_3857'
@@ -833,12 +875,13 @@ def handle_raw_source(
                 add_projection_info(endpoint_config, asset)
                 assets[a["Identifier"]] = asset
             bbox = endpoint_config.get("Bbox", [-180, -85, 180, 85])
+            dt = parse_datestring_to_tz_aware_datetime(time_entry["Time"])
             item = Item(
-                id=time_entry["Time"],
+                id=format_datetime_to_isostring_zulu(dt),
                 bbox=bbox,
                 properties={},
                 geometry=create_geojson_from_bbox(bbox),
-                datetime=parser.isoparse(time_entry["Time"]),
+                datetime=dt,
                 assets=assets,
                 extra_fields={},
             )
@@ -859,7 +902,7 @@ def handle_raw_source(
                 )
                 item.add_link(style_link)
             link = collection.add_item(item)
-            link.extra_fields["datetime"] = time_entry["Time"]
+            link.extra_fields["datetime"] = format_datetime_to_isostring_zulu(dt)
             link.extra_fields["assets"] = [a["File"] for a in time_entry["Assets"]]
         # eodash v4 compatibility, adding last referenced style to collection
         if style_link:

{eodash_catalog-0.0.29 → eodash_catalog-0.0.31}/src/eodash_catalog/stac_handling.py

@@ -3,7 +3,6 @@ from datetime import datetime
 import requests
 import spdx_lookup as lookup
 import yaml
-from dateutil import parser
 from pystac import (
     Asset,
     Catalog,
@@ -18,7 +17,10 @@ from pystac import (
 from structlog import get_logger
 from yaml.loader import SafeLoader
 
-from eodash_catalog.utils import generateDateIsostringsFromInterval
+from eodash_catalog.utils import (
+    generateDatetimesFromInterval,
+    parse_datestring_to_tz_aware_datetime,
+)
 
 LOGGER = get_logger(__name__)
 
@@ -42,20 +44,12 @@ def get_or_create_collection(
             spatial_extent,
         ]
     )
-    times: list[str] = []
     temporal_extent = TemporalExtent([[datetime.now(), None]])
-    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_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])
+    if endpoint_config:
+        times_datetimes = get_collection_datetimes_from_config(endpoint_config)
+        if len(times_datetimes) > 0:
             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
@@ -387,17 +381,20 @@ def add_extra_fields(stac_object: Collection | Link, collection_config: dict) ->
         stac_object.extra_fields["eodash:mapProjection"] = collection_config["MapProjection"]
 
 
-def get_collection_times_from_config(endpoint_config: dict) -> list[str]:
-    times: list[str] = []
-    if endpoint_config and endpoint_config.get("Type") == "OverwriteTimes":
+def get_collection_datetimes_from_config(endpoint_config: dict) -> list[datetime]:
+    times_datetimes: list[datetime] = []
+    if endpoint_config:
         if endpoint_config.get("Times"):
             times = list(endpoint_config.get("Times", []))
+            times_datetimes = sorted(
+                [parse_datestring_to_tz_aware_datetime(time) for time in 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")
+            start = endpoint_config["DateTimeInterval"].get("Start", "2020-09-01T00:00:00Z")
+            end = endpoint_config["DateTimeInterval"].get("End", "2020-10-01T00:00:00Z")
             timedelta_config = endpoint_config["DateTimeInterval"].get("Timedelta", {"days": 1})
-            times = generateDateIsostringsFromInterval(start, end, timedelta_config)
-    return times
+            times_datetimes = generateDatetimesFromInterval(start, end, timedelta_config)
+    return times_datetimes
 
 
 def add_projection_info(

{eodash_catalog-0.0.29 → eodash_catalog-0.0.31}/src/eodash_catalog/thumbnails.py

@@ -7,7 +7,7 @@ from pystac import (
     Item,
 )
 
-from eodash_catalog.utils import generate_veda_cog_link
+from eodash_catalog.utils import format_datetime_to_isostring_zulu, generate_veda_cog_link
 
 
 def fetch_and_save_thumbnail(collection_config: dict, url: str) -> None:
@@ -45,7 +45,7 @@ def generate_thumbnail(
         # it is possible for datetime to be null,
         # if it is start and end datetime have to exist
         if item_datetime:
-            time = item_datetime.isoformat()[:-6] + "Z"
+            time = format_datetime_to_isostring_zulu(item_datetime)
         url = "https://services.sentinel-hub.com/ogc/wms/{}?{}&layers={}&time={}&{}".format(
             instanceId,
             wms_config,

{eodash_catalog-0.0.29 → eodash_catalog-0.0.31}/src/eodash_catalog/utils.py

@@ -14,6 +14,7 @@ from dateutil import parser
 from owslib.wms import WebMapService
 from owslib.wmts import WebMapTileService
 from pystac import Catalog, Collection, Item, RelType
+from pytz import timezone as pytztimezone
 from six import string_types
 from structlog import get_logger
 
@@ -57,7 +58,7 @@ def create_geojson_from_bbox(bbox: list[float | int]) -> dict:
 
 def retrieveExtentFromWMSWMTS(
     capabilities_url: str, layer: str, version: str = "1.1.1", wmts: bool = False
-) -> tuple[list[float], list[str]]:
+) -> tuple[list[float], list[datetime]]:
     times = []
     try:
         if not wmts:
@@ -96,7 +97,9 @@ def retrieveExtentFromWMSWMTS(
     bbox = [-180.0, -90.0, 180.0, 90.0]
     if service and service[layer].boundingBoxWGS84:
         bbox = [float(x) for x in service[layer].boundingBoxWGS84]
-    return bbox, times
+
+    datetimes = [parse_datestring_to_tz_aware_datetime(time_str) for time_str in times]
+    return bbox, datetimes
 
 
 def interval(start: datetime, stop: datetime, delta: timedelta) -> Iterator[datetime]:
@@ -151,19 +154,20 @@ def parse_duration(datestring):
     return ret
 
 
-def generateDateIsostringsFromInterval(
+def generateDatetimesFromInterval(
     start: str, end: str, timedelta_config: dict | None = None
-) -> list[str]:
+) -> list[datetime]:
     if timedelta_config is None:
         timedelta_config = {}
-    start_dt = datetime.fromisoformat(start)
+    start_dt = parse_datestring_to_tz_aware_datetime(start)
     if end == "today":
-        end = datetime.now().isoformat()
-    end_dt = datetime.fromisoformat(end)
+        end_dt = datetime.now(tz=timezone.utc)
+    else:
+        end_dt = parse_datestring_to_tz_aware_datetime(end)
     delta = timedelta(**timedelta_config)
     dates = []
     while start_dt <= end_dt:
-        dates.append(start_dt.isoformat())
+        dates.append(start_dt)
         start_dt += delta
     return dates
 
@@ -251,9 +255,9 @@ def add_single_item_if_collection_empty(collection: Collection) -> None:
             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(),
+            datetime=datetime(1970, 1, 1, 0, 0, 0, tzinfo=pytztimezone("UTC")),
+            start_datetime=datetime(1970, 1, 1, 0, 0, 0, tzinfo=pytztimezone("UTC")),
+            end_datetime=datetime.now(tz=pytztimezone("UTC")),
         )
         collection.add_item(item)
 
@@ -309,19 +313,28 @@ def retry(exceptions, tries=3, delay=2, backoff=1, logger=None):
     return decorator
 
 
-def filter_time_entries(time_entries: list[str], query: dict[str, str]) -> list[str]:
+def filter_time_entries(time_entries: list[datetime], query: dict[str, str]) -> list[datetime]:
     datetime_query = [
-        parser.isoparse(time_entries[0]).replace(tzinfo=timezone.utc),
-        parser.isoparse(time_entries[-1]).replace(tzinfo=timezone.utc),
+        time_entries[0],
+        time_entries[-1],
     ]
     if start := query.get("Start"):
-        datetime_query[0] = parser.isoparse(start).replace(tzinfo=timezone.utc)
+        datetime_query[0] = parse_datestring_to_tz_aware_datetime(start)
     if end := query.get("End"):
-        datetime_query[1] = parser.isoparse(end).replace(tzinfo=timezone.utc)
+        datetime_query[1] = parse_datestring_to_tz_aware_datetime(end)
     # filter times based on query Start/End
-    time_entries = [
-        datetime_str
-        for datetime_str in time_entries
-        if datetime_query[0] <= parser.isoparse(datetime_str) < datetime_query[1]
-    ]
+    time_entries = [dt for dt in time_entries if datetime_query[0] <= dt < datetime_query[1]]
     return time_entries
+
+
+def parse_datestring_to_tz_aware_datetime(datestring: str) -> datetime:
+    dt = parser.isoparse(datestring)
+    dt = pytztimezone("UTC").localize(dt) if dt.tzinfo is None else dt
+    return dt
+
+
+def format_datetime_to_isostring_zulu(datetime_obj: datetime) -> str:
+    # although "+00:00" is a valid ISO 8601 timezone designation for UTC,
+    # we rather convert it to Zulu based string in order for various clients
+    # to understand it better (WMS)
+    return (datetime_obj.replace(microsecond=0).isoformat()).replace("+00:00", "Z")