before tests

Author: Gomez324

stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/database/datetime.py

@@ -138,15 +138,18 @@ def return_date(
         return result
 
 
-def extract_date(date_str: str) -> date:
+def extract_date(date_str: str | None) -> date | None:
     """Extract date from ISO format string.
 
     Args:
         date_str: ISO format date string
 
     Returns:
-        A date object extracted from the input string.
+        A date object extracted from the input string or None.
     """
+    if not date_str:
+        return None
+
     date_str = date_str.replace("Z", "+00:00")
     return datetime_type.fromisoformat(date_str).date()
 

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

@@ -6,7 +6,7 @@
 import re
 from datetime import datetime
 from functools import lru_cache
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Tuple, Dict
 
 from dateutil.parser import parse  # type: ignore[import]
 
@@ -71,54 +71,69 @@ def indices(collection_ids: Optional[List[str]]) -> str:
 
 
 def filter_indexes_by_datetime(
-    indexes: List[str], gte: Optional[str], lte: Optional[str]
+    collection_indexes: List[Tuple[Dict[str, str], ...]],
+    datetime_search: Dict[str, Dict[str, str | None]]
 ) -> List[str]:
-    """Filter indexes based on datetime range extracted from index names.
+    def extract_date_from_alias(alias: str) -> tuple[datetime, datetime] | None:
+        date_pattern = re.compile(r'\d{4}-\d{2}-\d{2}')
+        try:
+            dates = date_pattern.findall(alias)
+
+            if not dates:
+                return None
+
+            if len(dates) >= 2:
+                return datetime.strptime(dates[-2], '%Y-%m-%d'), datetime.strptime(dates[-1], '%Y-%m-%d')
+            else:
+                date = datetime.strptime(dates[-1], '%Y-%m-%d')
+                return date, date
+        except (ValueError, IndexError):
+            return None
+
+    def parse_search_date(date_str: str | None) -> Optional[datetime.date]:
+        if not date_str:
+            return None
+        return datetime.fromisoformat(date_str.replace('Z', '+00:00')).date()
+
+    def check_criteria(value_begin: datetime.date, value_end: datetime.date, criteria: Dict) -> bool:
+        gte = parse_search_date(criteria.get('gte'))
+        lte = parse_search_date(criteria.get('lte'))
+
+        if gte and value_begin.date() < gte:
+            return False
+        if lte and value_end.date() > lte:
+            return False
+        return True
 
-    Args:
-        indexes: List of index names containing dates
-        gte: Greater than or equal date filter (ISO format, optional 'Z' suffix)
-        lte: Less than or equal date filter (ISO format, optional 'Z' suffix)
+    filtered_indexes = []
 
-    Returns:
-        List of filtered index names
-    """
+    for index_tuple in collection_indexes:
+        if not index_tuple:
+            continue
 
-    def parse_datetime(dt_str: str) -> datetime:
-        """Parse datetime string, handling both with and without 'Z' suffix."""
-        return parse(dt_str).replace(tzinfo=None)
-
-    def extract_date_range_from_index(index_name: str) -> tuple:
-        """Extract start and end dates from index name."""
-        date_pattern = r"(\d{4}-\d{2}-\d{2})"
-        dates = re.findall(date_pattern, index_name)
-
-        if len(dates) == 1:
-            start_date = datetime.strptime(dates[0], "%Y-%m-%d")
-            max_date = datetime.max.replace(microsecond=0)
-            return start_date, max_date
-        else:
-            start_date = datetime.strptime(dates[0], "%Y-%m-%d")
-            end_date = datetime.strptime(dates[1], "%Y-%m-%d")
-            return start_date, end_date
-
-    def is_index_in_range(
-        start_date: datetime, end_date: datetime, gte_dt: datetime, lte_dt: datetime
-    ) -> bool:
-        """Check if index date range overlaps with filter range."""
-        return not (
-            end_date.date() < gte_dt.date() or start_date.date() > lte_dt.date()
-        )
-
-    gte_dt = parse_datetime(gte) if gte else datetime.min.replace(microsecond=0)
-    lte_dt = parse_datetime(lte) if lte else datetime.max.replace(microsecond=0)
+        index_dict = index_tuple[0]
+        start_datetime_alias = index_dict.get('start_datetime')
+        end_datetime_alias = index_dict.get('end_datetime')
+        datetime_alias = index_dict.get('datetime')
 
-    filtered_indexes = []
+        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 start_range or not end_date or not datetime_date:
+            continue
+
+        if not check_criteria(start_range[0], start_range[1], datetime_search.get('start_datetime', {})):
+            continue
+        if not check_criteria(end_date[0], end_date[1], datetime_search.get('end_datetime', {})):
+            continue
+        if not check_criteria(datetime_date[0], datetime_date[1], datetime_search.get('datetime', {})):
+            continue
 
-    for index in indexes:
-        start_date, end_date = extract_date_range_from_index(index)
-        if is_index_in_range(start_date, end_date, gte_dt, lte_dt):
-            filtered_indexes.append(index)
+        filtered_indexes.append(start_datetime_alias)
 
     return filtered_indexes
 

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

@@ -1,7 +1,7 @@
 """Search engine adapters for different implementations."""
 
 import uuid
-from typing import Any, Dict
+from typing import Any, Dict, Literal, List
 
 from stac_fastapi.sfeos_helpers.database import (
     index_alias_by_collection_id,
@@ -39,26 +39,38 @@ async def create_simple_index(self, client: Any, collection_id: str) -> str:
         return index_name
 
     async def create_datetime_index(
-        self, client: Any, collection_id: str, start_date: str
+        self, client: Any, collection_id: str, start_datetime: str, datetime: str | None, end_datetime: str
     ) -> str:
         """Create a datetime-based index for the given collection.
 
         Args:
             client: Search engine client instance.
             collection_id (str): Collection identifier.
-            start_date (str): Start date for the alias.
+            start_datetime (str): Start datetime for the index alias.
+            datetime (str | None): Datetime for the datetime alias (can be None).
+            end_datetime (str): End datetime for the index alias.
 
         Returns:
-            str: Created index alias name.
+            str: Created start_datetime alias name.
         """
         index_name = self.create_index_name(collection_id)
-        alias_name = self.create_alias_name(collection_id, start_date)
+        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 = {
+            collection_alias: {},
+            alias_start_date: {},
+            alias_date: {},
+            alias_end_date: {},
+        }
+
         await client.indices.create(
             index=index_name,
-            body=self._create_index_body({collection_alias: {}, alias_name: {}}),
+            body=self._create_index_body(aliases),
         )
-        return alias_name
+        return alias_start_date
 
     @staticmethod
     async def update_index_alias(client: Any, end_date: str, old_alias: str) -> str:
@@ -84,23 +96,28 @@ async def update_index_alias(client: Any, end_date: str, old_alias: str) -> str:
         return new_alias
 
     @staticmethod
-    async def change_alias_name(client: Any, old_alias: str, new_alias: str) -> None:
-        """Change alias name from old to new.
+    async def change_alias_name(client: Any, old_start_datetime_alias: str, aliases_to_change: List[str], aliases_to_create: List[str]) -> None:
+        """Change alias names by removing old aliases and adding new ones.
 
         Args:
             client: Search engine client instance.
-            old_alias (str): Current alias name.
-            new_alias (str): New alias name.
+            old_start_datetime_alias (str): Current start_datetime alias name to identify the index.
+            aliases_to_change (List[str]): List of old alias names to remove.
+            aliases_to_create (List[str]): List of new alias names to add.
 
         Returns:
             None
         """
-        aliases_info = await client.indices.get_alias(name=old_alias)
+        aliases_info = await client.indices.get_alias(name=old_start_datetime_alias)
+        index_name = list(aliases_info.keys())[0]
         actions = []
 
-        for index_name in aliases_info.keys():
+        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}})
+
         await client.indices.update_aliases(body={"actions": actions})
 
     @staticmethod
@@ -117,18 +134,21 @@ def create_index_name(collection_id: str) -> str:
         return f"{ITEMS_INDEX_PREFIX}{cleaned.lower()}_{uuid.uuid4()}"
 
     @staticmethod
-    def create_alias_name(collection_id: str, start_date: str) -> str:
-        """Create index name from collection ID and uuid4.
+    def create_alias_name(
+        collection_id: str, name: Literal["start_datetime", "datetime", "end_datetime"], start_date: str
+    ) -> str:
+        """Create alias name from collection ID and date.
 
         Args:
             collection_id (str): Collection identifier.
-            start_date (str): Start date for the alias.
+            name (Literal["start_datetime", "datetime", "end_datetime"]): Type of alias to create.
+            start_date (str): Date value for the alias.
 
         Returns:
-            str: Alias name with initial date.
+            str: Formatted alias name with prefix, type, collection ID, and date.
         """
         cleaned = collection_id.translate(_ES_INDEX_NAME_UNSUPPORTED_CHARS_TABLE)
-        return f"{ITEMS_INDEX_PREFIX}{cleaned.lower()}_{start_date}"
+        return f"{ITEMS_INDEX_PREFIX}{name}_{cleaned.lower()}_{start_date}"
 
     @staticmethod
     def _create_index_body(aliases: Dict[str, Dict]) -> Dict[str, Any]:
@@ -148,19 +168,19 @@ def _create_index_body(aliases: Dict[str, Dict]) -> Dict[str, Any]:
 
     @staticmethod
     async def find_latest_item_in_index(client: Any, index_name: str) -> dict[str, Any]:
-        """Find the latest item date in the specified index.
+        """Find the latest item in the specified index.
 
         Args:
             client: Search engine client instance.
             index_name (str): Name of the index to query.
 
         Returns:
-            datetime: Date of the latest item in the index.
+            dict[str, Any]: Latest item document from the index with metadata.
         """
         query = {
             "size": 1,
-            "sort": [{"properties.datetime": {"order": "desc"}}],
-            "_source": ["properties.datetime"],
+            "sort": [{"properties.start_datetime": {"order": "desc"}}],
+            "_source": ["properties.start_datetime", "properties.datetime", "properties.end_datetime"],
         }
 
         response = await client.search(index=index_name, body=query)