eodag 3.1.0b1__py3-none-any.whl → 3.2.0__py3-none-any.whl

eodag/plugins/download/creodias_s3.py

@@ -15,7 +15,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from typing import List, Optional, Tuple
+from typing import Optional
 
 import boto3
 from botocore.exceptions import ClientError
@@ -73,7 +73,7 @@ class CreodiasS3Download(AwsDownload):
         product: EOProduct,
         asset_filter: Optional[str] = None,
         ignore_assets: Optional[bool] = False,
-    ) -> List[Tuple[str, Optional[str]]]:
+    ) -> list[tuple[str, Optional[str]]]:
         """
         Retrieves the bucket names and path prefixes for the assets
 

eodag/plugins/download/http.py

@@ -28,17 +28,7 @@ from email.message import Message
 from itertools import chain
 from json import JSONDecodeError
 from pathlib import Path
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    TypedDict,
-    Union,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, Iterator, Optional, TypedDict, Union, cast
 from urllib.parse import parse_qs, urlparse
 
 import geojson
@@ -72,6 +62,7 @@ from eodag.utils import (
     guess_file_type,
     parse_header,
     path_to_uri,
+    rename_with_version,
     sanitize,
     string_to_jsonpath,
     uri_to_path,
@@ -91,6 +82,7 @@ if TYPE_CHECKING:
     from eodag.api.product import Asset, EOProduct  # type: ignore
     from eodag.api.search_result import SearchResult
     from eodag.config import PluginConfig
+    from eodag.types import S3SessionKwargs
     from eodag.types.download_args import DownloadConf
     from eodag.utils import DownloadedCallback, Unpack
 
@@ -111,7 +103,7 @@ class HTTPDownload(Download):
           extracted; default: ``True``
         * :attr:`~eodag.config.PluginConfig.auth_error_code` (``int``): which error code is returned in case of an
           authentication error
-        * :attr:`~eodag.config.PluginConfig.dl_url_params` (``Dict[str, Any]``): parameters to be
+        * :attr:`~eodag.config.PluginConfig.dl_url_params` (``dict[str, Any]``): parameters to be
           added to the query params of the request
         * :attr:`~eodag.config.PluginConfig.archive_depth` (``int``): level in extracted path tree where to find data;
           default: ``1``
@@ -130,7 +122,7 @@ class HTTPDownload(Download):
           the search plugin used for the provider; default: ``False``
         * :attr:`~eodag.config.PluginConfig.order_method` (``str``): HTTP request method for the order request (``GET``
           or ``POST``); default: ``GET``
-        * :attr:`~eodag.config.PluginConfig.order_headers` (``[Dict[str, str]]``): headers to be added to the order
+        * :attr:`~eodag.config.PluginConfig.order_headers` (``[dict[str, str]]``): headers to be added to the order
           request
         * :attr:`~eodag.config.PluginConfig.order_on_response` (:class:`~eodag.config.PluginConfig.OrderOnResponse`):
           a typed dictionary containing the key ``metadata_mapping`` which can be used to add new product properties
@@ -138,7 +130,7 @@ class HTTPDownload(Download):
         * :attr:`~eodag.config.PluginConfig.order_status` (:class:`~eodag.config.PluginConfig.OrderStatus`):
           configuration to handle the order status; contains information which method to use, how the response data is
           interpreted, which status corresponds to success, ordered and error and what should be done on success.
-        * :attr:`~eodag.config.PluginConfig.products` (``Dict[str, Dict[str, Any]``): product type specific config; the
+        * :attr:`~eodag.config.PluginConfig.products` (``dict[str, dict[str, Any]``): product type specific config; the
           keys are the product types, the values are dictionaries which can contain the key
           :attr:`~eodag.config.PluginConfig.extract` to overwrite the provider config for a specific product type
 
@@ -152,7 +144,7 @@ class HTTPDownload(Download):
         product: EOProduct,
         auth: Optional[AuthBase] = None,
         **kwargs: Unpack[DownloadConf],
-    ) -> Optional[Dict[str, Any]]:
+    ) -> Optional[dict[str, Any]]:
         """Send product order request.
 
         It will be executed once before the download retry loop, if the product is OFFLINE
