sfeos-helpers 6.9.0__py3-none-any.whl → 6.10.0__py3-none-any.whl

stac_fastapi/sfeos_helpers/search_engine/selection/cache_manager.py

@@ -1,9 +1,9 @@
 """Cache management for index selection strategies."""
 
+import copy
 import threading
 import time
-from collections import defaultdict
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
 from stac_fastapi.sfeos_helpers.database import index_alias_by_collection_id
 from stac_fastapi.sfeos_helpers.mappings import ITEMS_INDEX_PREFIX
@@ -18,7 +18,7 @@ class IndexCacheManager:
         Args:
             cache_ttl_seconds (int): Time-to-live for cache entries in seconds.
         """
-        self._cache: Optional[Dict[str, List[str]]] = None
+        self._cache: Optional[Dict[str, List[Tuple[Dict[str, str]]]]] = None
         self._timestamp: float = 0
         self._ttl = cache_ttl_seconds
         self._lock = threading.Lock()
@@ -32,30 +32,32 @@ class IndexCacheManager:
         """
         return time.time() - self._timestamp > self._ttl
 
-    def get_cache(self) -> Optional[Dict[str, List[str]]]:
+    def get_cache(self) -> Optional[Dict[str, List[Tuple[Dict[str, str]]]]]:
         """Get the current cache if not expired.
 
         Returns:
-            Optional[Dict[str, List[str]]]: Cache data if valid, None if expired.
+            Optional[Dict[str, List[Tuple[Dict[str, str]]]]]: Cache data if valid, None if expired.
         """
         with self._lock:
             if self.is_expired:
                 return None
-            return {k: v.copy() for k, v in self._cache.items()}
+            return copy.deepcopy(self._cache) if self._cache else None
 
-    def set_cache(self, data: Dict[str, List[str]]) -> None:
+    def set_cache(self, data: Dict[str, List[Tuple[Dict[str, str]]]]) -> None:
         """Set cache data and update timestamp.
 
         Args:
-            data (Dict[str, List[str]]): Cache data to store.
+            data (Dict[str, List[Tuple[Dict[str, str]]]]): Cache data to store.
         """
-        self._cache = data
-        self._timestamp = time.time()
+        with self._lock:
+            self._cache = data
+            self._timestamp = time.time()
 
     def clear_cache(self) -> None:
         """Clear the cache and reset timestamp."""
-        self._cache = None
-        self._timestamp = 0
+        with self._lock:
+            self._cache = None
+            self._timestamp = 0
 
 
 class IndexAliasLoader:
@@ -71,15 +73,16 @@ class IndexAliasLoader:
         self.client = client
         self.cache_manager = cache_manager
 
-    async def load_aliases(self) -> Dict[str, List[str]]:
+    async def load_aliases(self) -> Dict[str, List[Tuple[Dict[str, str]]]]:
         """Load index aliases from search engine.
 
         Returns:
-            Dict[str, List[str]]: Mapping of base aliases to item aliases.
+            Dict[str, List[Tuple[Dict[str, str]]]]: Mapping of main collection aliases to their data.
         """
         response = await self.client.indices.get_alias(index=f"{ITEMS_INDEX_PREFIX}*")
