Module stac_fastapi.pgstac.app¶
FastAPI application using PGStac.
Enables the extensions specified as a comma-delimited list in
the ENABLED_EXTENSIONS environment variable (e.g. transactions,sort,query
).
If the variable is not set, enables all extensions.
Variables¶
api
app
collection_extensions_map
collection_search_extension
enabled_extensions
extensions
extensions_map
handler
settings
Functions¶
create_handler¶
def create_handler(
app
)
Create a handler to use with AWS Lambda if mangum available.
run¶
def run(
)
Run app from command line using uvicorn if available.
shutdown_event¶
def shutdown_event(
)
Close database connection.
startup_event¶
def startup_event(
)
Connect to database on startup.
Classes¶
collections_get_request_model¶
class collections_get_request_model(
bbox: Annotated[Optional[str], Query(PydanticUndefined)] = None,
datetime: Annotated[Optional[str], Query(PydanticUndefined)] = None,
limit: Annotated[Optional[Annotated[int, Gt(gt=0), AfterValidator(func=<function crop at 0x7f4d777da7a0>)]], Query(PydanticUndefined)] = 10,
query: Annotated[Optional[str], Query(PydanticUndefined)] = None,
sortby: Annotated[Optional[str], Query(PydanticUndefined)] = None,
fields: Annotated[Optional[str], Query(PydanticUndefined)] = None,
filter: Annotated[Optional[str], Query(PydanticUndefined)] = None,
filter_crs: Annotated[Optional[str], Query(PydanticUndefined)] = None,
filter_lang: Annotated[Optional[Literal['cql-json', 'cql2-json', 'cql2-text']], Query(PydanticUndefined)] = 'cql2-text'
)
Basics additional Collection-Search parameters for the GET request.
Ancestors (in MRO)¶
- stac_fastapi.extensions.core.collection_search.request.BaseCollectionSearchGetRequest
- stac_fastapi.extensions.core.query.request.QueryExtensionGetRequest
- stac_fastapi.extensions.core.sort.request.SortExtensionGetRequest
- stac_fastapi.extensions.core.fields.request.FieldsExtensionGetRequest
- stac_fastapi.extensions.core.filter.request.FilterExtensionGetRequest
- stac_fastapi.types.search.APIRequest
Methods¶
kwargs¶
def kwargs(
self
) -> Dict
Transform api request params into format which matches the signature of the
endpoint.
get_request_model¶
class get_request_model(
collections: Annotated[Optional[str], Query(PydanticUndefined)] = None,
ids: Annotated[Optional[str], Query(PydanticUndefined)] = None,
bbox: Annotated[Optional[str], Query(PydanticUndefined)] = None,
intersects: Annotated[Optional[str], Query(PydanticUndefined)] = None,
datetime: Annotated[Optional[str], Query(PydanticUndefined)] = None,
limit: Annotated[Optional[Annotated[int, Gt(gt=0), AfterValidator(func=<function crop at 0x7f4d777da7a0>)]], Query(PydanticUndefined)] = 10,
query: Annotated[Optional[str], Query(PydanticUndefined)] = None,
sortby: Annotated[Optional[str], Query(PydanticUndefined)] = None,
fields: Annotated[Optional[str], Query(PydanticUndefined)] = None,
token: Annotated[Optional[str], Query(PydanticUndefined)] = None,
filter: Annotated[Optional[str], Query(PydanticUndefined)] = None,
filter_crs: Annotated[Optional[str], Query(PydanticUndefined)] = None,
filter_lang: Annotated[Optional[Literal['cql-json', 'cql2-json', 'cql2-text']], Query(PydanticUndefined)] = 'cql2-text'
)
Base arguments for GET Request.
Ancestors (in MRO)¶
- stac_fastapi.types.search.BaseSearchGetRequest
- stac_fastapi.extensions.core.query.request.QueryExtensionGetRequest
- stac_fastapi.extensions.core.sort.request.SortExtensionGetRequest
- stac_fastapi.extensions.core.fields.request.FieldsExtensionGetRequest
- stac_fastapi.extensions.core.pagination.request.GETTokenPagination
- stac_fastapi.extensions.core.filter.request.FilterExtensionGetRequest
- stac_fastapi.types.search.APIRequest
Methods¶
kwargs¶
def kwargs(
self
) -> Dict
Transform api request params into format which matches the signature of the
endpoint.
items_get_request_model¶
class items_get_request_model(
collection_id: typing.Annotated[str, Path(PydanticUndefined)],
limit: Annotated[Optional[Annotated[int, Gt(gt=0), AfterValidator(func=<function crop at 0x7f4d777da7a0>)]], Query(PydanticUndefined)] = 10,
bbox: Annotated[Optional[str], Query(PydanticUndefined)] = None,
datetime: Annotated[Optional[str], Query(PydanticUndefined)] = None,
token: Annotated[Optional[str], Query(PydanticUndefined)] = None
)
Get item collection.
Ancestors (in MRO)¶
- stac_fastapi.api.models.ItemCollectionUri
- stac_fastapi.extensions.core.pagination.request.GETTokenPagination
- stac_fastapi.types.search.APIRequest
Methods¶
kwargs¶
def kwargs(
self
) -> Dict
Transform api request params into format which matches the signature of the
endpoint.
post_request_model¶
class post_request_model(
/,
**data: 'Any'
)
Search model.
Overrides the validation for datetime from the base request model.
Ancestors (in MRO)¶
- stac_fastapi.pgstac.types.search.PgstacSearch
- stac_fastapi.types.search.BaseSearchPostRequest
- stac_pydantic.api.search.Search
- pydantic.main.BaseModel
Class variables¶
model_computed_fields
model_config
model_fields
Static methods¶
construct¶
def construct(
_fields_set: 'set[str] | None' = None,
**values: 'Any'
) -> 'Self'
from_orm¶
def from_orm(
obj: 'Any'
) -> 'Self'
model_construct¶
def model_construct(
_fields_set: 'set[str] | None' = None,
**values: 'Any'
) -> 'Self'
Creates a new instance of the Model
class with validated data.
Creates a new model setting __dict__
and __pydantic_fields_set__
from trusted or pre-validated data.
Default values are respected, but no other validation is performed.
Note
model_construct()
generally respects the model_config.extra
setting on the provided model.
That is, if model_config.extra == 'allow'
, then all extra passed values are added to the model instance's __dict__
and __pydantic_extra__
fields. If model_config.extra == 'ignore'
(the default), then all extra passed values are ignored.
Because no validation is performed with a call to model_construct()
, having model_config.extra == 'forbid'
does not result in
an error if extra values are passed, but they will be ignored.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
_fields_set | None | A set of field names that were originally explicitly set during instantiation. If provided, this is directly used for the [ model_fields_set ][pydantic.BaseModel.model_fields_set] attribute.Otherwise, the field names from the values argument will be used. |
None |
values | None | Trusted or pre-validated data dictionary. | None |
Returns:
Type | Description |
---|---|
None | A new instance of the Model class with validated data. |
model_json_schema¶
def model_json_schema(
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}',
schema_generator: 'type[GenerateJsonSchema]' = <class 'pydantic.json_schema.GenerateJsonSchema'>,
mode: 'JsonSchemaMode' = 'validation'
) -> 'dict[str, Any]'
Generates a JSON schema for a model class.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
by_alias | None | Whether to use attribute aliases or not. | None |
ref_template | None | The reference template. | None |
schema_generator | None | To override the logic used to generate the JSON schema, as a subclass ofGenerateJsonSchema with your desired modifications |
None |
mode | None | The mode in which to generate the schema. | None |
Returns:
Type | Description |
---|---|
None | The JSON schema for the given model class. |
model_parametrized_name¶
def model_parametrized_name(
params: 'tuple[type[Any], ...]'
) -> 'str'
Compute the class name for parametrizations of generic classes.
This method can be overridden to achieve a custom naming scheme for generic BaseModels.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
params | None | Tuple of types of the class. Given a generic classModel with 2 type variables and a concrete model Model[str, int] ,the value (str, int) would be passed to params . |
None |
Returns:
Type | Description |
---|---|
None | String representing the new class where params are passed to cls as type variables. |
Raises:
Type | Description |
---|---|
TypeError | Raised when trying to generate concrete names for non-generic models. |
model_rebuild¶
def model_rebuild(
*,
force: 'bool' = False,
raise_errors: 'bool' = True,
_parent_namespace_depth: 'int' = 2,
_types_namespace: 'dict[str, Any] | None' = None
) -> 'bool | None'
Try to rebuild the pydantic-core schema for the model.
This may be necessary when one of the annotations is a ForwardRef which could not be resolved during the initial attempt to build the schema, and automatic rebuilding fails.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
force | None | Whether to force the rebuilding of the model schema, defaults to False . |
None |
raise_errors | None | Whether to raise errors, defaults to True . |
None |
_parent_namespace_depth | None | The depth level of the parent namespace, defaults to 2. | None |
_types_namespace | None | The types namespace, defaults to None . |
None |
Returns:
Type | Description |
---|---|
None | Returns None if the schema is already "complete" and rebuilding was not required.If rebuilding was required, returns True if rebuilding was successful, otherwise False . |
model_validate¶
def model_validate(
obj: 'Any',
*,
strict: 'bool | None' = None,
from_attributes: 'bool | None' = None,
context: 'Any | None' = None
) -> 'Self'
Validate a pydantic model instance.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
obj | None | The object to validate. | None |
strict | None | Whether to enforce types strictly. | None |
from_attributes | None | Whether to extract data from object attributes. | None |
context | None | Additional context to pass to the validator. | None |
Returns:
Type | Description |
---|---|
None | The validated model instance. |
Raises:
Type | Description |
---|---|
ValidationError | If the object could not be validated. |
model_validate_json¶
def model_validate_json(
json_data: 'str | bytes | bytearray',
*,
strict: 'bool | None' = None,
context: 'Any | None' = None
) -> 'Self'
Usage docs: docs.pydantic.dev/2.9/concepts/json/#json-parsing
Validate the given JSON data against the Pydantic model.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
json_data | None | The JSON data to validate. | None |
strict | None | Whether to enforce types strictly. | None |
context | None | Extra variables to pass to the validator. | None |
Returns:
Type | Description |
---|---|
None | The validated Pydantic model. |
Raises:
Type | Description |
---|---|
ValidationError | If json_data is not a JSON string or the object could not be validated. |
model_validate_strings¶
def model_validate_strings(
obj: 'Any',
*,
strict: 'bool | None' = None,
context: 'Any | None' = None
) -> 'Self'
Validate the given object with string data against the Pydantic model.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
obj | None | The object containing string data to validate. | None |
strict | None | Whether to enforce types strictly. | None |
context | None | Extra variables to pass to the validator. | None |
Returns:
Type | Description |
---|---|
None | The validated Pydantic model. |
parse_file¶
def parse_file(
path: 'str | Path',
*,
content_type: 'str | None' = None,
encoding: 'str' = 'utf8',
proto: 'DeprecatedParseProtocol | None' = None,
allow_pickle: 'bool' = False
) -> 'Self'
parse_obj¶
def parse_obj(
obj: 'Any'
) -> 'Self'
parse_raw¶
def parse_raw(
b: 'str | bytes',
*,
content_type: 'str | None' = None,
encoding: 'str' = 'utf8',
proto: 'DeprecatedParseProtocol | None' = None,
allow_pickle: 'bool' = False
) -> 'Self'
schema¶
def schema(
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}'
) -> 'Dict[str, Any]'
schema_json¶
def schema_json(
*,
by_alias: 'bool' = True,
ref_template: 'str' = '#/$defs/{model}',
**dumps_kwargs: 'Any'
) -> 'str'
update_forward_refs¶
def update_forward_refs(
**localns: 'Any'
) -> 'None'
validate¶
def validate(
value: 'Any'
) -> 'Self'
validate_bbox¶
def validate_bbox(
v: Union[Tuple[Union[float, int], Union[float, int], Union[float, int], Union[float, int]], Tuple[Union[float, int], Union[float, int], Union[float, int], Union[float, int], Union[float, int], Union[float, int]]]
) -> Union[Tuple[Union[float, int], Union[float, int], Union[float, int], Union[float, int]], Tuple[Union[float, int], Union[float, int], Union[float, int], Union[float, int], Union[float, int], Union[float, int]]]
validate_datetime¶
def validate_datetime(
value: str
) -> str
validate_query_uses_cql¶
def validate_query_uses_cql(
v: str,
info: pydantic_core.core_schema.ValidationInfo
)
Use of Query Extension is not allowed with cql2.
validate_spatial¶
def validate_spatial(
values: Dict[str, Any]
) -> Dict[str, Any]
Instance variables¶
end_date
model_extra
Get extra fields set during validation.
model_fields_set
Returns the set of fields that have been explicitly set on this model instance.
spatial_filter
Return a geojson-pydantic object representing the spatial filter for the search request.
Check for both because the bbox
and intersects
parameters are mutually exclusive.
start_date
Methods¶
copy¶
def copy(
self,
*,
include: 'AbstractSetIntStr | MappingIntStrAny | None' = None,
exclude: 'AbstractSetIntStr | MappingIntStrAny | None' = None,
update: 'Dict[str, Any] | None' = None,
deep: 'bool' = False
) -> 'Self'
Returns a copy of the model.
Deprecated
This method is now deprecated; use model_copy
instead.
If you need include
or exclude
, use:
data = self.model_dump(include=include, exclude=exclude, round_trip=True)
data = {**data, **(update or {})}
copied = self.model_validate(data)
Parameters:
Name | Type | Description | Default |
---|---|---|---|
include | None | Optional set or mapping specifying which fields to include in the copied model. | None |
exclude | None | Optional set or mapping specifying which fields to exclude in the copied model. | None |
update | None | Optional dictionary of field-value pairs to override field values in the copied model. | None |
deep | None | If True, the values of fields that are Pydantic models will be deep-copied. | None |
Returns:
Type | Description |
---|---|
None | A copy of the model with included, excluded and updated fields as specified. |
dict¶
def dict(
self,
*,
include: 'IncEx | None' = None,
exclude: 'IncEx | None' = None,
by_alias: 'bool' = False,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False
) -> 'Dict[str, Any]'
json¶
def json(
self,
*,
include: 'IncEx | None' = None,
exclude: 'IncEx | None' = None,
by_alias: 'bool' = False,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
encoder: 'Callable[[Any], Any] | None' = PydanticUndefined,
models_as_dict: 'bool' = PydanticUndefined,
**dumps_kwargs: 'Any'
) -> 'str'
model_copy¶
def model_copy(
self,
*,
update: 'dict[str, Any] | None' = None,
deep: 'bool' = False
) -> 'Self'
Usage docs: docs.pydantic.dev/2.9/concepts/serialization/#model_copy
Returns a copy of the model.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
update | None | Values to change/add in the new model. Note: the data is not validated before creating the new model. You should trust this data. |
None |
deep | None | Set to True to make a deep copy of the model. |
None |
Returns:
Type | Description |
---|---|
None | New model instance. |
model_dump¶
def model_dump(
self,
*,
mode: "Literal['json', 'python'] | str" = 'python',
include: 'IncEx | None' = None,
exclude: 'IncEx | None' = None,
context: 'Any | None' = None,
by_alias: 'bool' = False,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
round_trip: 'bool' = False,
warnings: "bool | Literal['none', 'warn', 'error']" = True,
serialize_as_any: 'bool' = False
) -> 'dict[str, Any]'
Usage docs: docs.pydantic.dev/2.9/concepts/serialization/#modelmodel_dump
Generate a dictionary representation of the model, optionally specifying which fields to include or exclude.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
mode | None | The mode in which to_python should run.If mode is 'json', the output will only contain JSON serializable types. If mode is 'python', the output may contain non-JSON-serializable Python objects. |
None |
include | None | A set of fields to include in the output. | None |
exclude | None | A set of fields to exclude from the output. | None |
context | None | Additional context to pass to the serializer. | None |
by_alias | None | Whether to use the field's alias in the dictionary key if defined. | None |
exclude_unset | None | Whether to exclude fields that have not been explicitly set. | None |
exclude_defaults | None | Whether to exclude fields that are set to their default value. | None |
exclude_none | None | Whether to exclude fields that have a value of None . |
None |
round_trip | None | If True, dumped values should be valid as input for non-idempotent types such as Json[T]. | None |
warnings | None | How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors, "error" raises a [ PydanticSerializationError ][pydantic_core.PydanticSerializationError]. |
None |
serialize_as_any | None | Whether to serialize fields with duck-typing serialization behavior. | None |
Returns:
Type | Description |
---|---|
None | A dictionary representation of the model. |
model_dump_json¶
def model_dump_json(
self,
*,
indent: 'int | None' = None,
include: 'IncEx | None' = None,
exclude: 'IncEx | None' = None,
context: 'Any | None' = None,
by_alias: 'bool' = False,
exclude_unset: 'bool' = False,
exclude_defaults: 'bool' = False,
exclude_none: 'bool' = False,
round_trip: 'bool' = False,
warnings: "bool | Literal['none', 'warn', 'error']" = True,
serialize_as_any: 'bool' = False
) -> 'str'
Usage docs: docs.pydantic.dev/2.9/concepts/serialization/#modelmodel_dump_json
Generates a JSON representation of the model using Pydantic's to_json
method.
Parameters:
Name | Type | Description | Default |
---|---|---|---|
indent | None | Indentation to use in the JSON output. If None is passed, the output will be compact. | None |
include | None | Field(s) to include in the JSON output. | None |
exclude | None | Field(s) to exclude from the JSON output. | None |
context | None | Additional context to pass to the serializer. | None |
by_alias | None | Whether to serialize using field aliases. | None |
exclude_unset | None | Whether to exclude fields that have not been explicitly set. | None |
exclude_defaults | None | Whether to exclude fields that are set to their default value. | None |
exclude_none | None | Whether to exclude fields that have a value of None . |
None |
round_trip | None | If True, dumped values should be valid as input for non-idempotent types such as Json[T]. | None |
warnings | None | How to handle serialization errors. False/"none" ignores them, True/"warn" logs errors, "error" raises a [ PydanticSerializationError ][pydantic_core.PydanticSerializationError]. |
None |
serialize_as_any | None | Whether to serialize fields with duck-typing serialization behavior. | None |
Returns:
Type | Description |
---|---|
None | A JSON string representation of the model. |
model_post_init¶
def model_post_init(
self: 'BaseModel',
context: 'Any',
/
) -> 'None'
We need to both initialize private attributes and call the user-defined model_post_init
method.