@@ -184,7 +176,7 @@ class HTTPDownload(Download):
         ssl_verify = getattr(self.config, "ssl_verify", True)
         timeout = getattr(self.config, "timeout", HTTP_REQ_TIMEOUT)
         OrderKwargs = TypedDict(
-            "OrderKwargs", {"json": Dict[str, Union[Any, List[str]]]}, total=False
+            "OrderKwargs", {"json": dict[str, Union[Any, list[str]]]}, total=False
         )
         order_kwargs: OrderKwargs = {}
         if order_method == "POST":
@@ -236,7 +228,7 @@ class HTTPDownload(Download):
 
     def order_response_process(
         self, response: Response, product: EOProduct
-    ) -> Optional[Dict[str, Any]]:
+    ) -> Optional[dict[str, Any]]:
         """Process order response
 
         :param response: The order response
@@ -300,7 +292,7 @@ class HTTPDownload(Download):
         def _request(
             url: str,
             method: str = "GET",
-            headers: Optional[Dict[str, Any]] = None,
+            headers: Optional[dict[str, Any]] = None,
             json: Optional[Any] = None,
             timeout: int = HTTP_REQ_TIMEOUT,
         ) -> Response:
@@ -336,7 +328,7 @@ class HTTPDownload(Download):
             except requests.exceptions.Timeout as exc:
                 raise TimeOutError(exc, timeout=timeout) from exc
 
-        status_request: Dict[str, Any] = status_config.get("request", {})
+        status_request: dict[str, Any] = status_config.get("request", {})
         status_request_method = str(status_request.get("method", "GET")).upper()
 
         if status_request_method == "POST":
@@ -353,8 +345,8 @@ class HTTPDownload(Download):
 
         # check header for success before full status request
         skip_parsing_status_response = False
-        status_dict: Dict[str, Any] = {}
-        config_on_success: Dict[str, Any] = status_config.get("on_success", {})
+        status_dict: dict[str, Any] = {}
+        config_on_success: dict[str, Any] = status_config.get("on_success", {})
         on_success_mm = config_on_success.get("metadata_mapping", {})
 
         status_response_content_needed = (
@@ -438,13 +430,13 @@ class HTTPDownload(Download):
             product.properties["orderStatus"] = status_dict.get("status")
 
             # handle status error
-            errors: Dict[str, Any] = status_config.get("error", {})
+            errors: dict[str, Any] = status_config.get("error", {})
             if errors and errors.items() <= status_dict.items():
                 raise DownloadError(
                     f"Provider {product.provider} returned: {status_dict.get('error_message', status_message)}"
                 )
 
-        success_status: Dict[str, Any] = status_config.get("success", {}).get("status")
+        success_status: dict[str, Any] = status_config.get("success", {}).get("status")
         # if not success
         if (success_status and success_status != status_dict.get("status")) or (
             success_code and success_code != response.status_code
@@ -562,7 +554,7 @@ class HTTPDownload(Download):
     def download(
         self,
         product: EOProduct,
-        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
+        auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
         progress_callback: Optional[ProgressCallback] = None,
         wait: float = DEFAULT_DOWNLOAD_WAIT,
         timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
@@ -666,6 +658,8 @@ class HTTPDownload(Download):
                 os.path.dirname(path),
                 sanitize(product.properties["title"]),
             )
+            if os.path.isfile(new_fs_path):
+                rename_with_version(new_fs_path)
             if not os.path.isdir(new_fs_path):
                 os.makedirs(new_fs_path)
             shutil.move(path, new_fs_path)
@@ -719,7 +713,7 @@ class HTTPDownload(Download):
     def _stream_download_dict(
         self,
         product: EOProduct,
-        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
+        auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
         progress_callback: Optional[ProgressCallback] = None,
         wait: float = DEFAULT_DOWNLOAD_WAIT,
         timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
@@ -778,13 +772,17 @@ class HTTPDownload(Download):
                     )
 
                 else:
+                    # get first chunk to check if it does not contain an error (if it does, that error will be raised)
+                    first_chunks_tuple = next(chunks_tuples)
                     outputs_filename = (
                         sanitize(product.properties["title"])
                         if "title" in product.properties
                         else sanitize(product.properties.get("id", "download"))
                     )
                     return StreamResponse(
-                        content=stream_zip(chunks_tuples),
+                        content=stream_zip(
+                            chain(iter([first_chunks_tuple]), chunks_tuples)
+                        ),
                         media_type="application/zip",
                         headers={
                             "content-disposition": f"attachment; filename={outputs_filename}.zip",
@@ -888,7 +886,7 @@ class HTTPDownload(Download):
     def order(
         self,
         product: EOProduct,
-        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
+        auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
         wait: float = DEFAULT_DOWNLOAD_WAIT,
         timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
     ) -> None:
@@ -951,7 +949,7 @@ class HTTPDownload(Download):
             if not query_dict and parts.query:
                 query_dict = geojson.loads(parts.query)
             req_url = parts._replace(query="").geturl()
-            req_kwargs: Dict[str, Any] = {"json": query_dict} if query_dict else {}
+            req_kwargs: dict[str, Any] = {"json": query_dict} if query_dict else {}
         else:
             req_url = url
             req_kwargs = {}
@@ -1019,7 +1017,7 @@ class HTTPDownload(Download):
         product: EOProduct,
         auth: Optional[AuthBase] = None,
         progress_callback: Optional[ProgressCallback] = None,
-        assets_values: List[Asset] = [],
+        assets_values: list[Asset] = [],
         **kwargs: Unpack[DownloadConf],
     ) -> Iterator[Any]:
         if progress_callback is None:
@@ -1289,9 +1287,9 @@ class HTTPDownload(Download):
 
     def _get_asset_sizes(
         self,
-        assets_values: List[Asset],
+        assets_values: list[Asset],
         auth: Optional[AuthBase],
-        params: Optional[Dict[str, str]],
+        params: Optional[dict[str, str]],
         zipped: bool = False,
     ) -> int:
         total_size = 0
@@ -1364,7 +1362,7 @@ class HTTPDownload(Download):
     def download_all(
         self,
         products: SearchResult,
-        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
+        auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
         downloaded_callback: Optional[DownloadedCallback] = None,
         progress_callback: Optional[ProgressCallback] = None,
         wait: float = DEFAULT_DOWNLOAD_WAIT,

eodag/plugins/download/s3rest.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 import logging
 import os
 import os.path
-from typing import TYPE_CHECKING, Dict, List, Optional, Union
+from typing import TYPE_CHECKING, Optional, Union
 from xml.dom import minidom
 from xml.parsers.expat import ExpatError
 
@@ -54,6 +54,7 @@ from eodag.utils.exceptions import (
 if TYPE_CHECKING:
     from eodag.api.product import EOProduct
     from eodag.config import PluginConfig
+    from eodag.types import S3SessionKwargs
     from eodag.types.download_args import DownloadConf
     from eodag.utils import Unpack
 
@@ -78,7 +79,7 @@ class S3RestDownload(Download):
         * :attr:`~eodag.config.PluginConfig.order_enabled` (``bool``): whether order is enabled
           or not if product is `OFFLINE`
         * :attr:`~eodag.config.PluginConfig.order_method` (``str``) HTTP request method, ``GET`` (default) or ``POST``
-        * :attr:`~eodag.config.PluginConfig.order_headers` (``[Dict[str, str]]``): order request headers
+        * :attr:`~eodag.config.PluginConfig.order_headers` (``[dict[str, str]]``): order request headers
         * :attr:`~eodag.config.PluginConfig.order_on_response` (:class:`~eodag.config.PluginConfig.OrderOnResponse`):
           a typed dictionary containing the key :attr:`~eodag.config.PluginConfig.OrderOnResponse.metadata_mapping`
           which can be used to add new product properties based on the data in response to the order request
@@ -93,7 +94,7 @@ class S3RestDownload(Download):
     def download(
         self,
         product: EOProduct,
-        auth: Optional[Union[AuthBase, Dict[str, str]]] = None,
+        auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
         progress_callback: Optional[ProgressCallback] = None,
         wait: float = DEFAULT_DOWNLOAD_WAIT,
         timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
@@ -270,7 +271,7 @@ class S3RestDownload(Download):
                 os.remove(record_filename)
 
             # total size for progress_callback
-            size_list: List[int] = [
+            size_list: list[int] = [
                 int(node.firstChild.nodeValue)  # type: ignore[attr-defined]
                 for node in xmldoc.getElementsByTagName("Size")
                 if node.firstChild is not None

eodag/plugins/manager.py

@@ -21,18 +21,7 @@ import logging
 import re
 from operator import attrgetter
 from pathlib import Path
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Dict,
-    Iterator,
-    List,
-    Optional,
-    Tuple,
-    Type,
-    Union,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, Iterator, Optional, Union, cast
 
 import pkg_resources
 
@@ -61,6 +50,7 @@ if TYPE_CHECKING:
     from eodag.api.product import EOProduct
     from eodag.config import PluginConfig, ProviderConfig
     from eodag.plugins.base import PluginTopic
+    from eodag.types import S3SessionKwargs
 
 
 logger = logging.getLogger("eodag.plugins.manager")
@@ -84,11 +74,11 @@ class PluginManager:
 
     supported_topics = set(PLUGINS_TOPICS_KEYS)
 
-    product_type_to_provider_config_map: Dict[str, List[ProviderConfig]]
+    product_type_to_provider_config_map: dict[str, list[ProviderConfig]]
 
-    skipped_plugins: List[str]
+    skipped_plugins: list[str]
 
-    def __init__(self, providers_config: Dict[str, ProviderConfig]) -> None:
+    def __init__(self, providers_config: dict[str, ProviderConfig]) -> None:
         self.skipped_plugins = []
         self.providers_config = providers_config
         # Load all the plugins. This will make all plugin classes of a particular
@@ -144,14 +134,14 @@ class PluginManager:
         self.rebuild()
 
     def rebuild(
-        self, providers_config: Optional[Dict[str, ProviderConfig]] = None
+        self, providers_config: Optional[dict[str, ProviderConfig]] = None
     ) -> None:
         """(Re)Build plugin manager mapping and cache"""
         if providers_config is not None:
             self.providers_config = providers_config
 
         self.build_product_type_to_provider_config_map()
-        self._built_plugins_cache: Dict[Tuple[str, str, str], Any] = {}
+        self._built_plugins_cache: dict[tuple[str, str, str], Any] = {}
 
     def build_product_type_to_provider_config_map(self) -> None:
         """Build mapping conf between product types and providers"""
@@ -211,7 +201,7 @@ class PluginManager:
                 )
             return plugin
 
-        configs: Optional[List[ProviderConfig]]
+        configs: Optional[list[ProviderConfig]]
         if product_type:
             configs = self.product_type_to_provider_config_map.get(product_type)
             if not configs:
@@ -378,7 +368,7 @@ class PluginManager:
         provider: str,
         matching_url: Optional[str] = None,
         matching_conf: Optional[PluginConfig] = None,
-    ) -> Optional[Union[AuthBase, Dict[str, str]]]:
+    ) -> Optional[Union[AuthBase, S3SessionKwargs]]:
         """Authenticate and return the authenticated object for the first matching
         authentication plugin
 
