eodag 3.0.0b2__py3-none-any.whl → 3.0.1__py3-none-any.whl

eodag/api/product/__init__.py

@@ -16,11 +16,17 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-# type: ignore
 """EODAG product package"""
 try:
     # import from eodag-cube if installed
-    from eodag_cube.api.product import Asset, AssetsDict, EOProduct  # noqa
+    from eodag_cube.api.product import (  # pyright: ignore[reportMissingImports]
+        Asset,
+        AssetsDict,
+        EOProduct,
+    )
 except ImportError:
-    from ._assets import Asset, AssetsDict  # noqa
-    from ._product import EOProduct  # noqa
+    from ._assets import Asset, AssetsDict  # type: ignore[assignment]
+    from ._product import EOProduct  # type: ignore[assignment]
+
+# exportable content
+__all__ = ["Asset", "AssetsDict", "EOProduct"]

eodag/api/product/_assets.py

@@ -35,11 +35,8 @@ class AssetsDict(UserDict):
     :class:`~eodag.api.product._product.EOProduct` resulting from a search.
 
     :param product: Product resulting from a search
-    :type product: :class:`~eodag.api.product._product.EOProduct`
     :param args: (optional) Arguments used to init the dictionary
-    :type args: Any
     :param kwargs: (optional) Additional named-arguments used to init the dictionary
-    :type kwargs: Any
     """
 
     product: EOProduct
@@ -56,17 +53,15 @@ class AssetsDict(UserDict):
 
         :returns: The representation of a :class:`~eodag.api.product._assets.AssetsDict`
                   as a Python dict
-        :rtype: dict
         """
         return {k: v.as_dict() for k, v in self.data.items()}
 
     def get_values(self, asset_filter: str = "") -> List[Asset]:
         """
         retrieves the assets matching the given filter
-        :param asset_filter: filter with which the assets should be matched
-        :type asset_filter: str
+
+        :param asset_filter: regex filter with which the assets should be matched
         :return: list of assets
-        :rtype: List[Asset]
         """
         if asset_filter:
             filter_regex = re.compile(asset_filter)
@@ -128,13 +123,9 @@ class Asset(UserDict):
     :class:`~eodag.api.product._product.EOProduct` resulting from a search.
 
     :param product: Product resulting from a search
-    :type product: :class:`~eodag.api.product._product.EOProduct`
     :param key: asset key
-    :type key: str
     :param args: (optional) Arguments used to init the dictionary
-    :type args: Any
     :param kwargs: (optional) Additional named-arguments used to init the dictionary
-    :type kwargs: Any
     """
 
     product: EOProduct
@@ -152,7 +143,6 @@ class Asset(UserDict):
 
         :returns: The representation of a :class:`~eodag.api.product._assets.Asset` as a
                   Python dict
-        :rtype: dict
         """
         return self.data
 
@@ -160,9 +150,7 @@ class Asset(UserDict):
         """Downloads a single asset
 
         :param kwargs: (optional) Additional named-arguments passed to `plugin.download()`
-        :type kwargs: Any
         :returns: The absolute path to the downloaded product on the local filesystem
-        :rtype: str
         """
         return self.product.download(asset=self.key, **kwargs)
 

eodag/api/product/_product.py

@@ -32,9 +32,11 @@ from shapely.errors import ShapelyError
 
 try:
     # import from eodag-cube if installed
-    from eodag_cube.api.product import AssetsDict  # type: ignore # noqa
+    from eodag_cube.api.product import (  # pyright: ignore[reportMissingImports]
+        AssetsDict,
+    )
 except ImportError:
