}"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"one_product.search_kwargs"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"('https://peps.cnes.fr/resto/collections/S2ST/387c7327-9a71-5a34-9163-0dfdeb024522/download',\n",
" 'https://peps.cnes.fr/resto/collections/S2ST/387c7327-9a71-5a34-9163-0dfdeb024522/download')"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"one_product.remote_location, one_product.location"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"dict_keys(['abstract', 'instrument', 'platform', 'platformSerialIdentifier', 'processingLevel', 'keywords', 'sensorType', 'license', 'missionStartDate', 'title', 'productType', 'uid', 'keyword', 'resolution', 'organisationName', 'publicationDate', 'parentIdentifier', 'orbitNumber', 'orbitDirection', 'cloudCover', 'snowCover', 'creationDate', 'modificationDate', 'sensorMode', 'startTimeFromAscendingNode', 'completionTimeFromAscendingNode', 'id', 'quicklook', 'downloadLink', 'storageStatus', 'thumbnail', 'resourceSize', 'resourceChecksum', 'visible', 'newVersion', 'isNrt', 'realtime', 'relativeOrbitNumber', 'useDatalake', 's2TakeId', 'mgrs', 'bareSoil', 'highProbaClouds', 'mediumProbaClouds', 'lowProbaClouds', 'snowIce', 'vegetation', 'water', 'isRefined', 'nrtResource', 'services', 'links', 'storage'])"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"one_product.properties.keys()"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"An [EOProduct](../../api_reference/eoproduct.rst#eodag.api.product._product.EOProduct) has an [as_dict()](../../api_reference/eoproduct.rst#eodag.api.product._product.EOProduct.as_dict) to convert it into a GeoJSON-like dictionary and a [from_geojson()](../../api_reference/eoproduct.rst#eodag.api.product._product.EOProduct.from_geojson) method to create an [EOProduct](../../api_reference/eoproduct.rst#eodag.api.product._product.EOProduct) from a GeoJSON dictionary."
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"EOProduct(id=S2B_MSIL1C_20210328T103629_N0209_R008_T31TCJ_20210328T124650, provider=peps)"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from eodag import EOProduct\n",
"product_geojson_structure = one_product.as_dict()\n",
"recreated_product = EOProduct.from_geojson(product_geojson_structure)\n",
"recreated_product"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Since [EOProduct](../../api_reference/eoproduct.rst#eodag.api.product._product.EOProduct)s have a way to convert themselves to a GeoJSON dictionary, it is natural to be able to convert a [SearchResult](../../api_reference/searchresult.rst#eodag.api.search_result.SearchResult) object to a GeoJSON *FeatureCollection* ([as_geojson_object()](../../api_reference/searchresult.rst#eodag.api.search_result.SearchResult.as_geojson_object)). It is also possible to create a [SearchResult](../../api_reference/searchresult.rst#eodag.api.search_result.SearchResult) from a dictionary structured as a *FeatureCollection* with [from_geojson()](../../api_reference/searchresult.rst#eodag.api.search_result.SearchResult.from_geojson)."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"SearchResult([EOProduct(id=S2B_MSIL1C_20210328T103629_N0209_R008_T31TCJ_20210328T124650, provider=peps),\n",
" EOProduct(id=S2B_MSIL1C_20210328T103629_N0209_R008_T31TCH_20210328T124650, provider=peps)])"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from eodag import SearchResult\n",
"feature_collection = all_products.as_geojson_object()\n",
"recreated_search_result = SearchResult.from_geojson(feature_collection)\n",
"recreated_search_result[:2]"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"You can also convert a [SearchResult](../../api_reference/searchresult.rst#eodag.api.search_result.SearchResult) object to other formats, like `shapely.geometry.GeometryCollection` ([as_shapely_geometry_object()](../../api_reference/searchresult.rst#eodag.api.search_result.SearchResult.as_shapely_geometry_object)), and `WKT` ([as_wkt_object()](../../api_reference/searchresult.rst#eodag.api.search_result.SearchResult.as_wkt_object))."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"Note\n",
"\n",
"[EOProduct](../../api_reference/eoproduct.rst#eodag.api.product._product.EOProduct) and [SearchResult](../../api_reference/searchresult.rst#eodag.api.search_result.SearchResult) objects have more methods and attributes than the ones listed aboved.\n",
"They are gradually introduced in the next pages of this user guide.\n",
"\n",
"
\n",
"\n",
"\n",
"\n",
"Note\n",
"\n",
"When [eodag-cube](https://github.com/CS-SI/eodag-cube) is installed the [EOProduct](../../api_reference/eoproduct.rst#eodag.api.product._product.EOProduct) class used by `eodag` is the one provided by [eodag-cube](https://github.com/CS-SI/eodag-cube), which extends it with a few more capabilities, including a `get_data()` method to directly access the product's data.\n",
"\n",
"
"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Search parameters"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"The search methods have exposed in their signature a common set of search parameters:\n",
"\n",
"* `productType`\n",
"* `start` and `end`\n",
"* `geom`\n",
"* `locations`\n",
"\n",
"More parameters can be passed through *kwargs*, they are also described below."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Product type"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"The `productType` parameter allows to specify which kind of product is searched for. It should be one of `eodag`'s product type ID, such as `S2_MSI_L1C`. They are discoverable with the method [list_product_types()](../../api_reference/core.rst#eodag.api.core.EODataAccessGateway.list_product_types) or can be viewed [here](../../getting_started_guide/product_types.rst)."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"Warning\n",
"\n",
"The feature described below is intended for advanced users.\n",
"\n",
"
\n",
"\n",
"The product types exposed by `eodag` for a given provider are hard-coded in a configuration file. This means that a provider can add a new product type to its catalog, which would then not be listed in `eodag`'s configuration until it is updated. To cover this case, it has been made possible to search for a product type not referenced by `eodag`.\n",
"\n",
"Internally, a generic product type has been created (`GENERIC_PRODUCT_TYPE`) to emulate a non-referenced product type. The parameters required to search for a non-referenced product type are saved in [eodag's internal provider configuration file](../../add_provider.rst#providers-pre-configuration). For example *creodias* is configured with this generic produc type:\n",
"\n",
"```\n",
" GENERIC_PRODUCT_TYPE:\n",
" productType: '{productType}'\n",
" collection: '{collection}'\n",
"```\n",
"\n",
"The above configuration indicates that for this provider a non-referenced product type can be searched for by passing the `productType` and `collection` parameters to a search method, e.g. `dag.search(collection=\"foo\", productType=\"bar\")`. **The values these parameters should take must be found by the user, eodag has just no clue about them**.\n",
"\n",
"To provide a more concrete example, `eodag` allows to search for `S2_MSI_L1C` product types with *creodias*. This product type configuration is the following:\n",
"\n",
"```\n",
" S2_MSI_L1C:\n",
" productType: L1C\n",
" collection: Sentinel2\n",
"```\n",
"\n",
"This means that `dag.search(productType=\"L1C\", collection=\"Sentinel2\")` should return the same products as `dag.search(productType=\"S2_MSI_L1C\")`."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Time period"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"`start` and `end` parameters are optional. They are used to search for products that have been sensed between these two times. Dates or datetimes must be passed as `strings` in UTC ISO8601 format (e.g. `yyyy-MM-dd`, `yyyy-MM-ddThh:mm:ss.SSSZ`)."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"### Area of interest"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"`eodag` provides multiple ways to define the area over which products should be searched for. The products returned are those that **intersect** with the area of interest, which means that their geometry can sometimes only partially overlap with the search geometry."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"\n",
"Warning\n",
"\n",
"`eodag` transforms the area of interest passed by the user (e.g. a `shapely` polygon) to a geometry representation accepted by the targeted provider (e.g. a WKT string). Providers can set a limit to the size of its query parameters. In the case of a very large and detailed geometry passed by the user, its representation might exceed the provider's limit (e.g. a very long WKT string). `eodag` tries internally to detect too long WKT strings, and simplifies them if so, by reducing the resolution of the input geometry iteratively. However, this algorithm doesn't enforce the output WKT string to be lower than a certain limit, `eodag` doesn't want to change too much the geometry passed by the user. As a consequence, the request sent might still contain a WKT string that is above the provider's limit (a *WARNING* is emitted), which would then end up in an error. In that case, it's the user's responsability to pass to `eodag` a simplified geometry, either by generating a convex hull or by splitting it (and executing multiple searches).\n",
"\n",
"
"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"[folium](https://python-visualization.github.io/folium/) is used in this section to display the search area and the extent of the products found on an interactive map."
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [],
"source": [
"import folium"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"#### `geom` parameter"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"The first way to define an area of interest is to define the optinal `geom` parameter which accepts the following different inputs:\n",
"\n",
"* a `Shapely` geometry object (any kind of geometry: point, line, polygon, multipolygon...)\n",
"* a *Well-Known Text* (WKT) string (any kind of geometry: point, line, polygon, multipolygon...)\n",
"* a bounding box as a dictionary with keys: `\"lonmin\"`, `\"latmin\"`, `\"lonmax\"`, `\"latmax\"`\n",
"* a bounding box as a list with elements provided in the order [lonmin, latmin, lonmax, latmax]\n",
"\n",
"The coordinates must be provided in the **WGS84** projection (EPSG: 4326)."
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"10 products are going to be mapped.\n"
]
}
],
"source": [
"# Only a subset of the products is used not to overload the map\n",
"prods_to_map = all_products[::5]\n",
"print(f\"{len(prods_to_map)} products are going to be mapped.\")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"In the previous searches made `geom` was defined as a bounding box expressed as a dictionary."
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'lonmin': 1, 'latmin': 43, 'lonmax': 2, 'latmax': 44}"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"geometry = default_search_criteria[\"geom\"]\n",
"geometry"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"This is equivalent to:"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
"geom = [1, 43, 2, 44] # or geom = (1, 43, 1, 44)"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [],
"source": [
"from shapely.geometry import Polygon\n",
"geom = Polygon([[1, 43], [2, 43], [2, 44], [1, 44], [1, 43]])"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [],
"source": [
"geom = \"POLYGON ((1 43, 2 43, 2 44, 1 44, 1 43))\" # WKT string"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"Make this Notebook Trusted to load map: File -> Trust Notebook
Make this Notebook Trusted to load map: File -> Trust Notebook
\n",
"\n",
"Note\n",
"\n",
"\n",
"\n",
"
"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Add locations search"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Users are obsviously able to modify the location configuration file to add their own *locations* or to create their own YAML location configuration file. [EODataAccessGateway](../../api_reference/core.rst#eodag.api.core.EODataAccessGateway) accepts the optional `locations_conf_path` parameter that can set to the path to another location configuration file. Alternatively, the environment variable `EODAG_LOCS_CFG_FILE` can also be set to define the path to another location configuration file (this has priority over the parameter value if passed too)."
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [],
"source": [
"# dag = EODataAccessGateway(locations_conf_path=\"path/to/my_own_location_config.yaml\")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"#### Combined `geom` and locations search"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"`eodag` allows to combine a geometry search (e.g. a bounding box) with a location search. In that case the search area becomes the union of the two geometries found."
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'productType': 'S2_MSI_L1C',\n",
" 'start': '2021-03-01',\n",
" 'end': '2021-03-31',\n",
" 'geom': {'lonmin': 1, 'latmin': 43, 'lonmax': 2, 'latmax': 44},\n",
" 'locations': {'country': 'BEL|CHE'}}"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"combined_search_criteria = default_search_criteria.copy()\n",
"combined_search_criteria[\"locations\"] = location_search_criteria[\"locations\"]\n",
"combined_search_criteria"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2023-01-13 11:07:18,062 eodag.core [INFO ] Searching product type 'S2_MSI_L1C' on provider: peps\n",
"2023-01-13 11:07:18,064 eodag.plugins.search.qssearch [INFO ] Sending count request: https://peps.cnes.fr/resto/api/collections/S2ST/search.json?startDate=2021-03-01&completionDate=2021-03-31&geometry=MULTIPOLYGON (((6.1567 50.8037, 5.6070 51.0373, 4.9740 51.4750, 4.0471 51.2673, 3.3150 51.3458, 3.3150 51.3458, 3.3150 51.3458, 2.5136 51.1485, 2.6584 50.7968, 3.1233 50.7804, 3.5882 50.3790, 4.2860 49.9075, 4.7992 49.9854, 5.6741 49.5295, 5.7824 50.0903, 6.0431 50.1281, 6.1567 50.8037)), ((9.5942 47.5251, 8.5226 47.8308, 8.3173 47.6136, 7.4668 47.6206, 7.1922 47.4498, 6.7366 47.5418, 6.7687 47.2877, 6.0374 46.7258, 6.0226 46.2730, 6.5001 46.4297, 6.8436 45.9911, 7.2739 45.7769, 7.7560 45.8245, 8.3166 46.1636, 8.4900 46.0052, 8.9663 46.0369, 9.1829 46.4402, 9.9228 46.3149, 10.3634 46.4836, 10.4427 46.8935, 9.9324 46.9207, 9.4800 47.1028, 9.6329 47.3476, 9.5942 47.5251)), ((1.0000 43.0000, 1.0000 44.0000, 2.0000 44.0000, 2.0000 43.0000, 1.0000 43.0000)))&productType=S2MSI1C&maxRecords=1&page=1\n",
"2023-01-13 11:07:18,515 eodag.plugins.search.qssearch [INFO ] Sending search request: https://peps.cnes.fr/resto/api/collections/S2ST/search.json?startDate=2021-03-01&completionDate=2021-03-31&geometry=MULTIPOLYGON (((6.1567 50.8037, 5.6070 51.0373, 4.9740 51.4750, 4.0471 51.2673, 3.3150 51.3458, 3.3150 51.3458, 3.3150 51.3458, 2.5136 51.1485, 2.6584 50.7968, 3.1233 50.7804, 3.5882 50.3790, 4.2860 49.9075, 4.7992 49.9854, 5.6741 49.5295, 5.7824 50.0903, 6.0431 50.1281, 6.1567 50.8037)), ((9.5942 47.5251, 8.5226 47.8308, 8.3173 47.6136, 7.4668 47.6206, 7.1922 47.4498, 6.7366 47.5418, 6.7687 47.2877, 6.0374 46.7258, 6.0226 46.2730, 6.5001 46.4297, 6.8436 45.9911, 7.2739 45.7769, 7.7560 45.8245, 8.3166 46.1636, 8.4900 46.0052, 8.9663 46.0369, 9.1829 46.4402, 9.9228 46.3149, 10.3634 46.4836, 10.4427 46.8935, 9.9324 46.9207, 9.4800 47.1028, 9.6329 47.3476, 9.5942 47.5251)), ((1.0000 43.0000, 1.0000 44.0000, 2.0000 44.0000, 2.0000 43.0000, 1.0000 43.0000)))&productType=S2MSI1C&maxRecords=50&page=1\n",
"2023-01-13 11:07:20,210 eodag.core [INFO ] Found 425 result(s) on provider 'peps'\n"
]
}
],
"source": [
"combined_products, estimated_total_number = dag.search(**combined_search_criteria, items_per_page=50)"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
"Make this Notebook Trusted to load map: File -> Trust Notebook
\n",
"\n",
"Warning\n",
"\n",
"This feature is intended for advanced users.\n",
"\n",
"
"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Providers generally accept many more request parameters than the basic ones provided by `eodag` by default (geometry and time period). Many of these parameters are actually known to `eodag` and configured internally (see the [providers pre-configuration section](../../add_provider.rst#providers-pre-configuration)). They are just not exposed in the signature of the search methods, not to overload it, and also because these parameters are not necessarily share among all the providers.\n",
"\n",
"A common parameter used when searching for EO products is the percentage of cloud cover. *PEPS* for instance accepts a `cloudCover` parameter. `eodag` knows how to transform it in a way that is adapted to *PEPS*."
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2023-01-13 11:10:05,660 eodag.core [INFO ] Searching product type 'S2_MSI_L1C' on provider: peps\n",
"2023-01-13 11:10:05,664 eodag.plugins.search.qssearch [INFO ] Sending count request: https://peps.cnes.fr/resto/api/collections/S2ST/search.json?cloudCover=[0,10]&startDate=2021-03-01&completionDate=2021-03-31&geometry=POLYGON ((1.0000 43.0000, 1.0000 44.0000, 2.0000 44.0000, 2.0000 43.0000, 1.0000 43.0000))&productType=S2MSI1C&maxRecords=1&page=1\n",
"2023-01-13 11:10:06,223 eodag.plugins.search.qssearch [INFO ] Sending search request: https://peps.cnes.fr/resto/api/collections/S2ST/search.json?cloudCover=[0,10]&startDate=2021-03-01&completionDate=2021-03-31&geometry=POLYGON ((1.0000 43.0000, 1.0000 44.0000, 2.0000 44.0000, 2.0000 43.0000, 1.0000 43.0000))&productType=S2MSI1C&maxRecords=20&page=1\n",
"2023-01-13 11:10:06,922 eodag.core [INFO ] Found 10 result(s) on provider 'peps'\n"
]
}
],
"source": [
"products, estimated_total_number = dag.search(\n",
" cloudCover=10, # cloud cover Less than 10\n",
" **default_search_criteria\n",
")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"It is possible to check that the search returned products than have a cloud cover less than 10%."
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[0, 7.7926, 1.5388000000000002, 0.0185, 0, 0, 4.4443, 1.7617, 6.8998, 0]"
]
},
"execution_count": 53,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[p.properties[\"cloudCover\"] for p in products]"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Having a closer look at the URL displayed in the logs above, it can be observed that `cloudCover=10` was actually converted by `eodag` to the query string `cloudCover=[0,10]`. This proves that `eodag` indeed knows about this parameter and how to adapt it for *PEPS*."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"Query parameters unknown to `eodag` are also propagated until they are directly requested to the provider, albeit as is."
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2023-01-13 11:10:20,091 eodag.core [INFO ] Searching product type 'S2_MSI_L1C' on provider: peps\n",
"2023-01-13 11:10:20,094 eodag.plugins.search.qssearch [INFO ] Sending count request: https://peps.cnes.fr/resto/api/collections/S2ST/search.json?random_parameter=random_value&startDate=2021-03-01&completionDate=2021-03-31&geometry=POLYGON ((1.0000 43.0000, 1.0000 44.0000, 2.0000 44.0000, 2.0000 43.0000, 1.0000 43.0000))&productType=S2MSI1C&maxRecords=1&page=1\n",
"2023-01-13 11:10:20,543 eodag.plugins.search.qssearch [INFO ] Sending search request: https://peps.cnes.fr/resto/api/collections/S2ST/search.json?random_parameter=random_value&startDate=2021-03-01&completionDate=2021-03-31&geometry=POLYGON ((1.0000 43.0000, 1.0000 44.0000, 2.0000 44.0000, 2.0000 43.0000, 1.0000 43.0000))&productType=S2MSI1C&maxRecords=20&page=1\n",
"2023-01-13 11:10:21,423 eodag.core [INFO ] Found 48 result(s) on provider 'peps'\n"
]
}
],
"source": [
"products, estimated_total_number = dag.search(\n",
" random_parameter=\"random_value\",\n",
" **default_search_criteria\n",
")"
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"The logs above show that the random kwarg passed to the [search()](../../api_reference/core.rst#eodag.api.core.EODataAccessGateway.search) method was indeed propagated to the request made to *PEPS*. It happens that *PEPS* accept unsupported parameters and still returned products, another provider might just have sent an error."
]
},
{
"attachments": {},
"cell_type": "markdown",
"metadata": {},
"source": [
"## Fallback in case of error\n",
"\n",
"Usually, search is performed on the provider with the highest priority. If the request to this provider fails, i.e. if an error is returned (for example because the provider is currently unavailable) or if no results are returned, a request to the the provider with the next highest priority offering the desired product type will be attempted. In this case a warning message will be shown in the logs. If the request fails for all providers offering the desired product type, an error message will be returned."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"2023-07-03 13:38:24,041 eodag.core [INFO] (core) No result from provider 'peps' due to an error during search. Raise verbosity of log messages for details\n",
"2023-07-03 13:38:24,041 eodag.core [WARNING] (core) No result could be obtained from provider peps, we will try to get the data from another provider"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Queryables"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To know which query parameters can be used to filter the search result, the `list_queryables` method can be used. It has two optional arguments, `provider` and `productType`, additional keyword arguments to filter the queryable values can be added.\n",
"\n",
"If the function is called without any arguments, the basic queryables that are available for all providers and product types will be returned:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'productType': typing.Annotated[str, FieldInfo(annotation=NoneType, required=True)],\n",
" 'id': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'start': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='startTimeFromAscendingNode', alias_priority=2)],\n",
" 'end': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='completionTimeFromAscendingNode', alias_priority=2)],\n",
" 'geom': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='geometry', alias_priority=2)]}"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dag.list_queryables()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If the function is called for a specific product type, the queryables available for this product type, i.e., the basic queryables and product type specific queryables, are shown. Only parameters available for all providers offering the product are returned."
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'sky_type': typing.Annotated[typing.Literal['clear', 'observed_cloud'], FieldInfo(annotation=NoneType, required=False, default='clear')],\n",
" 'time_step': typing.Annotated[typing.Literal['15minute', '1day', '1hour', '1minute', '1month'], FieldInfo(annotation=NoneType, required=False, default='1minute')],\n",
" 'time_reference': typing.Annotated[typing.Literal['true_solar_time', 'universal_time'], FieldInfo(annotation=NoneType, required=False, default='true_solar_time')],\n",
" 'location': typing.Annotated[dict, FieldInfo(annotation=NoneType, required=False, default={'latitude': 0, 'longitude': 0})],\n",
" 'altitude': typing.Annotated[int, FieldInfo(annotation=NoneType, required=False, default=-999)],\n",
" 'format': typing.Annotated[typing.Literal['csv', 'netcdf'], FieldInfo(annotation=NoneType, required=False, default='csv')],\n",
" 'end': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='completionTimeFromAscendingNode', alias_priority=2)],\n",
" 'geom': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='geometry', alias_priority=2)],\n",
" 'productType': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False, default='CAMS_SOLAR_RADIATION')],\n",
" 'id': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'start': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='startTimeFromAscendingNode', alias_priority=2)]}"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dag.list_queryables(productType=\"CAMS_SOLAR_RADIATION\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The queryables can also be retrieved for a specific provider. These queryables are either taken from the queryables endpoint of the provider (if available), the constraints for the query parameter values defined by the provider (if available) or the provider configuration in EODAG. In the example below we use a provider offering a queryables endpoint."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"2024-02-19 12:01:07,071 eodag.search.qssearch [INFO ] Fetching queryables: https://planetarycomputer.microsoft.com/api/stac/v1/search/../collections/sentinel-1-grd/queryables\n"
]
},
{
"data": {
"text/plain": [
"{'id': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'end': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='completionTimeFromAscendingNode', alias_priority=2)],\n",
" 'geom': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='geometry', alias_priority=2)],\n",
" 'platform': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 's1:shape': typing.Annotated[list, FieldInfo(annotation=NoneType, required=False)],\n",
" 'end_datetime': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False, title='End datetime', description='End datetime', metadata=[PydanticGeneralMetadata(pattern='(\\\\+00:00|Z)$')])],\n",
" 's1:resolution': typing.Annotated[typing.Literal['full', 'high', 'medium'], FieldInfo(annotation=NoneType, required=False, title='Resolution')],\n",
" 's1:datatake_id': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False, title='Datatake ID')],\n",
" 'start_datetime': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False, title='Start datetime', description='Start datetime', metadata=[PydanticGeneralMetadata(pattern='(\\\\+00:00|Z)$')])],\n",
" 's1:orbit_source': typing.Annotated[typing.Literal['DOWNLINK', 'POEORB', 'PREORB', 'RESORB'], FieldInfo(annotation=NoneType, required=False, title='Orbit Source')],\n",
" 's1:slice_number': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False, title='Slice Number')],\n",
" 's1:total_slices': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False, title='Total Slices')],\n",
" 'sar:looks_range': typing.Annotated[int, FieldInfo(annotation=NoneType, required=False, title='Looks range')],\n",
" 'orbitDirection': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'sar:product_type': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False, title='Product type')],\n",
" 'sar:looks_azimuth': typing.Annotated[int, FieldInfo(annotation=NoneType, required=False, title='Looks azimuth')],\n",
" 'polarizationChannels': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'dopplerFrequency': typing.Annotated[typing.Optional[float], FieldInfo(annotation=NoneType, required=False)],\n",
" 'sat:absolute_orbit': typing.Annotated[NoneType, FieldInfo(annotation=NoneType, required=False, title='Absolute Orbit', json_schema_extra={'$ref': 'https://stac-extensions.github.io/sat/v1.0.0/schema.json#/definitions/fields/properties/sat:absolute_orbit'})],\n",
" 'orbitNumber': typing.Annotated[typing.Optional[int], FieldInfo(annotation=NoneType, required=False)],\n",
" 's1:processing_level': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False)],\n",
" 'sensorMode': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'sar:center_frequency': typing.Annotated[float, FieldInfo(annotation=NoneType, required=False, title='Center Frequency (GHz)')],\n",
" 'sar:resolution_range': typing.Annotated[float, FieldInfo(annotation=NoneType, required=False, title='Resolution range (m)')],\n",
" 's1:product_timeliness': typing.Annotated[typing.Literal['Fast-24h', 'NRT-10m', 'NRT-1h', 'NRT-3h', 'Off-line', 'Reprocessing'], FieldInfo(annotation=NoneType, required=False, title='Product Timeliness')],\n",
" 'sar:resolution_azimuth': typing.Annotated[float, FieldInfo(annotation=NoneType, required=False, title='Resolution azimuth (m)')],\n",
" 'sar:pixel_spacing_range': typing.Annotated[float, FieldInfo(annotation=NoneType, required=False, title='Pixel spacing range (m)')],\n",
" 'sar:observation_direction': typing.Annotated[typing.Literal['left', 'right'], FieldInfo(annotation=NoneType, required=False, title='Antenna pointing direction')],\n",
" 'sar:pixel_spacing_azimuth': typing.Annotated[float, FieldInfo(annotation=NoneType, required=False, title='Pixel spacing azimuth (m)')],\n",
" 'sar:looks_equivalent_number': typing.Annotated[float, FieldInfo(annotation=NoneType, required=False, title='Equivalent number of looks (ENL)')],\n",
" 's1:instrument_configuration_ID': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False)],\n",
" 'sat:platform_international_designator': typing.Annotated[typing.Literal['0000-000A', '2014-016A', '2016-025A'], FieldInfo(annotation=NoneType, required=False, title='Platform Designation')],\n",
" 'productType': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False, default='S1_SAR_GRD')],\n",
" 'doi': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'platformSerialIdentifier': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'instrument': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'processingLevel': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'resolution': typing.Annotated[typing.Optional[int], FieldInfo(annotation=NoneType, required=False)],\n",
" 'publicationDate': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'cloudCover': typing.Annotated[typing.Optional[typing.Annotated[int, Gt(gt=0), Lt(lt=100)]], FieldInfo(annotation=NoneType, required=False)],\n",
" 'productVersion': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'creationDate': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'modificationDate': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'availabilityTime': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'acquisitionStation': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'acquisitionSubType': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'illuminationAzimuthAngle': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'illuminationElevationAngle': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'start': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='startTimeFromAscendingNode', alias_priority=2)]}"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dag.list_queryables(productType=\"S1_SAR_GRD\", provider=\"planetary_computer\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For each queryable the possible values will be included in the result if they are available from either the provider queryables or the constraints. If constraints are available for a provider, the queryables can be filtered by the value of a specific parameter. E.g. if the queryables month and day are available, we can set the month to a specific value to get only the days available for that month."
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'api_product_type': typing.Annotated[typing.Literal['reanalysis'], FieldInfo(annotation=NoneType, required=False, default='reanalysis')],\n",
" 'time': typing.Annotated[typing.Literal['00:00', '01:00', '02:00', '03:00', '04:00', '05:00', '06:00', '07:00', '08:00', '09:00', '10:00', '11:00', '12:00', '13:00', '14:00', '15:00', '16:00', '17:00', '18:00', '19:00', '20:00', '21:00', '22:00', '23:00'], FieldInfo(annotation=NoneType, required=False, default='00:00')],\n",
" 'format': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False, default='grib')],\n",
" 'month': typing.Annotated[typing.Literal['01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12'], FieldInfo(annotation=NoneType, required=False, default='02')],\n",
" 'day': typing.Annotated[typing.Literal['01', '02', '03', '04', '05', '06', '07', '08', '09', '10', '11', '12', '13', '14', '15', '16', '17', '18', '19', '20', '21', '22', '23', '24', '25', '26', '27', '28', '29'], FieldInfo(annotation=NoneType, required=True)],\n",
" 'variable': typing.Annotated[typing.Literal['100m_u_component_of_wind', '100m_v_component_of_wind', '10m_u_component_of_neutral_wind', '10m_u_component_of_wind', '10m_v_component_of_neutral_wind', '10m_v_component_of_wind', '10m_wind_gust_since_previous_post_processing', '2m_dewpoint_temperature', '2m_temperature', 'air_density_over_the_oceans', 'angle_of_sub_gridscale_orography', 'anisotropy_of_sub_gridscale_orography', 'benjamin_feir_index', 'boundary_layer_dissipation', 'boundary_layer_height', 'charnock', 'clear_sky_direct_solar_radiation_at_surface', 'cloud_base_height', 'coefficient_of_drag_with_waves', 'convective_available_potential_energy', 'convective_inhibition', 'convective_precipitation', 'convective_rain_rate', 'convective_snowfall', 'convective_snowfall_rate_water_equivalent', 'downward_uv_radiation_at_the_surface', 'duct_base_height', 'eastward_gravity_wave_surface_stress', 'eastward_turbulent_surface_stress', 'evaporation', 'forecast_albedo', 'forecast_logarithm_of_surface_roughness_for_heat', 'forecast_surface_roughness', 'free_convective_velocity_over_the_oceans', 'friction_velocity', 'geopotential', 'gravity_wave_dissipation', 'high_cloud_cover', 'high_vegetation_cover', 'ice_temperature_layer_1', 'ice_temperature_layer_2', 'ice_temperature_layer_3', 'ice_temperature_layer_4', 'instantaneous_10m_wind_gust', 'instantaneous_eastward_turbulent_surface_stress', 'instantaneous_large_scale_surface_precipitation_fraction', 'instantaneous_moisture_flux', 'instantaneous_northward_turbulent_surface_stress', 'instantaneous_surface_sensible_heat_flux', 'k_index', 'lake_bottom_temperature', 'lake_cover', 'lake_depth', 'lake_ice_depth', 'lake_ice_temperature', 'lake_mix_layer_depth', 'lake_mix_layer_temperature', 'lake_shape_factor', 'lake_total_layer_temperature', 'land_sea_mask', 'large_scale_precipitation', 'large_scale_precipitation_fraction', 'large_scale_rain_rate', 'large_scale_snowfall', 'large_scale_snowfall_rate_water_equivalent', 'leaf_area_index_high_vegetation', 'leaf_area_index_low_vegetation', 'low_cloud_cover', 'low_vegetation_cover', 'maximum_2m_temperature_since_previous_post_processing', 'maximum_individual_wave_height', 'maximum_total_precipitation_rate_since_previous_post_processing', 'mean_boundary_layer_dissipation', 'mean_convective_precipitation_rate', 'mean_convective_snowfall_rate', 'mean_direction_of_total_swell', 'mean_direction_of_wind_waves', 'mean_eastward_gravity_wave_surface_stress', 'mean_eastward_turbulent_surface_stress', 'mean_evaporation_rate', 'mean_gravity_wave_dissipation', 'mean_large_scale_precipitation_fraction', 'mean_large_scale_precipitation_rate', 'mean_large_scale_snowfall_rate', 'mean_northward_gravity_wave_surface_stress', 'mean_northward_turbulent_surface_stress', 'mean_period_of_total_swell', 'mean_period_of_wind_waves', 'mean_potential_evaporation_rate', 'mean_runoff_rate', 'mean_sea_level_pressure', 'mean_snow_evaporation_rate', 'mean_snowfall_rate', 'mean_snowmelt_rate', 'mean_square_slope_of_waves', 'mean_sub_surface_runoff_rate', 'mean_surface_direct_short_wave_radiation_flux', 'mean_surface_direct_short_wave_radiation_flux_clear_sky', 'mean_surface_downward_long_wave_radiation_flux', 'mean_surface_downward_long_wave_radiation_flux_clear_sky', 'mean_surface_downward_short_wave_radiation_flux', 'mean_surface_downward_short_wave_radiation_flux_clear_sky', 'mean_surface_downward_uv_radiation_flux', 'mean_surface_latent_heat_flux', 'mean_surface_net_long_wave_radiation_flux', 'mean_surface_net_long_wave_radiation_flux_clear_sky', 'mean_surface_net_short_wave_radiation_flux', 'mean_surface_net_short_wave_radiation_flux_clear_sky', 'mean_surface_runoff_rate', 'mean_surface_sensible_heat_flux', 'mean_top_downward_short_wave_radiation_flux', 'mean_top_net_long_wave_radiation_flux', 'mean_top_net_long_wave_radiation_flux_clear_sky', 'mean_top_net_short_wave_radiation_flux', 'mean_top_net_short_wave_radiation_flux_clear_sky', 'mean_total_precipitation_rate', 'mean_vertical_gradient_of_refractivity_inside_trapping_layer', 'mean_vertically_integrated_moisture_divergence', 'mean_wave_direction', 'mean_wave_direction_of_first_swell_partition', 'mean_wave_direction_of_second_swell_partition', 'mean_wave_direction_of_third_swell_partition', 'mean_wave_period', 'mean_wave_period_based_on_first_moment', 'mean_wave_period_based_on_first_moment_for_swell', 'mean_wave_period_based_on_first_moment_for_wind_waves', 'mean_wave_period_based_on_second_moment_for_swell', 'mean_wave_period_based_on_second_moment_for_wind_waves', 'mean_wave_period_of_first_swell_partition', 'mean_wave_period_of_second_swell_partition', 'mean_wave_period_of_third_swell_partition', 'mean_zero_crossing_wave_period', 'medium_cloud_cover', 'minimum_2m_temperature_since_previous_post_processing', 'minimum_total_precipitation_rate_since_previous_post_processing', 'minimum_vertical_gradient_of_refractivity_inside_trapping_layer', 'model_bathymetry', 'near_ir_albedo_for_diffuse_radiation', 'near_ir_albedo_for_direct_radiation', 'normalized_energy_flux_into_ocean', 'normalized_energy_flux_into_waves', 'normalized_stress_into_ocean', 'northward_gravity_wave_surface_stress', 'northward_turbulent_surface_stress', 'ocean_surface_stress_equivalent_10m_neutral_wind_direction', 'ocean_surface_stress_equivalent_10m_neutral_wind_speed', 'peak_wave_period', 'period_corresponding_to_maximum_individual_wave_height', 'potential_evaporation', 'precipitation_type', 'runoff', 'sea_ice_cover', 'sea_surface_temperature', 'significant_height_of_combined_wind_waves_and_swell', 'significant_height_of_total_swell', 'significant_height_of_wind_waves', 'significant_wave_height_of_first_swell_partition', 'significant_wave_height_of_second_swell_partition', 'significant_wave_height_of_third_swell_partition', 'skin_reservoir_content', 'skin_temperature', 'slope_of_sub_gridscale_orography', 'snow_albedo', 'snow_density', 'snow_depth', 'snow_evaporation', 'snowfall', 'snowmelt', 'soil_temperature_level_1', 'soil_temperature_level_2', 'soil_temperature_level_3', 'soil_temperature_level_4', 'soil_type', 'standard_deviation_of_filtered_subgrid_orography', 'standard_deviation_of_orography', 'sub_surface_runoff', 'surface_latent_heat_flux', 'surface_net_solar_radiation', 'surface_net_solar_radiation_clear_sky', 'surface_net_thermal_radiation', 'surface_net_thermal_radiation_clear_sky', 'surface_pressure', 'surface_runoff', 'surface_sensible_heat_flux', 'surface_solar_radiation_downward_clear_sky', 'surface_solar_radiation_downwards', 'surface_thermal_radiation_downward_clear_sky', 'surface_thermal_radiation_downwards', 'temperature_of_snow_layer', 'toa_incident_solar_radiation', 'top_net_solar_radiation', 'top_net_solar_radiation_clear_sky', 'top_net_thermal_radiation', 'top_net_thermal_radiation_clear_sky', 'total_cloud_cover', 'total_column_cloud_ice_water', 'total_column_cloud_liquid_water', 'total_column_ozone', 'total_column_rain_water', 'total_column_snow_water', 'total_column_supercooled_liquid_water', 'total_column_water', 'total_column_water_vapour', 'total_precipitation', 'total_sky_direct_solar_radiation_at_surface', 'total_totals_index', 'trapping_layer_base_height', 'trapping_layer_top_height', 'type_of_high_vegetation', 'type_of_low_vegetation', 'u_component_stokes_drift', 'uv_visible_albedo_for_diffuse_radiation', 'uv_visible_albedo_for_direct_radiation', 'v_component_stokes_drift', 'vertical_integral_of_divergence_of_cloud_frozen_water_flux', 'vertical_integral_of_divergence_of_cloud_liquid_water_flux', 'vertical_integral_of_divergence_of_geopotential_flux', 'vertical_integral_of_divergence_of_kinetic_energy_flux', 'vertical_integral_of_divergence_of_mass_flux', 'vertical_integral_of_divergence_of_moisture_flux', 'vertical_integral_of_divergence_of_ozone_flux', 'vertical_integral_of_divergence_of_thermal_energy_flux', 'vertical_integral_of_divergence_of_total_energy_flux', 'vertical_integral_of_eastward_cloud_frozen_water_flux', 'vertical_integral_of_eastward_cloud_liquid_water_flux', 'vertical_integral_of_eastward_geopotential_flux', 'vertical_integral_of_eastward_heat_flux', 'vertical_integral_of_eastward_kinetic_energy_flux', 'vertical_integral_of_eastward_mass_flux', 'vertical_integral_of_eastward_ozone_flux', 'vertical_integral_of_eastward_total_energy_flux', 'vertical_integral_of_eastward_water_vapour_flux', 'vertical_integral_of_energy_conversion', 'vertical_integral_of_kinetic_energy', 'vertical_integral_of_mass_of_atmosphere', 'vertical_integral_of_mass_tendency', 'vertical_integral_of_northward_cloud_frozen_water_flux', 'vertical_integral_of_northward_cloud_liquid_water_flux', 'vertical_integral_of_northward_geopotential_flux', 'vertical_integral_of_northward_heat_flux', 'vertical_integral_of_northward_kinetic_energy_flux', 'vertical_integral_of_northward_mass_flux', 'vertical_integral_of_northward_ozone_flux', 'vertical_integral_of_northward_total_energy_flux', 'vertical_integral_of_northward_water_vapour_flux', 'vertical_integral_of_potential_and_internal_energy', 'vertical_integral_of_potential_internal_and_latent_energy', 'vertical_integral_of_temperature', 'vertical_integral_of_thermal_energy', 'vertical_integral_of_total_energy', 'vertically_integrated_moisture_divergence', 'volumetric_soil_water_layer_1', 'volumetric_soil_water_layer_2', 'volumetric_soil_water_layer_3', 'volumetric_soil_water_layer_4', 'wave_spectral_directional_width', 'wave_spectral_directional_width_for_swell', 'wave_spectral_directional_width_for_wind_waves', 'wave_spectral_kurtosis', 'wave_spectral_peakedness', 'wave_spectral_skewness', 'zero_degree_level'], FieldInfo(annotation=NoneType, required=True)],\n",
" 'year': typing.Annotated[typing.Literal['1940', '1941', '1942', '1943', '1944', '1945', '1946', '1947', '1948', '1949', '1950', '1951', '1952', '1953', '1954', '1955', '1956', '1957', '1958', '1959', '1960', '1961', '1962', '1963', '1964', '1965', '1966', '1967', '1968', '1969', '1970', '1971', '1972', '1973', '1974', '1975', '1976', '1977', '1978', '1979', '1980', '1981', '1982', '1983', '1984', '1985', '1986', '1987', '1988', '1989', '1990', '1991', '1992', '1993', '1994', '1995', '1996', '1997', '1998', '1999', '2000', '2001', '2002', '2003', '2004', '2005', '2006', '2007', '2008', '2009', '2010', '2011', '2012', '2013', '2014', '2015', '2016', '2017', '2018', '2019', '2020', '2021', '2022', '2023', '2024'], FieldInfo(annotation=NoneType, required=True)],\n",
" 'end': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='completionTimeFromAscendingNode', alias_priority=2)],\n",
" 'geom': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='geometry', alias_priority=2)],\n",
" 'productType': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False, default='ERA5_SL')],\n",
" 'id': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'start': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='startTimeFromAscendingNode', alias_priority=2)]}"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dag.list_queryables(\n",
" productType=\"ERA5_SL\", \n",
" provider=\"cop_cds\", \n",
" month=\"02\"\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If default values are defined for a parameter in the configuration, the values of the other parameters will be filtered by this default value if constraints are available. If all possible configurations shall be shown, the default value can be removed by setting it to empty. The example below shows on request in which all default values are used and one where the default for api_product_type is removed."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'variable': typing.Annotated[typing.Literal['glacier_area'], FieldInfo(annotation=NoneType, required=False, default='glacier_area')],\n",
" 'api_product_type': typing.Annotated[typing.Literal['gridded', 'hypsometry', 'vector'], FieldInfo(annotation=NoneType, required=False, default='gridded')],\n",
" 'version': typing.Annotated[typing.Literal['6_0'], FieldInfo(annotation=NoneType, required=False, default='6_0')],\n",
" 'format': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False, default='zip')],\n",
" 'end': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='completionTimeFromAscendingNode', alias_priority=2)],\n",
" 'geom': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='geometry', alias_priority=2)],\n",
" 'productType': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False, default='GLACIERS_DIST_RANDOLPH')],\n",
" 'id': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'start': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='startTimeFromAscendingNode', alias_priority=2)]}"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dag.list_queryables(\n",
" productType=\"GLACIERS_DIST_RANDOLPH\", \n",
" provider=\"cop_cds\"\n",
")"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'variable': typing.Annotated[typing.Literal['glacier_area'], FieldInfo(annotation=NoneType, required=False, default='glacier_area')],\n",
" 'api_product_type': typing.Annotated[typing.Literal['gridded', 'hypsometry', 'vector'], FieldInfo(annotation=NoneType, required=True)],\n",
" 'version': typing.Annotated[typing.Literal['5_0', '6_0'], FieldInfo(annotation=NoneType, required=False, default='6_0')],\n",
" 'format': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False, default='zip')],\n",
" 'end': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='completionTimeFromAscendingNode', alias_priority=2)],\n",
" 'geom': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='geometry', alias_priority=2)],\n",
" 'productType': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False, default='GLACIERS_DIST_RANDOLPH')],\n",
" 'id': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False)],\n",
" 'start': typing.Annotated[typing.Optional[str], FieldInfo(annotation=NoneType, required=False, alias='startTimeFromAscendingNode', alias_priority=2)]}"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"dag.list_queryables(\n",
" productType=\"GLACIERS_DIST_RANDOLPH\", \n",
" provider=\"cop_cds\", \n",
" api_product_type=None\n",
")"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.10.12"
},
"widgets": {
"application/vnd.jupyter.widget-state+json": {
"state": {},
"version_major": 2,
"version_minor": 0
}
}
},
"nbformat": 4,
"nbformat_minor": 4
}