@@ -447,7 +437,7 @@ class PluginManager:
         self,
         provider: str,
         plugin_conf: PluginConfig,
-        topic_class: Type[PluginTopic],
+        topic_class: type[PluginTopic],
     ) -> Union[Api, Search, Download, Authentication, Crunch]:
         """Build the plugin of the given topic with the given plugin configuration and
         registered as the given provider

eodag/plugins/search/__init__.py

@@ -24,11 +24,12 @@ from typing import TYPE_CHECKING
 from eodag.utils import DEFAULT_ITEMS_PER_PAGE, DEFAULT_PAGE
 
 if TYPE_CHECKING:
-    from typing import Any, Dict, List, Optional, Union
+    from typing import Any, Optional, Union
 
     from requests.auth import AuthBase
 
     from eodag.plugins.authentication.base import Authentication
+    from eodag.types import S3SessionKwargs
 
 
 @dataclass
@@ -38,7 +39,7 @@ class PreparedSearch:
     product_type: Optional[str] = None
     page: Optional[int] = DEFAULT_PAGE
     items_per_page: Optional[int] = DEFAULT_ITEMS_PER_PAGE
-    auth: Optional[Union[AuthBase, Dict[str, str]]] = None
+    auth: Optional[Union[AuthBase, S3SessionKwargs]] = None
     auth_plugin: Optional[Authentication] = None
     count: bool = True
     url: Optional[str] = None
@@ -46,9 +47,9 @@ class PreparedSearch:
     exception_message: Optional[str] = None
 
     need_count: bool = field(init=False, repr=False)
-    query_params: Dict[str, Any] = field(init=False, repr=False)
+    query_params: dict[str, Any] = field(init=False, repr=False)
     query_string: str = field(init=False, repr=False)
-    search_urls: List[str] = field(init=False, repr=False)
-    product_type_def_params: Dict[str, Any] = field(init=False, repr=False)
+    search_urls: list[str] = field(init=False, repr=False)
+    product_type_def_params: dict[str, Any] = field(init=False, repr=False)
     total_items_nb: int = field(init=False, repr=False)
     sort_by_qs: str = field(init=False, repr=False)

eodag/plugins/search/base.py

@@ -43,12 +43,13 @@ from eodag.utils import (
 from eodag.utils.exceptions import ValidationError
 
 if TYPE_CHECKING:
-    from typing import Any, Dict, List, Optional, Tuple, Union
+    from typing import Any, Optional, Union
 
     from requests.auth import AuthBase
 
     from eodag.api.product import EOProduct
     from eodag.config import PluginConfig
+    from eodag.types import S3SessionKwargs
 
 logger = logging.getLogger("eodag.search.base")
 
@@ -60,9 +61,9 @@ class Search(PluginTopic):
     :param config: An EODAG plugin configuration
     """
 
