cr

Author: Gomez324

stac_fastapi/core/stac_fastapi/core/core.py

@@ -830,7 +830,7 @@ async def post_search(
 
         datetime_parsed = format_datetime_range(date_str=search_request.datetime)
         try:
-            search, datetime_search = self.database.apply_datetime_filter(
+            search = self.database.apply_datetime_filter(
                 search=search, datetime=datetime_parsed
             )
         except (ValueError, TypeError) as e:
@@ -910,7 +910,7 @@ async def post_search(
             token=token_param,
             sort=sort,
             collection_ids=getattr(search_request, "collections", None),
-            datetime_search=datetime_search,
+            datetime_search=datetime_parsed,
         )
 
         fields = getattr(search_request, "fields", None)

stac_fastapi/elasticsearch/pyproject.toml

@@ -33,7 +33,6 @@ dependencies = [
     "elasticsearch[async]~=8.19.1",
     "uvicorn~=0.23.0",
     "starlette>=0.35.0,<0.36.0",
-    "redis==6.4.0",
 ]
 
 [project.urls]

stac_fastapi/elasticsearch/stac_fastapi/elasticsearch/database_logic.py

@@ -811,7 +811,7 @@ async def execute_search(
         token: Optional[str],
         sort: Optional[Dict[str, Dict[str, str]]],
         collection_ids: Optional[List[str]],
-        datetime_search: Dict[str, Optional[str]],
+        datetime_search: str,
         ignore_unavailable: bool = True,
     ) -> Tuple[Iterable[Dict[str, Any]], Optional[int], Optional[str]]:
         """Execute a search query with limit and other optional parameters.
@@ -822,7 +822,7 @@ async def execute_search(
             token (Optional[str]): The token used to return the next set of results.
             sort (Optional[Dict[str, Dict[str, str]]]): Specifies how the results should be sorted.
             collection_ids (Optional[List[str]]): The collection ids to search.
-            datetime_search (Dict[str, Optional[str]]): Datetime range used for index selection.
+            datetime_search (str): Datetime used for index selection.
             ignore_unavailable (bool, optional): Whether to ignore unavailable collections. Defaults to True.
 
         Returns:
@@ -912,7 +912,7 @@ async def aggregate(
         geometry_geohash_grid_precision: int,
         geometry_geotile_grid_precision: int,
         datetime_frequency_interval: str,
-        datetime_search,
+        datetime_search: str,
         ignore_unavailable: Optional[bool] = True,
     ):
         """Return aggregations of STAC Items."""

stac_fastapi/opensearch/pyproject.toml

@@ -34,7 +34,6 @@ dependencies = [
     "opensearch-py[async]~=2.8.0",
     "uvicorn~=0.23.0",
     "starlette>=0.35.0,<0.36.0",
-    "redis==6.4.0",
 ]
 
 [project.urls]

stac_fastapi/opensearch/stac_fastapi/opensearch/database_logic.py

@@ -811,7 +811,7 @@ async def execute_search(
         token: Optional[str],
         sort: Optional[Dict[str, Dict[str, str]]],
         collection_ids: Optional[List[str]],
-        datetime_search: Dict[str, Optional[str]],
+        datetime_search: str,
         ignore_unavailable: bool = True,
     ) -> Tuple[Iterable[Dict[str, Any]], Optional[int], Optional[str]]:
         """Execute a search query with limit and other optional parameters.
@@ -822,7 +822,7 @@ async def execute_search(
             token (Optional[str]): The token used to return the next set of results.
             sort (Optional[Dict[str, Dict[str, str]]]): Specifies how the results should be sorted.
             collection_ids (Optional[List[str]]): The collection ids to search.
-            datetime_search (Dict[str, Optional[str]]): Datetime range used for index selection.
+            datetime_search (str): Datetime used for index selection.
             ignore_unavailable (bool, optional): Whether to ignore unavailable collections. Defaults to True.
 
         Returns:
@@ -918,7 +918,7 @@ async def aggregate(
         geometry_geohash_grid_precision: int,
         geometry_geotile_grid_precision: int,
         datetime_frequency_interval: str,
-        datetime_search,
+        datetime_search: str,
         ignore_unavailable: Optional[bool] = True,
     ):
         """Return aggregations of STAC Items."""

stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/aggregation/client.py

@@ -313,11 +313,9 @@ async def aggregate(
             )
 
         if aggregate_request.datetime:
-            search, datetime_search = self.database.apply_datetime_filter(
+            search = self.database.apply_datetime_filter(
                 search=search, datetime=aggregate_request.datetime
             )
-        else:
-            datetime_search = {"gte": None, "lte": None}
 
         if aggregate_request.bbox:
             bbox = aggregate_request.bbox
@@ -416,7 +414,7 @@ async def aggregate(
                 geometry_geohash_grid_precision,
                 geometry_geotile_grid_precision,
                 datetime_frequency_interval,
-                datetime_search,
+                aggregate_request.datetime,
             )
         except Exception as error:
             if not isinstance(error, IndexError):

stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/database/index.py

@@ -71,6 +71,7 @@ def indices(collection_ids: Optional[List[str]]) -> str:
 def filter_indexes_by_datetime(
     collection_indexes: List[Tuple[Dict[str, str], ...]],
     datetime_search: Dict[str, Dict[str, Optional[str]]],
+    use_datetime: bool,
 ) -> List[str]:
     """
     Filter Elasticsearch index aliases based on datetime search criteria.
@@ -85,6 +86,9 @@ def filter_indexes_by_datetime(
         datetime_search (Dict[str, Dict[str, Optional[str]]]): A dictionary with keys 'datetime',
             'start_datetime', and 'end_datetime', each containing 'gte' and 'lte' criteria as ISO format
             datetime strings or None.
+        use_datetime (bool): Flag determining which datetime field to filter on:
+            - True: Filters using 'datetime' alias.
+            - False: Filters using 'start_datetime' and 'end_datetime' aliases.
 
     Returns:
         List[str]: A list of start_datetime aliases that match all provided search criteria.
@@ -138,29 +142,30 @@ def check_criteria(
         end_datetime_alias = index_dict.get("end_datetime")
         datetime_alias = index_dict.get("datetime")
 
-        if not start_datetime_alias:
-            continue
-
-        start_range = extract_date_from_alias(start_datetime_alias)
-        end_date = extract_date_from_alias(end_datetime_alias)
-        datetime_date = extract_date_from_alias(datetime_alias)
-
-        if not check_criteria(
-            start_range[0], start_range[1], datetime_search.get("start_datetime", {})
-        ):
-            continue
-        if end_date:
+        if start_datetime_alias:
+            start_date = extract_date_from_alias(start_datetime_alias)
+            if not check_criteria(
+                start_date[0], start_date[1], datetime_search.get("start_datetime", {})
+            ):
+                continue
+        if end_datetime_alias:
+            end_date = extract_date_from_alias(end_datetime_alias)
             if not check_criteria(
                 end_date[0], end_date[1], datetime_search.get("end_datetime", {})
             ):
                 continue
-        if datetime_date:
+        if datetime_alias:
+            datetime_date = extract_date_from_alias(datetime_alias)
             if not check_criteria(
                 datetime_date[0], datetime_date[1], datetime_search.get("datetime", {})
             ):
                 continue
 
-        filtered_indexes.append(start_datetime_alias)
+        primary_datetime_alias = (
+            datetime_alias if use_datetime else start_datetime_alias
+        )
+
+        filtered_indexes.append(primary_datetime_alias)
 
     return filtered_indexes
 

stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/search_engine/index_operations.py

@@ -3,6 +3,7 @@
 import uuid
 from typing import Any, Dict, List, Literal
 
+from stac_fastapi.core.utilities import get_bool_env
 from stac_fastapi.sfeos_helpers.database import (
     index_alias_by_collection_id,
     index_by_collection_id,
@@ -18,6 +19,16 @@
 class IndexOperations:
     """Base class for search engine adapters with common implementations."""
 
+    @property
+    def use_datetime(self) -> bool:
+        """Get USE_DATETIME setting dynamically."""
+        return get_bool_env("USE_DATETIME", default=True)
+
+    @property
+    def primary_datetime_name(self) -> str:
+        """Get primary datetime field name based on current USE_DATETIME setting."""
+        return "datetime" if self.use_datetime else "start_datetime"
+
     async def create_simple_index(self, client: Any, collection_id: str) -> str:
         """Create a simple index for the given collection.
 
@@ -42,44 +53,48 @@ async def create_datetime_index(
         self,
         client: Any,
         collection_id: str,
-        start_datetime: str,
-        datetime: str,
-        end_datetime: str,
+        start_datetime: str | None,
+        datetime: str | None,
+        end_datetime: str | None,
     ) -> str:
         """Create a datetime-based index for the given collection.
 
         Args:
             client: Search engine client instance.
             collection_id (str): Collection identifier.
-            start_datetime (str): Start datetime for the index alias.
-            datetime (str): Datetime for the datetime alias (can be None).
-            end_datetime (str): End datetime for the index alias.
+            start_datetime (str | None): Start datetime for the index alias.
+            datetime (str | None): Datetime for the datetime alias.
+            end_datetime (str | None): End datetime for the index alias.
 
         Returns:
-            str: Created start_datetime alias name.
+            str: Created datetime alias name.
         """
         index_name = self.create_index_name(collection_id)
-        alias_start_date = self.create_alias_name(
-            collection_id, "start_datetime", start_datetime
-        )
-        alias_date = self.create_alias_name(collection_id, "datetime", datetime)
-        alias_end_date = self.create_alias_name(
-            collection_id, "end_datetime", end_datetime
-        )
         collection_alias = index_alias_by_collection_id(collection_id)
 
         aliases: Dict[str, Any] = {
             collection_alias: {},
-            alias_start_date: {},
-            alias_date: {},
-            alias_end_date: {},
         }
 
+        if start_datetime:
+            alias_start_date = self.create_alias_name(
+                collection_id, "start_datetime", start_datetime
+            )
+            alias_end_date = self.create_alias_name(
+                collection_id, "end_datetime", end_datetime
+            )
+            aliases[alias_start_date] = {}
+            aliases[alias_end_date] = {}
+            created_alias = alias_start_date
+        else:
+            created_alias = self.create_alias_name(collection_id, "datetime", datetime)
+            aliases[created_alias] = {}
+
         await client.indices.create(
             index=index_name,
             body=self._create_index_body(aliases),
         )
-        return alias_start_date
+        return created_alias
 
     @staticmethod
     async def update_index_alias(client: Any, end_date: str, old_alias: str) -> str:
@@ -126,12 +141,12 @@ async def change_alias_name(
         index_name = list(aliases_info.keys())[0]
         actions = []
 
-        for old_alias in aliases_to_change:
-            actions.append({"remove": {"index": index_name, "alias": old_alias}})
-
         for new_alias in aliases_to_create:
             actions.append({"add": {"index": index_name, "alias": new_alias}})
 
+        for old_alias in aliases_to_change:
+            actions.append({"remove": {"index": index_name, "alias": old_alias}})
+
         await client.indices.update_aliases(body={"actions": actions})
 
     @staticmethod
@@ -182,8 +197,9 @@ def _create_index_body(aliases: Dict[str, Dict]) -> Dict[str, Any]:
             "settings": ES_ITEMS_SETTINGS,
         }
 
-    @staticmethod
-    async def find_latest_item_in_index(client: Any, index_name: str) -> dict[str, Any]:
+    async def find_latest_item_in_index(
+        self, client: Any, index_name: str
+    ) -> dict[str, Any]:
         """Find the latest item in the specified index.
 
         Args:
@@ -195,7 +211,7 @@ async def find_latest_item_in_index(client: Any, index_name: str) -> dict[str, A
         """
         query = {
             "size": 1,
-            "sort": [{"properties.start_datetime": {"order": "desc"}}],
+            "sort": [{f"properties.{self.primary_datetime_name}": {"order": "desc"}}],
             "_source": [
                 "properties.start_datetime",
                 "properties.datetime",