stac-fastapi-opensearch 4.0.0__py3-none-any.whl

stac_fastapi/opensearch/__init__.py

@@ -0,0 +1 @@
+"""opensearch submodule."""

stac_fastapi/opensearch/app.py

@@ -0,0 +1,150 @@
+"""FastAPI application."""
+
+import os
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI
+
+from stac_fastapi.api.app import StacApi
+from stac_fastapi.api.models import create_get_request_model, create_post_request_model
+from stac_fastapi.core.core import (
+    BulkTransactionsClient,
+    CoreClient,
+    EsAsyncBaseFiltersClient,
+    TransactionsClient,
+)
+from stac_fastapi.core.extensions import QueryExtension
+from stac_fastapi.core.extensions.aggregation import (
+    EsAggregationExtensionGetRequest,
+    EsAggregationExtensionPostRequest,
+    EsAsyncAggregationClient,
+)
+from stac_fastapi.core.extensions.fields import FieldsExtension
+from stac_fastapi.core.rate_limit import setup_rate_limit
+from stac_fastapi.core.route_dependencies import get_route_dependencies
+from stac_fastapi.core.session import Session
+from stac_fastapi.extensions.core import (
+    AggregationExtension,
+    FilterExtension,
+    FreeTextExtension,
+    SortExtension,
+    TokenPaginationExtension,
+    TransactionExtension,
+)
+from stac_fastapi.extensions.third_party import BulkTransactionExtension
+from stac_fastapi.opensearch.config import OpensearchSettings
+from stac_fastapi.opensearch.database_logic import (
+    DatabaseLogic,
+    create_collection_index,
+    create_index_templates,
+)
+
+settings = OpensearchSettings()
+session = Session.create_from_settings(settings)
+
+database_logic = DatabaseLogic()
+
+filter_extension = FilterExtension(
+    client=EsAsyncBaseFiltersClient(database=database_logic)
+)
+filter_extension.conformance_classes.append(
+    "http://www.opengis.net/spec/cql2/1.0/conf/advanced-comparison-operators"
+)
+
+aggregation_extension = AggregationExtension(
+    client=EsAsyncAggregationClient(
+        database=database_logic, session=session, settings=settings
+    )
+)
+aggregation_extension.POST = EsAggregationExtensionPostRequest
+aggregation_extension.GET = EsAggregationExtensionGetRequest
+
+search_extensions = [
+    TransactionExtension(
+        client=TransactionsClient(
+            database=database_logic, session=session, settings=settings
+        ),
+        settings=settings,
+    ),
+    BulkTransactionExtension(
+        client=BulkTransactionsClient(
+            database=database_logic,
+            session=session,
+            settings=settings,
+        )
+    ),
+    FieldsExtension(),
+    QueryExtension(),
+    SortExtension(),
+    TokenPaginationExtension(),
+    filter_extension,
+    FreeTextExtension(),
+]
+
+extensions = [aggregation_extension] + search_extensions
+
+database_logic.extensions = [type(ext).__name__ for ext in extensions]
+
+post_request_model = create_post_request_model(search_extensions)
+
+api = StacApi(
+    title=os.getenv("STAC_FASTAPI_TITLE", "stac-fastapi-opensearch"),
+    description=os.getenv("STAC_FASTAPI_DESCRIPTION", "stac-fastapi-opensearch"),
+    api_version=os.getenv("STAC_FASTAPI_VERSION", "4.0.0"),
+    settings=settings,
+    extensions=extensions,
+    client=CoreClient(
+        database=database_logic, session=session, post_request_model=post_request_model
+    ),
+    search_get_request_model=create_get_request_model(search_extensions),
+    search_post_request_model=post_request_model,
+    route_dependencies=get_route_dependencies(),
+)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    """Lifespan handler for FastAPI app. Initializes index templates and collections at startup."""
+    await create_index_templates()
+    await create_collection_index()
+    yield
+
+
+app = api.app
+app.router.lifespan_context = lifespan
+app.root_path = os.getenv("STAC_FASTAPI_ROOT_PATH", "")
+# Add rate limit
+setup_rate_limit(app, rate_limit=os.getenv("STAC_FASTAPI_RATE_LIMIT"))
+
+
+def run() -> None:
+    """Run app from command line using uvicorn if available."""
+    try:
+        import uvicorn
+
+        uvicorn.run(
+            "stac_fastapi.opensearch.app:app",
+            host=settings.app_host,
+            port=settings.app_port,
+            log_level="info",
+            reload=settings.reload,
+        )
+    except ImportError:
+        raise RuntimeError("Uvicorn must be installed in order to use command")
+
+
+if __name__ == "__main__":
+    run()
+
+
+def create_handler(app):
+    """Create a handler to use with AWS Lambda if mangum available."""
+    try:
+        from mangum import Mangum
+
+        return Mangum(app)
+    except ImportError:
+        return None
+
+
+handler = create_handler(app)