-    auth: Union[AuthBase, Dict[str, str]]
+    auth: Union[AuthBase, S3SessionKwargs]
     next_page_url: Optional[str]
-    next_page_query_obj: Optional[Dict[str, Any]]
+    next_page_query_obj: Optional[dict[str, Any]]
     total_items_nb: int
     need_count: bool
     _request: Any  # needed by deprecated load_stac_items
@@ -71,7 +72,7 @@ class Search(PluginTopic):
         super(Search, self).__init__(provider, config)
         # Prepare the metadata mapping
         # Do a shallow copy, the structure is flat enough for this to be sufficient
-        metas: Dict[str, Any] = DEFAULT_METADATA_MAPPING.copy()
+        metas: dict[str, Any] = DEFAULT_METADATA_MAPPING.copy()
         # Update the defaults with the mapping value. This will add any new key
         # added by the provider mapping that is not in the default metadata
         if self.config.metadata_mapping:
@@ -90,7 +91,7 @@ class Search(PluginTopic):
         self,
         prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
-    ) -> Tuple[List[EOProduct], Optional[int]]:
+    ) -> tuple[list[EOProduct], Optional[int]]:
         """Implementation of how the products must be searched goes here.
 
         This method must return a tuple with (1) a list of :class:`~eodag.api.product._product.EOProduct` instances
@@ -99,13 +100,13 @@ class Search(PluginTopic):
         """
         raise NotImplementedError("A Search plugin must implement a method named query")
 