-    from eodag.api.product._assets import AssetsDict  # type: ignore # noqa
+    from eodag.api.product._assets import AssetsDict
 
 from eodag.api.product.drivers import DRIVERS, NoDriver
 from eodag.api.product.metadata_mapping import (
@@ -86,9 +88,7 @@ class EOProduct:
     parameters that led to its creation.
 
     :param provider: The provider from which the product originates
-    :type provider: str
     :param properties: The metadata of the product
-    :type properties: dict
     :ivar product_type: The product type
     :vartype product_type: str
     :ivar location: The path to the product, either remote or local if downloaded
@@ -180,7 +180,6 @@ class EOProduct:
 
         :returns: The representation of a :class:`~eodag.api.product._product.EOProduct` as a
                   Python dict
-        :rtype: dict
         """
         search_intersection = None
         if self.search_intersection is not None:
@@ -212,9 +211,7 @@ class EOProduct:
 
         :param feature: The representation of a :class:`~eodag.api.product._product.EOProduct`
                         as a Python dict
-        :type feature: dict
         :returns: An instance of :class:`~eodag.api.product._product.EOProduct`
-        :rtype: :class:`~eodag.api.product._product.EOProduct`
         """
         properties = feature["properties"]
         properties["geometry"] = feature["geometry"]
@@ -248,11 +245,9 @@ class EOProduct:
         """Give to the product the information needed to download itself.
 
         :param downloader: The download method that it can use
-        :type downloader: Concrete subclass of
                           :class:`~eodag.plugins.download.base.Download` or
                           :class:`~eodag.plugins.api.base.Api`
         :param authenticator: The authentication method needed to perform the download
-        :type authenticator: Concrete subclass of
                              :class:`~eodag.plugins.authentication.base.Authentication`
         """
         self.downloader = downloader
@@ -302,20 +297,15 @@ class EOProduct:
                                   size as inputs and handle progress bar
                                   creation and update to give the user a
                                   feedback on the download progress
-        :type progress_callback: :class:`~eodag.utils.ProgressCallback` or None
         :param wait: (optional) If download fails, wait time in minutes between
                      two download tries
-        :type wait: int
         :param timeout: (optional) If download fails, maximum time in minutes
                         before stop retrying to download
-        :type timeout: int
-        :param kwargs: `outputs_prefix` (str), `extract` (bool), `delete_archive` (bool)
+        :param kwargs: `output_dir` (str), `extract` (bool), `delete_archive` (bool)
                         and `dl_url_params` (dict) can be provided as additional kwargs
                         and will override any other values defined in a configuration
                         file or with environment variables.
-        :type kwargs: Union[str, bool, dict]
         :returns: The absolute path to the downloaded product on the local filesystem
-        :rtype: str
         :raises: :class:`~eodag.utils.exceptions.PluginImplementationError`
         :raises: :class:`RuntimeError`
         """
@@ -383,7 +373,7 @@ class EOProduct:
     def get_quicklook(
         self,
         filename: Optional[str] = None,
-        base_dir: Optional[str] = None,
+        output_dir: Optional[str] = None,
         progress_callback: Optional[ProgressCallback] = None,
     ) -> str:
         """Download the quicklook image of a given EOProduct from its provider if it
@@ -391,18 +381,14 @@ class EOProduct:
 
         :param filename: (optional) The name to give to the downloaded quicklook. If not
                          given, it defaults to the product's ID (without file extension).
-        :type filename: str
-        :param base_dir: (optional) The absolute path of the directory where to store
+        :param output_dir: (optional) The absolute path of the directory where to store
                          the quicklooks in the filesystem. If not given, it defaults to the
-                         `quicklooks` directory under this EO product downloader's ``outputs_prefix``
+                         `quicklooks` directory under this EO product downloader's ``output_dir``
                          config param (e.g. '/tmp/quicklooks/')
-        :type base_dir: str
         :param progress_callback: (optional) A method or a callable object which takes
                                    a current size and a maximum size as inputs and handle progress bar
                                    creation and update to give the user a feedback on the download progress
-        :type progress_callback: :class:`~eodag.utils.ProgressCallback` or None
         :returns: The absolute path of the downloaded quicklook
-        :rtype: str
         """
 
         def format_quicklook_address() -> None:
@@ -439,20 +425,20 @@ class EOProduct:
 
         format_quicklook_address()
 
-        if base_dir is not None:
-            quicklooks_base_dir = os.path.abspath(os.path.realpath(base_dir))
+        if output_dir is not None:
+            quicklooks_output_dir = os.path.abspath(os.path.realpath(output_dir))
         else:
             tempdir = tempfile.gettempdir()
-            outputs_prefix = (
-                getattr(self.downloader.config, "outputs_prefix", tempdir)
+            downloader_output_dir = (
+                getattr(self.downloader.config, "output_dir", tempdir)
                 if self.downloader
                 else tempdir
             )
-            quicklooks_base_dir = os.path.join(outputs_prefix, "quicklooks")
-        if not os.path.isdir(quicklooks_base_dir):
-            os.makedirs(quicklooks_base_dir)
+            quicklooks_output_dir = os.path.join(downloader_output_dir, "quicklooks")
+        if not os.path.isdir(quicklooks_output_dir):
+            os.makedirs(quicklooks_output_dir)
         quicklook_file = os.path.join(
-            quicklooks_base_dir,
+            quicklooks_output_dir,
             filename if filename is not None else self.properties["id"],
         )
 

eodag/api/product/drivers/__init__.py

@@ -16,9 +16,14 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """EODAG drivers package"""
-from eodag.api.product.drivers.base import DatasetDriver, NoDriver  # noqa
+from eodag.api.product.drivers.base import DatasetDriver, NoDriver
 
 try:
-    from eodag_cube.api.product.drivers import DRIVERS
+    from eodag_cube.api.product.drivers import (  # pyright: ignore[reportMissingImports]
+        DRIVERS,
+    )
 except ImportError:
     DRIVERS = []
+
+# exportable content
+__all__ = ["DRIVERS", "DatasetDriver", "NoDriver"]

eodag/api/product/drivers/base.py

@@ -30,11 +30,8 @@ class DatasetDriver(metaclass=type):
         """Retrieve the address of the dataset represented by `eo_product`.
 
         :param eo_product: The product whom underlying dataset address is to be retrieved
-        :type eo_product: :class:`~eodag.api.product._product.EOProduct`
         :param band: The band to retrieve (e.g: 'B01')
-        :type band: str
         :returns: An address for the dataset
-        :rtype: str
         :raises: :class:`~eodag.utils.exceptions.AddressNotFound`
         :raises: :class:`~eodag.utils.exceptions.UnsupportedDatasetAddressScheme`
         """

eodag/api/product/metadata_mapping.py

@@ -41,6 +41,7 @@ import geojson
 import orjson
 import pyproj
 from dateutil.parser import isoparse
+from dateutil.relativedelta import relativedelta
 from dateutil.tz import UTC, tzutc
 from jsonpath_ng.jsonpath import Child, JSONPath
 from lxml import etree
@@ -120,10 +121,8 @@ def get_metadata_path(
                       in the provider search config. For example, it is the list
                       `['productType', '$.properties.productType']` with the sample
                       above. Or the string `$.properties.id`.
-    :type map_value: str or list(str)
     :returns: Either, None and the path to the metadata value, or a list of converter
              and its args, and the path to the metadata value.
-    :rtype: tuple(list(str) or None, str)
     """
     path = get_metadata_path_value(map_value)
     try:
@@ -147,16 +146,14 @@ def get_search_param(map_value: List[str]) -> str:
 
     :param map_value: The value originating from the definition of `metadata_mapping`
                       in the provider search config
-    :type map_value: list
     :returns: The value of the search parameter as defined in the provider config
-    :rtype: str
     """
     # Assume that caller will pass in the value as a list
     return map_value[0]
 
 
 def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
-    """Format a string of form {<field_name>#<conversion_function>}
+    """Format a string of form ``{<field_name>#<conversion_function>}``
 
     The currently understood converters are:
         - ``datetime_to_timestamp_milliseconds``: converts a utc date string to a timestamp in
@@ -190,13 +187,9 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
         - ``get_ecmwf_time``: get the time of a datetime string in the ECMWF format
 
     :param search_param: The string to be formatted
-    :type search_param: str
     :param args: (optional) Additional arguments to use in the formatting process
-    :type args: tuple
     :param kwargs: (optional) Additional named-arguments to use when formatting
-    :type kwargs: Any
     :returns: The formatted string
-    :rtype: str
     """
 
     class MetadataFormatter(Formatter):
@@ -839,7 +832,7 @@ def format_metadata(search_param: str, *args: Any, **kwargs: Any) -> str:
         def convert_get_hydrological_year(date: str):
             utc_date = MetadataFormatter.convert_to_iso_utc_datetime(date)
             date_object = datetime.strptime(utc_date, "%Y-%m-%dT%H:%M:%S.%fZ")
-            date_object_second_year = date_object + timedelta(days=365)
+            date_object_second_year = date_object + relativedelta(years=1)
             return [
                 f'{date_object.strftime("%Y")}_{date_object_second_year.strftime("%y")}'
             ]
@@ -926,7 +919,6 @@ def properties_from_json(
     """Extract properties from a provider json result.
 
     :param json: The representation of a provider result as a json object
-    :type json: dict
     :param mapping: A mapping between :class:`~eodag.api.product._product.EOProduct`'s metadata
                     keys and the location of the values of these properties in the json
                     representation, expressed as a
@@ -934,9 +926,7 @@ def properties_from_json(
     :param discovery_config: (optional) metadata discovery configuration dict, accepting among other items
                              `discovery_pattern` (Regex pattern for metadata key discovery, e.g. "^[a-zA-Z]+$"),
                              `discovery_path` (String representation of jsonpath)
-    :type discovery_config: dict
     :returns: The metadata of the :class:`~eodag.api.product._product.EOProduct`
-    :rtype: dict
     """
     properties: Dict[str, Any] = {}
     templates = {}
@@ -1073,7 +1063,6 @@ def properties_from_xml(
     """Extract properties from a provider xml result.
 
     :param xml_as_text: The representation of a provider result as xml
-    :type xml_as_text: str
     :param mapping: A mapping between :class:`~eodag.api.product._product.EOProduct`'s metadata
                     keys and the location of the values of these properties in the xml
                     representation, expressed as a
@@ -1083,13 +1072,10 @@ def properties_from_xml(
                             not supporting empty namespace prefix. The
                             xpath in `mapping` must use this value to be able to
                             correctly reach empty-namespace prefixed elements
-    :type empty_ns_prefix: str
     :param discovery_config: (optional) metadata discovery configuration dict, accepting among other items
                              `discovery_pattern` (Regex pattern for metadata key discovery, e.g. "^[a-zA-Z]+$"),
                              `discovery_path` (String representation of xpath)
-    :type discovery_config: dict
     :returns: the metadata of the :class:`~eodag.api.product._product.EOProduct`
-    :rtype: dict
     """
     properties: Dict[str, Any] = {}
     templates = {}
@@ -1223,16 +1209,13 @@ def mtd_cfg_as_conversion_and_querypath(
     dest_dict: Dict[str, Any] = {},
     result_type: str = "json",
 ) -> Dict[str, Any]:
-    """Metadata configuration dictionary to querypath with conversion dictionnary
+    """Metadata configuration dictionary to querypath with conversion dictionary
     Transform every src_dict value from jsonpath_str to tuple `(conversion, jsonpath_object)`
     or from xpath_str to tuple `(conversion, xpath_str)`
 
     :param src_dict: Input dict containing jsonpath str as values
-    :type src_dict: dict
     :param dest_dict: (optional) Output dict containing jsonpath objects as values
-    :type dest_dict: dict
     :returns: dest_dict
-    :rtype: dict
     """
     # check if the configuration has already been converted
     some_configured_value = (
@@ -1476,13 +1459,18 @@ def get_queryable_from_provider(
     """Get EODAG configured queryable parameter from provider queryable parameter
 
     :param provider_queryable: provider queryable parameter
-    :type provider_queryable: str
     :param metadata_mapping: metadata-mapping configuration
-    :type metadata_mapping: Dict[str, Union[str, List[str]]])
     :returns: EODAG configured queryable parameter or None
-    :rtype: Optional[str]
     """
     pattern = rf"\b{provider_queryable}\b"
+    # if 1:1 mapping exists privilege this one instead of other mapping
+    # e.g. provider queryable = year -> use year and not date in which year also appears
+    mapping_values = [
+        v[0] if isinstance(v, list) else "" for v in metadata_mapping.values()
+    ]
+    if provider_queryable in mapping_values:
+        ind = mapping_values.index(provider_queryable)
+        return Queryables.get_queryable_from_alias(list(metadata_mapping.keys())[ind])
     for param, param_conf in metadata_mapping.items():
         if isinstance(param_conf, list) and re.search(pattern, param_conf[0]):
             return Queryables.get_queryable_from_alias(param)
@@ -1495,11 +1483,8 @@ def get_provider_queryable_path(
     """Get EODAG configured queryable path from its parameter
 
     :param queryable: eodag queryable parameter
-    :type queryable: str
     :param metadata_mapping: metadata-mapping configuration
-    :type metadata_mapping: Dict[str, Union[str, List[str]]])
     :returns: EODAG configured queryable path or None
-    :rtype: Optional[str]
     """
     parameter_conf = metadata_mapping.get(queryable, None)
     if isinstance(parameter_conf, list):
@@ -1515,13 +1500,9 @@ def get_provider_queryable_key(
 ) -> str:
     """finds the provider queryable corresponding to the given eodag key based on the metadata mapping
     :param eodag_key: key in eodag
-    :type eodag_key: str
     :param provider_queryables: queryables returned from the provider
-    :type provider_queryables: dict
     :param metadata_mapping: metadata mapping from which the keys are retrieved
-    :type metadata_mapping: Dict[str, Union[List[Any], str]]
     :returns: provider queryable key
-    :rtype: str
     """
     if eodag_key not in metadata_mapping:
         return ""

eodag/api/search_result.py

@@ -18,9 +18,20 @@
 from __future__ import annotations
 
 from collections import UserList
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Union
+from typing import (
+    TYPE_CHECKING,
+    Annotated,
+    Any,
+    Dict,
+    Iterable,
+    List,
+    Optional,
+    Tuple,
+    Union,
+)
 
 from shapely.geometry import GeometryCollection, shape
+from typing_extensions import Doc
 
 from eodag.api.product import EOProduct
 from eodag.plugins.crunch.filter_date import FilterDate
@@ -39,28 +50,34 @@ class SearchResult(UserList):
     """An object representing a collection of :class:`~eodag.api.product._product.EOProduct` resulting from a search.
 
     :param products: A list of products resulting from a search
-    :type products: list(:class:`~eodag.api.product._product.EOProduct`)
     :param number_matched: (optional) the estimated total number of matching results
-    :type number_matched: Optional[int]
+
+    :cvar data: List of products
+    :ivar number_matched: Estimated total number of matching results
     """
 
     data: List[EOProduct]
 
+    errors: Annotated[
+        List[Tuple[str, Exception]], Doc("Tuple of provider name, exception")
+    ]
+
     def __init__(
-        self, products: List[EOProduct], number_matched: Optional[int] = None
+        self,
+        products: List[EOProduct],
+        number_matched: Optional[int] = None,
+        errors: List[Tuple[str, Exception]] = [],
     ) -> None:
-        super(SearchResult, self).__init__(products)
+        super().__init__(products)
         self.number_matched = number_matched
+        self.errors = errors
 
     def crunch(self, cruncher: Crunch, **search_params: Any) -> SearchResult:
         """Do some crunching with the underlying EO products.
 
         :param cruncher: The plugin instance to use to work on the products
-        :type cruncher: subclass of :class:`~eodag.plugins.crunch.base.Crunch`
         :param search_params: The criteria that have been used to produce this result
-        :type search_params: dict
         :returns: The result of the application of the crunching method to the EO products
-        :rtype: :class:`~eodag.api.search_result.SearchResult`
         """
         crunched_results = cruncher.proceed(self.data, **search_params)
         return SearchResult(crunched_results)
@@ -135,9 +152,7 @@ class SearchResult(UserList):
         """Builds an :class:`~eodag.api.search_result.SearchResult` object from its representation as geojson
 
         :param feature_collection: A collection representing a search result.
-        :type feature_collection: dict
         :returns: An eodag representation of a search result
-        :rtype: :class:`~eodag.api.search_result.SearchResult`
         """
         return SearchResult(
             [
@@ -154,7 +169,7 @@ class SearchResult(UserList):
         }
 
     def as_shapely_geometry_object(self) -> GeometryCollection:
-        """:class:`shapely.geometry.GeometryCollection` representation of SearchResult"""
+        """:class:`shapely.GeometryCollection` representation of SearchResult"""
         return GeometryCollection(
             [
                 shape(feature["geometry"]).buffer(0)
@@ -201,12 +216,18 @@ class SearchResult(UserList):
             + "</table>"
         )
 
+    def extend(self, other: Iterable) -> None:
+        """override extend method to include errors"""
+        if isinstance(other, SearchResult):
+            self.errors.extend(other.errors)
+
+        return super().extend(other)
+
 
 class RawSearchResult(UserList):
     """An object representing a collection of raw/unparsed search results obtained from a provider.
 
     :param results: A list of raw/unparsed search results
-    :type results: List[Any]
     """
 
     data: List[Any]

eodag/cli.py

@@ -39,6 +39,7 @@ Commands:
 
   noqa: D103
 """
+
 from __future__ import annotations
 
 import json
@@ -553,12 +554,13 @@ def download(ctx: Context, **kwargs: Any) -> None:
 
         for idx, product in enumerate(search_results):
             if product.downloader is None:
+                downloader = satim_api._plugins_manager.get_download_plugin(product)
                 auth = product.downloader_auth
                 if auth is None:
-                    auth = satim_api._plugins_manager.get_auth_plugin(product.provider)
-                search_results[idx].register_downloader(
-                    satim_api._plugins_manager.get_download_plugin(product), auth
-                )
+                    auth = satim_api._plugins_manager.get_auth_plugin(
+                        downloader, product
+                    )
+                search_results[idx].register_downloader(downloader, auth)
 
             downloaded_file = product.get_quicklook()
             if not downloaded_file:
@@ -573,12 +575,13 @@ def download(ctx: Context, **kwargs: Any) -> None:
         # register downloader
         for idx, product in enumerate(search_results):
             if product.downloader is None:
+                downloader = satim_api._plugins_manager.get_download_plugin(product)
                 auth = product.downloader_auth
                 if auth is None:
-                    auth = satim_api._plugins_manager.get_auth_plugin(product.provider)
-                search_results[idx].register_downloader(
-                    satim_api._plugins_manager.get_download_plugin(product), auth
-                )
+                    auth = satim_api._plugins_manager.get_auth_plugin(
+                        downloader, product
+                    )
+                search_results[idx].register_downloader(downloader, auth)
 
         downloaded_files = satim_api.download_all(search_results)
         if downloaded_files and len(downloaded_files) > 0:
@@ -684,19 +687,32 @@ def serve_rest(
         else:
             sys.exit(0)
     else:
+        import logging
+
         logging_config = uvicorn.config.LOGGING_CONFIG
-        if debug:
-            logging_config["loggers"]["uvicorn"]["level"] = "DEBUG"
-            logging_config["loggers"]["uvicorn.error"]["level"] = "DEBUG"
-            logging_config["loggers"]["uvicorn.access"]["level"] = "DEBUG"
-            logging_config["formatters"]["default"][
-                "fmt"
-            ] = "%(asctime)-15s %(name)-32s [%(levelname)-8s] (%(module)-17s) %(message)s"
-            logging_config["loggers"]["eodag"] = {
-                "handlers": ["default"],
-                "level": "DEBUG" if debug else "INFO",
-                "propagate": False,
+        uvicorn_fmt = "%(asctime)-15s %(name)-32s [%(levelname)-8s] %(message)s"
+        logging_config["formatters"]["access"]["fmt"] = uvicorn_fmt
+        logging_config["formatters"]["default"]["fmt"] = uvicorn_fmt
+
+        eodag_formatter = logging.Formatter(
+            "%(asctime)-15s %(name)-32s [%(levelname)-8s] (tid=%(thread)d) %(message)s"
+        )
+        logging.getLogger("eodag").handlers[0].setFormatter(eodag_formatter)
+
+        if ctx.obj["verbosity"] <= 1:
+            logging_config["handlers"]["null"] = {
+                "level": "DEBUG",
+                "class": "logging.NullHandler",
             }
+            logging_config["loggers"]["uvicorn"]["handlers"] = ["null"]
+            logging_config["loggers"]["uvicorn.error"]["handlers"] = ["null"]
+            logging_config["loggers"]["uvicorn.access"]["handlers"] = ["null"]
+        else:
+            log_level = "INFO" if ctx.obj["verbosity"] == 2 else "DEBUG"
+            logging_config["loggers"]["uvicorn"]["level"] = log_level
+            logging_config["loggers"]["uvicorn.error"]["level"] = log_level
+            logging_config["loggers"]["uvicorn.access"]["level"] = log_level
+
         uvicorn.run(
             "eodag.rest.server:app",
             host=bind_host,