-        result = defaultdict(list)
-        for index_info in response.values():
+        result: Dict[str, List[Tuple[Dict[str, str]]]] = {}
+
+        for index_name, index_info in response.items():
             aliases = index_info.get("aliases", {})
             items_aliases = sorted(
                 [
@@ -90,38 +93,92 @@ class IndexAliasLoader:
             )
 
             if items_aliases:
-                result[items_aliases[0]].extend(items_aliases[1:])
+                main_alias = self._find_main_alias(items_aliases)
+                aliases_dict = self._organize_aliases(items_aliases, main_alias)
+
+                if aliases_dict:
+                    if main_alias not in result:
+                        result[main_alias] = []
+
+                    result[main_alias].append((aliases_dict,))
 
         self.cache_manager.set_cache(result)
         return result
 
-    async def get_aliases(self) -> Dict[str, List[str]]:
+    @staticmethod
+    def _find_main_alias(aliases: List[str]) -> str:
+        """Find the main collection alias (without temporal suffixes).
+
+        Args:
+            aliases (List[str]): List of all aliases for an index.
+
+        Returns:
+            str: The main collection alias.
+        """
+        temporal_keywords = ["datetime", "start_datetime", "end_datetime"]
+
+        for alias in aliases:
+            if not any(keyword in alias for keyword in temporal_keywords):
+                return alias
+
+        return aliases[0]
+
+    @staticmethod
+    def _organize_aliases(aliases: List[str], main_alias: str) -> Dict[str, str]:
+        """Organize temporal aliases into a dictionary with type as key.
+
+        Args:
+            aliases (List[str]): All aliases for the index.
+            main_alias (str): The main collection alias.
+
+        Returns:
+            Dict[str, str]: Dictionary with datetime types as keys and alias names as values.
+        """
+        aliases_dict = {}
+
+        for alias in aliases:
+            if alias == main_alias:
+                continue
+
+            if "start_datetime" in alias:
+                aliases_dict["start_datetime"] = alias
+            elif "end_datetime" in alias:
+                aliases_dict["end_datetime"] = alias
+            elif "datetime" in alias:
+                aliases_dict["datetime"] = alias
+
+        return aliases_dict
+
+    async def get_aliases(self) -> Dict[str, List[Tuple[Dict[str, str]]]]:
         """Get aliases from cache or load if expired.
 
         Returns:
-            Dict[str, List[str]]: Alias mapping data.
+            Dict[str, List[Tuple[Dict[str, str]]]]: Alias mapping data.
         """
         cached = self.cache_manager.get_cache()
         if cached is not None:
             return cached
         return await self.load_aliases()
 
-    async def refresh_aliases(self) -> Dict[str, List[str]]:
+    async def refresh_aliases(self) -> Dict[str, List[Tuple[Dict[str, str]]]]:
         """Force refresh aliases from search engine.
 
         Returns:
-            Dict[str, List[str]]: Fresh alias mapping data.
+            Dict[str, List[Tuple[Dict[str, str]]]]: Fresh alias mapping data.
         """
         return await self.load_aliases()
 
-    async def get_collection_indexes(self, collection_id: str) -> List[str]:
-        """Get all index aliases for a specific collection.
+    async def get_collection_indexes(
+        self, collection_id: str
+    ) -> List[Tuple[Dict[str, str]]]:
+        """Get index information for a specific collection.
 
         Args:
             collection_id (str): Collection identifier.
 
         Returns:
-            List[str]: List of index aliases for the collection.
+            List[Tuple[Dict[str, str]]]: List of tuples with alias dictionaries.
         """
         aliases = await self.get_aliases()
-        return aliases.get(index_alias_by_collection_id(collection_id), [])
+        main_alias = index_alias_by_collection_id(collection_id)
+        return aliases.get(main_alias, [])

stac_fastapi/sfeos_helpers/search_engine/selection/selectors.py

@@ -1,8 +1,9 @@
 """Async index selectors with datetime-based filtering."""
 
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List, Optional, Tuple
 
-from stac_fastapi.sfeos_helpers.database import filter_indexes_by_datetime
+from stac_fastapi.core.utilities import get_bool_env
+from stac_fastapi.sfeos_helpers.database import filter_indexes_by_datetime, return_date
 from stac_fastapi.sfeos_helpers.mappings import ITEM_INDICES
 
 from ...database import indices
@@ -40,23 +41,30 @@ class DatetimeBasedIndexSelector(BaseIndexSelector):
             self.alias_loader = IndexAliasLoader(client, self.cache_manager)
             self._initialized = True
 
-    async def refresh_cache(self) -> Dict[str, List[str]]:
+    @property
+    def use_datetime(self) -> bool:
+        """Get USE_DATETIME setting dynamically."""
+        return get_bool_env("USE_DATETIME", default=True)
+
+    async def refresh_cache(self) -> Dict[str, List[Tuple[Dict[str, str]]]]:
         """Force refresh of the aliases cache.
 
         Returns:
-            Dict[str, List[str]]: Refreshed dictionary mapping base collection aliases
+            Dict[str, List[Tuple[Dict[str, str]]]]: Refreshed dictionary mapping base collection aliases
                 to lists of their corresponding item index aliases.
         """
         return await self.alias_loader.refresh_aliases()
 
-    async def get_collection_indexes(self, collection_id: str) -> List[str]:
+    async def get_collection_indexes(
+        self, collection_id: str
+    ) -> List[tuple[dict[str, str]]]:
         """Get all index aliases for a specific collection.
 
         Args:
             collection_id (str): The ID of the collection to retrieve indexes for.
 
         Returns:
-            List[str]: List of index aliases associated with the collection.
+            List[tuple[dict[str, str]]]: List of index aliases associated with the collection.
                 Returns empty list if collection is not found in cache.
         """
         return await self.alias_loader.get_collection_indexes(collection_id)
@@ -64,7 +72,8 @@ class DatetimeBasedIndexSelector(BaseIndexSelector):
     async def select_indexes(
         self,
         collection_ids: Optional[List[str]],
-        datetime_search: Dict[str, Optional[str]],
+        datetime_search: str,
+        for_insertion: bool = False,
     ) -> str:
         """Select indexes filtered by collection IDs and datetime criteria.
 
@@ -75,22 +84,23 @@ class DatetimeBasedIndexSelector(BaseIndexSelector):
         Args:
             collection_ids (Optional[List[str]]): List of collection IDs to filter by.
                 If None or empty, returns all item indices.
-            datetime_search (Dict[str, Optional[str]]): Dictionary containing datetime
-                search criteria with 'gte' and 'lte' keys for range filtering.
+            datetime_search (str): Datetime search criteria.
+            for_insertion (bool): If True, selects indexes for inserting items into
+                the database. If False, selects indexes for searching/querying items.
+                Defaults to False (search mode).
 
         Returns:
             str: Comma-separated string of selected index names that match the
                 collection and datetime criteria. Returns empty string if no
                 indexes match the criteria.
         """
+        datetime_filters = self.parse_datetime_filters(datetime_search, for_insertion)
         if collection_ids:
             selected_indexes = []
             for collection_id in collection_ids:
                 collection_indexes = await self.get_collection_indexes(collection_id)
                 filtered_indexes = filter_indexes_by_datetime(
-                    collection_indexes,
-                    datetime_search.get("gte"),
-                    datetime_search.get("lte"),
+                    collection_indexes, datetime_filters, self.use_datetime
                 )
                 selected_indexes.extend(filtered_indexes)
 
@@ -98,6 +108,49 @@ class DatetimeBasedIndexSelector(BaseIndexSelector):
 
         return ITEM_INDICES
 
+    def parse_datetime_filters(
+        self, datetime: str, for_insertion: bool
+    ) -> Dict[str, Dict[str, Optional[str]]]:
+        """Parse datetime string into structured filter criteria.
+
+        Args:
+            datetime: Datetime search criteria string
+            for_insertion (bool): If True, generates filters for inserting items.
+                If False, generates filters for searching items. Defaults to False.
+
+        Returns:
+            Dictionary with datetime, start_datetime, and end_datetime filters
+        """
+        parsed_datetime = return_date(datetime)
+
+        if for_insertion:
+            return {
+                "datetime": {
+                    "gte": datetime if self.use_datetime else None,
+                    "lte": datetime if self.use_datetime else None,
+                },
+                "start_datetime": {
+                    "gte": datetime if not self.use_datetime else None,
+                    "lte": datetime if not self.use_datetime else None,
+                },
+                "end_datetime": {"gte": None, "lte": None},
+            }
+
+        return {
+            "datetime": {
+                "gte": parsed_datetime.get("gte") if self.use_datetime else None,
+                "lte": parsed_datetime.get("lte") if self.use_datetime else None,
+            },
+            "start_datetime": {
+                "gte": parsed_datetime.get("gte") if not self.use_datetime else None,
+                "lte": None,
+            },
+            "end_datetime": {
+                "gte": None,
+                "lte": parsed_datetime.get("lte") if not self.use_datetime else None,
+            },
+        }
+
 
 class UnfilteredIndexSelector(BaseIndexSelector):
     """Index selector that returns all available indices without filtering."""
@@ -105,15 +158,19 @@ class UnfilteredIndexSelector(BaseIndexSelector):
     async def select_indexes(
         self,
         collection_ids: Optional[List[str]],
-        datetime_search: Dict[str, Optional[str]],
+        datetime_search: str,
+        for_insertion: bool = False,
     ) -> str:
         """Select all indices for given collections without datetime filtering.
 
         Args:
             collection_ids (Optional[List[str]]): List of collection IDs to filter by.
                 If None, all collections are considered.
-            datetime_search (Dict[str, Optional[str]]): Datetime search criteria
+            datetime_search (str): Datetime search criteria
                 (ignored by this implementation).
+            for_insertion (bool): If True, selects indexes for inserting items into
+                the database. If False, selects indexes for searching/querying items.
+                Defaults to False (search mode).
 
         Returns:
             str: Comma-separated string of all available index names for the collections.

stac_fastapi/sfeos_helpers/version.py

@@ -1,2 +1,2 @@
 """library version."""
-__version__ = "6.9.0"
+__version__ = "6.10.0"