stac-fastapi-elasticsearch 5.0.0a1__py3-none-any.whl → 6.0.0__py3-none-any.whl

stac_fastapi/elasticsearch/app.py

@@ -37,6 +37,7 @@ from stac_fastapi.extensions.core import (
     TokenPaginationExtension,
     TransactionExtension,
 )
+from stac_fastapi.extensions.core.filter import FilterConformanceClasses
 from stac_fastapi.extensions.third_party import BulkTransactionExtension
 from stac_fastapi.sfeos_helpers.aggregation import EsAsyncBaseAggregationClient
 from stac_fastapi.sfeos_helpers.filter import EsAsyncBaseFiltersClient
@@ -56,7 +57,7 @@ filter_extension = FilterExtension(
     client=EsAsyncBaseFiltersClient(database=database_logic)
 )
 filter_extension.conformance_classes.append(
-    "http://www.opengis.net/spec/cql2/1.0/conf/advanced-comparison-operators"
+    FilterConformanceClasses.ADVANCED_COMPARISON_OPERATORS
 )
 
 aggregation_extension = AggregationExtension(
@@ -103,22 +104,24 @@ database_logic.extensions = [type(ext).__name__ for ext in extensions]
 
 post_request_model = create_post_request_model(search_extensions)
 
-api = StacApi(
-    title=os.getenv("STAC_FASTAPI_TITLE", "stac-fastapi-elasticsearch"),
-    description=os.getenv("STAC_FASTAPI_DESCRIPTION", "stac-fastapi-elasticsearch"),
-    api_version=os.getenv("STAC_FASTAPI_VERSION", "5.0.0a1"),
-    settings=settings,
-    extensions=extensions,
-    client=CoreClient(
+app_config = {
+    "title": os.getenv("STAC_FASTAPI_TITLE", "stac-fastapi-elasticsearch"),
+    "description": os.getenv("STAC_FASTAPI_DESCRIPTION", "stac-fastapi-elasticsearch"),
+    "api_version": os.getenv("STAC_FASTAPI_VERSION", "6.0.0"),
+    "settings": settings,
+    "extensions": extensions,
+    "client": CoreClient(
         database=database_logic,
         session=session,
         post_request_model=post_request_model,
         landing_page_id=os.getenv("STAC_FASTAPI_LANDING_PAGE_ID", "stac-fastapi"),
     ),
-    search_get_request_model=create_get_request_model(search_extensions),
-    search_post_request_model=post_request_model,
-    route_dependencies=get_route_dependencies(),
-)
+    "search_get_request_model": create_get_request_model(search_extensions),
+    "search_post_request_model": post_request_model,
+    "route_dependencies": get_route_dependencies(),
+}
+
+api = StacApi(**app_config)
 
 
 @asynccontextmanager

stac_fastapi/elasticsearch/database_logic.py

@@ -1,7 +1,6 @@
 """Database logic."""
 
 import asyncio
-import json
 import logging
 from base64 import urlsafe_b64decode, urlsafe_b64encode
 from copy import deepcopy
@@ -9,8 +8,11 @@ from typing import Any, Dict, Iterable, List, Optional, Tuple, Type, Union
 
 import attr
 import elasticsearch.helpers as helpers
+import orjson
 from elasticsearch.dsl import Q, Search
+from elasticsearch.exceptions import BadRequestError
 from elasticsearch.exceptions import NotFoundError as ESNotFoundError
+from fastapi import HTTPException
 from starlette.requests import Request
 
 from stac_fastapi.core.base_database_logic import BaseDatabaseLogic
@@ -20,6 +22,11 @@ from stac_fastapi.elasticsearch.config import AsyncElasticsearchSettings
 from stac_fastapi.elasticsearch.config import (
     ElasticsearchSettings as SyncElasticsearchSettings,
 )
+from stac_fastapi.extensions.core.transaction.request import (
+    PartialCollection,
+    PartialItem,
+    PatchOperation,
+)
 from stac_fastapi.sfeos_helpers import filter
 from stac_fastapi.sfeos_helpers.database import (
     apply_free_text_filter_shared,
@@ -36,6 +43,10 @@ from stac_fastapi.sfeos_helpers.database import (
     return_date,
     validate_refresh,
 )
+from stac_fastapi.sfeos_helpers.database.utils import (
+    merge_to_operations,
+    operations_to_script,
+)
 from stac_fastapi.sfeos_helpers.mappings import (
     AGGREGATION_MAPPING,
     COLLECTIONS_INDEX,
@@ -45,6 +56,7 @@ from stac_fastapi.sfeos_helpers.mappings import (
     Geometry,
 )
 from stac_fastapi.types.errors import ConflictError, NotFoundError
+from stac_fastapi.types.links import resolve_links
 from stac_fastapi.types.rfc3339 import DateTimeType
 from stac_fastapi.types.stac import Collection, Item
 
@@ -245,121 +257,97 @@ class DatabaseLogic(BaseDatabaseLogic):
     @staticmethod
     def apply_datetime_filter(
         search: Search, interval: Optional[Union[DateTimeType, str]]
-    ):
+    ) -> Search:
         """Apply a filter to search on datetime, start_datetime, and end_datetime fields.
 
         Args:
-            search (Search): The search object to filter.
-            interval: Optional[Union[DateTimeType, str]]
+            search: The search object to filter.
+            interval: Optional datetime interval to filter by. Can be:
+                - A single datetime string (e.g., "2023-01-01T12:00:00")
+                - A datetime range string (e.g., "2023-01-01/2023-12-31")
+                - A datetime object
+                - A tuple of (start_datetime, end_datetime)
 
         Returns:
-            Search: The filtered search object.
+            The filtered search object.
         """
+        if not interval:
+            return search
+
         should = []
-        datetime_search = return_date(interval)
+        try:
+            datetime_search = return_date(interval)
+        except (ValueError, TypeError) as e:
+            # Handle invalid interval formats if return_date fails
+            logger.error(f"Invalid interval format: {interval}, error: {e}")
+            return search
 
-        # If the request is a single datetime return
-        # items with datetimes equal to the requested datetime OR
-        # the requested datetime is between their start and end datetimes
         if "eq" in datetime_search:
-            should.extend(
-                [
-                    Q(
-                        "bool",
-                        filter=[
-                            Q(
-                                "term",
-                                properties__datetime=datetime_search["eq"],
-                            ),
-                        ],
-                    ),
-                    Q(
-                        "bool",
-                        filter=[
-                            Q(
-                                "range",
-                                properties__start_datetime={
-                                    "lte": datetime_search["eq"],
-                                },
-                            ),
-                            Q(
-                                "range",
-                                properties__end_datetime={
-                                    "gte": datetime_search["eq"],
-                                },
-                            ),
-                        ],
-                    ),
-                ]
-            )
-
-        # If the request is a date range return
-        # items with datetimes within the requested date range OR
-        # their startdatetime ithin the requested date range OR
-        # their enddatetime ithin the requested date range OR
-        # the requested daterange within their start and end datetimes
+            # For exact matches, include:
+            # 1. Items with matching exact datetime
+            # 2. Items with datetime:null where the time falls within their range
+            should = [
+                Q(
+                    "bool",
+                    filter=[
+                        Q("exists", field="properties.datetime"),
+                        Q("term", **{"properties__datetime": datetime_search["eq"]}),
+                    ],
+                ),
+                Q(
+                    "bool",
+                    must_not=[Q("exists", field="properties.datetime")],
+                    filter=[
+                        Q("exists", field="properties.start_datetime"),
+                        Q("exists", field="properties.end_datetime"),
+                        Q(
+                            "range",
+                            properties__start_datetime={"lte": datetime_search["eq"]},
+                        ),
+                        Q(
+                            "range",
+                            properties__end_datetime={"gte": datetime_search["eq"]},
+                        ),
+                    ],
+                ),
+            ]
         else:
-            should.extend(
-                [
-                    Q(
-                        "bool",
-                        filter=[
-                            Q(
-                                "range",
-                                properties__datetime={
-                                    "gte": datetime_search["gte"],
-                                    "lte": datetime_search["lte"],
-                                },
-                            ),
-                        ],
-                    ),
-                    Q(
-                        "bool",
-                        filter=[
-                            Q(
-                                "range",
-                                properties__start_datetime={
-                                    "gte": datetime_search["gte"],
-                                    "lte": datetime_search["lte"],
-                                },
-                            ),
-                        ],
-                    ),
-                    Q(
-                        "bool",
-                        filter=[
-                            Q(
-                                "range",
-                                properties__end_datetime={
-                                    "gte": datetime_search["gte"],
-                                    "lte": datetime_search["lte"],
-                                },
-                            ),
-                        ],
-                    ),
-                    Q(
-                        "bool",
-                        filter=[
-                            Q(
-                                "range",
-                                properties__start_datetime={
-                                    "lte": datetime_search["gte"]
-                                },
-                            ),
-                            Q(
-                                "range",
-                                properties__end_datetime={
-                                    "gte": datetime_search["lte"]
-                                },
-                            ),
-                        ],
-                    ),
-                ]
-            )
-
-        search = search.query(Q("bool", filter=[Q("bool", should=should)]))
-
-        return search
+            # For date ranges, include:
+            # 1. Items with datetime in the range
+            # 2. Items with datetime:null that overlap the search range
+            should = [
+                Q(
+                    "bool",
+                    filter=[
+                        Q("exists", field="properties.datetime"),
+                        Q(
+                            "range",
+                            properties__datetime={
+                                "gte": datetime_search["gte"],
+                                "lte": datetime_search["lte"],
+                            },
+                        ),
+                    ],
+                ),
+                Q(
+                    "bool",
+                    must_not=[Q("exists", field="properties.datetime")],
+                    filter=[
+                        Q("exists", field="properties.start_datetime"),
+                        Q("exists", field="properties.end_datetime"),
+                        Q(
+                            "range",
+                            properties__start_datetime={"lte": datetime_search["lte"]},
+                        ),
+                        Q(
+                            "range",
+                            properties__end_datetime={"gte": datetime_search["gte"]},
+                        ),
+                    ],
+                ),
+            ]
+
+        return search.query(Q("bool", should=should, minimum_should_match=1))
 
     @staticmethod
     def apply_bbox_filter(search: Search, bbox: List):
@@ -527,7 +515,7 @@ class DatabaseLogic(BaseDatabaseLogic):
         search_after = None
 
         if token:
-            search_after = json.loads(urlsafe_b64decode(token).decode())
+            search_after = orjson.loads(urlsafe_b64decode(token))
 
         query = search.query.to_dict() if search.query else None
 
@@ -567,7 +555,7 @@ class DatabaseLogic(BaseDatabaseLogic):
         next_token = None
         if len(hits) > limit and limit < max_result_window:
             if hits and (sort_array := hits[limit - 1].get("sort")):
-                next_token = urlsafe_b64encode(json.dumps(sort_array).encode()).decode()
+                next_token = urlsafe_b64encode(orjson.dumps(sort_array)).decode()
 
         matched = (
             es_response["hits"]["total"]["value"]
@@ -836,6 +824,135 @@ class DatabaseLogic(BaseDatabaseLogic):
             refresh=refresh,
         )
 
+    async def merge_patch_item(
+        self,
+        collection_id: str,
+        item_id: str,
+        item: PartialItem,
+        base_url: str,
+        refresh: bool = True,
+    ) -> Item:
+        """Database logic for merge patching an item following RF7396.
+
+        Args:
+            collection_id(str): Collection that item belongs to.
+            item_id(str): Id of item to be patched.
+            item (PartialItem): The partial item to be updated.
+            base_url: (str): The base URL used for constructing URLs for the item.
+            refresh (bool, optional): Refresh the index after performing the operation. Defaults to True.
+
+        Returns:
+            patched item.
+        """
+        operations = merge_to_operations(item.model_dump())
+
+        return await self.json_patch_item(
+            collection_id=collection_id,
+            item_id=item_id,
+            operations=operations,
+            base_url=base_url,
+            refresh=refresh,
+        )
+
+    async def json_patch_item(
+        self,
+        collection_id: str,
+        item_id: str,
+        operations: List[PatchOperation],
+        base_url: str,
+        refresh: bool = True,
+    ) -> Item:
+        """Database logic for json patching an item following RF6902.
+
+        Args:
+            collection_id(str): Collection that item belongs to.
+            item_id(str): Id of item to be patched.
+            operations (list): List of operations to run.
+            base_url (str): The base URL used for constructing URLs for the item.
+            refresh (bool, optional): Refresh the index after performing the operation. Defaults to True.
+
+        Returns:
+            patched item.
+        """
+        new_item_id = None
+        new_collection_id = None
+        script_operations = []
+
+        for operation in operations:
+            if operation.path in ["collection", "id"] and operation.op in [
+                "add",
+                "replace",
+            ]:
+
+                if operation.path == "collection" and collection_id != operation.value:
+                    await self.check_collection_exists(collection_id=operation.value)
+                    new_collection_id = operation.value
+
+                if operation.path == "id" and item_id != operation.value:
+                    new_item_id = operation.value
+
+            else:
+                script_operations.append(operation)
+
+        script = operations_to_script(script_operations)
+
+        try:
+            await self.client.update(
+                index=index_alias_by_collection_id(collection_id),
+                id=mk_item_id(item_id, collection_id),
+                script=script,
+                refresh=True,
+            )
+
+        except BadRequestError as exc:
+            raise HTTPException(
+                status_code=400, detail=exc.info["error"]["caused_by"]
+            ) from exc
+
+        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,
+            )
+
+            await self.delete_item(
+                item_id=item_id,
+                collection_id=collection_id,
+                refresh=refresh,
+            )
+
+            item["collection"] = new_collection_id
+            collection_id = new_collection_id
+
+        if new_item_id:
+            item["id"] = new_item_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,
+                collection_id=collection_id,
+                refresh=refresh,
+            )
+
+        return item
+
     async def delete_item(self, item_id: str, collection_id: str, **kwargs: Any):
         """Delete a single item from the database.
 
@@ -895,6 +1012,37 @@ class DatabaseLogic(BaseDatabaseLogic):
         except ESNotFoundError:
             raise NotFoundError(f"Mapping for index {index_name} not found")
 
+    async def get_items_unique_values(
+        self, collection_id: str, field_names: Iterable[str], *, limit: int = 100
+    ) -> Dict[str, List[str]]:
+        """Get the unique values for the given fields in the collection."""
+        limit_plus_one = limit + 1
+        index_name = index_alias_by_collection_id(collection_id)
+
+        query = await self.client.search(
+            index=index_name,
+            body={
+                "size": 0,
+                "aggs": {
+                    field: {"terms": {"field": field, "size": limit_plus_one}}
+                    for field in field_names
+                },
+            },
+        )
+
+        result: Dict[str, List[str]] = {}
+        for field, agg in query["aggregations"].items():
+            if len(agg["buckets"]) > limit:
+                logger.warning(
+                    "Skipping enum field %s: exceeds limit of %d unique values. "
+                    "Consider excluding this field from enumeration or increase the limit.",
+                    field,
+                    limit,
+                )
+                continue
+            result[field] = [bucket["key"] for bucket in agg["buckets"]]
+        return result
+
     async def create_collection(self, collection: Collection, **kwargs: Any):
         """Create a single collection in the database.
 
@@ -1038,6 +1186,95 @@ class DatabaseLogic(BaseDatabaseLogic):
                 refresh=refresh,
             )
 
+    async def merge_patch_collection(
+        self,
+        collection_id: str,
+        collection: PartialCollection,
+        base_url: str,
+        refresh: bool = True,
+    ) -> Collection:
+        """Database logic for merge patching a collection following RF7396.
+
+        Args:
+            collection_id(str): Id of collection to be patched.
+            collection (PartialCollection): The partial collection to be updated.
+            base_url: (str): The base URL used for constructing links.
+            refresh (bool, optional): Refresh the index after performing the operation. Defaults to True.
+
+
+        Returns:
+            patched collection.
+        """
+        operations = merge_to_operations(collection.model_dump())
+
+        return await self.json_patch_collection(
+            collection_id=collection_id,
+            operations=operations,
+            base_url=base_url,
+            refresh=refresh,
+        )
+
+    async def json_patch_collection(
+        self,
+        collection_id: str,
+        operations: List[PatchOperation],
+        base_url: str,
+        refresh: bool = True,
+    ) -> Collection:
+        """Database logic for json patching a collection following RF6902.
+
+        Args:
+            collection_id(str): Id of collection to be patched.
+            operations (list): List of operations to run.
+            base_url (str): The base URL used for constructing links.
+            refresh (bool, optional): Refresh the index after performing the operation. Defaults to True.
+
+        Returns:
+            patched collection.
+        """
+        new_collection_id = None
+        script_operations = []
+
+        for operation in operations:
+            if (
+                operation.op in ["add", "replace"]
+                and operation.path == "collection"
+                and collection_id != operation.value
+            ):
+                new_collection_id = operation.value
+
+            else:
+                script_operations.append(operation)
+
+        script = operations_to_script(script_operations)
+
+        try:
+            await self.client.update(
+                index=COLLECTIONS_INDEX,
+                id=collection_id,
+                script=script,
+                refresh=True,
+            )
+
+        except BadRequestError as exc:
+            raise HTTPException(
+                status_code=400, detail=exc.info["error"]["caused_by"]
+            ) from exc
+
+        collection = await self.find_collection(collection_id)
+
+        if new_collection_id:
+            collection["id"] = new_collection_id
+            collection["links"] = resolve_links([], base_url)
+
+            await self.update_collection(
+                collection_id=collection_id,
+                collection=collection,
+                refresh=refresh,
+            )
+
+        return collection
+
     async def delete_collection(self, collection_id: str, **kwargs: Any):
         """Delete a collection from the database.
 
@@ -1061,28 +1298,15 @@ class DatabaseLogic(BaseDatabaseLogic):
         # Ensure kwargs is a dictionary
         kwargs = kwargs or {}
 
-        # Verify that the collection exists
-        await self.find_collection(collection_id=collection_id)
-
-        # Resolve the `refresh` parameter
         refresh = kwargs.get("refresh", self.async_settings.database_refresh)
         refresh = validate_refresh(refresh)
 
-        # Log the deletion attempt
-        logger.info(f"Deleting collection {collection_id} with refresh={refresh}")
-
-        # Delete the collection from the database
+        # Verify that the collection exists
+        await self.find_collection(collection_id=collection_id)
         await self.client.delete(
             index=COLLECTIONS_INDEX, id=collection_id, refresh=refresh
         )
-
-        # Delete the item index for the collection
-        try:
-            await delete_item_index(collection_id)
-        except Exception as e:
-            logger.error(
-                f"Failed to delete item index for collection {collection_id}: {e}"
-            )
+        await delete_item_index(collection_id)
 
     async def bulk_async(
         self,

stac_fastapi/elasticsearch/version.py

@@ -1,2 +1,2 @@
 """library version."""
-__version__ = "5.0.0a1"
+__version__ = "6.0.0"

{stac_fastapi_elasticsearch-5.0.0a1.dist-info → stac_fastapi_elasticsearch-6.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi-elasticsearch
-Version: 5.0.0a1
+Version: 6.0.0
 Summary: An implementation of STAC API based on the FastAPI framework with both Elasticsearch and Opensearch.
 Home-page: https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch
 License: MIT
@@ -15,8 +15,8 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
-Requires-Dist: stac-fastapi-core==5.0.0a1
-Requires-Dist: sfeos-helpers==5.0.0a1
+Requires-Dist: stac-fastapi-core==6.0.0
+Requires-Dist: sfeos-helpers==6.0.0
 Requires-Dist: elasticsearch[async]~=8.18.0
 Requires-Dist: uvicorn~=0.23.0
 Requires-Dist: starlette<0.36.0,>=0.35.0
@@ -25,7 +25,6 @@ Requires-Dist: pytest~=7.0.0; extra == "dev"
 Requires-Dist: pytest-cov~=4.0.0; extra == "dev"
 Requires-Dist: pytest-asyncio~=0.21.0; extra == "dev"
 Requires-Dist: pre-commit~=3.0.0; extra == "dev"
-Requires-Dist: requests<3.0.0,>=2.32.0; extra == "dev"
 Requires-Dist: ciso8601~=2.3.0; extra == "dev"
 Requires-Dist: httpx<0.28.0,>=0.24.0; extra == "dev"
 Provides-Extra: docs

stac_fastapi_elasticsearch-6.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+stac_fastapi/elasticsearch/__init__.py,sha256=w_MZutYLreNV372sCuO46bPb0TngmPs4u8737ueS0wE,31
+stac_fastapi/elasticsearch/app.py,sha256=CPa_JaIA39dJ1qTYRZsCsmcmpcnjAZ2T4S0wyeUzqEg,5188
+stac_fastapi/elasticsearch/config.py,sha256=PKSowbXmSryMj0Oq15XJduyPL2c_NlDkewXnR1DFP2o,5181
+stac_fastapi/elasticsearch/database_logic.py,sha256=dvhYUe2baZhA4-Saww4tV89scLMHrDgK3lwas-m3U70,55930
+stac_fastapi/elasticsearch/version.py,sha256=Fo5UFEQVxJZ3nywa3IY-enu5UQBE0X45nrQaRBe8c9o,45
+stac_fastapi_elasticsearch-6.0.0.dist-info/METADATA,sha256=pHi-zn9w3UJAYmrCLN_mU7MCKMFGtvo8BMa4JKrhFQs,31931
+stac_fastapi_elasticsearch-6.0.0.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
+stac_fastapi_elasticsearch-6.0.0.dist-info/entry_points.txt,sha256=aCKixki0LpUl64UPsPMtiNvfdyq-QsTCxVjJ54VF6Jk,82
+stac_fastapi_elasticsearch-6.0.0.dist-info/top_level.txt,sha256=vqn-D9-HsRPTTxy0Vk_KkDmTiMES4owwBQ3ydSZYb2s,13
+stac_fastapi_elasticsearch-6.0.0.dist-info/RECORD,,

stac_fastapi_elasticsearch-5.0.0a1.dist-info/RECORD

@@ -1,10 +0,0 @@
-stac_fastapi/elasticsearch/__init__.py,sha256=w_MZutYLreNV372sCuO46bPb0TngmPs4u8737ueS0wE,31
-stac_fastapi/elasticsearch/app.py,sha256=uuBk3Vg8vdl15yIQCFCxJ8UfFtaKjMvmXXULMd8Lw0g,5080
-stac_fastapi/elasticsearch/config.py,sha256=PKSowbXmSryMj0Oq15XJduyPL2c_NlDkewXnR1DFP2o,5181
-stac_fastapi/elasticsearch/database_logic.py,sha256=-qvrOTyoVWe4Ua4lu5Fjq1NmrY_fj_3Emt1HV8i5Dsw,48248
-stac_fastapi/elasticsearch/version.py,sha256=MQ4i7PSJnhrL3abG-m_vOwI3ksvRoHcs0eiBtxywE3E,47
-stac_fastapi_elasticsearch-5.0.0a1.dist-info/METADATA,sha256=9sB79eLh3KasJb7ykxdvhHvB2w-peD1_N6Z4wltzJmA,31992
-stac_fastapi_elasticsearch-5.0.0a1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-stac_fastapi_elasticsearch-5.0.0a1.dist-info/entry_points.txt,sha256=aCKixki0LpUl64UPsPMtiNvfdyq-QsTCxVjJ54VF6Jk,82
-stac_fastapi_elasticsearch-5.0.0a1.dist-info/top_level.txt,sha256=vqn-D9-HsRPTTxy0Vk_KkDmTiMES4owwBQ3ydSZYb2s,13
-stac_fastapi_elasticsearch-5.0.0a1.dist-info/RECORD,,