-    def discover_product_types(self, **kwargs: Any) -> Optional[Dict[str, Any]]:
+    def discover_product_types(self, **kwargs: Any) -> Optional[dict[str, Any]]:
         """Fetch product types list from provider using `discover_product_types` conf"""
         return None
 
     def discover_queryables(
         self, **kwargs: Any
-    ) -> Optional[Dict[str, Annotated[Any, FieldInfo]]]:
+    ) -> Optional[dict[str, Annotated[Any, FieldInfo]]]:
         """Fetch queryables list from provider using :attr:`~eodag.config.PluginConfig.discover_queryables` conf
 
         :param kwargs: additional filters for queryables (``productType`` and other search
@@ -118,7 +119,7 @@ class Search(PluginTopic):
 
     def _get_defaults_as_queryables(
         self, product_type: str
-    ) -> Dict[str, Annotated[Any, FieldInfo]]:
+    ) -> dict[str, Annotated[Any, FieldInfo]]:
         """
         Return given product type default settings as queryables
 
@@ -128,7 +129,7 @@ class Search(PluginTopic):
         defaults = deepcopy(self.config.products.get(product_type, {}))
         defaults.pop("metadata_mapping", None)
 
-        queryables: Dict[str, Annotated[Any, FieldInfo]] = {}
+        queryables: dict[str, Annotated[Any, FieldInfo]] = {}
         for parameter, value in defaults.items():
             queryables[parameter] = Annotated[type(value), Field(default=value)]
         return queryables
