stac-fastapi.core 3.0.0a3__tar.gz → 3.2.0__tar.gz

{stac_fastapi_core-3.0.0a3 → stac-fastapi.core-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.core
-Version: 3.0.0a3
+Version: 3.2.0
 Summary: Core library for the Elasticsearch and Opensearch stac-fastapi backends.
 Home-page: https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch
 License: MIT
@@ -15,19 +15,6 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: fastapi-slim
-Requires-Dist: attrs>=23.2.0
-Requires-Dist: pydantic[dotenv]
-Requires-Dist: stac_pydantic>=3
-Requires-Dist: stac-fastapi.types==3.0.0a4
-Requires-Dist: stac-fastapi.api==3.0.0a4
-Requires-Dist: stac-fastapi.extensions==3.0.0a4
-Requires-Dist: orjson
-Requires-Dist: overrides
-Requires-Dist: geojson-pydantic
-Requires-Dist: pygeofilter==0.2.1
-Requires-Dist: typing_extensions==4.8.0
-Requires-Dist: jsonschema
 
 # stac-fastapi-elasticsearch-opensearch (sfeos)
 
@@ -415,3 +402,7 @@ Available aggregations are:
 - geometry_geotile_grid_frequency ([geotile grid](https://opensearch.org/docs/latest/aggregations/bucket/geotile-grid/) on Item.geometry)
 
 Support for additional fields and new aggregations can be added in the associated `database_logic.py` file.
+
+## Rate Limiting
+
+Rate limiting is an optional security feature that controls API request frequency on a remote address basis. It's enabled by setting the `STAC_FASTAPI_RATE_LIMIT` environment variable, e.g., `500/minute`. This limits each client to 500 requests per minute, helping prevent abuse and maintain API stability. Implementation examples are available in the [examples/rate_limit](examples/rate_limit) directory.

{stac_fastapi_core-3.0.0a3 → stac-fastapi.core-3.2.0}/README.md

@@ -383,4 +383,8 @@ Available aggregations are:
 - geometry_geohash_grid_frequency ([geohash grid](https://opensearch.org/docs/latest/aggregations/bucket/geohash-grid/) on Item.geometry)
 - geometry_geotile_grid_frequency ([geotile grid](https://opensearch.org/docs/latest/aggregations/bucket/geotile-grid/) on Item.geometry)
 
-Support for additional fields and new aggregations can be added in the associated `database_logic.py` file.
+Support for additional fields and new aggregations can be added in the associated `database_logic.py` file.
+
+## Rate Limiting
+
+Rate limiting is an optional security feature that controls API request frequency on a remote address basis. It's enabled by setting the `STAC_FASTAPI_RATE_LIMIT` environment variable, e.g., `500/minute`. This limits each client to 500 requests per minute, helping prevent abuse and maintain API stability. Implementation examples are available in the [examples/rate_limit](examples/rate_limit) directory.

{stac_fastapi_core-3.0.0a3 → stac-fastapi.core-3.2.0}/setup.py

@@ -10,15 +10,16 @@ install_requires = [
     "attrs>=23.2.0",
     "pydantic[dotenv]",
     "stac_pydantic>=3",
-    "stac-fastapi.types==3.0.0a4",
-    "stac-fastapi.api==3.0.0a4",
-    "stac-fastapi.extensions==3.0.0a4",
+    "stac-fastapi.types==3.0.0",
+    "stac-fastapi.api==3.0.0",
+    "stac-fastapi.extensions==3.0.0",
     "orjson",
     "overrides",
     "geojson-pydantic",
     "pygeofilter==0.2.1",
     "typing_extensions==4.8.0",
     "jsonschema",
+    "slowapi==0.1.9",
 ]
 
 setup(

{stac_fastapi_core-3.0.0a3 → stac-fastapi.core-3.2.0}/stac_fastapi/core/core.py

@@ -1,6 +1,6 @@
 """Core client."""
+
 import logging
-import re
 from datetime import datetime as datetime_type
 from datetime import timezone
 from enum import Enum
@@ -279,8 +279,8 @@ class CoreClient(AsyncBaseCoreClient):
         collection_id: str,
         bbox: Optional[BBox] = None,
         datetime: Optional[DateTimeType] = None,
-        limit: int = 10,
-        token: str = None,
+        limit: Optional[int] = 10,
+        token: Optional[str] = None,
         **kwargs,
     ) -> stac_types.ItemCollection:
         """Read items from a specific collection in the database.
@@ -302,6 +302,8 @@ class CoreClient(AsyncBaseCoreClient):
             Exception: If any error occurs while reading the items from the database.
         """
         request: Request = kwargs["request"]
+        token = request.query_params.get("token")
+
         base_url = str(request.base_url)
 
         collection = await self.get_collection(
@@ -455,6 +457,7 @@ class CoreClient(AsyncBaseCoreClient):
         token: Optional[str] = None,
         fields: Optional[List[str]] = None,
         sortby: Optional[str] = None,
+        q: Optional[List[str]] = None,
         intersects: Optional[str] = None,
         filter: Optional[str] = None,
         filter_lang: Optional[str] = None,
@@ -472,6 +475,7 @@ class CoreClient(AsyncBaseCoreClient):
             token (Optional[str]): Access token to use when searching the catalog.
             fields (Optional[List[str]]): Fields to include or exclude from the results.
             sortby (Optional[str]): Sorting options for the results.
+            q (Optional[List[str]]): Free text query to filter the results.
             intersects (Optional[str]): GeoJSON geometry to search in.
             kwargs: Additional parameters to be passed to the API.
 
@@ -488,16 +492,9 @@ class CoreClient(AsyncBaseCoreClient):
             "limit": limit,
             "token": token,
             "query": orjson.loads(query) if query else query,
+            "q": q,
         }
 
-        # this is borrowed from stac-fastapi-pgstac
-        # Kludgy fix because using factory does not allow alias for filter-lan
-        query_params = str(request.query_params)
-        if filter_lang is None:
-            match = re.search(r"filter-lang=([a-z0-9-]+)", query_params, re.IGNORECASE)
-            if match:
-                filter_lang = match.group(1)
-
         if datetime:
             base_args["datetime"] = self._format_datetime_range(datetime)
 
@@ -606,6 +603,15 @@ class CoreClient(AsyncBaseCoreClient):
                     status_code=400, detail=f"Error with cql2_json filter: {e}"
                 )
 
+        if hasattr(search_request, "q"):
+            free_text_queries = getattr(search_request, "q", None)
+            try:
+                search = self.database.apply_free_text_filter(search, free_text_queries)
+            except Exception as e:
+                raise HTTPException(
+                    status_code=400, detail=f"Error with free text query: {e}"
+                )
+
         sort = None
         if search_request.sortby:
             sort = self.database.populate_sort(search_request.sortby)

{stac_fastapi_core-3.0.0a3 → stac-fastapi.core-3.2.0}/stac_fastapi/core/extensions/aggregation.py

@@ -1,6 +1,5 @@
 """Request model for the Aggregation extension."""
 
-import re
 from datetime import datetime
 from datetime import datetime as datetime_type
 from typing import Dict, List, Literal, Optional, Union
@@ -51,6 +50,7 @@ class EsAggregationExtensionGetRequest(
     centroid_geotile_grid_frequency_precision: Optional[int] = attr.ib(default=None)
     geometry_geohash_grid_frequency_precision: Optional[int] = attr.ib(default=None)
     geometry_geotile_grid_frequency_precision: Optional[int] = attr.ib(default=None)
+    datetime_frequency_interval: Optional[str] = attr.ib(default=None)
 
 
 class EsAggregationExtensionPostRequest(
@@ -63,6 +63,7 @@ class EsAggregationExtensionPostRequest(
     centroid_geotile_grid_frequency_precision: Optional[int] = None
     geometry_geohash_grid_frequency_precision: Optional[int] = None
     geometry_geotile_grid_frequency_precision: Optional[int] = None
+    datetime_frequency_interval: Optional[str] = None
 
 
 @attr.s
@@ -125,6 +126,8 @@ class EsAsyncAggregationClient(AsyncBaseAggregationClient):
     MAX_GEOHASH_PRECISION = 12
     MAX_GEOHEX_PRECISION = 15
     MAX_GEOTILE_PRECISION = 29
+    SUPPORTED_DATETIME_INTERVAL = {"day", "month", "year"}
+    DEFAULT_DATETIME_INTERVAL = "month"
 
     async def get_aggregations(self, collection_id: Optional[str] = None, **kwargs):
         """Get the available aggregations for a catalog or collection defined in the STAC JSON. If no aggregations, default aggregations are used."""
@@ -144,7 +147,7 @@ class EsAsyncAggregationClient(AsyncBaseAggregationClient):
                     {
                         "rel": "self",
                         "type": "application/json",
-                        "href": urljoin(collection_endpoint, "aggregations"),
+                        "href": urljoin(collection_endpoint + "/", "aggregations"),
                     },
                 ]
             )
@@ -183,6 +186,30 @@ class EsAsyncAggregationClient(AsyncBaseAggregationClient):
         else:
             return min_value
 
+    def extract_date_histogram_interval(self, value: Optional[str]) -> str:
+        """
+        Ensure that the interval for the date histogram is valid. If no value is provided, the default will be returned.
+
+        Args:
+            value: value entered by the user
+
+        Returns:
+            string containing the date histogram interval to use.
+
+        Raises:
+            HTTPException: if the supplied value is not in the supported intervals
+        """
+        if value is not None:
+            if value not in self.SUPPORTED_DATETIME_INTERVAL:
+                raise HTTPException(
+                    status_code=400,
+                    detail=f"Invalid datetime interval. Must be one of {self.SUPPORTED_DATETIME_INTERVAL}",
+                )
+            else:
+                return value
+        else:
+            return self.DEFAULT_DATETIME_INTERVAL
+
     @staticmethod
     def _return_date(
         interval: Optional[Union[DateTimeType, str]]
@@ -271,7 +298,7 @@ class EsAsyncAggregationClient(AsyncBaseAggregationClient):
     def get_filter(self, filter, filter_lang):
         """Format the filter parameter in cql2-json or cql2-text."""
         if filter_lang == "cql2-text":
-            return orjson.loads(unquote_plus(to_cql2(parse_cql2_text(filter))))
+            return orjson.loads(to_cql2(parse_cql2_text(filter)))
         elif filter_lang == "cql2-json":
             if isinstance(filter, str):
                 return orjson.loads(unquote_plus(filter))
@@ -320,6 +347,7 @@ class EsAsyncAggregationClient(AsyncBaseAggregationClient):
         centroid_geotile_grid_frequency_precision: Optional[int] = None,
         geometry_geohash_grid_frequency_precision: Optional[int] = None,
         geometry_geotile_grid_frequency_precision: Optional[int] = None,
+        datetime_frequency_interval: Optional[str] = None,
         **kwargs,
     ) -> Union[Dict, Exception]:
         """Get aggregations from the database."""
@@ -340,6 +368,7 @@ class EsAsyncAggregationClient(AsyncBaseAggregationClient):
                 "centroid_geotile_grid_frequency_precision": centroid_geotile_grid_frequency_precision,
                 "geometry_geohash_grid_frequency_precision": geometry_geohash_grid_frequency_precision,
                 "geometry_geotile_grid_frequency_precision": geometry_geotile_grid_frequency_precision,
+                "datetime_frequency_interval": datetime_frequency_interval,
             }
 
             if collection_id:
@@ -351,18 +380,6 @@ class EsAsyncAggregationClient(AsyncBaseAggregationClient):
             if datetime:
                 base_args["datetime"] = self._format_datetime_range(datetime)
 
-            # this is borrowed from stac-fastapi-pgstac
-            # Kludgy fix because using factory does not allow alias for filter-lang
-            # If the value is the default, check if the request is different.
-            query_params = str(request.query_params)
-            if filter_lang is None:
-                match = re.search(
-                    r"filter-lang=([a-z0-9-]+)", query_params, re.IGNORECASE
-                )
-                if match:
-                    filter_lang = match.group(1)
-                else:
-                    filter_lang = "cql2-text"
             if filter:
                 base_args["filter"] = self.get_filter(filter, filter_lang)
             aggregate_request = EsAggregationExtensionPostRequest(**base_args)
@@ -447,6 +464,8 @@ class EsAsyncAggregationClient(AsyncBaseAggregationClient):
                         status_code=400,
                         detail=f"Aggregation {agg_name} not supported at catalog level",
                     )
+
+        if aggregate_request.filter:
             try:
                 search = self.database.apply_cql2_filter(
                     search, aggregate_request.filter
@@ -486,6 +505,10 @@ class EsAsyncAggregationClient(AsyncBaseAggregationClient):
             self.MAX_GEOTILE_PRECISION,
         )
 
+        datetime_frequency_interval = self.extract_date_histogram_interval(
+            aggregate_request.datetime_frequency_interval,
+        )
+
         try:
             db_response = await self.database.aggregate(
                 collections,
@@ -496,6 +519,7 @@ class EsAsyncAggregationClient(AsyncBaseAggregationClient):
                 centroid_geotile_grid_precision,
                 geometry_geohash_grid_precision,
                 geometry_geotile_grid_precision,
+                datetime_frequency_interval,
             )
         except Exception as error:
             if not isinstance(error, IndexError):

{stac_fastapi_core-3.0.0a3 → stac-fastapi.core-3.2.0}/stac_fastapi/core/extensions/filter.py

@@ -17,31 +17,41 @@ import re
 from enum import Enum
 from typing import Any, Dict
 
+_cql2_like_patterns = re.compile(r"\\.|[%_]|\\$")
+_valid_like_substitutions = {
+    "\\\\": "\\",
+    "\\%": "%",
+    "\\_": "_",
+    "%": "*",
+    "_": "?",
+}
+
+
+def _replace_like_patterns(match: re.Match) -> str:
+    pattern = match.group()
+    try:
+        return _valid_like_substitutions[pattern]
+    except KeyError:
+        raise ValueError(f"'{pattern}' is not a valid escape sequence")
+
 
 def cql2_like_to_es(string: str) -> str:
     """
-    Convert CQL2 wildcard characters to Elasticsearch wildcard characters. Specifically, it converts '_' to '?' and '%' to '*', handling escape characters properly.
+    Convert CQL2 "LIKE" characters to Elasticsearch "wildcard" characters.
 
     Args:
         string (str): The string containing CQL2 wildcard characters.
 
     Returns:
         str: The converted string with Elasticsearch compatible wildcards.
+
+    Raises:
+        ValueError: If an invalid escape sequence is encountered.
     """
-    # Translate '%' and '_' only if they are not preceded by a backslash '\'
-    percent_pattern = r"(?<!\\)%"
-    underscore_pattern = r"(?<!\\)_"
-    # Remove the escape character before '%' or '_'
-    escape_pattern = r"\\(?=[_%])"
-
-    # Replace '%' with '*' for broad wildcard matching
-    string = re.sub(percent_pattern, "*", string)
-    # Replace '_' with '?' for single character wildcard matching
-    string = re.sub(underscore_pattern, "?", string)
-    # Remove the escape character used in the CQL2 format
-    string = re.sub(escape_pattern, "", string)
-
-    return string
+    return _cql2_like_patterns.sub(
+        repl=_replace_like_patterns,
+        string=string,
+    )
 
 
 class LogicalOp(str, Enum):

{stac_fastapi_core-3.0.0a3 → stac-fastapi.core-3.2.0}/stac_fastapi/core/models/links.py

@@ -114,6 +114,14 @@ class CollectionLinks(BaseLinks):
     collection_id: str = attr.ib()
     extensions: List[str] = attr.ib(default=attr.Factory(list))
 
+    def link_self(self) -> Dict:
+        """Return the self link."""
+        return dict(
+            rel=Relations.self.value,
+            type=MimeTypes.json.value,
+            href=urljoin(self.base_url, f"collections/{self.collection_id}"),
+        )
+
     def link_parent(self) -> Dict[str, Any]:
         """Create the `parent` link."""
         return dict(rel=Relations.parent, type=MimeTypes.json.value, href=self.base_url)

stac-fastapi.core-3.2.0/stac_fastapi/core/rate_limit.py

@@ -0,0 +1,44 @@
+"""Rate limiting middleware."""
+
+import logging
+import os
+from typing import Optional
+
+from fastapi import FastAPI, Request
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.errors import RateLimitExceeded
+from slowapi.middleware import SlowAPIMiddleware
+from slowapi.util import get_remote_address
+
+logger = logging.getLogger(__name__)
+
+
+def get_limiter(key_func=get_remote_address):
+    """Create and return a Limiter instance for rate limiting."""
+    return Limiter(key_func=key_func)
+
+
+def setup_rate_limit(
+    app: FastAPI, rate_limit: Optional[str] = None, key_func=get_remote_address
+):
+    """Set up rate limiting middleware."""
+    RATE_LIMIT = rate_limit or os.getenv("STAC_FASTAPI_RATE_LIMIT")
+
+    if not RATE_LIMIT:
+        logger.info("Rate limiting is disabled")
+        return
+
+    logger.info(f"Setting up rate limit with RATE_LIMIT={RATE_LIMIT}")
+
+    limiter = get_limiter(key_func)
+    app.state.limiter = limiter
+    app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+    app.add_middleware(SlowAPIMiddleware)
+
+    @app.middleware("http")
+    @limiter.limit(RATE_LIMIT)
+    async def rate_limit_middleware(request: Request, call_next):
+        response = await call_next(request)
+        return response
+
+    logger.info("Rate limit setup complete")

stac-fastapi.core-3.2.0/stac_fastapi/core/version.py

@@ -0,0 +1,2 @@
+"""library version."""
+__version__ = "3.2.0"

{stac_fastapi_core-3.0.0a3 → stac-fastapi.core-3.2.0}/stac_fastapi.core.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: stac-fastapi.core
-Version: 3.0.0a3
+Version: 3.2.0
 Summary: Core library for the Elasticsearch and Opensearch stac-fastapi backends.
 Home-page: https://github.com/stac-utils/stac-fastapi-elasticsearch-opensearch
 License: MIT
@@ -15,19 +15,6 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: License :: OSI Approved :: MIT License
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
-Requires-Dist: fastapi-slim
-Requires-Dist: attrs>=23.2.0
-Requires-Dist: pydantic[dotenv]
-Requires-Dist: stac_pydantic>=3
-Requires-Dist: stac-fastapi.types==3.0.0a4
-Requires-Dist: stac-fastapi.api==3.0.0a4
-Requires-Dist: stac-fastapi.extensions==3.0.0a4
-Requires-Dist: orjson
-Requires-Dist: overrides
-Requires-Dist: geojson-pydantic
-Requires-Dist: pygeofilter==0.2.1
-Requires-Dist: typing_extensions==4.8.0
-Requires-Dist: jsonschema
 
 # stac-fastapi-elasticsearch-opensearch (sfeos)
 
@@ -415,3 +402,7 @@ Available aggregations are:
 - geometry_geotile_grid_frequency ([geotile grid](https://opensearch.org/docs/latest/aggregations/bucket/geotile-grid/) on Item.geometry)
 
 Support for additional fields and new aggregations can be added in the associated `database_logic.py` file.
+
+## Rate Limiting
+
+Rate limiting is an optional security feature that controls API request frequency on a remote address basis. It's enabled by setting the `STAC_FASTAPI_RATE_LIMIT` environment variable, e.g., `500/minute`. This limits each client to 500 requests per minute, helping prevent abuse and maintain API stability. Implementation examples are available in the [examples/rate_limit](examples/rate_limit) directory.

{stac_fastapi_core-3.0.0a3 → stac-fastapi.core-3.2.0}/stac_fastapi.core.egg-info/SOURCES.txt

@@ -13,6 +13,7 @@ stac_fastapi/core/base_settings.py
 stac_fastapi/core/basic_auth.py
 stac_fastapi/core/core.py
 stac_fastapi/core/datetime_utils.py
+stac_fastapi/core/rate_limit.py
 stac_fastapi/core/route_dependencies.py
 stac_fastapi/core/serializers.py
 stac_fastapi/core/session.py

{stac_fastapi_core-3.0.0a3 → stac-fastapi.core-3.2.0}/stac_fastapi.core.egg-info/requires.txt

@@ -2,12 +2,13 @@ fastapi-slim
 attrs>=23.2.0
 pydantic[dotenv]
 stac_pydantic>=3
-stac-fastapi.types==3.0.0a4
-stac-fastapi.api==3.0.0a4
-stac-fastapi.extensions==3.0.0a4
+stac-fastapi.types==3.0.0
+stac-fastapi.api==3.0.0
+stac-fastapi.extensions==3.0.0
 orjson
 overrides
 geojson-pydantic
 pygeofilter==0.2.1
 typing_extensions==4.8.0
 jsonschema
+slowapi==0.1.9

{stac_fastapi_core-3.0.0a3 → stac-fastapi.core-3.2.0}/stac_fastapi.core.egg-info/top_level.txt

@@ -1,2 +1 @@
-dist
 stac_fastapi

stac_fastapi_core-3.0.0a3/stac_fastapi/core/version.py

@@ -1,2 +0,0 @@
-"""library version."""
-__version__ = "3.0.0a3"