search

stac_fastapi.types.search

stac_fastapi.types.search module.

APIRequest

Generic API Request base class.

Source code in stac_fastapi/types/search.py

@attr.s
class APIRequest:
    """Generic API Request base class."""

    def kwargs(self) -> Dict:
        """Transform api request params into format which matches the signature of the
        endpoint."""
        return self.__dict__

kwargs

kwargs() -> Dict

Transform api request params into format which matches the signature of the endpoint.

Source code in stac_fastapi/types/search.py

def kwargs(self) -> Dict:
    """Transform api request params into format which matches the signature of the
    endpoint."""
    return self.__dict__

BaseSearchGetRequest

Bases: APIRequest, DatetimeMixin

Base arguments for GET Request.

Source code in stac_fastapi/types/search.py

@attr.s
class BaseSearchGetRequest(APIRequest, DatetimeMixin):
    """Base arguments for GET Request."""

    collections: Optional[List[str]] = attr.ib(
        default=None, converter=_collection_converter
    )
    ids: Optional[List[str]] = attr.ib(default=None, converter=_ids_converter)
    bbox: Optional[BBox] = attr.ib(default=None, converter=_bbox_converter)
    intersects: Annotated[
        Optional[str],
        Query(
            description="""Only return items intersecting this GeoJSON Geometry. Mutually exclusive with **bbox**. \n
*Remember to URL encode the GeoJSON geometry when using GET request*.""",  # noqa: E501
            openapi_examples={
                "user-provided": {"value": None},
                "madrid": {
                    "value": {
                        "type": "Feature",
                        "properties": {},
                        "geometry": {
                            "coordinates": [
                                [
                                    [-3.8549260500072933, 40.54923557897152],
                                    [-3.8549260500072933, 40.29428000041938],
                                    [-3.516597069715033, 40.29428000041938],
                                    [-3.516597069715033, 40.54923557897152],
                                    [-3.8549260500072933, 40.54923557897152],
                                ]
                            ],
                            "type": "Polygon",
                        },
                    },
                },
                "new-york": {
                    "value": {
                        "type": "Feature",
                        "properties": {},
                        "geometry": {
                            "coordinates": [
                                [
                                    [-74.50117532354284, 41.128266394414055],
                                    [-74.50117532354284, 40.35633909727355],
                                    [-73.46713183168603, 40.35633909727355],
                                    [-73.46713183168603, 41.128266394414055],
                                    [-74.50117532354284, 41.128266394414055],
                                ]
                            ],
                            "type": "Polygon",
                        },
                    },
                },
            },
        ),
    ] = attr.ib(default=None)
    datetime: DateTimeQueryType = attr.ib(default=None, validator=_validate_datetime)
    limit: Annotated[
        Optional[Limit],
        Query(
            description="Limits the number of results that are included in each page of the response (capped to 10_000)."  # noqa: E501
        ),
    ] = attr.ib(default=10)

BaseSearchPostRequest

Bases: Search

Base arguments for POST Request.

Source code in stac_fastapi/types/search.py

class BaseSearchPostRequest(Search):
    """Base arguments for POST Request."""

    limit: Optional[Limit] = Field(
        10,
        description="Limits the number of results that are included in each page of the response (capped to 10_000).",  # noqa: E501
    )

DatetimeMixin

Datetime Mixin.

Source code in stac_fastapi/types/search.py

@attr.s
class DatetimeMixin:
    """Datetime Mixin."""

    datetime: DateTimeQueryType = attr.ib(default=None, validator=_validate_datetime)

    def parse_datetime(self) -> Optional[DateTimeType]:
        """Return Datetime objects."""
        return str_to_interval(self.datetime)

    @property
    def start_date(self) -> Optional[dt]:
        """Start Date."""
        parsed = self.parse_datetime()
        if parsed is None:
            return None

        return parsed[0] if isinstance(parsed, tuple) else parsed

    @property
    def end_date(self) -> Optional[dt]:
        """End Date."""
        parsed = self.parse_datetime()
        if parsed is None:
            return None

        return parsed[1] if isinstance(parsed, tuple) else None

end_date property

end_date: Optional[datetime]

End Date.

start_date property

start_date: Optional[datetime]

Start Date.

parse_datetime

parse_datetime() -> Optional[DateTimeType]

Return Datetime objects.

Source code in stac_fastapi/types/search.py

def parse_datetime(self) -> Optional[DateTimeType]:
    """Return Datetime objects."""
    return str_to_interval(self.datetime)

crop

crop(v: PositiveInt) -> PositiveInt

Crop value to 10,000.

Source code in stac_fastapi/types/search.py

def crop(v: PositiveInt) -> PositiveInt:
    """Crop value to 10,000."""
    limit = 10_000
    if v > limit:
        v = limit
    return v

str2bbox

str2bbox(x: str) -> Optional[BBox]

Convert string to BBox based on , delimiter.

Source code in stac_fastapi/types/search.py

def str2bbox(x: str) -> Optional[BBox]:
    """Convert string to BBox based on , delimiter."""
    if x:
        try:
            t = tuple(float(v) for v in x.split(","))
        except ValueError:
            raise HTTPException(status_code=400, detail=f"invalid bbox: {x}")

        if len(t) not in (4, 6):
            raise HTTPException(
                status_code=400, detail=f"BBox '{x}' must have 4 or 6 values."
            )

        return t

    return None

str2list

str2list(x: str) -> Optional[List[str]]

Convert string to list base on , delimiter.

Source code in stac_fastapi/types/search.py

def str2list(x: str) -> Optional[List[str]]:
    """Convert string to list base on , delimiter."""
    if x:
        return x.split(",")

    return None