eodag 3.10.1__py3-none-any.whl → 4.0.0a2__py3-none-any.whl

eodag/plugins/apis/usgs.py

@@ -31,10 +31,10 @@ from usgs import USGSAuthExpiredError, USGSError, api
 
 from eodag.api.product import EOProduct
 from eodag.api.product.metadata_mapping import (
-    DEFAULT_METADATA_MAPPING,
     mtd_cfg_as_conversion_and_querypath,
     properties_from_json,
 )
+from eodag.api.search_result import SearchResult
 from eodag.plugins.apis.base import Api
 from eodag.plugins.search import PreparedSearch
 from eodag.utils import (
@@ -42,7 +42,7 @@ from eodag.utils import (
     DEFAULT_DOWNLOAD_WAIT,
     DEFAULT_ITEMS_PER_PAGE,
     DEFAULT_PAGE,
-    GENERIC_PRODUCT_TYPE,
+    GENERIC_COLLECTION,
     USER_AGENT,
     ProgressCallback,
     format_dict_items,
@@ -50,7 +50,7 @@ from eodag.utils import (
 )
 from eodag.utils.exceptions import (
     AuthenticationError,
-    NoMatchingProductType,
+    NoMatchingCollection,
     NotAvailableError,
     RequestError,
     ValidationError,
@@ -60,9 +60,7 @@ if TYPE_CHECKING:
     from mypy_boto3_s3 import S3ServiceResource
     from requests.auth import AuthBase
 
-    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
 
@@ -101,7 +99,7 @@ class UsgsApi(Api):
         # Same method as in base.py, Search.__init__()
         # 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] = {}
         # 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.
         metas.update(self.config.metadata_mapping)
@@ -140,31 +138,38 @@ class UsgsApi(Api):
         self,
         prep: PreparedSearch = PreparedSearch(),
         **kwargs: Any,
-    ) -> tuple[list[EOProduct], Optional[int]]:
+    ) -> SearchResult:
         """Search for data on USGS catalogues"""
-        page = prep.page if prep.page is not None else DEFAULT_PAGE
+        token = (
+            int(prep.next_page_token)
+            if prep.next_page_token is not None
+            else DEFAULT_PAGE
+        )
         items_per_page = (
             prep.items_per_page
-            if prep.items_per_page is not None
-            else DEFAULT_ITEMS_PER_PAGE
+            or kwargs.pop("max_results", None)
+            or DEFAULT_ITEMS_PER_PAGE
         )
-        product_type = kwargs.get("productType")
-        if product_type is None:
-            raise NoMatchingProductType(
-                "Cannot search on USGS without productType specified"
+        search_params = {"items_per_page": items_per_page} | kwargs
+        collection = kwargs.get("collection")
+        if collection is None:
+            raise NoMatchingCollection(
+                "Cannot search on USGS without collection specified"
             )
         if kwargs.get("sort_by"):
             raise ValidationError("USGS does not support sorting feature")
 
         self.authenticate()
 
-        product_type_def_params = self.config.products.get(  # type: ignore
-            product_type,
-            self.config.products[GENERIC_PRODUCT_TYPE],  # type: ignore
+        collection_def_params = self.config.products.get(  # type: ignore
+            collection,
+            self.config.products[GENERIC_COLLECTION],  # type: ignore
         )
-        usgs_dataset = format_dict_items(product_type_def_params, **kwargs)["dataset"]
-        start_date = kwargs.pop("startTimeFromAscendingNode", None)
-        end_date = kwargs.pop("completionTimeFromAscendingNode", None)
+        usgs_collection = format_dict_items(collection_def_params, **kwargs)[
+            "_collection"
+        ]
+        start_date = kwargs.pop("start_datetime", None)
+        end_date = kwargs.pop("end_datetime", None)
         geom = kwargs.pop("geometry", None)
         footprint: dict[str, str] = {}
         if hasattr(geom, "bounds"):
@@ -196,19 +201,21 @@ class UsgsApi(Api):
                 ll=lower_left,
                 ur=upper_right,
                 max_results=items_per_page,
-                starting_number=(1 + (page - 1) * items_per_page),
+                starting_number=token,
             )
 
             # search by id
             if searched_id := kwargs.get("id"):
-                dataset_filters = api.dataset_filters(usgs_dataset)
+                dataset_filters = api.dataset_filters(usgs_collection)
                 # ip pattern set as parameter queryable (first element of param conf list)
                 id_pattern = self.config.metadata_mapping["id"][0]
                 # loop on matching dataset_filters until one returns expected results
                 for dataset_filter in dataset_filters["data"]:
                     if id_pattern in dataset_filter["searchSql"]:
                         logger.debug(
-                            f"Try using {dataset_filter['searchSql']} dataset filter to search by id on {usgs_dataset}"
+                            "Try using %s dataset filter to search by id on %s",
+                            dataset_filter["searchSql"],
+                            usgs_collection,
                         )
                         full_api_search_kwargs = {
                             "where": {
@@ -218,19 +225,19 @@ class UsgsApi(Api):
                             **api_search_kwargs,
                         }
                         logger.info(
-                            f"Sending search request for {usgs_dataset} with {full_api_search_kwargs}"
+                            f"Sending search request for {usgs_collection} with {full_api_search_kwargs}"
                         )
                         results = api.scene_search(
-                            usgs_dataset, **full_api_search_kwargs
+                            usgs_collection, **full_api_search_kwargs
                         )
                         if len(results["data"]["results"]) == 1:
                             # search by id using this dataset_filter succeeded
                             break
             else:
                 logger.info(
-                    f"Sending search request for {usgs_dataset} with {api_search_kwargs}"
+                    f"Sending search request for {usgs_collection} with {api_search_kwargs}"
                 )
-                results = api.scene_search(usgs_dataset, **api_search_kwargs)
+                results = api.scene_search(usgs_collection, **api_search_kwargs)
 
             # update results with storage info from download_options()
             results_by_entity_id = {
@@ -240,7 +247,7 @@ class UsgsApi(Api):
                 f"Adapting {len(results_by_entity_id)} plugin results to eodag product representation"
             )
             download_options = api.download_options(
-                usgs_dataset, list(results_by_entity_id.keys())
+                usgs_collection, list(results_by_entity_id.keys())
             )
             if download_options.get("data") is not None:
                 for download_option in download_options["data"]:
@@ -262,7 +269,7 @@ class UsgsApi(Api):
             results["data"]["results"] = list(results_by_entity_id.values())
 
             for result in results["data"]["results"]:
-                result["productType"] = usgs_dataset
+                result["collection"] = usgs_collection
 
                 product_properties = properties_from_json(
                     result, self.config.metadata_mapping
@@ -270,7 +277,7 @@ class UsgsApi(Api):
 
                 final.append(
                     EOProduct(
-                        productType=product_type,
+                        collection=collection,
                         provider=self.provider,
                         properties=product_properties,
                         geometry=footprint,
@@ -278,7 +285,7 @@ class UsgsApi(Api):
                 )
         except USGSError as e:
             logger.warning(
-                f"Product type {usgs_dataset} may not exist on USGS EE catalog"
+                f"Collection {usgs_collection} may not exist on USGS EE catalog"
             )
             api.logout()
             raise RequestError.from_error(e) from e
@@ -292,12 +299,18 @@ class UsgsApi(Api):
         else:
             total_results = 0
 
-        return final, total_results
+        formated_result = SearchResult(
+            final,
+            total_results,
+            search_params=search_params,
+            next_page_token=results["data"]["nextRecord"],
+        )
+        return formated_result
 
     def download(
         self,
         product: EOProduct,
-        auth: Optional[Union[AuthBase, S3SessionKwargs, S3ServiceResource]] = None,
+        auth: Optional[Union[AuthBase, S3ServiceResource]] = None,
         progress_callback: Optional[ProgressCallback] = None,
         wait: float = DEFAULT_DOWNLOAD_WAIT,
         timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
@@ -314,7 +327,7 @@ class UsgsApi(Api):
         output_extension = cast(
             str,
             self.config.products.get(  # type: ignore
-                product.product_type, self.config.products[GENERIC_PRODUCT_TYPE]  # type: ignore
+                product.collection, self.config.products[GENERIC_COLLECTION]  # type: ignore
             ).get("output_extension", ".tar.gz"),
         )
         kwargs["output_extension"] = kwargs.get("output_extension", output_extension)
@@ -335,11 +348,13 @@ class UsgsApi(Api):
             raise NotAvailableError(
                 f"No USGS products found for {product.properties['id']}"
             )
-
+        usgs_dataset = self.config.products.get(product.collection, {}).get(
+            "_collection", GENERIC_COLLECTION
+        )
         download_request_results = api.download_request(
-            product.properties["productType"],
-            product.properties["entityId"],
-            product.properties["productId"],
+            usgs_dataset,
+            product.properties["usgs:entityId"],
+            product.properties["usgs:productId"],
         )
 
         req_urls: list[str] = []
@@ -422,7 +437,7 @@ class UsgsApi(Api):
         download_request(product, fs_path, progress_callback, **kwargs)
 
         with open(record_filename, "w") as fh:
-            fh.write(product.properties["downloadLink"])
+            fh.write(product.properties["eodag:download_link"])
         logger.debug(f"Download recorded in {record_filename}")
 
         api.logout()
@@ -466,7 +481,7 @@ class UsgsApi(Api):
     def download_all(
         self,
         products: SearchResult,
-        auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
+        auth: Optional[Union[AuthBase, S3ServiceResource]] = None,
         downloaded_callback: Optional[DownloadedCallback] = None,
         progress_callback: Optional[ProgressCallback] = None,
         wait: float = DEFAULT_DOWNLOAD_WAIT,

eodag/plugins/authentication/base.py

@@ -27,8 +27,6 @@ if TYPE_CHECKING:
     from mypy_boto3_s3 import S3ServiceResource
     from requests.auth import AuthBase
 
-    from eodag.types import S3SessionKwargs
-
 
 class Authentication(PluginTopic):
     """Plugins authentication Base plugin
@@ -42,7 +40,7 @@ class Authentication(PluginTopic):
           configuration that needs authentication and helps identifying it
     """
 
-    def authenticate(self) -> Union[AuthBase, S3SessionKwargs, S3ServiceResource]:
+    def authenticate(self) -> Union[AuthBase, S3ServiceResource]:
         """Authenticate"""
         raise NotImplementedError
 

eodag/plugins/crunch/filter_date.py

@@ -49,7 +49,7 @@ class FilterDate(Crunch):
     @staticmethod
     def sort_product_by_start_date(product: EOProduct) -> dt:
         """Get product start date"""
-        start_date = product.properties.get("startTimeFromAscendingNode")
+        start_date = product.properties.get("start_datetime")
         if not start_date:
             # Retrieve year, month, day, hour, minute, second of EPOCH start
             epoch = time.gmtime(0)[:-3]
@@ -93,7 +93,7 @@ class FilterDate(Crunch):
         for product in products:
 
             # product start date
-            product_start_str = product.properties.get("startTimeFromAscendingNode")
+            product_start_str = product.properties.get("start_datetime")
             if product_start_str:
                 product_start = dateutil.parser.parse(product_start_str)
                 if not product_start.tzinfo:
@@ -102,7 +102,7 @@ class FilterDate(Crunch):
                 product_start = None
 
             # product end date
-            product_end_str = product.properties.get("completionTimeFromAscendingNode")
+            product_end_str = product.properties.get("end_datetime")
             if product_end_str:
                 product_end = dateutil.parser.parse(product_end_str)
                 if not product_end.tzinfo:

eodag/plugins/crunch/filter_latest_intersect.py

@@ -46,7 +46,7 @@ class FilterLatestIntersect(Crunch):
     @staticmethod
     def sort_product_by_start_date(product: EOProduct) -> dt:
         """Get product start date"""
-        start_date = product.properties.get("startTimeFromAscendingNode")
+        start_date = product.properties.get("start_datetime")
         if not start_date:
             # Retrieve year, month, day, hour, minute, second of EPOCH start
             epoch = time.gmtime(0)[:-3]
@@ -67,7 +67,7 @@ class FilterLatestIntersect(Crunch):
         logger.debug("Start filtering for latest products")
         if not products:
             return []
-        # Warning: May crash if startTimeFromAscendingNode is not in the appropriate format
+        # Warning: May crash if start_datetime is not in the appropriate format
         products.sort(key=self.sort_product_by_start_date, reverse=True)
         filtered: list[EOProduct] = []
         search_extent: BaseGeometry

eodag/plugins/crunch/filter_latest_tpl_name.py

@@ -75,7 +75,7 @@ class FilterLatestByName(Crunch):
                     logger.debug(
                         "Latest product found for tileid=%s: date=%s",
                         tileid,
-                        product.properties["startTimeFromAscendingNode"],
+                        product.properties["start_datetime"],
                     )
                     filtered.append(product)
                     processed.append(tileid)

eodag/plugins/download/aws.py

@@ -44,6 +44,7 @@ from eodag.utils import (
     ProgressCallback,
     StreamResponse,
     flatten_top_directories,
+    format_string,
     get_bucket_name_and_prefix,
     path_to_uri,
     rename_subfolder,
@@ -53,7 +54,7 @@ from eodag.utils.exceptions import (
     AuthenticationError,
     DownloadError,
     MisconfiguredError,
-    NoMatchingProductType,
+    NoMatchingCollection,
     NotAvailableError,
     TimeOutError,
 )
@@ -66,7 +67,6 @@ if TYPE_CHECKING:
     from eodag.api.product import EOProduct
     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
 
@@ -202,17 +202,17 @@ class AwsDownload(Download):
         * :attr:`~eodag.config.PluginConfig.flatten_top_dirs` (``bool``): if the directory structure
           should be flattened; default: ``True``
         * :attr:`~eodag.config.PluginConfig.ignore_assets` (``bool``): ignore assets and download
-          using ``downloadLink``; default: ``False``
+          using ``eodag:download_link``; default: ``False``
         * :attr:`~eodag.config.PluginConfig.ssl_verify` (``bool``): if the ssl certificates should
           be verified in requests; default: ``True``
         * :attr:`~eodag.config.PluginConfig.bucket_path_level` (``int``): at which level of the
           path part of the url the bucket can be found; If no bucket_path_level is given, the bucket
           is taken from the first element of the netloc part.
-        * :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 keys:
+        * :attr:`~eodag.config.PluginConfig.products` (``dict[str, dict[str, Any]``): collection
+          specific config; the keys are the collections, the values are dictionaries which can contain the keys:
 
-          * **default_bucket** (``str``): bucket where the product type can be found
-          * **complementary_url_key** (``str``): keys to add additional urls
+          * **default_bucket** (``str``): bucket where the collection can be found
+          * **complementary_url_key** (``str``): properties keys pointing to additional urls of content to download
           * **build_safe** (``bool``): if a SAFE (Standard Archive Format for Europe) product should
             be created; used for Sentinel products; default: False
           * **fetch_metadata** (``dict[str, Any]``): config for metadata to be fetched for the SAFE product
@@ -225,7 +225,7 @@ class AwsDownload(Download):
     def download(
         self,
         product: EOProduct,
-        auth: Optional[Union[AuthBase, S3SessionKwargs, S3ServiceResource]] = None,
+        auth: Optional[Union[AuthBase, S3ServiceResource]] = None,
         progress_callback: Optional[ProgressCallback] = None,
         wait: float = DEFAULT_DOWNLOAD_WAIT,
         timeout: float = DEFAULT_DOWNLOAD_TIMEOUT,
@@ -234,7 +234,7 @@ class AwsDownload(Download):
         """Download method for AWS S3 API.
 
         The product can be downloaded as it is, or as SAFE-formatted product.
-        SAFE-build is configured for a given provider and product type.
+        SAFE-build is configured for a given provider and collection.
         If the product title is configured to be updated during download and
         SAFE-formatted, its destination path will be:
         `{output_dir}/{title}`
@@ -266,9 +266,7 @@ class AwsDownload(Download):
         if not record_filename or not product_local_path:
             return product_local_path
 
-        product_conf = getattr(self.config, "products", {}).get(
-            product.product_type, {}
-        )
+        product_conf = getattr(self.config, "products", {}).get(product.collection, {})
 
         # do not try to build SAFE if asset filter is used
         asset_filter = kwargs.get("asset")
@@ -368,7 +366,7 @@ class AwsDownload(Download):
             logger.warning("Unexpected error: %s" % e)
 
         # finalize safe product
-        if build_safe and product.product_type and "S2_MSI" in product.product_type:
+        if build_safe and product.collection and "S2_MSI" in product.collection:
             self.finalize_s2_safe_product(product_local_path)
         # flatten directory structure
         elif flatten_top_dirs:
@@ -479,17 +477,15 @@ class AwsDownload(Download):
         :param build_safe: if safe build is enabled
         :param product: product to be updated
         """
-        product_conf = getattr(self.config, "products", {}).get(
-            product.product_type, {}
-        )
+        product_conf = getattr(self.config, "products", {}).get(product.collection, {})
         ssl_verify = getattr(self.config, "ssl_verify", True)
         timeout = getattr(self.config, "timeout", HTTP_REQ_TIMEOUT)
 
         if build_safe and "fetch_metadata" in product_conf.keys():
             fetch_format = product_conf["fetch_metadata"]["fetch_format"]
             update_metadata = product_conf["fetch_metadata"]["update_metadata"]
-            fetch_url = product_conf["fetch_metadata"]["fetch_url"].format(
-                **product.properties
+            fetch_url = format_string(
+                None, product_conf["fetch_metadata"]["fetch_url"], **product.properties
             )
             logger.info("Fetching extra metadata from %s" % fetch_url)
             try:
@@ -619,14 +615,14 @@ class AwsDownload(Download):
                 )
 
         if not unique_product_chunks and raise_error:
-            raise NoMatchingProductType("No product found to download.")
+            raise NoMatchingCollection("No product found to download.")
 
         return unique_product_chunks
 
     def _stream_download_dict(
         self,
         product: EOProduct,
-        auth: Optional[Union[AuthBase, S3SessionKwargs, S3ServiceResource]] = None,
+        auth: Optional[Union[AuthBase, S3ServiceResource]] = None,
         byte_range: tuple[Optional[int], Optional[int]] = (None, None),
         compress: Literal["zip", "raw", "auto"] = "auto",
         wait: float = DEFAULT_DOWNLOAD_WAIT,
@@ -664,7 +660,7 @@ class AwsDownload(Download):
 
         #### SAFE Archive Support:
 
-        If the product type supports SAFE structure and no `asset_regex` is specified (i.e., full product download),
+        If the collection supports SAFE structure and no `asset_regex` is specified (i.e., full product download),
         the method attempts to reconstruct a valid SAFE archive layout in the streamed output.
 
         :param product: The EO product to download.
@@ -680,9 +676,7 @@ class AwsDownload(Download):
         """
         asset_regex = kwargs.get("asset")
 
-        product_conf = getattr(self.config, "products", {}).get(
-            product.product_type, {}
-        )
+        product_conf = getattr(self.config, "products", {}).get(product.collection, {})
 
         build_safe = (
             False if asset_regex is not None else product_conf.get("build_safe", False)
@@ -716,7 +710,7 @@ class AwsDownload(Download):
             ignore_assets,
             product,
         )
-        if auth and isinstance(auth, boto3.resource("s3").__class__):
+        if auth and isinstance(auth, boto3.resources.base.ServiceResource):
             s3_resource = auth
         else:
             s3_resource = boto3.resource(
@@ -724,9 +718,7 @@ class AwsDownload(Download):
                 endpoint_url=getattr(self.config, "s3_endpoint", None),
             )
 
-        product_conf = getattr(self.config, "products", {}).get(
-            product.product_type, {}
-        )
+        product_conf = getattr(self.config, "products", {}).get(product.collection, {})
         flatten_top_dirs = product_conf.get(
             "flatten_top_dirs", getattr(self.config, "flatten_top_dirs", True)
         )
@@ -814,7 +806,7 @@ class AwsDownload(Download):
         if bucket is None:
             bucket = (
                 getattr(self.config, "products", {})
-                .get(product.product_type, {})
+                .get(product.collection, {})
                 .get("default_bucket", "")
             )
 
@@ -925,7 +917,7 @@ class AwsDownload(Download):
         s2_processing_level: str = ""
         s1_title_suffix: Optional[str] = None
         # S2 common
-        if product.product_type and "S2_MSI" in product.product_type:
+        if product.collection and "S2_MSI" in product.collection:
             title_search: Optional[re.Match[str]] = re.search(
                 r"^\w+_\w+_(\w+)_(\w+)_(\w+)_(\w+)_(\w+)$",
                 product.properties["title"],
@@ -937,9 +929,9 @@ class AwsDownload(Download):
                 product.properties.get("originalSceneID", ""),
             )
             ds_dir = ds_dir_search.group(1) if ds_dir_search else 0
-            s2_processing_level = product.product_type.split("_")[-1]
+            s2_processing_level = product.collection.split("_")[-1]
         # S1 common
-        elif product.product_type == "S1_SAR_GRD":
+        elif product.collection == "S1_SAR_GRD":
             s1_title_suffix_search = re.search(
                 r"^.+_([A-Z0-9_]+_[A-Z0-9_]+_[A-Z0-9_]+_[A-Z0-9_]+)_\w+$",
                 product.properties["title"],
@@ -950,6 +942,12 @@ class AwsDownload(Download):
                 else None
             )
 
+        # S1 polarization mode
+        if product_title := product.properties.get("title"):
+            polarization_mode = re.sub(r".{14}([A-Z]{2}).*", r"\1", product_title)
+        else:
+            polarization_mode = None
+
         # S2 L2A Tile files -----------------------------------------------
         if matched := S2L2A_TILE_IMG_REGEX.match(chunk.key):
             found_dict = matched.groupdict()
@@ -1057,37 +1055,43 @@ class AwsDownload(Download):
             found_dict = matched.groupdict()
             product_path = "%s" % found_dict["file"]
         # S1 --------------------------------------------------------------
-        elif matched := S1_CALIB_REGEX.match(chunk.key):
+        elif (
+            matched := S1_CALIB_REGEX.match(chunk.key)
+        ) and polarization_mode is not None:
             found_dict = matched.groupdict()
             product_path = "annotation/calibration/%s-%s-%s-grd-%s-%s-%03d.xml" % (
                 found_dict["file_prefix"],
-                product.properties["platformSerialIdentifier"].lower(),
+                product.properties["platform"].lower(),
                 found_dict["file_beam"],
                 found_dict["file_pol"],
                 s1_title_suffix,
-                S1_IMG_NB_PER_POLAR.get(product.properties["polarizationMode"], {}).get(
+                S1_IMG_NB_PER_POLAR.get(polarization_mode, {}).get(
                     found_dict["file_pol"].upper(), 1
                 ),
             )
-        elif matched := S1_ANNOT_REGEX.match(chunk.key):
+        elif (
+            matched := S1_ANNOT_REGEX.match(chunk.key)
+        ) and polarization_mode is not None:
             found_dict = matched.groupdict()
             product_path = "annotation/%s-%s-grd-%s-%s-%03d.xml" % (
-                product.properties["platformSerialIdentifier"].lower(),
+                product.properties["platform"].lower(),
                 found_dict["file_beam"],
                 found_dict["file_pol"],
                 s1_title_suffix,
-                S1_IMG_NB_PER_POLAR.get(product.properties["polarizationMode"], {}).get(
+                S1_IMG_NB_PER_POLAR.get(polarization_mode, {}).get(
                     found_dict["file_pol"].upper(), 1
                 ),
             )
-        elif matched := S1_MEAS_REGEX.match(chunk.key):
+        elif (
+            matched := S1_MEAS_REGEX.match(chunk.key)
+        ) and polarization_mode is not None:
             found_dict = matched.groupdict()
             product_path = "measurement/%s-%s-grd-%s-%s-%03d.%s" % (
-                product.properties["platformSerialIdentifier"].lower(),
+                product.properties["platform"].lower(),
                 found_dict["file_beam"],
                 found_dict["file_pol"],
                 s1_title_suffix,
-                S1_IMG_NB_PER_POLAR.get(product.properties["polarizationMode"], {}).get(
+                S1_IMG_NB_PER_POLAR.get(polarization_mode, {}).get(
                     found_dict["file_pol"].upper(), 1
                 ),
                 found_dict["file_ext"],
@@ -1112,7 +1116,7 @@ class AwsDownload(Download):
     def download_all(
         self,
         products: SearchResult,
-        auth: Optional[Union[AuthBase, S3SessionKwargs]] = None,
+        auth: Optional[Union[AuthBase, S3ServiceResource]] = None,
         downloaded_callback: Optional[DownloadedCallback] = None,
         progress_callback: Optional[ProgressCallback] = None,
         wait: float = DEFAULT_DOWNLOAD_WAIT,