stac_fastapi/opensearch/config.py

@@ -0,0 +1,121 @@
+"""API configuration."""
+import logging
+import os
+import ssl
+from typing import Any, Dict, Set
+
+import certifi
+from opensearchpy import AsyncOpenSearch, OpenSearch
+
+from stac_fastapi.core.base_settings import ApiBaseSettings
+from stac_fastapi.core.utilities import get_bool_env
+from stac_fastapi.types.config import ApiSettings
+
+
+def _es_config() -> Dict[str, Any]:
+    # Determine the scheme (http or https)
+    use_ssl = get_bool_env("ES_USE_SSL", default=True)
+    scheme = "https" if use_ssl else "http"
+
+    # Configure the hosts parameter with the correct scheme
+    es_hosts = os.getenv(
+        "ES_HOST", "localhost"
+    ).strip()  # Default to localhost if ES_HOST is not set
+    es_port = os.getenv("ES_PORT", "9200")  # Default to 9200 if ES_PORT is not set
+
+    # Validate ES_HOST
+    if not es_hosts:
+        raise ValueError("ES_HOST environment variable is empty or invalid.")
+
+    hosts = [f"{scheme}://{host.strip()}:{es_port}" for host in es_hosts.split(",")]
+
+    # Initialize the configuration dictionary
+    config: Dict[str, Any] = {
+        "hosts": hosts,
+        "headers": {"accept": "application/json", "Content-Type": "application/json"},
+    }
+
+    http_compress = get_bool_env("ES_HTTP_COMPRESS", default=True)
+    if http_compress:
+        config["http_compress"] = True
+
+    # Explicitly exclude SSL settings when not using SSL
+    if not use_ssl:
+        return config
+
+    # Include SSL settings if using https
+    config["ssl_version"] = ssl.PROTOCOL_SSLv23
+    config["verify_certs"] = get_bool_env("ES_VERIFY_CERTS", default=True)
+
+    # Include CA Certificates if verifying certs
+    if config["verify_certs"]:
+        config["ca_certs"] = os.getenv("CURL_CA_BUNDLE", certifi.where())
+
+    # Handle authentication
+    if (u := os.getenv("ES_USER")) and (p := os.getenv("ES_PASS")):
+        config["http_auth"] = (u, p)
+
+    if api_key := os.getenv("ES_API_KEY"):
+        if isinstance(config["headers"], dict):
+            headers = {**config["headers"], "x-api-key": api_key}
+
+        else:
+            config["headers"] = {"x-api-key": api_key}
+
+        config["headers"] = headers
+
+    return config
+
+
+_forbidden_fields: Set[str] = {"type"}
+
+
+class OpensearchSettings(ApiSettings, ApiBaseSettings):
+    """
+    API settings.
+
+    Set enable_direct_response via the ENABLE_DIRECT_RESPONSE environment variable.
+    If enabled, all API routes use direct response for maximum performance, but ALL FastAPI dependencies (including authentication, custom status codes, and validation) are disabled.
+    Default is False for safety.
+    """
+
+    forbidden_fields: Set[str] = _forbidden_fields
+    indexed_fields: Set[str] = {"datetime"}
+    enable_response_models: bool = False
+    enable_direct_response: bool = get_bool_env("ENABLE_DIRECT_RESPONSE", default=False)
+
+    @property
+    def create_client(self):
+        """Create es client."""
+        return OpenSearch(**_es_config())
+
+
+class AsyncOpensearchSettings(ApiSettings, ApiBaseSettings):
+    """
+    API settings.
+
+    Set enable_direct_response via the ENABLE_DIRECT_RESPONSE environment variable.
+    If enabled, all API routes use direct response for maximum performance, but ALL FastAPI dependencies (including authentication, custom status codes, and validation) are disabled.
+    Default is False for safety.
+    """
+
+    forbidden_fields: Set[str] = _forbidden_fields
+    indexed_fields: Set[str] = {"datetime"}
+    enable_response_models: bool = False
+    enable_direct_response: bool = get_bool_env("ENABLE_DIRECT_RESPONSE", default=False)
+
+    @property
+    def create_client(self):
+        """Create async elasticsearch client."""
+        return AsyncOpenSearch(**_es_config())
+
+
+# Warn at import if direct response is enabled (applies to either settings class)
+if (
+    OpensearchSettings().enable_direct_response
+    or AsyncOpensearchSettings().enable_direct_response
+):
+    logging.basicConfig(level=logging.WARNING)
+    logging.warning(
+        "ENABLE_DIRECT_RESPONSE is True: All FastAPI dependencies (including authentication) are DISABLED for all routes!"
+    )