created shared datetime fiter fn

Author: jonhealy1

stac_fastapi/elasticsearch/stac_fastapi/elasticsearch/database_logic.py

@@ -30,13 +30,13 @@
 from stac_fastapi.sfeos_helpers import filter as filter_module
 from stac_fastapi.sfeos_helpers.database import (
     apply_collections_bbox_filter_shared,
+    apply_collections_datetime_filter_shared,
     apply_free_text_filter_shared,
     apply_intersects_filter_shared,
     create_index_templates_shared,
     delete_item_index_shared,
     get_queryables_mapping_shared,
     index_alias_by_collection_id,
-    index_by_collection_id,
     mk_actions,
     mk_item_id,
     populate_sort_shared,
@@ -100,26 +100,6 @@ async def create_collection_index() -> None:
     await client.close()
 
 
-async def create_item_index(collection_id: str):
-    """
-    Create the index for Items. The settings of the index template will be used implicitly.
-
-    Args:
-        collection_id (str): Collection identifier.
-
-    Returns:
-        None
-
-    """
-    client = AsyncElasticsearchSettings().create_client
-
-    await client.options(ignore_status=400).indices.create(
-        index=f"{index_by_collection_id(collection_id)}-000001",
-        body={"aliases": {index_alias_by_collection_id(collection_id): {}}},
-    )
-    await client.close()
-
-
 async def delete_item_index(collection_id: str):
     """Delete the index for items in a collection.
 
@@ -322,12 +302,10 @@ async def get_all_collections(
         if bbox_filter:
             query_parts.append(bbox_filter)
 
-        # Combine all query parts with AND logic if there are multiple
-        datetime_filter = None
-        if datetime:
-            datetime_filter = self._apply_collection_datetime_filter(datetime)
-            if datetime_filter:
-                query_parts.append(datetime_filter)
+        # Apply datetime filter if provided
+        datetime_filter = apply_collections_datetime_filter_shared(datetime)
+        if datetime_filter:
+            query_parts.append(datetime_filter)
 
         # Combine all query parts with AND logic
         if query_parts:
@@ -386,41 +364,6 @@ async def get_all_collections(
 
         return collections, next_token, matched
 
-    @staticmethod
-    def _apply_collection_datetime_filter(
-        datetime_str: Optional[str],
-    ) -> Optional[Dict[str, Any]]:
-        """Create a temporal filter for collections based on their extent."""
-        if not datetime_str:
-            return None
-
-        # Parse the datetime string into start and end
-        if "/" in datetime_str:
-            start, end = datetime_str.split("/")
-            # Replace open-ended ranges with concrete dates
-            if start == "..":
-                # For open-ended start, use a very early date
-                start = "1800-01-01T00:00:00Z"
-            if end == "..":
-                # For open-ended end, use a far future date
-                end = "2999-12-31T23:59:59Z"
-        else:
-            # If it's just a single date, use it for both start and end
-            start = end = datetime_str
-
-        return {
-            "bool": {
-                "must": [
-                    # Check if any date in the array is less than or equal to the query end date
-                    # This will match if the collection's start date is before or equal to the query end date
-                    {"range": {"extent.temporal.interval": {"lte": end}}},
-                    # Check if any date in the array is greater than or equal to the query start date
-                    # This will match if the collection's end date is after or equal to the query start date
-                    {"range": {"extent.temporal.interval": {"gte": start}}},
-                ]
-            }
-        }
-
     async def get_one_item(self, collection_id: str, item_id: str) -> Dict:
         """Retrieve a single item from the database.
 
@@ -1388,7 +1331,7 @@ async def create_collection(self, collection: Collection, **kwargs: Any):
             None
 
         Notes:
-            A new index is created for the items in the Collection using the `create_item_index` function.
+            A new index is created for the items in the Collection if the index insertion strategy requires it.
         """
         collection_id = collection["id"]
 

stac_fastapi/opensearch/stac_fastapi/opensearch/database_logic.py

@@ -30,6 +30,7 @@
 from stac_fastapi.sfeos_helpers import filter as filter_module
 from stac_fastapi.sfeos_helpers.database import (
     apply_collections_bbox_filter_shared,
+    apply_collections_datetime_filter_shared,
     apply_free_text_filter_shared,
     apply_intersects_filter_shared,
     create_index_templates_shared,
@@ -306,12 +307,10 @@ async def get_all_collections(
         if bbox_filter:
             query_parts.append(bbox_filter)
 
-        # Combine all query parts with AND logic if there are multiple
-        datetime_filter = None
-        if datetime:
-            datetime_filter = self._apply_collection_datetime_filter(datetime)
-            if datetime_filter:
-                query_parts.append(datetime_filter)
+        # Apply datetime filter if provided
+        datetime_filter = apply_collections_datetime_filter_shared(datetime)
+        if datetime_filter:
+            query_parts.append(datetime_filter)
 
         # Combine all query parts with AND logic
         if query_parts:
@@ -456,41 +455,6 @@ def apply_free_text_filter(search: Search, free_text_queries: Optional[List[str]
             search=search, free_text_queries=free_text_queries
         )
 
-    @staticmethod
-    def _apply_collection_datetime_filter(
-        datetime_str: Optional[str],
-    ) -> Optional[Dict[str, Any]]:
-        """Create a temporal filter for collections based on their extent."""
-        if not datetime_str:
-            return None
-
-        # Parse the datetime string into start and end
-        if "/" in datetime_str:
-            start, end = datetime_str.split("/")
-            # Replace open-ended ranges with concrete dates
-            if start == "..":
-                # For open-ended start, use a very early date
-                start = "1800-01-01T00:00:00Z"
-            if end == "..":
-                # For open-ended end, use a far future date
-                end = "2999-12-31T23:59:59Z"
-        else:
-            # If it's just a single date, use it for both start and end
-            start = end = datetime_str
-
-        return {
-            "bool": {
-                "must": [
-                    # Check if any date in the array is less than or equal to the query end date
-                    # This will match if the collection's start date is before or equal to the query end date
-                    {"range": {"extent.temporal.interval": {"lte": end}}},
-                    # Check if any date in the array is greater than or equal to the query start date
-                    # This will match if the collection's end date is after or equal to the query start date
-                    {"range": {"extent.temporal.interval": {"gte": start}}},
-                ]
-            }
-        }
-
     @staticmethod
     def apply_datetime_filter(
         search: Search, datetime: Optional[str]
@@ -1358,7 +1322,7 @@ async def create_collection(self, collection: Collection, **kwargs: Any):
             ConflictError: If a Collection with the same id already exists in the database.
 
         Notes:
-            A new index is created for the items in the Collection using the `create_item_index` function.
+            A new index is created for the items in the Collection if the index insertion strategy requires it.
         """
         collection_id = collection["id"]
 

stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/database/__init__.py

@@ -43,6 +43,7 @@
 from .mapping import get_queryables_mapping_shared
 from .query import (
     apply_collections_bbox_filter_shared,
+    apply_collections_datetime_filter_shared,
     apply_free_text_filter_shared,
     apply_intersects_filter_shared,
     populate_sort_shared,
@@ -61,6 +62,7 @@
     "apply_free_text_filter_shared",
     "apply_intersects_filter_shared",
     "apply_collections_bbox_filter_shared",
+    "apply_collections_datetime_filter_shared",
     "populate_sort_shared",
     # Mapping operations
     "get_queryables_mapping_shared",

stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/database/query.py

@@ -68,6 +68,67 @@ def apply_intersects_filter_shared(
     }
 
 
+def apply_collections_datetime_filter_shared(
+    datetime_str: Optional[str],
+) -> Optional[Dict[str, Any]]:
+    """Create a temporal filter for collections based on their extent.
+
+    Args:
+        datetime_str: The datetime parameter. Can be:
+            - A single datetime string (e.g., "2020-01-01T00:00:00Z")
+            - A datetime range with "/" separator (e.g., "2020-01-01T00:00:00Z/2021-01-01T00:00:00Z")
+            - Open-ended ranges using ".." (e.g., "../2021-01-01T00:00:00Z" or "2020-01-01T00:00:00Z/..")
+            - None if no datetime filter is provided
+
+    Returns:
+        Optional[Dict[str, Any]]: A dictionary containing the temporal filter configuration
+            that can be used with Elasticsearch/OpenSearch queries, or None if datetime_str is None.
+            Example return value:
+            {
+                "bool": {
+                    "must": [
+                        {"range": {"extent.temporal.interval": {"lte": "2021-01-01T00:00:00Z"}}},
+                        {"range": {"extent.temporal.interval": {"gte": "2020-01-01T00:00:00Z"}}}
+                    ]
+                }
+            }
+
+    Notes:
+        - This function is specifically for filtering collections by their temporal extent
+        - It queries the extent.temporal.interval field
+        - Open-ended ranges (..) are replaced with concrete dates (1800-01-01 for start, 2999-12-31 for end)
+    """
+    if not datetime_str:
+        return None
+
+    # Parse the datetime string into start and end
+    if "/" in datetime_str:
+        start, end = datetime_str.split("/")
+        # Replace open-ended ranges with concrete dates
+        if start == "..":
+            # For open-ended start, use a very early date
+            start = "1800-01-01T00:00:00Z"
+        if end == "..":
+            # For open-ended end, use a far future date
+            end = "2999-12-31T23:59:59Z"
+    else:
+        # If it's just a single date, use it for both start and end
+        start = end = datetime_str
+
+    return {
+        "bool": {
+            "must": [
+                # Check if any date in the array is less than or equal to the query end date
+                # This will match if the collection's start date is before or equal to the query end date
+                {"range": {"extent.temporal.interval": {"lte": end}}},
+                # Check if any date in the array is greater than or equal to the query start date
+                # This will match if the collection's end date is after or equal to the query start date
+                {"range": {"extent.temporal.interval": {"gte": start}}},
+            ]
+        }
+    }
+
+
 def apply_collections_bbox_filter_shared(
     bbox: Union[str, List[float], None]
 ) -> Optional[Dict[str, Dict]]: