sfeos-helpers 6.5.1__py3-none-any.whl → 6.7.0__py3-none-any.whl

sfeos_helpers-6.7.0.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: sfeos_helpers
+Version: 6.7.0
+Summary: Helper library for the Elasticsearch and Opensearch stac-fastapi backends.
+Project-URL: Homepage, https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch
+License: MIT
+Keywords: Elasticsearch,FastAPI,Opensearch,STAC,STAC-API,stac-fastapi
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Information Technology
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.9
+Requires-Dist: stac-fastapi-core==6.7.0
+Description-Content-Type: text/markdown
+
+# sfeos-helpers
+
+<p align="left">
+  <img src="https://raw.githubusercontent.com/stac-utils/stac-fastapi-elasticsearch-opensearch/refs/heads/main/assets/sfeos.png" width=1000>
+</p>
+
+  [![Downloads](https://static.pepy.tech/badge/stac-fastapi-core?color=blue)](https://pepy.tech/project/stac-fastapi-core)
+  [![GitHub contributors](https://img.shields.io/github/contributors/stac-utils/stac-fastapi-elasticsearch-opensearch?color=blue)](https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch/graphs/contributors)
+  [![GitHub stars](https://img.shields.io/github/stars/stac-utils/stac-fastapi-elasticsearch-opensearch.svg?color=blue)](https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch/stargazers)
+  [![GitHub forks](https://img.shields.io/github/forks/stac-utils/stac-fastapi-elasticsearch-opensearch.svg?color=blue)](https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch/network/members)
+   [![PyPI version](https://img.shields.io/pypi/v/stac-fastapi-elasticsearch.svg?color=blue)](https://pypi.org/project/stac-fastapi-elasticsearch/)
+  [![STAC](https://img.shields.io/badge/STAC-1.1.0-blue.svg)](https://github.com/radiantearth/stac-spec/tree/v1.1.0)
+  [![stac-fastapi](https://img.shields.io/badge/stac--fastapi-6.0.0-blue.svg)](https://github.com/stac-utils/stac-fastapi)
+
+Helper utilities for the stac-fastapi project. For full documentation, please see the [main README](https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch/blob/main/README.md).
+
+## Package Information
+
+- **Package name**: sfeos-helpers
+- **Description**: Helper utilities for the stac-fastapi project.
+- **Documentation**: [https://stac-utils.github.io/stac-fastapi-elasticsearch-opensearch/](https://stac-utils.github.io/stac-fastapi-elasticsearch-opensearch/)
+- **Source**: [GitHub Repository](https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch/)
+
+## Installation
+
+This package is a dependency of stac-fastapi-elasticsearch and stac-fastapi-opensearch and is typically installed automatically.
+
+```bash
+pip install stac-fastapi-elasticsearch  # or stac-fastapi-opensearch
+```
+
+## Quick Start
+
+For detailed usage and examples, please refer to the [main documentation](https://stac-utils.github.io/stac-fastapi-elasticsearch-opensearch/).

{sfeos_helpers-6.5.1.dist-info → sfeos_helpers-6.7.0.dist-info}/RECORD

@@ -1,17 +1,20 @@
-stac_fastapi/sfeos_helpers/mappings.py,sha256=u7ZHyUu3NPS_sXaflfQPSP2Yleld3jgqCG0yKcQ64w4,8600
-stac_fastapi/sfeos_helpers/version.py,sha256=FuGC3fKnAmD4Wk95swJ6qCVBs5mZiShrlRKuSH-voyE,45
+stac_fastapi/sfeos_helpers/mappings.py,sha256=IqYd0tQUG-FnWVg6Fp1MU9audntF_-pMGm-BUTGbZMM,8596
+stac_fastapi/sfeos_helpers/version.py,sha256=GMc7YzxyWeUVpr_RMVlweeoH2lCLxOWemF-FOkqKXx8,45
+stac_fastapi/sfeos_helpers/aggregation/README.md,sha256=SDlvCOpKyaJrlJvx84T2RzCnGALe_PK51zNeo3RP9ac,2122
 stac_fastapi/sfeos_helpers/aggregation/__init__.py,sha256=Mym17lFh90by1GnoQgMyIKAqRNJnvCgVSXDYzjBiPQk,1210
 stac_fastapi/sfeos_helpers/aggregation/client.py,sha256=PPUk0kAZnms46FlLGrR5w8wa52vG-dT6BG37896R5CY,17939
 stac_fastapi/sfeos_helpers/aggregation/format.py,sha256=qUW1jjh2EEjy-V7riliFR77grpi-AgsTmP76z60K5Lo,2011
-stac_fastapi/sfeos_helpers/database/__init__.py,sha256=T0YwePfhG3ukL1oUFCh3FYHA9jZZe36FJRYCQplfb18,2645
+stac_fastapi/sfeos_helpers/database/README.md,sha256=TVYFDD4PqDD57ZsWBv4i4LawaL_DAEIOjM6OQuqwLAU,4049
+stac_fastapi/sfeos_helpers/database/__init__.py,sha256=Kvnz8hpXq_sSz8K5OW3PoPsvh9864Vv1zWhI5hxgd4o,2891
 stac_fastapi/sfeos_helpers/database/datetime.py,sha256=XMyi9Q09cuP_hj97qbGbHFtelq7WQVPdehUfzqNZFV4,4040
 stac_fastapi/sfeos_helpers/database/document.py,sha256=LtjX15gvaOuZC_k2t_oQhys_c-zRTLN5rwX0hNJkHnM,1725
 stac_fastapi/sfeos_helpers/database/index.py,sha256=g7_sKfd5XUwq4IhdKRNiasejk045dKlullsdeDSZTq8,6585
 stac_fastapi/sfeos_helpers/database/mapping.py,sha256=4-MSd4xH5wg7yoC4aPjzYMDSEvP026bw4k2TfffMT5E,1387
-stac_fastapi/sfeos_helpers/database/query.py,sha256=g2iGdfgqpx6o8GoQJBMl3AMmqcbSf792qvKWfWipR5w,4193
-stac_fastapi/sfeos_helpers/database/utils.py,sha256=9zU9hEglZb6f-uxOhd95saSw2id9w5PR36dWtyfXTb0,8757
+stac_fastapi/sfeos_helpers/database/query.py,sha256=bbSYe0cLC7oFbhkHR5WTKCF7Ca9iZI3fdanD90KYN98,9476
+stac_fastapi/sfeos_helpers/database/utils.py,sha256=CLtZgoUT37oklc9MsExXsxDviv4bzK-ZP7oxAOXS32Y,11780
+stac_fastapi/sfeos_helpers/filter/README.md,sha256=Rb5qHmDkI-7-o3I82Lb_zfmrviqUj958wef021xI6pQ,1955
 stac_fastapi/sfeos_helpers/filter/__init__.py,sha256=n3zL_MhEGOoxMz1KeijyK_UKiZ0MKPl90zHtYI5RAy8,1557
-stac_fastapi/sfeos_helpers/filter/client.py,sha256=QQ6gnUEMqzS_qG8G5QHcX9x3LNk5JvCp1rRJltMTmM4,4414
+stac_fastapi/sfeos_helpers/filter/client.py,sha256=QZP0Dm_T7SoMdR65IOjFmKBW7Rphr4z2xPgozZ93TPs,5339
 stac_fastapi/sfeos_helpers/filter/cql2.py,sha256=Cg9kRYD9CVkVSyRqOyB5oVXmlyteSn2bw88sqklGpUM,955
 stac_fastapi/sfeos_helpers/filter/transform.py,sha256=1GEWQSp-rbq7_1nDVv1ApDbWxt8DswJWxwaxzV85gj4,4644
 stac_fastapi/sfeos_helpers/models/patch.py,sha256=s5n85ktnH6M2SMqpqyItR8uLxliXmnSTg1WO0QLVsmI,3127
@@ -26,7 +29,6 @@ stac_fastapi/sfeos_helpers/search_engine/selection/base.py,sha256=106c4FK50cgMmT
 stac_fastapi/sfeos_helpers/search_engine/selection/cache_manager.py,sha256=5yrgf9JA4mgRNMPDKih6xySF8mD724lEWnXhWud7m2c,4039
 stac_fastapi/sfeos_helpers/search_engine/selection/factory.py,sha256=vbgNVCUW2lviePqzpgsPLxp6IEqcX3GHiahqN2oVObA,1305
 stac_fastapi/sfeos_helpers/search_engine/selection/selectors.py,sha256=q83nfCfNfLUqtkHpORwNHNRU9Pa-heeaDIPO0RlHb-8,4779
-sfeos_helpers-6.5.1.dist-info/METADATA,sha256=yCy4qbL5pERMI0QAwOwK2PKff7u0Cus4BLjRr8xuGHg,41326
-sfeos_helpers-6.5.1.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-sfeos_helpers-6.5.1.dist-info/top_level.txt,sha256=vqn-D9-HsRPTTxy0Vk_KkDmTiMES4owwBQ3ydSZYb2s,13
-sfeos_helpers-6.5.1.dist-info/RECORD,,
+sfeos_helpers-6.7.0.dist-info/METADATA,sha256=GHCTNfc1-AdmRtby5GAqUQMmB56qyZdhRpGudb63mp4,3214
+sfeos_helpers-6.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sfeos_helpers-6.7.0.dist-info/RECORD,,

{sfeos_helpers-6.5.1.dist-info → sfeos_helpers-6.7.0.dist-info}/WHEEL

@@ -1,5 +1,4 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.45.1)
+Generator: hatchling 1.27.0
 Root-Is-Purelib: true
 Tag: py3-none-any
-

stac_fastapi/sfeos_helpers/aggregation/README.md

@@ -0,0 +1,57 @@
+# STAC FastAPI Aggregation Package
+
+This package contains shared aggregation functionality used by both the Elasticsearch and OpenSearch implementations of STAC FastAPI. It helps reduce code duplication and ensures consistent behavior between the two implementations.
+
+## Package Structure
+
+The aggregation package is organized into three main modules:
+
+- **client.py**: Contains the base aggregation client implementation
+  - `EsAsyncBaseAggregationClient`: The main class that implements the STAC aggregation extension for Elasticsearch/OpenSearch
+  - Methods for handling aggregation requests, validating parameters, and formatting responses
+
+- **format.py**: Contains functions for formatting aggregation responses
+  - `frequency_agg`: Formats frequency distribution aggregation responses
+  - `metric_agg`: Formats metric aggregation responses
+
+- **__init__.py**: Package initialization and exports
+  - Exports the main classes and functions for use by other modules
+
+## Features
+
+The aggregation package provides the following features:
+
+- Support for various aggregation types:
+  - Datetime frequency
+  - Collection frequency
+  - Property frequency
+  - Geospatial grid aggregations (geohash, geohex, geotile)
+  - Metric aggregations (min, max, etc.)
+
+- Parameter validation:
+  - Precision validation for geospatial aggregations
+  - Interval validation for datetime aggregations
+
+- Response formatting:
+  - Consistent response structure
+  - Proper typing and documentation
+
+## Usage
+
+The aggregation package is used by the Elasticsearch and OpenSearch implementations to provide aggregation functionality for STAC API. The main entry point is the `EsAsyncBaseAggregationClient` class, which is instantiated in the respective app.py files.
+
+Example:
+```python
+from stac_fastapi.sfeos_helpers.aggregation import EsAsyncBaseAggregationClient
+
+# Create an instance of the aggregation client
+aggregation_client = EsAsyncBaseAggregationClient(database)
+
+# Register the aggregation extension with the API
+api = StacApi(
+    ...,
+    extensions=[
+        ...,
+        AggregationExtension(client=aggregation_client),
+    ],
+)

stac_fastapi/sfeos_helpers/database/README.md

@@ -0,0 +1,61 @@
+# STAC FastAPI Database Package
+
+This package contains shared database operations used by both the Elasticsearch and OpenSearch
+implementations of STAC FastAPI. It helps reduce code duplication and ensures consistent behavior
+between the two implementations.
+
+## Package Structure
+
+The database package is organized into five main modules:
+
+- **index.py**: Contains functions for managing indices
+  - [create_index_templates_shared](cci:1://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/database_logic_helpers.py:15:0-48:33): Creates index templates for Collections and Items
+  - [delete_item_index_shared](cci:1://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/database_logic_helpers.py:128:0-153:30): Deletes an item index for a collection
+  - [index_by_collection_id](cci:1://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/utilities.py:86:0-100:5): Translates a collection ID into an index name
+  - [index_alias_by_collection_id](cci:1://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/utilities.py:103:0-115:5): Translates a collection ID into an index alias
+  - [indices](cci:1://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/utilities.py:118:0-132:5): Gets a comma-separated string of index names
+
+- **query.py**: Contains functions for building and manipulating queries
+  - [apply_free_text_filter_shared](cci:1://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/database_logic_helpers.py:51:0-74:16): Applies a free text filter to a search
+  - [apply_intersects_filter_shared](cci:1://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/database_logic_helpers.py:77:0-104:5): Creates a geo_shape filter for intersecting geometry
+  - [populate_sort_shared](cci:1://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/database_logic_helpers.py:107:0-125:16): Creates a sort configuration for queries
+
+- **mapping.py**: Contains functions for working with mappings
+  - [get_queryables_mapping_shared](cci:1://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/database_logic_helpers.py:156:0-185:27): Retrieves mapping of Queryables for search
+
+- **document.py**: Contains functions for working with documents
+  - [mk_item_id](cci:1://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/utilities.py:140:0-150:5): Creates a document ID for an Item
+  - [mk_actions](cci:1://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/utilities.py:153:0-175:5): Creates bulk actions for indexing items
+
+- **utils.py**: Contains utility functions for database operations
+  - [validate_refresh](cci:1://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/utilities.py:41:0-78:5): Validates the refresh parameter value
+
+## Usage
+
+Import the necessary components from the database package:
+
+```python
+from stac_fastapi.sfeos_helpers.database import (
+    # Index operations
+    create_index_templates_shared,
+    delete_item_index_shared,
+    index_alias_by_collection_id,
+    index_by_collection_id,
+    indices,
+    
+    # Query operations
+    apply_free_text_filter_shared,
+    apply_intersects_filter_shared,
+    populate_sort_shared,
+    
+    # Mapping operations
+    get_queryables_mapping_shared,
+    
+    # Document operations
+    mk_item_id,
+    mk_actions,
+    
+    # Utility functions
+    validate_refresh,
+)
+```

stac_fastapi/sfeos_helpers/database/__init__.py

@@ -42,11 +42,13 @@ from .index import (
 )
 from .mapping import get_queryables_mapping_shared
 from .query import (
+    apply_collections_bbox_filter_shared,
+    apply_collections_datetime_filter_shared,
     apply_free_text_filter_shared,
     apply_intersects_filter_shared,
     populate_sort_shared,
 )
-from .utils import get_bool_env, validate_refresh
+from .utils import add_bbox_shape_to_collection, get_bool_env, validate_refresh
 
 __all__ = [
     # Index operations
@@ -59,6 +61,8 @@ __all__ = [
     # Query operations
     "apply_free_text_filter_shared",
     "apply_intersects_filter_shared",
+    "apply_collections_bbox_filter_shared",
+    "apply_collections_datetime_filter_shared",
     "populate_sort_shared",
     # Mapping operations
     "get_queryables_mapping_shared",
@@ -68,6 +72,7 @@ __all__ = [
     # Utility functions
     "validate_refresh",
     "get_bool_env",
+    "add_bbox_shape_to_collection",
     # Datetime utilities
     "return_date",
     "extract_date",

stac_fastapi/sfeos_helpers/database/query.py

@@ -3,8 +3,10 @@
 This module provides functions for building and manipulating Elasticsearch/OpenSearch queries.
 """
 
-from typing import Any, Dict, List, Optional
+import logging
+from typing import Any, Dict, List, Optional, Union
 
+from stac_fastapi.core.utilities import bbox2polygon
 from stac_fastapi.sfeos_helpers.mappings import Geometry
 
 ES_MAX_URL_LENGTH = 4096
@@ -66,6 +68,139 @@ def apply_intersects_filter_shared(
     }
 
 
+def apply_collections_datetime_filter_shared(
+    datetime_str: Optional[str],
+) -> Optional[Dict[str, Any]]:
+    """Create a temporal filter for collections based on their extent.
+
+    Args:
+        datetime_str: The datetime parameter. Can be:
+            - A single datetime string (e.g., "2020-01-01T00:00:00Z")
+            - A datetime range with "/" separator (e.g., "2020-01-01T00:00:00Z/2021-01-01T00:00:00Z")
+            - Open-ended ranges using ".." (e.g., "../2021-01-01T00:00:00Z" or "2020-01-01T00:00:00Z/..")
+            - None if no datetime filter is provided
+
+    Returns:
+        Optional[Dict[str, Any]]: A dictionary containing the temporal filter configuration
+            that can be used with Elasticsearch/OpenSearch queries, or None if datetime_str is None.
+            Example return value:
+            {
+                "bool": {
+                    "must": [
+                        {"range": {"extent.temporal.interval": {"lte": "2021-01-01T00:00:00Z"}}},
+                        {"range": {"extent.temporal.interval": {"gte": "2020-01-01T00:00:00Z"}}}
+                    ]
+                }
+            }
+
+    Notes:
+        - This function is specifically for filtering collections by their temporal extent
+        - It queries the extent.temporal.interval field
+        - Open-ended ranges (..) are replaced with concrete dates (1800-01-01 for start, 2999-12-31 for end)
+    """
+    if not datetime_str:
+        return None
+
+    # Parse the datetime string into start and end
+    if "/" in datetime_str:
+        start, end = datetime_str.split("/")
+        # Replace open-ended ranges with concrete dates
+        if start == "..":
+            # For open-ended start, use a very early date
+            start = "1800-01-01T00:00:00Z"
+        if end == "..":
+            # For open-ended end, use a far future date
+            end = "2999-12-31T23:59:59Z"
+    else:
+        # If it's just a single date, use it for both start and end
+        start = end = datetime_str
+
+    return {
+        "bool": {
+            "must": [
+                # Check if any date in the array is less than or equal to the query end date
+                # This will match if the collection's start date is before or equal to the query end date
+                {"range": {"extent.temporal.interval": {"lte": end}}},
+                # Check if any date in the array is greater than or equal to the query start date
+                # This will match if the collection's end date is after or equal to the query start date
+                {"range": {"extent.temporal.interval": {"gte": start}}},
+            ]
+        }
+    }
+
+
+def apply_collections_bbox_filter_shared(
+    bbox: Union[str, List[float], None]
+) -> Optional[Dict[str, Dict]]:
+    """Create a geo_shape filter for collections bbox search.
+
+    This function handles bbox parsing from both GET requests (string format) and POST requests
+    (list format), and constructs a geo_shape query for filtering collections by their bbox_shape field.
+
+    Args:
+        bbox: The bounding box parameter. Can be:
+            - A string of comma-separated coordinates (from GET requests)
+            - A list of floats [minx, miny, maxx, maxy] for 2D bbox
+            - None if no bbox filter is provided
+
+    Returns:
+        Optional[Dict[str, Dict]]: A dictionary containing the geo_shape filter configuration
+            that can be used with Elasticsearch/OpenSearch queries, or None if bbox is invalid.
+            Example return value:
+            {
+                "geo_shape": {
+                    "bbox_shape": {
+                        "shape": {
+                            "type": "Polygon",
+                            "coordinates": [[[minx, miny], [maxx, miny], [maxx, maxy], [minx, maxy], [minx, miny]]]
+                        },
+                        "relation": "intersects"
+                    }
+                }
+            }
+
+    Notes:
+        - This function is specifically for filtering collections by their spatial extent
+        - It queries the bbox_shape field (not the geometry field used for items)
+        - The bbox is expected to be 2D (4 values) after any 3D to 2D conversion in the API layer
+    """
+    logger = logging.getLogger(__name__)
+
+    if not bbox:
+        return None
+
+    # Parse bbox if it's a string (from GET requests)
+    if isinstance(bbox, str):
+        try:
+            bbox = [float(x.strip()) for x in bbox.split(",")]
+        except (ValueError, AttributeError) as e:
+            logger.error(f"Invalid bbox format: {bbox}, error: {e}")
+            return None
+
+    if not bbox or len(bbox) != 4:
+        if bbox:
+            logger.warning(
+                f"bbox has incorrect number of coordinates (length={len(bbox)}), expected 4 (2D bbox)"
+            )
+        return None
+
+    # Convert bbox to a polygon for geo_shape query
+    bbox_polygon = {
+        "type": "Polygon",
+        "coordinates": bbox2polygon(bbox[0], bbox[1], bbox[2], bbox[3]),
+    }
+
+    # Return geo_shape query for bbox_shape field
+    return {
+        "geo_shape": {
+            "bbox_shape": {
+                "shape": bbox_polygon,
+                "relation": "intersects",
+            }
+        }
+    }
+
+
 def populate_sort_shared(sortby: List) -> Optional[Dict[str, Dict[str, str]]]:
     """Create a sort configuration for Elasticsearch/OpenSearch queries.
 

stac_fastapi/sfeos_helpers/database/utils.py

@@ -5,9 +5,9 @@ in Elasticsearch/OpenSearch, such as parameter validation.
 """
 
 import logging
-from typing import Dict, List, Union
+from typing import Any, Dict, List, Union
 
-from stac_fastapi.core.utilities import get_bool_env
+from stac_fastapi.core.utilities import bbox2polygon, get_bool_env
 from stac_fastapi.extensions.core.transaction.request import (
     PatchAddReplaceTest,
     PatchOperation,
@@ -15,6 +15,84 @@ from stac_fastapi.extensions.core.transaction.request import (
 )
 from stac_fastapi.sfeos_helpers.models.patch import ElasticPath, ESCommandSet
 
+logger = logging.getLogger(__name__)
+
+
+def add_bbox_shape_to_collection(collection: Dict[str, Any]) -> bool:
+    """Add bbox_shape field to a collection document for spatial queries.
+
+    This function extracts the bounding box from a collection's spatial extent
+    and converts it to a GeoJSON polygon shape that can be used for geospatial
+    queries in Elasticsearch/OpenSearch.
+
+    Args:
+        collection: Collection document dictionary to modify in-place.
+
+    Returns:
+        bool: True if bbox_shape was added, False if it was skipped (already exists,
+            no spatial extent, or invalid bbox).
+
+    Notes:
+        - Modifies the collection dictionary in-place by adding a 'bbox_shape' field
+        - Handles both 2D [minx, miny, maxx, maxy] and 3D [minx, miny, minz, maxx, maxy, maxz] bboxes
+        - Uses the first bbox if multiple are present in the collection
+        - Logs warnings for collections with invalid or missing bbox data
+    """
+    collection_id = collection.get("id", "unknown")
+
+    # Check if bbox_shape already exists
+    if "bbox_shape" in collection:
+        logger.debug(
+            f"Collection '{collection_id}' already has bbox_shape field, skipping"
+        )
+        return False
+
+    # Check if collection has spatial extent
+    if "extent" not in collection or "spatial" not in collection["extent"]:
+        logger.warning(f"Collection '{collection_id}' has no spatial extent, skipping")
+        return False
+
+    spatial_extent = collection["extent"]["spatial"]
+    if "bbox" not in spatial_extent or not spatial_extent["bbox"]:
+        logger.warning(
+            f"Collection '{collection_id}' has no bbox in spatial extent, skipping"
+        )
+        return False
+
+    # Get the first bbox (collections can have multiple bboxes, but we use the first one)
+    bbox = (
+        spatial_extent["bbox"][0]
+        if isinstance(spatial_extent["bbox"][0], list)
+        else spatial_extent["bbox"]
+    )
+
+    if len(bbox) < 4:
+        logger.warning(
+            f"Collection '{collection_id}': bbox has insufficient coordinates (length={len(bbox)}), expected at least 4"
+        )
+        return False
+
+    # Extract 2D coordinates (bbox can be 2D [minx, miny, maxx, maxy] or 3D [minx, miny, minz, maxx, maxy, maxz])
+    # For 2D polygon, we only need the x,y coordinates and discard altitude (z) values
+    minx, miny = bbox[0], bbox[1]
+    if len(bbox) == 4:
+        # 2D bbox: [minx, miny, maxx, maxy]
+        maxx, maxy = bbox[2], bbox[3]
+    else:
+        # 3D bbox: [minx, miny, minz, maxx, maxy, maxz]
+        # Extract indices 3,4 for maxx,maxy - discarding altitude at indices 2 (minz) and 5 (maxz)
+        maxx, maxy = bbox[3], bbox[4]
+
+    # Convert bbox to GeoJSON polygon
+    bbox_polygon_coords = bbox2polygon(minx, miny, maxx, maxy)
+    collection["bbox_shape"] = {
+        "type": "Polygon",
+        "coordinates": bbox_polygon_coords,
+    }
+
+    logger.debug(f"Collection '{collection_id}': Added bbox_shape field")
+    return True
+
 
 def validate_refresh(value: Union[str, bool]) -> str:
     """

stac_fastapi/sfeos_helpers/filter/README.md

@@ -0,0 +1,30 @@
+# STAC FastAPI Filter Package
+
+This package contains shared filter extension functionality used by both the Elasticsearch and OpenSearch
+implementations of STAC FastAPI. It helps reduce code duplication and ensures consistent behavior
+between the two implementations.
+
+## Package Structure
+
+The filter package is organized into three main modules:
+
+- **cql2.py**: Contains functions for converting CQL2 patterns to Elasticsearch/OpenSearch compatible formats
+
+  - [cql2_like_to_es](cci:1://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/filter.py:59:0-75:5): Converts CQL2 "LIKE" characters to Elasticsearch "wildcard" characters
+  - [\_replace_like_patterns](cci:1://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/filter.py:51:0-56:71): Helper function for pattern replacement
+
+- **transform.py**: Contains functions for transforming CQL2 queries to Elasticsearch/OpenSearch query DSL
+
+  - [to_es_field](cci:1://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/filter.py:83:0-93:47): Maps field names using queryables mapping
+  - [to_es](cci:1://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/filter.py:96:0-201:13): Transforms CQL2 query structures to Elasticsearch/OpenSearch query DSL
+
+- **client.py**: Contains the base filter client implementation
+  - [EsAsyncBaseFiltersClient](cci:2://file:///home/computer/Code/stac-fastapi-elasticsearch-opensearch/stac_fastapi/sfeos_helpers/stac_fastapi/sfeos_helpers/filter.py:209:0-293:25): Base class for implementing the STAC filter extension
+
+## Usage
+
+Import the necessary components from the filter package:
+
+```python
+from stac_fastapi.sfeos_helpers.filter import cql2_like_to_es, to_es, EsAsyncBaseFiltersClient
+```

stac_fastapi/sfeos_helpers/filter/client.py

@@ -1,7 +1,8 @@
 """Filter client implementation for Elasticsearch/OpenSearch."""
 
+import os
 from collections import deque
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Optional
 
 import attr
 from fastapi import Request
@@ -18,9 +19,29 @@ class EsAsyncBaseFiltersClient(AsyncBaseFiltersClient):
 
     database: BaseDatabaseLogic = attr.ib()
 
+    @staticmethod
+    def _get_excluded_from_queryables() -> set[str]:
+        """Get fields to exclude from queryables endpoint and filtering.
+
+        Reads from EXCLUDED_FROM_QUERYABLES environment variable.
+        Supports comma-separated list of field names.
+
+        Example:
+            EXCLUDED_FROM_QUERYABLES="auth:schemes,storage:schemes"
+
+        Returns:
+            Set[str]: Set of field names to exclude from queryables
+        """
+        excluded = os.getenv("EXCLUDED_FROM_QUERYABLES", "")
+        if not excluded:
+            return set()
+        return {field.strip() for field in excluded.split(",") if field.strip()}
+
     async def get_queryables(
-        self, collection_id: Optional[str] = None, **kwargs
-    ) -> Dict[str, Any]:
+        self,
+        collection_id: Optional[str] = None,  # noqa: UP045
+        **kwargs: Any,
+    ) -> dict[str, Any]:
         """Get the queryables available for the given collection_id.
 
         If collection_id is None, returns the intersection of all
@@ -38,21 +59,23 @@ class EsAsyncBaseFiltersClient(AsyncBaseFiltersClient):
         Returns:
             Dict[str, Any]: A dictionary containing the queryables for the given collection.
         """
-        request: Optional[Request] = kwargs.get("request")
-        url_str: str = str(request.url) if request else ""
-        queryables: Dict[str, Any] = {
+        request: Optional[Request] = kwargs.get("request")  # noqa: UP045
+        url_str = str(request.url) if request else ""
+
+        queryables: dict[str, Any] = {
             "$schema": "https://json-schema.org/draft-07/schema",
-            "$id": f"{url_str}",
+            "$id": url_str,
             "type": "object",
             "title": "Queryables for STAC API",
             "description": "Queryable names for the STAC API Item Search filter.",
             "properties": DEFAULT_QUERYABLES,
             "additionalProperties": True,
         }
+
         if not collection_id:
             return queryables
 
-        properties: Dict[str, Any] = queryables["properties"].copy()
+        properties = queryables["properties"].copy()
         queryables.update(
             {
                 "properties": properties,
@@ -62,8 +85,9 @@ class EsAsyncBaseFiltersClient(AsyncBaseFiltersClient):
 
         mapping_data = await self.database.get_items_mapping(collection_id)
         mapping_properties = next(iter(mapping_data.values()))["mappings"]["properties"]
-        stack: deque[Tuple[str, Dict[str, Any]]] = deque(mapping_properties.items())
-        enum_fields: Dict[str, Dict[str, Any]] = {}
+        stack: deque[tuple[str, dict[str, Any]]] = deque(mapping_properties.items())
+        enum_fields: dict[str, dict[str, Any]] = {}
+        excluded_fields = self._get_excluded_from_queryables()
 
         while stack:
             field_fqn, field_def = stack.popleft()
@@ -75,11 +99,16 @@ class EsAsyncBaseFiltersClient(AsyncBaseFiltersClient):
                     (f"{field_fqn}.{k}", v)
                     for k, v in field_properties.items()
                     if v.get("enabled", True)
+                    and f"{field_fqn}.{k}" not in excluded_fields
                 )
 
             # Skip non-indexed or disabled fields
             field_type = field_def.get("type")
-            if not field_type or not field_def.get("enabled", True):
+            if (
+                not field_type
+                or not field_def.get("enabled", True)
+                or field_fqn in excluded_fields
+            ):
                 continue
 
             # Fields in Item Properties should be exposed with their un-prefixed names,
@@ -88,7 +117,7 @@ class EsAsyncBaseFiltersClient(AsyncBaseFiltersClient):
             field_name = field_fqn.removeprefix("properties.")
 
             # Generate field properties
-            field_result = ALL_QUERYABLES.get(field_name, {})
+            field_result = ALL_QUERYABLES.get(field_name, {}).copy()
             properties[field_name] = field_result
 
             field_name_human = field_name.replace("_", " ").title()
@@ -104,9 +133,10 @@ class EsAsyncBaseFiltersClient(AsyncBaseFiltersClient):
                 enum_fields[field_fqn] = field_result
 
         if enum_fields:
-            for field_fqn, unique_values in (
-                await self.database.get_items_unique_values(collection_id, enum_fields)
-            ).items():
-                enum_fields[field_fqn]["enum"] = unique_values
+            unique_values = await self.database.get_items_unique_values(
+                collection_id, enum_fields
+            )
+            for field_fqn, values in unique_values.items():
+                enum_fields[field_fqn]["enum"] = values
 
         return queryables