Feature/query formats

ogc/edr/edr_api.py

@@ -155,10 +155,18 @@ def describe_collections(api: API, request: APIRequest, dataset: str | None = No
 
             collection["output_formats"] = collection_configuration[collection_id].get("output_formats", [])
 
+            collection_queryable = EdrProvider.is_collection_queryable(provider["base_url"], collection_id)
+            if not collection_queryable:
+                collection_without_queryables = EdrAPI._remove_query_metadata(collection)
+                collection["links"] = collection_without_queryables["links"]
+                collection["data_queries"] = collection_without_queryables["data_queries"]
+
             height_units = collection_configuration[collection_id].get("height_units", [])
+            query_formats = collection_configuration[collection_id].get("query_formats", {})
             for query_type in collection["data_queries"]:
                 data_query_additions = {
                     "query_type": query_type,
+                    **(query_formats.get(query_type) if query_formats.get(query_type) is not None else {}),
                     **({"height_units": height_units} if query_type == "cube" else {}),
                 }
                 variables = collection["data_queries"][query_type]["link"].get("variables", {})
@@ -229,9 +237,11 @@ def get_collection_edr_instances(
             instance["output_formats"] = collection_configuration[dataset].get("output_formats", [])
 
             height_units = collection_configuration[dataset].get("height_units")
+            query_formats = collection_configuration[dataset].get("query_formats", {})
             for query_type in instance["data_queries"]:
                 data_query_additions = {
                     "query_type": query_type,
+                    **(query_formats.get(query_type) if query_formats.get(query_type) is not None else {}),
                     **({"height_units": height_units} if query_type == "cube" else {}),
                 }
                 variables = instance["data_queries"][query_type]["link"].get("variables", {})
@@ -352,7 +362,7 @@ def _instance_parameters(
         Dict[str, Any]
             The metadata for available parameters in the instance.
         """
-        instance_parameters = {"parameter_names": {}}
+        instance_parameters = {}
         for key, value in provider_parameters.items():
             layer = next((layer for layer in collection_layers if layer.identifier == key), None)
             if layer is not None and instance in layer.time_instances():
@@ -374,6 +384,30 @@ def _instance_parameters(
                 }
         return instance_parameters
 
+    @staticmethod
+    def _remove_query_metadata(data: Dict[str, Any]) -> Dict[str, Any]:
+        """Remove metadata from the dictionary which relates to query types such as position and cube.
+
+        Parameters
+        ----------
+        data : Dict[str, Any]
+            The dictionary to remove query metadata from.
+
+        Returns
+        -------
+        Dict[str, Any]
+            The updated dictionary with metadata removed.
+        """
+        filtered_data = data.copy()
+        data_queries = data.get("data_queries", {})
+        filtered_data["data_queries"] = {"instances": data_queries.get("instances")}
+        filtered_data["links"] = []
+        for link in data["links"]:
+            if link.get("rel") != "data" or "/instances" in link.get("href", ""):
+                filtered_data["links"].append(link)
+
+        return filtered_data
+
     @staticmethod
     def _openapi_update(api: Dict[str, Any]) -> Dict[str, Any]:
         """Update the default OpenAPI definition to a custom format.

ogc/edr/edr_config.py

@@ -99,7 +99,8 @@ def _resources_definition(base_url: str, layers: List[pogc.Layer]) -> Dict[str,
                     "keywords": ["podpac"],
                     "extents": EdrConfig._generate_extents(group_layers),
                     "height_units": EdrConfig._vertical_units(group_layers),
-                    "output_formats": settings.EDR_QUERY_FORMATS,
+                    "output_formats": list({item for values in settings.EDR_QUERY_FORMATS.values() for item in values}),
+                    "query_formats": EdrConfig.data_query_formats(),
                     "providers": [
                         {
                             "type": "edr",
@@ -158,9 +159,9 @@ def _generate_extents(layers: List[pogc.Layer]) -> Dict[str, Any]:
                 urc_lon = max(urc_lon, urc_lon_tmp)
                 urc_lat = max(urc_lat, urc_lat_tmp)
 
-            coordinates_list = layer.get_coordinates_list()
-            if len(coordinates_list) > 0 and "alt" in coordinates_list[0].udims:
-                vertical_range.update(coordinates_list[0]["alt"].coordinates)
+            coordinates = layer.get_coordinates()
+            if coordinates is not None and "alt" in coordinates.udims:
+                vertical_range.update(coordinates["alt"].coordinates)
 
             if hasattr(layer, "valid_times") and layer.valid_times is not tl.Undefined and len(layer.valid_times) > 0:
                 time_range.update(layer.valid_times)
@@ -239,8 +240,25 @@ def _vertical_units(layers: List[pogc.Layer]) -> List[str]:
         """
         vertical_units = set()
         for layer in layers:
-            coordinates_list = layer.get_coordinates_list()
-            if len(coordinates_list) > 0 and coordinates_list[0].alt_units:
-                vertical_units.add(coordinates_list[0].alt_units)
+            coordinates = layer.get_coordinates()
+            if coordinates is not None and coordinates.alt_units:
+                vertical_units.add(coordinates.alt_units)
 
         return list(vertical_units)
+
+    @staticmethod
+    def data_query_formats() -> Dict[str, Any]:
+        """Get data related to the available query output formats and the default format.
+
+        Returns
+        -------
+        Dict[str, Any]
+            Query format data for each query type.
+        """
+        query_formats = {}
+        for query_type, formats in settings.EDR_QUERY_FORMATS.items():
+            query_formats[query_type] = {
+                "output_formats": formats,
+                "default_output_format": settings.EDR_QUERY_DEFAULTS.get(query_type),
+            }
+        return query_formats