stac-fastapi-core 6.6.0__tar.gz → 6.7.1__tar.gz

{stac_fastapi_core-6.6.0 → stac_fastapi_core-6.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: stac_fastapi_core
-Version: 6.6.0
+Version: 6.7.1
 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.7.1/README.md

@@ -0,0 +1,32 @@
+# 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
+
+- **Package name**: stac-fastapi-core
+- **Description**: Core functionality for STAC API implementations.
+- **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
+
+```bash
+pip install stac-fastapi-core
+```
+
+## Quick Start
+
+For detailed usage and examples, please refer to the [main documentation](https://stac-utils.github.io/stac-fastapi-elasticsearch-opensearch/).

{stac_fastapi_core-6.6.0 → stac_fastapi_core-6.7.1}/pyproject.toml

@@ -44,6 +44,7 @@ dependencies = [
     "pygeofilter~=0.3.1",
     "jsonschema~=4.0.0",
     "slowapi~=0.1.9",
+    "redis==6.4.0",
 ]
 
 [project.urls]

{stac_fastapi_core-6.6.0 → stac_fastapi_core-6.7.1}/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-6.7.1/stac_fastapi/core/extensions/collections_search.py

@@ -0,0 +1,384 @@
+"""Collections search extension."""
+
+from typing import Any, Dict, List, Optional, Type, Union
+
+from fastapi import APIRouter, Body, FastAPI, Query, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+from stac_pydantic.api.search import ExtendedSearch
+from starlette.responses import Response
+
+from stac_fastapi.api.models import APIRequest
+from stac_fastapi.types.core import BaseCoreClient
+from stac_fastapi.types.extension import ApiExtension
+from stac_fastapi.types.stac import Collections
+
+
+class CollectionsSearchRequest(ExtendedSearch):
+    """Extended search model for collections with free text search support."""
+
+    q: Optional[Union[str, List[str]]] = None
+    token: Optional[str] = None
+    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):
+    """Collections search endpoint extension.
+
+    This extension adds a dedicated /collections-search endpoint for collection search operations.
+    """
+
+    def __init__(
+        self,
+        client: Optional[BaseCoreClient] = None,
+        settings: dict = None,
+        GET: Optional[Type[Union[BaseModel, APIRequest]]] = None,
+        POST: Optional[Type[Union[BaseModel, APIRequest]]] = None,
+        conformance_classes: Optional[List[str]] = None,
+    ):
+        """Initialize the extension.
+
+        Args:
+            client: Optional BaseCoreClient instance to use for this extension.
+            settings: Dictionary of settings to pass to the extension.
+            GET: Optional GET request model.
+            POST: Optional POST request model.
+            conformance_classes: Optional list of conformance classes to add to the API.
+        """
+        super().__init__()
+        self.client = client
+        self.settings = settings or {}
+        self.GET = GET
+        self.POST = POST
+        self.conformance_classes = conformance_classes or []
+        self.router = APIRouter()
+
+    def register(self, app: FastAPI) -> None:
+        """Register the extension with a FastAPI application.
+
+        Args:
+            app: target FastAPI application.
+
+        Returns:
+            None
+        """
+        # Remove any existing routes to avoid duplicates
+        self.router.routes = []
+
+        # 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(
+                path="/collections-search",
+                endpoint=documented_endpoint,
+                response_model=None,
+                response_class=JSONResponse,
+                methods=["GET"],
+                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(
+                path="/collections-search",
+                endpoint=documented_post_endpoint,
+                response_model=None,
+                response_class=JSONResponse,
+                methods=["POST"],
+                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]:
+        """GET /collections-search endpoint.
+
+        Args:
+            request: Request object.
+
+        Returns:
+            Collections: Collections object.
+        """
+        # Extract query parameters from the request
+        params = dict(request.query_params)
+
+        # Convert query parameters to appropriate types
+        if "limit" in params:
+            try:
+                params["limit"] = int(params["limit"])
+            except ValueError:
+                pass
+
+        # Handle fields parameter
+        if "fields" in params:
+            fields_str = params.pop("fields")
+            fields = fields_str.split(",")
+            params["fields"] = fields
+
+        # Handle sortby parameter
+        if "sortby" in params:
+            sortby_str = params.pop("sortby")
+            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
+
+    async def collections_search_post_endpoint(
+        self, request: Request, body: dict
+    ) -> Union[Collections, Response]:
+        """POST /collections-search endpoint.
+
+        Args:
+            request: Request object.
+            body: Search request body.
+
+        Returns:
+            Collections: Collections object.
+        """
+        # Convert the dict to an ExtendedSearch model
+        search_request = CollectionsSearchRequest.model_validate(body)
+
+        # Check if fields are present in the body
+        if "fields" in body:
+            # Extract fields from body and add them to search_request
+            if hasattr(search_request, "field"):
+                from stac_pydantic.api.extensions.fields import FieldsExtension
+
+                fields_data = body["fields"]
+                search_request.field = FieldsExtension(
+                    includes=fields_data.get("include"),
+                    excludes=fields_data.get("exclude"),
+                )
+
+        # Set the postbody on the request for pagination links
+        request.postbody = body
+
+        collections = await self.client.post_all_collections(
+            search_request=search_request, request=request
+        )
+
+        return collections
+
+    @classmethod
+    def from_extensions(
+        cls, extensions: List[ApiExtension]
+    ) -> "CollectionsSearchEndpointExtension":
+        """Create a CollectionsSearchEndpointExtension from a list of extensions.
+
+        Args:
+            extensions: List of extensions to include in the CollectionsSearchEndpointExtension.
+
+        Returns:
+            CollectionsSearchEndpointExtension: A new CollectionsSearchEndpointExtension instance.
+        """
+        from stac_fastapi.api.models import (
+            create_get_request_model,
+            create_post_request_model,
+        )
+
+        get_model = create_get_request_model(extensions)
+        post_model = create_post_request_model(extensions)
+
+        return cls(
+            GET=get_model,
+            POST=post_model,
+            conformance_classes=[
+                ext.conformance_classes
+                for ext in extensions
+                if hasattr(ext, "conformance_classes")
+            ],
+        )

stac_fastapi_core-6.7.1/stac_fastapi/core/redis_utils.py

@@ -0,0 +1,269 @@
+"""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, 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: Optional[int] = None
+    REDIS_RETRY_TIMEOUT: bool = True
+    REDIS_DECODE_RESPONSES: bool = True
+    REDIS_CLIENT_NAME: str = "stac-fastapi-app"
+    REDIS_HEALTH_CHECK_INTERVAL: int = Field(default=30, gt=0)
+    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_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: Optional[int] = None
+    REDIS_RETRY_TIMEOUT: bool = True
+    REDIS_DECODE_RESPONSES: bool = True
+    REDIS_CLIENT_NAME: str = "stac-fastapi-app"
+    REDIS_HEALTH_CHECK_INTERVAL: int = Field(default=30, gt=0)
+    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_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-6.6.0 → stac_fastapi_core-6.7.1}/stac_fastapi/core/version.py

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

stac_fastapi_core-6.6.0/README.md

@@ -1,20 +0,0 @@
-# stac-fastapi-core
-
-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
-
-- **Package name**: stac-fastapi-core
-- **Description**: Core functionality for STAC API implementations.
-- **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
-
-```bash
-pip install stac-fastapi-core
-```
-
-## Quick Start
-
-For detailed usage and examples, please refer to the [main documentation](https://stac-utils.github.io/stac-fastapi-elasticsearch-opensearch/).

stac_fastapi_core-6.6.0/stac_fastapi/core/extensions/collections_search.py

@@ -1,194 +0,0 @@
-"""Collections search extension."""
-
-from typing import List, Optional, Type, Union
-
-from fastapi import APIRouter, FastAPI, Request
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel
-from stac_pydantic.api.search import ExtendedSearch
-from starlette.responses import Response
-
-from stac_fastapi.api.models import APIRequest
-from stac_fastapi.types.core import BaseCoreClient
-from stac_fastapi.types.extension import ApiExtension
-from stac_fastapi.types.stac import Collections
-
-
-class CollectionsSearchRequest(ExtendedSearch):
-    """Extended search model for collections with free text search support."""
-
-    q: Optional[Union[str, List[str]]] = None
-    token: Optional[str] = None
-    query: Optional[
-        str
-    ] = None  # Legacy query extension (deprecated but still supported)
-
-
-class CollectionsSearchEndpointExtension(ApiExtension):
-    """Collections search endpoint extension.
-
-    This extension adds a dedicated /collections-search endpoint for collection search operations.
-    """
-
-    def __init__(
-        self,
-        client: Optional[BaseCoreClient] = None,
-        settings: dict = None,
-        GET: Optional[Type[Union[BaseModel, APIRequest]]] = None,
-        POST: Optional[Type[Union[BaseModel, APIRequest]]] = None,
-        conformance_classes: Optional[List[str]] = None,
-    ):
-        """Initialize the extension.
-
-        Args:
-            client: Optional BaseCoreClient instance to use for this extension.
-            settings: Dictionary of settings to pass to the extension.
-            GET: Optional GET request model.
-            POST: Optional POST request model.
-            conformance_classes: Optional list of conformance classes to add to the API.
-        """
-        super().__init__()
-        self.client = client
-        self.settings = settings or {}
-        self.GET = GET
-        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.
-
-        Args:
-            app: target FastAPI application.
-
-        Returns:
-            None
-        """
-        app.include_router(self.router)
-
-    def create_endpoints(self) -> None:
-        """Create endpoints for the extension."""
-        if self.GET:
-            self.router.add_api_route(
-                name="Get Collections Search",
-                path="/collections-search",
-                response_model=None,
-                response_class=JSONResponse,
-                methods=["GET"],
-                endpoint=self.collections_search_get_endpoint,
-                **(self.settings if isinstance(self.settings, dict) else {}),
-            )
-
-        if self.POST:
-            self.router.add_api_route(
-                name="Post Collections Search",
-                path="/collections-search",
-                response_model=None,
-                response_class=JSONResponse,
-                methods=["POST"],
-                endpoint=self.collections_search_post_endpoint,
-                **(self.settings if isinstance(self.settings, dict) else {}),
-            )
-
-    async def collections_search_get_endpoint(
-        self, request: Request
-    ) -> Union[Collections, Response]:
-        """GET /collections-search endpoint.
-
-        Args:
-            request: Request object.
-
-        Returns:
-            Collections: Collections object.
-        """
-        # Extract query parameters from the request
-        params = dict(request.query_params)
-
-        # Convert query parameters to appropriate types
-        if "limit" in params:
-            try:
-                params["limit"] = int(params["limit"])
-            except ValueError:
-                pass
-
-        # Handle fields parameter
-        if "fields" in params:
-            fields_str = params.pop("fields")
-            fields = fields_str.split(",")
-            params["fields"] = fields
-
-        # Handle sortby parameter
-        if "sortby" in params:
-            sortby_str = params.pop("sortby")
-            sortby = sortby_str.split(",")
-            params["sortby"] = sortby
-
-        collections = await self.client.all_collections(request=request, **params)
-        return collections
-
-    async def collections_search_post_endpoint(
-        self, request: Request, body: dict
-    ) -> Union[Collections, Response]:
-        """POST /collections-search endpoint.
-
-        Args:
-            request: Request object.
-            body: Search request body.
-
-        Returns:
-            Collections: Collections object.
-        """
-        # Convert the dict to an ExtendedSearch model
-        search_request = CollectionsSearchRequest.model_validate(body)
-
-        # Check if fields are present in the body
-        if "fields" in body:
-            # Extract fields from body and add them to search_request
-            if hasattr(search_request, "field"):
-                from stac_pydantic.api.extensions.fields import FieldsExtension
-
-                fields_data = body["fields"]
-                search_request.field = FieldsExtension(
-                    includes=fields_data.get("include"),
-                    excludes=fields_data.get("exclude"),
-                )
-
-        # Set the postbody on the request for pagination links
-        request.postbody = body
-
-        collections = await self.client.post_all_collections(
-            search_request=search_request, request=request
-        )
-
-        return collections
-
-    @classmethod
-    def from_extensions(
-        cls, extensions: List[ApiExtension]
-    ) -> "CollectionsSearchEndpointExtension":
-        """Create a CollectionsSearchEndpointExtension from a list of extensions.
-
-        Args:
-            extensions: List of extensions to include in the CollectionsSearchEndpointExtension.
-
-        Returns:
-            CollectionsSearchEndpointExtension: A new CollectionsSearchEndpointExtension instance.
-        """
-        from stac_fastapi.api.models import (
-            create_get_request_model,
-            create_post_request_model,
-        )
-
-        get_model = create_get_request_model(extensions)
-        post_model = create_post_request_model(extensions)
-
-        return cls(
-            GET=get_model,
-            POST=post_model,
-            conformance_classes=[
-                ext.conformance_classes
-                for ext in extensions
-                if hasattr(ext, "conformance_classes")
-            ],
-        )