stac-fastapi-opensearch 6.9.0__tar.gz → 6.10.1__tar.gz

{stac_fastapi_opensearch-6.9.0 → stac_fastapi_opensearch-6.10.1}/.gitignore

@@ -141,3 +141,14 @@ venv
 /docs/src/api/*
 
 .DS_Store
+
+# Helm
+*.tgz
+charts/*/charts/
+charts/*/requirements.lock
+charts/*/Chart.lock
+helm-chart/stac-fastapi/charts/
+helm-chart/stac-fastapi/Chart.lock
+helm-chart/stac-fastapi/*.tgz
+helm-chart/test-results/
+helm-chart/tmp/

{stac_fastapi_opensearch-6.9.0 → stac_fastapi_opensearch-6.10.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stac_fastapi_opensearch
-Version: 6.9.0
+Version: 6.10.1
 Summary: An implementation of STAC API based on the FastAPI framework with Opensearch.
 Project-URL: Homepage, https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch
 License: MIT
@@ -16,8 +16,8 @@ Classifier: Programming Language :: Python :: 3.14
 Requires-Python: >=3.11
 Requires-Dist: opensearch-py[async]~=2.8.0
 Requires-Dist: opensearch-py~=2.8.0
-Requires-Dist: sfeos-helpers==6.9.0
-Requires-Dist: stac-fastapi-core==6.9.0
+Requires-Dist: sfeos-helpers==6.10.1
+Requires-Dist: stac-fastapi-core==6.10.1
 Requires-Dist: starlette<0.36.0,>=0.35.0
 Requires-Dist: uvicorn~=0.23.0
 Provides-Extra: dev
@@ -29,13 +29,13 @@ Requires-Dist: pytest-cov~=4.0.0; extra == 'dev'
 Requires-Dist: pytest~=8.0; extra == 'dev'
 Requires-Dist: redis~=6.4.0; extra == 'dev'
 Requires-Dist: retry~=0.9.2; extra == 'dev'
-Requires-Dist: stac-fastapi-core[redis]==6.9.0; extra == 'dev'
+Requires-Dist: stac-fastapi-core[redis]==6.10.1; extra == 'dev'
 Provides-Extra: docs
 Requires-Dist: mkdocs-material~=9.0.0; extra == 'docs'
 Requires-Dist: mkdocs~=1.4.0; extra == 'docs'
 Requires-Dist: pdocs~=1.2.0; extra == 'docs'
 Provides-Extra: redis
-Requires-Dist: stac-fastapi-core[redis]==6.9.0; extra == 'redis'
+Requires-Dist: stac-fastapi-core[redis]==6.10.1; extra == 'redis'
 Provides-Extra: server
 Requires-Dist: uvicorn[standard]~=0.23.0; extra == 'server'
 Description-Content-Type: text/markdown

{stac_fastapi_opensearch-6.9.0 → stac_fastapi_opensearch-6.10.1}/pyproject.toml

@@ -28,8 +28,8 @@ keywords = [
 ]
 dynamic = ["version"]
 dependencies = [
-    "stac-fastapi-core==6.9.0",
-    "sfeos-helpers==6.9.0",
+    "stac-fastapi-core==6.10.1",
+    "sfeos-helpers==6.10.1",
     "opensearch-py~=2.8.0",
     "opensearch-py[async]~=2.8.0",
     "uvicorn~=0.23.0",
@@ -49,7 +49,7 @@ dev = [
     "httpx>=0.24.0,<0.28.0",
     "redis~=6.4.0",
     "retry~=0.9.2",
-    "stac-fastapi-core[redis]==6.9.0",
+    "stac-fastapi-core[redis]==6.10.1",
 ]
 docs = [
     "mkdocs~=1.4.0",
@@ -57,7 +57,7 @@ docs = [
     "pdocs~=1.2.0",
 ]
 redis = [
-    "stac-fastapi-core[redis]==6.9.0",
+    "stac-fastapi-core[redis]==6.10.1",
 ]
 server = [
     "uvicorn[standard]~=0.23.0",

{stac_fastapi_opensearch-6.9.0 → stac_fastapi_opensearch-6.10.1}/stac_fastapi/opensearch/app.py

@@ -214,7 +214,7 @@ if ENABLE_CATALOGS_ROUTE:
         ),
         settings=settings,
         conformance_classes=[
-            "https://api.stacspec.org/v1.0.0-beta.1/catalogs-endpoint",
+            "https://api.stacspec.org/v1.0.0-beta.1/multi-tenant-catalogs",
         ],
     )
     extensions.append(catalogs_extension)
@@ -243,7 +243,7 @@ items_get_request_model = create_request_model(
 app_config = {
     "title": os.getenv("STAC_FASTAPI_TITLE", "stac-fastapi-opensearch"),
     "description": os.getenv("STAC_FASTAPI_DESCRIPTION", "stac-fastapi-opensearch"),
-    "api_version": os.getenv("STAC_FASTAPI_VERSION", "6.9.0"),
+    "api_version": os.getenv("STAC_FASTAPI_VERSION", "6.10.1"),
     "settings": settings,
     "extensions": extensions,
     "client": CoreClient(

{stac_fastapi_opensearch-6.9.0 → stac_fastapi_opensearch-6.10.1}/stac_fastapi/opensearch/database_logic.py

@@ -29,11 +29,14 @@ from stac_fastapi.opensearch.config import (
 )
 from stac_fastapi.opensearch.config import OpensearchSettings as SyncSearchSettings
 from stac_fastapi.sfeos_helpers.database import (
+    ItemAlreadyExistsError,
     add_bbox_shape_to_collection,
     apply_collections_bbox_filter_shared,
     apply_collections_datetime_filter_shared,
     apply_free_text_filter_shared,
     apply_intersects_filter_shared,
+    check_item_exists_in_alias,
+    check_item_exists_in_alias_sync,
     create_index_templates_shared,
     delete_item_index_shared,
     get_queryables_mapping_shared,
@@ -49,6 +52,7 @@ from stac_fastapi.sfeos_helpers.database.query import (
     add_collections_to_body,
 )
 from stac_fastapi.sfeos_helpers.database.utils import (
+    add_hidden_filter,
     merge_to_operations,
     operations_to_script,
 )
@@ -64,6 +68,7 @@ from stac_fastapi.sfeos_helpers.mappings import (
 from stac_fastapi.sfeos_helpers.search_engine import (
     BaseIndexInserter,
     BaseIndexSelector,
+    DatetimeIndexInserter,
     IndexInsertionFactory,
     IndexSelectorFactory,
 )
@@ -406,12 +411,22 @@ class DatabaseLogic(BaseDatabaseLogic):
         Notes:
             The Item is retrieved from the Opensearch database using the `client.get` method,
             with the index for the Collection as the target index and the combined `mk_item_id` as the document id.
+            Item is hidden if hide_item_path is configured via env var.
         """
         try:
+            base_query = {"term": {"_id": mk_item_id(item_id, collection_id)}}
+
+            HIDE_ITEM_PATH = os.getenv("HIDE_ITEM_PATH", None)
+
+            if HIDE_ITEM_PATH:
+                query = add_hidden_filter(base_query, HIDE_ITEM_PATH)
+            else:
+                query = base_query
+
             response = await self.client.search(
                 index=index_alias_by_collection_id(collection_id),
                 body={
-                    "query": {"term": {"_id": mk_item_id(item_id, collection_id)}},
+                    "query": query,
                     "size": 1,
                 },
             )
@@ -811,7 +826,7 @@ class DatabaseLogic(BaseDatabaseLogic):
         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 +837,7 @@ class DatabaseLogic(BaseDatabaseLogic):
             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:
@@ -846,7 +861,11 @@ class DatabaseLogic(BaseDatabaseLogic):
             index_param = ITEM_INDICES
             query = add_collections_to_body(collection_ids, query)
 
-        if query:
+        HIDE_ITEM_PATH = os.getenv("HIDE_ITEM_PATH", None)
+
+        if HIDE_ITEM_PATH:
+            search_body["query"] = add_hidden_filter(query, HIDE_ITEM_PATH)
+        elif query:
             search_body["query"] = query
 
         search_after = None
@@ -871,11 +890,17 @@ class DatabaseLogic(BaseDatabaseLogic):
             )
         )
 
+        # Ensure hidden item is not counted
+        count_query = search.to_dict(count=True)
+        if HIDE_ITEM_PATH:
+            q = count_query.get("query")
+            count_query["query"] = add_hidden_filter(q, HIDE_ITEM_PATH)
+
         count_task = asyncio.create_task(
             self.client.count(
                 index=index_param,
                 ignore_unavailable=ignore_unavailable,
-                body=search.to_dict(count=True),
+                body=count_query,
             )
         )
 
@@ -918,7 +943,7 @@ class DatabaseLogic(BaseDatabaseLogic):
         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."""
@@ -978,6 +1003,44 @@ class DatabaseLogic(BaseDatabaseLogic):
         if not await self.client.exists(index=COLLECTIONS_INDEX, id=collection_id):
             raise NotFoundError(f"Collection {collection_id} does not exist")
 
+    async def _check_item_exists_in_collection(
+        self, collection_id: str, item_id: str
+    ) -> bool:
+        """Check if an item exists across all indexes for a collection.
+
+        Args:
+            collection_id (str): The collection identifier.
+            item_id (str): The item identifier.
+
+        Returns:
+            bool: True if the item exists in any index, False otherwise.
+        """
+        alias = index_alias_by_collection_id(collection_id)
+        doc_id = mk_item_id(item_id, collection_id)
+        try:
+            return await check_item_exists_in_alias(self.client, alias, doc_id)
+        except Exception:
+            return False
+
+    def _check_item_exists_in_collection_sync(
+        self, collection_id: str, item_id: str
+    ) -> bool:
+        """Check if an item exists across all indexes for a collection (sync version).
+
+        Args:
+            collection_id (str): The collection identifier.
+            item_id (str): The item identifier.
+
+        Returns:
+            bool: True if the item exists in any index, False otherwise.
+        """
+        alias = index_alias_by_collection_id(collection_id)
+        doc_id = mk_item_id(item_id, collection_id)
+        try:
+            return check_item_exists_in_alias_sync(self.sync_client, alias, doc_id)
+        except Exception:
+            return False
+
     async def async_prep_create_item(
         self, item: Item, base_url: str, exist_ok: bool = False
     ) -> Item:
@@ -993,31 +1056,21 @@ class DatabaseLogic(BaseDatabaseLogic):
             Item: The prepped item.
 
         Raises:
-            ConflictError: If the item already exists in the database.
+            ItemAlreadyExistsError: If the item already exists in the database.
 
         """
         await self.check_collection_exists(collection_id=item["collection"])
-        alias = index_alias_by_collection_id(item["collection"])
-        doc_id = mk_item_id(item["id"], item["collection"])
-
-        if not exist_ok:
-            alias_exists = await self.client.indices.exists_alias(name=alias)
 
-            if alias_exists:
-                alias_info = await self.client.indices.get_alias(name=alias)
-                indices = list(alias_info.keys())
-
-                for index in indices:
-                    if await self.client.exists(index=index, id=doc_id):
-                        raise ConflictError(
-                            f"Item {item['id']} in collection {item['collection']} already exists"
-                        )
+        if not exist_ok and await self._check_item_exists_in_collection(
+            item["collection"], item["id"]
+        ):
+            raise ItemAlreadyExistsError(item["id"], item["collection"])
 
         return self.item_serializer.stac_to_db(item, base_url)
 
     async def bulk_async_prep_create_item(
         self, item: Item, base_url: str, exist_ok: bool = False
-    ) -> Item:
+    ) -> Optional[Item]:
         """
         Prepare an item for insertion into the database.
 
@@ -1045,20 +1098,19 @@ class DatabaseLogic(BaseDatabaseLogic):
         # Check if the collection exists
         await self.check_collection_exists(collection_id=item["collection"])
 
-        # Check if the item already exists in the database
-        if not exist_ok and await self.client.exists(
-            index=index_alias_by_collection_id(item["collection"]),
-            id=mk_item_id(item["id"], item["collection"]),
+        # Check if the item already exists in the database (across all datetime indexes)
+        if not exist_ok and await self._check_item_exists_in_collection(
+            item["collection"], item["id"]
         ):
-            error_message = (
-                f"Item {item['id']} in collection {item['collection']} already exists."
-            )
             if self.async_settings.raise_on_bulk_error:
-                raise ConflictError(error_message)
+                raise ItemAlreadyExistsError(item["id"], item["collection"])
             else:
                 logger.warning(
-                    f"{error_message} Continuing as `RAISE_ON_BULK_ERROR` is set to false."
+                    f"Item {item['id']} in collection {item['collection']} already exists. "
+                    "Skipping as `RAISE_ON_BULK_ERROR` is set to false."
                 )
+                return None
+
         # Serialize the item into a database-compatible format
         prepped_item = self.item_serializer.stac_to_db(item, base_url)
         logger.debug(f"Item {item['id']} prepared successfully.")
@@ -1066,7 +1118,7 @@ class DatabaseLogic(BaseDatabaseLogic):
 
     def bulk_sync_prep_create_item(
         self, item: Item, base_url: str, exist_ok: bool = False
-    ) -> Item:
+    ) -> Optional[Item]:
         """
         Prepare an item for insertion into the database.
 
@@ -1095,20 +1147,18 @@ class DatabaseLogic(BaseDatabaseLogic):
         if not self.sync_client.exists(index=COLLECTIONS_INDEX, id=item["collection"]):
             raise NotFoundError(f"Collection {item['collection']} does not exist")
 
-        # Check if the item already exists in the database
-        if not exist_ok and self.sync_client.exists(
-            index=index_alias_by_collection_id(item["collection"]),
-            id=mk_item_id(item["id"], item["collection"]),
+        # Check if the item already exists in the database (across all datetime indexes)
+        if not exist_ok and self._check_item_exists_in_collection_sync(
+            item["collection"], item["id"]
         ):
-            error_message = (
-                f"Item {item['id']} in collection {item['collection']} already exists."
-            )
             if self.sync_settings.raise_on_bulk_error:
-                raise ConflictError(error_message)
+                raise ItemAlreadyExistsError(item["id"], item["collection"])
             else:
                 logger.warning(
-                    f"{error_message} Continuing as `RAISE_ON_BULK_ERROR` is set to false."
+                    f"Item {item['id']} in collection {item['collection']} already exists. "
+                    "Skipping as `RAISE_ON_BULK_ERROR` is set to false."
                 )
+                return None
 
         # Serialize the item into a database-compatible format
         prepped_item = self.item_serializer.stac_to_db(item, base_url)
@@ -1152,6 +1202,31 @@ class DatabaseLogic(BaseDatabaseLogic):
             f"Creating item {item_id} in collection {collection_id} with refresh={refresh}"
         )
 
+        if exist_ok and isinstance(self.async_index_inserter, DatetimeIndexInserter):
+            existing_item = await self.get_one_item(collection_id, item_id)
+            primary_datetime_name = self.async_index_inserter.primary_datetime_name
+
+            existing_primary_datetime = existing_item.get("properties", {}).get(
+                primary_datetime_name
+            )
+            new_primary_datetime = item.get("properties", {}).get(primary_datetime_name)
+
+            if existing_primary_datetime != new_primary_datetime:
+                self.async_index_inserter.validate_datetime_field_update(
+                    f"properties/{primary_datetime_name}"
+                )
+
+            if primary_datetime_name == "start_datetime":
+                existing_end_datetime = existing_item.get("properties", {}).get(
+                    "end_datetime"
+                )
+                new_end_datetime = item.get("properties", {}).get("end_datetime")
+
+                if existing_end_datetime != new_end_datetime:
+                    self.async_index_inserter.validate_datetime_field_update(
+                        "properties/end_datetime"
+                    )
+
         item = await self.async_prep_create_item(
             item=item, base_url=base_url, exist_ok=exist_ok
         )
@@ -1219,6 +1294,10 @@ class DatabaseLogic(BaseDatabaseLogic):
         Returns:
             patched item.
         """
+        for operation in operations:
+            if operation.op in ["add", "replace", "remove"]:
+                self.async_index_inserter.validate_datetime_field_update(operation.path)
+
         new_item_id = None
         new_collection_id = None
         script_operations = []
@@ -1238,8 +1317,6 @@ class DatabaseLogic(BaseDatabaseLogic):
             else:
                 script_operations.append(operation)
 
-        script = operations_to_script(script_operations, create_nest=create_nest)
-
         try:
             search_response = await self.client.search(
                 index=index_alias_by_collection_id(collection_id),
@@ -1252,13 +1329,18 @@ class DatabaseLogic(BaseDatabaseLogic):
                 raise NotFoundError(
                     f"Item {item_id} does not exist inside Collection {collection_id}"
                 )
-            document_index = search_response["hits"]["hits"][0]["_index"]
-            await self.client.update(
-                index=document_index,
-                id=mk_item_id(item_id, collection_id),
-                body={"script": script},
-                refresh=True,
-            )
+
+            if script_operations:
+                script = operations_to_script(
+                    script_operations, create_nest=create_nest
+                )
+                document_index = search_response["hits"]["hits"][0]["_index"]
+                await self.client.update(
+                    index=document_index,
+                    id=mk_item_id(item_id, collection_id),
+                    body={"script": script},
+                    refresh=True,
+                )
         except exceptions.NotFoundError:
             raise NotFoundError(
                 f"Item {item_id} does not exist inside Collection {collection_id}"
@@ -1271,24 +1353,9 @@ class DatabaseLogic(BaseDatabaseLogic):
         item = await self.get_one_item(collection_id, item_id)
 
         if new_collection_id:
-            await self.client.reindex(
-                body={
-                    "dest": {"index": f"{ITEMS_INDEX_PREFIX}{new_collection_id}"},
-                    "source": {
-                        "index": f"{ITEMS_INDEX_PREFIX}{collection_id}",
-                        "query": {"term": {"id": {"value": item_id}}},
-                    },
-                    "script": {
-                        "lang": "painless",
-                        "source": (
-                            f"""ctx._id = ctx._id.replace('{collection_id}', '{new_collection_id}');"""
-                            f"""ctx._source.collection = '{new_collection_id}';"""
-                        ),
-                    },
-                },
-                wait_for_completion=True,
-                refresh=True,
-            )
+            item["collection"] = new_collection_id
+            item = await self.async_prep_create_item(item=item, base_url=base_url)
+            await self.create_item(item=item, refresh=True)
 
             await self.delete_item(
                 item_id=item_id,
@@ -1296,7 +1363,6 @@ class DatabaseLogic(BaseDatabaseLogic):
                 refresh=refresh,
             )
 
-            item["collection"] = new_collection_id
             collection_id = new_collection_id
 
         if new_item_id:
@@ -1657,6 +1723,7 @@ class DatabaseLogic(BaseDatabaseLogic):
         )
         # Delete the item index for the collection
         await delete_item_index(collection_id)
+        await self.async_index_inserter.refresh_cache()
 
     async def bulk_async(
         self,

{stac_fastapi_opensearch-6.9.0 → stac_fastapi_opensearch-6.10.1}/stac_fastapi/opensearch/version.py

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