stac-fastapi-core 6.6.0__py3-none-any.whl → 6.7.0__py3-none-any.whl

stac_fastapi/core/core.py

@@ -24,9 +24,10 @@ from stac_fastapi.core.base_database_logic import BaseDatabaseLogic
 from stac_fastapi.core.base_settings import ApiBaseSettings
 from stac_fastapi.core.datetime_utils import format_datetime_range
 from stac_fastapi.core.models.links import PagingLinks
+from stac_fastapi.core.redis_utils import redis_pagination_links
 from stac_fastapi.core.serializers import CollectionSerializer, ItemSerializer
 from stac_fastapi.core.session import Session
-from stac_fastapi.core.utilities import filter_fields
+from stac_fastapi.core.utilities import filter_fields, get_bool_env
 from stac_fastapi.extensions.core.transaction import AsyncBaseTransactionsClient
 from stac_fastapi.extensions.core.transaction.request import (
     PartialCollection,
@@ -262,6 +263,7 @@ class CoreClient(AsyncBaseCoreClient):
             A Collections object containing all the collections in the database and links to various resources.
         """
         base_url = str(request.base_url)
+        redis_enable = get_bool_env("REDIS_ENABLE", default=False)
 
         global_max_limit = (
             int(os.getenv("STAC_GLOBAL_COLLECTION_MAX_LIMIT"))
@@ -417,6 +419,14 @@ class CoreClient(AsyncBaseCoreClient):
             },
         ]
 
+        if redis_enable:
+            await redis_pagination_links(
+                current_url=str(request.url),
+                token=token,
+                next_token=next_token,
+                links=links,
+            )
+
         if next_token:
             next_link = PagingLinks(next=next_token, request=request).link_next()
             links.append(next_link)
@@ -761,8 +771,8 @@ class CoreClient(AsyncBaseCoreClient):
         search_request.limit = limit
 
         base_url = str(request.base_url)
-
         search = self.database.make_search()
+        redis_enable = get_bool_env("REDIS_ENABLE", default=False)
 
         if search_request.ids:
             search = self.database.apply_ids_filter(
@@ -866,6 +876,34 @@ class CoreClient(AsyncBaseCoreClient):
         ]
         links = await PagingLinks(request=request, next=next_token).get_links()
 
+        collection_links = []
+        # Add "collection" and "parent" rels only for /collections/{collection_id}/items
+        if search_request.collections and "/items" in str(request.url):
+            for collection_id in search_request.collections:
+                collection_links.extend(
+                    [
+                        {
+                            "rel": "collection",
+                            "type": "application/json",
+                            "href": urljoin(base_url, f"collections/{collection_id}"),
+                        },
+                        {
+                            "rel": "parent",
+                            "type": "application/json",
+                            "href": urljoin(base_url, f"collections/{collection_id}"),
+                        },
+                    ]
+                )
+        links.extend(collection_links)
+
+        if redis_enable:
+            await redis_pagination_links(
+                current_url=str(request.url),
+                token=token_param,
+                next_token=next_token,
+                links=links,
+            )
+
         return stac_types.ItemCollection(
             type="FeatureCollection",
             features=items,

stac_fastapi/core/extensions/collections_search.py

@@ -1,8 +1,8 @@
 """Collections search extension."""
 
-from typing import List, Optional, Type, Union
+from typing import Any, Dict, List, Optional, Type, Union
 
-from fastapi import APIRouter, FastAPI, Request
+from fastapi import APIRouter, Body, FastAPI, Query, Request
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 from stac_pydantic.api.search import ExtendedSearch
@@ -22,6 +22,168 @@ class CollectionsSearchRequest(ExtendedSearch):
     query: Optional[
         str
     ] = None  # Legacy query extension (deprecated but still supported)
+    filter_expr: Optional[str] = None
+    filter_lang: Optional[str] = None
+
+
+def build_get_collections_search_doc(original_endpoint):
+    """Return a documented GET endpoint wrapper for /collections-search."""
+
+    async def documented_endpoint(
+        request: Request,
+        q: Optional[Union[str, List[str]]] = Query(
+            None,
+            description="Free text search query",
+        ),
+        query: Optional[str] = Query(
+            None,
+            description="Additional filtering expressed as a string (legacy support)",
+            example="platform=landsat AND collection_category=level2",
+        ),
+        limit: int = Query(
+            10,
+            ge=1,
+            description=(
+                "The maximum number of collections to return (page size). Defaults to 10."
+            ),
+        ),
+        token: Optional[str] = Query(
+            None,
+            description="Pagination token for the next page of results",
+        ),
+        bbox: Optional[str] = Query(
+            None,
+            description=(
+                "Bounding box for spatial filtering in format 'minx,miny,maxx,maxy' "
+                "or 'minx,miny,minz,maxx,maxy,maxz'"
+            ),
+        ),
+        datetime: Optional[str] = Query(
+            None,
+            description=(
+                "Temporal filter in ISO 8601 format (e.g., "
+                "'2020-01-01T00:00:00Z/2021-01-01T00:00:00Z')"
+            ),
+        ),
+        sortby: Optional[str] = Query(
+            None,
+            description=(
+                "Sorting criteria in the format 'field' or '-field' for descending order"
+            ),
+        ),
+        fields: Optional[List[str]] = Query(
+            None,
+            description=(
+                "Comma-separated list of fields to include or exclude (use -field to exclude)"
+            ),
+            alias="fields[]",
+        ),
+        filter: Optional[str] = Query(
+            None,
+            description=(
+                "Structured filter expression in CQL2 JSON or CQL2-text format"
+            ),
+            example='{"op": "=", "args": [{"property": "properties.category"}, "level2"]}',
+        ),
+        filter_lang: Optional[str] = Query(
+            None,
+            description=(
+                "Filter language. Must be 'cql2-json' or 'cql2-text' if specified"
+            ),
+            example="cql2-json",
+        ),
+    ):
+        # Delegate to original endpoint with parameters
+        # Since FastAPI extracts parameters from the URL when they're defined as function parameters,
+        # we need to create a request wrapper that provides our modified query_params
+
+        # Create a mutable copy of query_params
+        if hasattr(request, "_query_params"):
+            query_params = dict(request._query_params)
+        else:
+            query_params = dict(request.query_params)
+
+        # Add q parameter back to query_params if it was provided
+        # Convert to list format to match /collections behavior
+        if q is not None:
+            if isinstance(q, str):
+                # Single string should become a list with one element
+                query_params["q"] = [q]
+            elif isinstance(q, list):
+                # Already a list, use as-is
+                query_params["q"] = q
+
+        # Add filter parameters back to query_params if they were provided
+        if filter is not None:
+            query_params["filter"] = filter
+        if filter_lang is not None:
+            query_params["filter-lang"] = filter_lang
+
+        # Create a request wrapper that provides our modified query_params
+        class RequestWrapper:
+            def __init__(self, original_request, modified_query_params):
+                self._original = original_request
+                self._query_params = modified_query_params
+
+            @property
+            def query_params(self):
+                return self._query_params
+
+            def __getattr__(self, name):
+                # Delegate all other attributes to the original request
+                return getattr(self._original, name)
+
+        wrapped_request = RequestWrapper(request, query_params)
+        return await original_endpoint(wrapped_request)
+
+    documented_endpoint.__name__ = original_endpoint.__name__
+    return documented_endpoint
+
+
+def build_post_collections_search_doc(original_post_endpoint):
+    """Return a documented POST endpoint wrapper for /collections-search."""
+
+    async def documented_post_endpoint(
+        request: Request,
+        body: Dict[str, Any] = Body(
+            ...,
+            description=(
+                "Search parameters for collections.\n\n"
+                "- `q`: Free text search query (string or list of strings)\n"
+                "- `query`: Additional filtering expressed as a string (legacy support)\n"
+                "- `filter`: Structured filter expression in CQL2 JSON or CQL2-text format\n"
+                "- `filter_lang`: Filter language. Must be 'cql2-json' or 'cql2-text' if specified\n"
+                "- `limit`: Maximum number of results to return (default: 10)\n"
+                "- `token`: Pagination token for the next page of results\n"
+                "- `bbox`: Bounding box [minx, miny, maxx, maxy] or [minx, miny, minz, maxx, maxy, maxz]\n"
+                "- `datetime`: Temporal filter in ISO 8601 (e.g., '2020-01-01T00:00:00Z/2021-01-01T12:31:12Z')\n"
+                "- `sortby`: List of sort criteria objects with 'field' and 'direction' (asc/desc)\n"
+                "- `fields`: Object with 'include' and 'exclude' arrays for field selection"
+            ),
+            example={
+                "q": "landsat",
+                "query": "platform=landsat AND collection_category=level2",
+                "filter": {
+                    "op": "=",
+                    "args": [{"property": "properties.category"}, "level2"],
+                },
+                "filter_lang": "cql2-json",
+                "limit": 10,
+                "token": "next-page-token",
+                "bbox": [-180, -90, 180, 90],
+                "datetime": "2020-01-01T00:00:00Z/2021-01-01T12:31:12Z",
+                "sortby": [{"field": "id", "direction": "asc"}],
+                "fields": {
+                    "include": ["id", "title", "description"],
+                    "exclude": ["properties"],
+                },
+            },
+        ),
+    ) -> Union[Collections, Response]:
+        return await original_post_endpoint(request, body)
+
+    documented_post_endpoint.__name__ = original_post_endpoint.__name__
+    return documented_post_endpoint
 
 
 class CollectionsSearchEndpointExtension(ApiExtension):
@@ -54,7 +216,6 @@ class CollectionsSearchEndpointExtension(ApiExtension):
         self.POST = POST
         self.conformance_classes = conformance_classes or []
         self.router = APIRouter()
-        self.create_endpoints()
 
     def register(self, app: FastAPI) -> None:
         """Register the extension with a FastAPI application.
@@ -65,32 +226,53 @@ class CollectionsSearchEndpointExtension(ApiExtension):
         Returns:
             None
         """
-        app.include_router(self.router)
+        # Remove any existing routes to avoid duplicates
+        self.router.routes = []
 
-    def create_endpoints(self) -> None:
-        """Create endpoints for the extension."""
+        # Recreate endpoints with proper OpenAPI documentation
         if self.GET:
+            original_endpoint = self.collections_search_get_endpoint
+            documented_endpoint = build_get_collections_search_doc(original_endpoint)
+
             self.router.add_api_route(
-                name="Get Collections Search",
                 path="/collections-search",
+                endpoint=documented_endpoint,
                 response_model=None,
                 response_class=JSONResponse,
                 methods=["GET"],
-                endpoint=self.collections_search_get_endpoint,
+                summary="Search collections",
+                description=(
+                    "Search for collections using query parameters. "
+                    "Supports filtering, sorting, and field selection."
+                ),
+                response_description="A list of collections matching the search criteria",
+                tags=["Collections Search Extension"],
                 **(self.settings if isinstance(self.settings, dict) else {}),
             )
 
         if self.POST:
+            original_post_endpoint = self.collections_search_post_endpoint
+            documented_post_endpoint = build_post_collections_search_doc(
+                original_post_endpoint
+            )
+
             self.router.add_api_route(
-                name="Post Collections Search",
                 path="/collections-search",
+                endpoint=documented_post_endpoint,
                 response_model=None,
                 response_class=JSONResponse,
                 methods=["POST"],
-                endpoint=self.collections_search_post_endpoint,
+                summary="Search collections",
+                description=(
+                    "Search for collections using a JSON request body. "
+                    "Supports filtering, sorting, field selection, and pagination."
+                ),
+                tags=["Collections Search Extension"],
                 **(self.settings if isinstance(self.settings, dict) else {}),
             )
 
+        app.include_router(self.router)
+
     async def collections_search_get_endpoint(
         self, request: Request
     ) -> Union[Collections, Response]:
@@ -124,6 +306,14 @@ class CollectionsSearchEndpointExtension(ApiExtension):
             sortby = sortby_str.split(",")
             params["sortby"] = sortby
 
+        # Handle filter parameter mapping (fixed for collections-search)
+        if "filter" in params:
+            params["filter_expr"] = params.pop("filter")
+
+        # Handle filter-lang parameter mapping (fixed for collections-search)
+        if "filter-lang" in params:
+            params["filter_lang"] = params.pop("filter-lang")
+
         collections = await self.client.all_collections(request=request, **params)
         return collections
 

stac_fastapi/core/redis_utils.py

@@ -0,0 +1,301 @@
+"""Utilities for connecting to and managing Redis connections."""
+
+import json
+import logging
+from typing import List, Optional, Tuple
+from urllib.parse import parse_qs, urlencode, urlparse, urlunparse
+
+from pydantic import field_validator
+from pydantic_settings import BaseSettings
+from redis import asyncio as aioredis
+from redis.asyncio.sentinel import Sentinel
+
+logger = logging.getLogger(__name__)
+
+
+class RedisSentinelSettings(BaseSettings):
+    """Configuration for connecting to Redis Sentinel."""
+
+    REDIS_SENTINEL_HOSTS: str = ""
+    REDIS_SENTINEL_PORTS: str = "26379"
+    REDIS_SENTINEL_MASTER_NAME: str = "master"
+    REDIS_DB: int = 15
+
+    REDIS_MAX_CONNECTIONS: int = 10
+    REDIS_RETRY_TIMEOUT: bool = True
+    REDIS_DECODE_RESPONSES: bool = True
+    REDIS_CLIENT_NAME: str = "stac-fastapi-app"
+    REDIS_HEALTH_CHECK_INTERVAL: int = 30
+    REDIS_SELF_LINK_TTL: int = 1800
+
+    @field_validator("REDIS_DB")
+    @classmethod
+    def validate_db_sentinel(cls, v: int) -> int:
+        """Validate REDIS_DB is not negative integer."""
+        if v < 0:
+            raise ValueError("REDIS_DB must be a positive integer")
+        return v
+
+    @field_validator("REDIS_MAX_CONNECTIONS")
+    @classmethod
+    def validate_max_connections_sentinel(cls, v: int) -> int:
+        """Validate REDIS_MAX_CONNECTIONS is at least 1."""
+        if v < 1:
+            raise ValueError("REDIS_MAX_CONNECTIONS must be at least 1")
+        return v
+
+    @field_validator("REDIS_HEALTH_CHECK_INTERVAL")
+    @classmethod
+    def validate_health_check_interval_sentinel(cls, v: int) -> int:
+        """Validate REDIS_HEALTH_CHECK_INTERVAL is not negative integer."""
+        if v < 0:
+            raise ValueError("REDIS_HEALTH_CHECK_INTERVAL must be a positive integer")
+        return v
+
+    @field_validator("REDIS_SELF_LINK_TTL")
+    @classmethod
+    def validate_self_link_ttl_sentinel(cls, v: int) -> int:
+        """Validate REDIS_SELF_LINK_TTL is not a negative integer."""
+        if v < 0:
+            raise ValueError("REDIS_SELF_LINK_TTL must be a positive integer")
+        return v
+
+    def get_sentinel_hosts(self) -> List[str]:
+        """Parse Redis Sentinel hosts from string to list."""
+        if not self.REDIS_SENTINEL_HOSTS:
+            return []
+
+        if self.REDIS_SENTINEL_HOSTS.strip().startswith("["):
+            return json.loads(self.REDIS_SENTINEL_HOSTS)
+        else:
+            return [
+                h.strip() for h in self.REDIS_SENTINEL_HOSTS.split(",") if h.strip()
+            ]
+
+    def get_sentinel_ports(self) -> List[int]:
+        """Parse Redis Sentinel ports from string to list of integers."""
+        if not self.REDIS_SENTINEL_PORTS:
+            return [26379]
+
+        if self.REDIS_SENTINEL_PORTS.strip().startswith("["):
+            return json.loads(self.REDIS_SENTINEL_PORTS)
+        else:
+            ports_str_list = [
+                p.strip() for p in self.REDIS_SENTINEL_PORTS.split(",") if p.strip()
+            ]
+            return [int(port) for port in ports_str_list]
+
+    def get_sentinel_nodes(self) -> List[Tuple[str, int]]:
+        """Get list of (host, port) tuples for Sentinel connection."""
+        hosts = self.get_sentinel_hosts()
+        ports = self.get_sentinel_ports()
+
+        if not hosts:
+            return []
+
+        if len(ports) == 1 and len(hosts) > 1:
+            ports = ports * len(hosts)
+
+        if len(hosts) != len(ports):
+            raise ValueError(
+                f"Mismatch between hosts ({len(hosts)}) and ports ({len(ports)})"
+            )
+
+        return [(str(host), int(port)) for host, port in zip(hosts, ports)]
+
+
+class RedisSettings(BaseSettings):
+    """Configuration for connecting Redis."""
+
+    REDIS_HOST: str = ""
+    REDIS_PORT: int = 6379
+    REDIS_DB: int = 15
+
+    REDIS_MAX_CONNECTIONS: int = 10
+    REDIS_RETRY_TIMEOUT: bool = True
+    REDIS_DECODE_RESPONSES: bool = True
+    REDIS_CLIENT_NAME: str = "stac-fastapi-app"
+    REDIS_HEALTH_CHECK_INTERVAL: int = 30
+    REDIS_SELF_LINK_TTL: int = 1800
+
+    @field_validator("REDIS_PORT")
+    @classmethod
+    def validate_port_standalone(cls, v: int) -> int:
+        """Validate REDIS_PORT is not a negative integer."""
+        if v < 0:
+            raise ValueError("REDIS_PORT must be a positive integer")
+        return v
+
+    @field_validator("REDIS_DB")
+    @classmethod
+    def validate_db_standalone(cls, v: int) -> int:
+        """Validate REDIS_DB is not a negative integer."""
+        if v < 0:
+            raise ValueError("REDIS_DB must be a positive integer")
+        return v
+
+    @field_validator("REDIS_MAX_CONNECTIONS")
+    @classmethod
+    def validate_max_connections_standalone(cls, v: int) -> int:
+        """Validate REDIS_MAX_CONNECTIONS is at least 1."""
+        if v < 1:
+            raise ValueError("REDIS_MAX_CONNECTIONS must be at least 1")
+        return v
+
+    @field_validator("REDIS_HEALTH_CHECK_INTERVAL")
+    @classmethod
+    def validate_health_check_interval_standalone(cls, v: int) -> int:
+        """Validate REDIS_HEALTH_CHECK_INTERVAL is not a negative."""
+        if v < 0:
+            raise ValueError("REDIS_HEALTH_CHECK_INTERVAL must be a positive integer")
+        return v
+
+    @field_validator("REDIS_SELF_LINK_TTL")
+    @classmethod
+    def validate_self_link_ttl_standalone(cls, v: int) -> int:
+        """Validate REDIS_SELF_LINK_TTL is negative."""
+        if v < 0:
+            raise ValueError("REDIS_SELF_LINK_TTL must be a positive integer")
+        return v
+
+
+# Configure only one Redis configuration
+sentinel_settings = RedisSentinelSettings()
+standalone_settings = RedisSettings()
+
+
+async def connect_redis() -> Optional[aioredis.Redis]:
+    """Return a Redis connection Redis or Redis Sentinel."""
+    try:
+        if sentinel_settings.REDIS_SENTINEL_HOSTS:
+            sentinel_nodes = sentinel_settings.get_sentinel_nodes()
+            sentinel = Sentinel(
+                sentinel_nodes,
+                decode_responses=sentinel_settings.REDIS_DECODE_RESPONSES,
+            )
+
+            redis = sentinel.master_for(
+                service_name=sentinel_settings.REDIS_SENTINEL_MASTER_NAME,
+                db=sentinel_settings.REDIS_DB,
+                decode_responses=sentinel_settings.REDIS_DECODE_RESPONSES,
+                retry_on_timeout=sentinel_settings.REDIS_RETRY_TIMEOUT,
+                client_name=sentinel_settings.REDIS_CLIENT_NAME,
+                max_connections=sentinel_settings.REDIS_MAX_CONNECTIONS,
+                health_check_interval=sentinel_settings.REDIS_HEALTH_CHECK_INTERVAL,
+            )
+            logger.info("Connected to Redis Sentinel")
+
+        elif standalone_settings.REDIS_HOST:
+            pool = aioredis.ConnectionPool(
+                host=standalone_settings.REDIS_HOST,
+                port=standalone_settings.REDIS_PORT,
+                db=standalone_settings.REDIS_DB,
+                max_connections=standalone_settings.REDIS_MAX_CONNECTIONS,
+                decode_responses=standalone_settings.REDIS_DECODE_RESPONSES,
+                retry_on_timeout=standalone_settings.REDIS_RETRY_TIMEOUT,
+                health_check_interval=standalone_settings.REDIS_HEALTH_CHECK_INTERVAL,
+            )
+            redis = aioredis.Redis(
+                connection_pool=pool, client_name=standalone_settings.REDIS_CLIENT_NAME
+            )
+            logger.info("Connected to Redis")
+        else:
+            logger.warning("No Redis configuration found")
+            return None
+
+        return redis
+
+    except aioredis.ConnectionError as e:
+        logger.error(f"Redis connection error: {e}")
+        return None
+    except aioredis.AuthenticationError as e:
+        logger.error(f"Redis authentication error: {e}")
+        return None
+    except aioredis.TimeoutError as e:
+        logger.error(f"Redis timeout error: {e}")
+        return None
+    except Exception as e:
+        logger.error(f"Failed to connect to Redis: {e}")
+        return None
+
+
+def get_redis_key(url: str, token: str) -> str:
+    """Create Redis key using URL path and token."""
+    parsed = urlparse(url)
+    return f"nav:{parsed.path}:{token}"
+
+
+def build_url_with_token(base_url: str, token: str) -> str:
+    """Build URL with token parameter."""
+    parsed = urlparse(base_url)
+    query_params = parse_qs(parsed.query)
+
+    query_params["token"] = [token]
+
+    new_query = urlencode(query_params, doseq=True)
+
+    return urlunparse(
+        (
+            parsed.scheme,
+            parsed.netloc,
+            parsed.path,
+            parsed.params,
+            new_query,
+            parsed.fragment,
+        )
+    )
+
+
+async def save_prev_link(
+    redis: aioredis.Redis, next_url: str, current_url: str, next_token: str
+) -> None:
+    """Save the current page as the previous link for the next URL."""
+    if next_url and next_token:
+        if sentinel_settings.REDIS_SENTINEL_HOSTS:
+            ttl_seconds = sentinel_settings.REDIS_SELF_LINK_TTL
+        elif standalone_settings.REDIS_HOST:
+            ttl_seconds = standalone_settings.REDIS_SELF_LINK_TTL
+        key = get_redis_key(next_url, next_token)
+        await redis.setex(key, ttl_seconds, current_url)
+
+
+async def get_prev_link(
+    redis: aioredis.Redis, current_url: str, current_token: str
+) -> Optional[str]:
+    """Get the previous page link for the current token."""
+    if not current_url or not current_token:
+        return None
+    key = get_redis_key(current_url, current_token)
+    return await redis.get(key)
+
+
+async def redis_pagination_links(
+    current_url: str, token: str, next_token: str, links: list
+) -> None:
+    """Handle Redis pagination."""
+    redis = await connect_redis()
+    if not redis:
+        logger.warning("Redis connection failed.")
+        return
+
+    try:
+        if next_token:
+            next_url = build_url_with_token(current_url, next_token)
+            await save_prev_link(redis, next_url, current_url, next_token)
+
+        if token:
+            prev_link = await get_prev_link(redis, current_url, token)
+            if prev_link:
+                links.insert(
+                    0,
+                    {
+                        "rel": "previous",
+                        "type": "application/json",
+                        "method": "GET",
+                        "href": prev_link,
+                    },
+                )
+    except Exception as e:
+        logger.warning(f"Redis pagination operation failed: {e}")
+    finally:
+        await redis.close()

stac_fastapi/core/version.py

@@ -1,2 +1,2 @@
 """library version."""
-__version__ = "6.6.0"
+__version__ = "6.7.0"

{stac_fastapi_core-6.6.0.dist-info → stac_fastapi_core-6.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stac_fastapi_core
-Version: 6.6.0
+Version: 6.7.0
 Summary: Core library for the Elasticsearch and Opensearch stac-fastapi backends.
 Project-URL: Homepage, https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch
 License: MIT
@@ -24,6 +24,7 @@ Requires-Dist: orjson~=3.11.0
 Requires-Dist: overrides~=7.4.0
 Requires-Dist: pydantic<3.0.0,>=2.4.1
 Requires-Dist: pygeofilter~=0.3.1
+Requires-Dist: redis==6.4.0
 Requires-Dist: slowapi~=0.1.9
 Requires-Dist: stac-fastapi-api==6.0.0
 Requires-Dist: stac-fastapi-extensions==6.0.0
@@ -33,6 +34,18 @@ Description-Content-Type: text/markdown
 
 # stac-fastapi-core
 
+<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)
+
 Core functionality for stac-fastapi. For full documentation, please see the [main README](https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch/blob/main/README.md).
 
 ## Package Information

{stac_fastapi_core-6.6.0.dist-info → stac_fastapi_core-6.7.0.dist-info}/RECORD

@@ -2,23 +2,24 @@ stac_fastapi/core/__init__.py,sha256=8izV3IWRGdXmDOK1hIPQAanbWs9EI04PJCGgqG1ZGIs
 stac_fastapi/core/base_database_logic.py,sha256=3_XJ_j06ogQHE-Tcjkv5Vye_zNDn9OEU9lNYU03am1k,4618
 stac_fastapi/core/base_settings.py,sha256=R3_Sx7n5XpGMs3zAwFJD7y008WvGU_uI2xkaabm82Kg,239
 stac_fastapi/core/basic_auth.py,sha256=RhFv3RVSHF6OaqnaaU2DO4ncJ_S5nB1q8UNpnVJJsrk,2155
-stac_fastapi/core/core.py,sha256=f1-TJSH7Hl5MYTtdgjBUGUvFi7gFLex3MxU4ubYBqhI,48838
+stac_fastapi/core/core.py,sha256=0_H0QKQN-fkvzAidqGt8MvYfO2f_OF82pXXYs9HpQ_4,50387
 stac_fastapi/core/datetime_utils.py,sha256=TrTgbU7AKNC-ic4a3HptfE5XAc9tHR7uJasZyhOuwnc,2633
 stac_fastapi/core/rate_limit.py,sha256=Gu8dAaJReGsj1L91U6m2tflU6RahpXDRs2-AYSKoybA,1318
+stac_fastapi/core/redis_utils.py,sha256=hoghKhq7eHkqttU6T_Yq6uSWPPfgFjz9HrN8nMLJqNo,10440
 stac_fastapi/core/route_dependencies.py,sha256=hdtuMkv-zY1vg0YxiCz1aKP0SbBcORqDGEKDGgEazW8,5482
 stac_fastapi/core/serializers.py,sha256=ZW5hPgq-mftk6zxJeZGur-1Qxn7YGc3fJYFLsd-SYwM,7619
 stac_fastapi/core/session.py,sha256=aXqu4LXfVbAAsChMVXd9gAhczA2bZPne6HqPeklAwMY,474
 stac_fastapi/core/utilities.py,sha256=xXWO5oJCNDi7_C5jPYlHZD0B-DL-FN66eEUBUSW-cXw,7296
-stac_fastapi/core/version.py,sha256=zPQp-GtLh4R45hT8V_KAWzwZcP4-jyw7Xjms_eNMZBc,45
+stac_fastapi/core/version.py,sha256=GMc7YzxyWeUVpr_RMVlweeoH2lCLxOWemF-FOkqKXx8,45
 stac_fastapi/core/extensions/__init__.py,sha256=zSIAqou8jnakWPbkh4Ddcx1-oazZVBOs7U2PAakAdU0,291
 stac_fastapi/core/extensions/aggregation.py,sha256=v1hUHqlYuMqfQ554g3cTp16pUyRYucQxPERbHPAFtf8,1878
-stac_fastapi/core/extensions/collections_search.py,sha256=q7eRBykEqNRCiTfkmM_TobqKkxA3n1zQ7dYo37juE6s,6503
+stac_fastapi/core/extensions/collections_search.py,sha256=xpv51nffMq5a8grNSaLbv2IzeI5JH_pqcoWRbWhzn6Y,14406
 stac_fastapi/core/extensions/fields.py,sha256=NCT5XHvfaf297eDPNaIFsIzvJnbbUTpScqF0otdx0NA,1066
 stac_fastapi/core/extensions/filter.py,sha256=-NQGME7rR_ereuDx-LAa1M5JhEXFaKiTtkH2asraYHE,2998
 stac_fastapi/core/extensions/query.py,sha256=Xmo8pfZEZKPudZEjjozv3R0wLOP0ayjC9E67sBOXqWY,1803
 stac_fastapi/core/models/__init__.py,sha256=g-D1DiGfmC9Bg27DW9JzkN6fAvscv75wyhyiZ6NzvIk,48
 stac_fastapi/core/models/links.py,sha256=0dWSEMt3aa7NCISlHwo11zLBeIV1LwXG3JGjrXC3dZI,6672
 stac_fastapi/core/models/search.py,sha256=7SgAUyzHGXBXSqB4G6cwq9FMwoAS00momb7jvBkjyow,27
-stac_fastapi_core-6.6.0.dist-info/METADATA,sha256=h54wZw2qk4ZgGH7kFlwIFmxR3wgEHwoXJ3p69w-iOFs,2163
-stac_fastapi_core-6.6.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-stac_fastapi_core-6.6.0.dist-info/RECORD,,
+stac_fastapi_core-6.7.0.dist-info/METADATA,sha256=K8U8uKNxI9D5JM_ZIqaOV0wi0TLPgSwK9Qv4ca2VCb4,3494
+stac_fastapi_core-6.7.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+stac_fastapi_core-6.7.0.dist-info/RECORD,,