@@ -149,8 +150,8 @@ class Search(PluginTopic):
         )
 
     def get_product_type_def_params(
-        self, product_type: str, **kwargs: Any
-    ) -> Dict[str, Any]:
+        self, product_type: str, format_variables: Optional[dict[str, Any]] = None
+    ) -> dict[str, Any]:
         """Get the provider product type definition parameters and specific settings
 
         :param product_type: the desired product type
@@ -170,7 +171,8 @@ class Search(PluginTopic):
             return {
                 k: v
                 for k, v in format_dict_items(
-                    self.config.products[GENERIC_PRODUCT_TYPE], **kwargs
+                    self.config.products[GENERIC_PRODUCT_TYPE],
+                    **(format_variables or {}),
                 ).items()
                 if v
             }
@@ -200,7 +202,7 @@ class Search(PluginTopic):
 
     def get_metadata_mapping(
         self, product_type: Optional[str] = None
-    ) -> Dict[str, Union[str, List[str]]]:
+    ) -> dict[str, Union[str, list[str]]]:
         """Get the plugin metadata mapping configuration (product type specific if exists)
 
         :param product_type: the desired product type
@@ -212,7 +214,7 @@ class Search(PluginTopic):
             )
         return self.config.metadata_mapping
 
-    def get_sort_by_arg(self, kwargs: Dict[str, Any]) -> Optional[SortByList]:
+    def get_sort_by_arg(self, kwargs: dict[str, Any]) -> Optional[SortByList]:
         """Extract the ``sort_by`` argument from the kwargs or the provider default sort configuration
 
         :param kwargs: Search arguments
@@ -233,7 +235,7 @@ class Search(PluginTopic):
 
     def build_sort_by(
         self, sort_by_arg: SortByList
-    ) -> Tuple[str, Dict[str, List[Dict[str, str]]]]:
+    ) -> tuple[str, dict[str, list[dict[str, str]]]]:
         """Build the sorting part of the query string or body by transforming
         the ``sort_by`` argument into a provider-specific string or dictionary
 
@@ -247,9 +249,9 @@ class Search(PluginTopic):
         sort_by_arg = list(dict.fromkeys(sort_by_arg))
 
         sort_by_qs: str = ""
-        sort_by_qp: Dict[str, Any] = {}
+        sort_by_qp: dict[str, Any] = {}
 
-        provider_sort_by_tuples_used: List[Tuple[str, str]] = []
+        provider_sort_by_tuples_used: list[tuple[str, str]] = []
         for eodag_sort_by_tuple in sort_by_arg:
             eodag_sort_param = eodag_sort_by_tuple[0]
             provider_sort_param = self.config.sort["sort_param_mapping"].get(
@@ -282,7 +284,7 @@ class Search(PluginTopic):
                 if eodag_sort_order == "ASC"
                 else self.config.sort["sort_order_mapping"]["descending"]
             )
-            provider_sort_by_tuple: Tuple[str, str] = (
+            provider_sort_by_tuple: tuple[str, str] = (
                 provider_sort_param,
                 provider_sort_order,
             )
@@ -315,7 +317,7 @@ class Search(PluginTopic):
                 sort_order=provider_sort_by_tuple[1],
             )
             try:
-                parsed_sort_by_tpl_dict: Dict[str, Any] = orjson.loads(
+                parsed_sort_by_tpl_dict: dict[str, Any] = orjson.loads(
                     parsed_sort_by_tpl
                 )
                 sort_by_qp = update_nested_dict(
@@ -326,23 +328,25 @@ class Search(PluginTopic):
         return (sort_by_qs, sort_by_qp)
 
     def _get_product_type_queryables(
-        self, product_type: Optional[str], alias: Optional[str], filters: Dict[str, Any]
-    ) -> Dict[str, Annotated[Any, FieldInfo]]:
-        default_values: Dict[str, Any] = deepcopy(
+        self, product_type: Optional[str], alias: Optional[str], filters: dict[str, Any]
+    ) -> QueryablesDict:
+        default_values: dict[str, Any] = deepcopy(
             getattr(self.config, "products", {}).get(product_type, {})
         )
         default_values.pop("metadata_mapping", None)
         try:
             filters["productType"] = product_type
-            return self.discover_queryables(**{**default_values, **filters}) or {}
+            queryables = self.discover_queryables(**{**default_values, **filters}) or {}
         except NotImplementedError:
-            return self.queryables_from_metadata_mapping(product_type, alias)
+            queryables = self.queryables_from_metadata_mapping(product_type, alias)
+
+        return QueryablesDict(**queryables)
 
     def list_queryables(
         self,
-        filters: Dict[str, Any],
-        available_product_types: List[Any],
-        product_type_configs: Dict[str, Dict[str, Any]],
+        filters: dict[str, Any],
+        available_product_types: list[Any],
+        product_type_configs: dict[str, dict[str, Any]],
         product_type: Optional[str] = None,
         alias: Optional[str] = None,
     ) -> QueryablesDict:
@@ -369,19 +373,11 @@ class Search(PluginTopic):
             if product_type:
                 self.config.product_type_config = product_type_configs[product_type]
             queryables = self._get_product_type_queryables(product_type, alias, filters)
-            if getattr(self.config, "discover_queryables", {}).get(
-                "constraints_url", ""
-            ):
-                additional_properties = False
-            else:
-                additional_properties = True
-            return QueryablesDict(
-                additional_properties=additional_properties,
-                additional_information=additional_info,
-                **queryables,
-            )
+            queryables.additional_information = additional_info
+
+            return queryables
         else:
-            all_queryables: Dict[str, Any] = {}
+            all_queryables: dict[str, Any] = {}
             for pt in available_product_types:
                 self.config.product_type_config = product_type_configs[pt]
                 pt_queryables = self._get_product_type_queryables(pt, None, filters)
@@ -399,18 +395,18 @@ class Search(PluginTopic):
 
     def queryables_from_metadata_mapping(
         self, product_type: Optional[str] = None, alias: Optional[str] = None
-    ) -> Dict[str, Annotated[Any, FieldInfo]]:
+    ) -> dict[str, Annotated[Any, FieldInfo]]:
         """
         Extract queryable parameters from product type metadata mapping.
         :param product_type: product type id (optional)
         :param alias: (optional) alias of the product type
         :returns: dict of annotated queryables
         """
-        metadata_mapping: Dict[str, Any] = deepcopy(
+        metadata_mapping: dict[str, Any] = deepcopy(
             self.get_metadata_mapping(product_type)
         )
 
-        queryables: Dict[str, Annotated[Any, FieldInfo]] = {}
+        queryables: dict[str, Annotated[Any, FieldInfo]] = {}
 
         for param in list(metadata_mapping.keys()):
             if NOT_MAPPED in metadata_mapping[param] or not isinstance(