eodag 3.1.0b1__py3-none-any.whl → 3.1.0b2__py3-none-any.whl

eodag/utils/__init__.py

@@ -54,14 +54,10 @@ from typing import (
     TYPE_CHECKING,
     Any,
     Callable,
-    Dict,
     Iterable,
     Iterator,
-    List,
     Mapping,
     Optional,
-    Tuple,
-    Type,
     Union,
     cast,
 )
@@ -119,6 +115,7 @@ eodag_version = metadata("eodag")["Version"]
 USER_AGENT = {"User-Agent": f"eodag/{eodag_version}"}
 
 HTTP_REQ_TIMEOUT = 5  # in seconds
+DEFAULT_SEARCH_TIMEOUT = 20  # in seconds
 DEFAULT_STREAM_REQUESTS_TIMEOUT = 60  # in seconds
 
 REQ_RETRY_TOTAL = 3
@@ -322,7 +319,7 @@ def path_to_uri(path: str) -> str:
     return Path(path).as_uri()
 
 
-def mutate_dict_in_place(func: Callable[[Any], Any], mapping: Dict[Any, Any]) -> None:
+def mutate_dict_in_place(func: Callable[[Any], Any], mapping: dict[Any, Any]) -> None:
     """Apply func to values of mapping.
 
     The mapping object's values are modified in-place. The function is recursive,
@@ -340,7 +337,7 @@ def mutate_dict_in_place(func: Callable[[Any], Any], mapping: Dict[Any, Any]) ->
             mapping[key] = func(value)
 
 
-def merge_mappings(mapping1: Dict[Any, Any], mapping2: Dict[Any, Any]) -> None:
+def merge_mappings(mapping1: dict[Any, Any], mapping2: dict[Any, Any]) -> None:
     """Merge two mappings with string keys, values from ``mapping2`` overriding values
     from ``mapping1``.
 
@@ -605,9 +602,49 @@ def rename_subfolder(dirpath: str, name: str) -> None:
     )
 
 
+def rename_with_version(file_path: str, suffix: str = "old") -> str:
+    """
+    Renames a file by appending and incrementing a version number if a conflict exists.
+
+    :param file_path: full path of the file to rename
+    :param suffix: suffix preceding version number in case of name conflict
+    :returns: new file path with the version appended or incremented
+
+    Example:
+
+    >>> import tempfile
+    >>> from pathlib import Path
+    >>> with tempfile.TemporaryDirectory() as tmpdir:
+    ...     file_path = (Path(tmpdir) / "foo.txt")
+    ...     file_path.touch()
+    ...     (Path(tmpdir) / "foo_old1.txt").touch()
+    ...     expected = str(Path(tmpdir) / "foo_old2.txt")
+    ...     assert expected == rename_with_version(str(file_path))
+
+    """
+    if not os.path.isfile(file_path):
+        raise FileNotFoundError(f"The file '{file_path}' does not exist.")
+
+    dir_path, file_name = os.path.split(file_path)
+    file_base, file_ext = os.path.splitext(file_name)
+
+    new_file_path = file_path
+
+    # loop and iterate on conflicting existing files
+    version = 0
+    while os.path.exists(new_file_path):
+        version += 1
+        new_file_name = f"{file_base}_{suffix}{version}{file_ext}"
+        new_file_path = os.path.join(dir_path, new_file_name)
+
+    # Rename the file
+    os.rename(file_path, new_file_path)
+    return new_file_path
+
+
 def format_dict_items(
-    config_dict: Dict[str, Any], **format_variables: Any
-) -> Dict[Any, Any]:
+    config_dict: dict[str, Any], **format_variables: Any
+) -> dict[Any, Any]:
     r"""Recursively apply :meth:`str.format` to ``**format_variables`` on ``config_dict`` values
 
     >>> format_dict_items(
@@ -624,8 +661,8 @@ def format_dict_items(
 
 
 def jsonpath_parse_dict_items(
-    jsonpath_dict: Dict[str, Any], values_dict: Dict[str, Any]
-) -> Dict[Any, Any]:
+    jsonpath_dict: dict[str, Any], values_dict: dict[str, Any]
+) -> dict[Any, Any]:
     """Recursively parse :class:`jsonpath_ng.JSONPath` elements in dict
 
     >>> import jsonpath_ng.ext as jsonpath
@@ -643,12 +680,12 @@ def jsonpath_parse_dict_items(
 
 
 def update_nested_dict(
-    old_dict: Dict[Any, Any],
-    new_dict: Dict[Any, Any],
+    old_dict: dict[Any, Any],
+    new_dict: dict[Any, Any],
     extend_list_values: bool = False,
     allow_empty_values: bool = False,
     allow_extend_duplicates: bool = True,
-) -> Dict[Any, Any]:
+) -> dict[Any, Any]:
     """Update recursively ``old_dict`` items with ``new_dict`` ones
 
     >>> update_nested_dict(
@@ -728,10 +765,10 @@ def update_nested_dict(
 
 
 def items_recursive_apply(
-    input_obj: Union[Dict[Any, Any], List[Any]],
+    input_obj: Union[dict[Any, Any], list[Any]],
     apply_method: Callable[..., Any],
     **apply_method_parameters: Any,
-) -> Union[Dict[Any, Any], List[Any]]:
+) -> Union[dict[Any, Any], list[Any]]:
     """Recursive apply method to items contained in input object (dict or list)
 
     >>> items_recursive_apply(
@@ -769,10 +806,10 @@ def items_recursive_apply(
 
 
 def dict_items_recursive_apply(
-    config_dict: Dict[Any, Any],
+    config_dict: dict[Any, Any],
     apply_method: Callable[..., Any],
     **apply_method_parameters: Any,
-) -> Dict[Any, Any]:
+) -> dict[Any, Any]:
     """Recursive apply method to dict elements
 
     >>> dict_items_recursive_apply(
@@ -786,7 +823,7 @@ def dict_items_recursive_apply(
     :param apply_method_parameters: Optional parameters passed to the method
     :returns: Updated dict
     """
-    result_dict: Dict[Any, Any] = deepcopy(config_dict)
+    result_dict: dict[Any, Any] = deepcopy(config_dict)
     for dict_k, dict_v in result_dict.items():
         if isinstance(dict_v, dict):
             result_dict[dict_k] = dict_items_recursive_apply(
@@ -794,7 +831,7 @@ def dict_items_recursive_apply(
             )
         elif any(isinstance(dict_v, t) for t in (list, tuple)):
             result_dict[dict_k] = list_items_recursive_apply(
-                dict_v, apply_method, **apply_method_parameters
+                list(dict_v), apply_method, **apply_method_parameters
             )
         else:
             result_dict[dict_k] = apply_method(
@@ -805,10 +842,10 @@ def dict_items_recursive_apply(
 
 
 def list_items_recursive_apply(
-    config_list: List[Any],
+    config_list: list[Any],
     apply_method: Callable[..., Any],
     **apply_method_parameters: Any,
-) -> List[Any]:
+) -> list[Any]:
     """Recursive apply method to list elements
 
     >>> list_items_recursive_apply(
@@ -841,8 +878,8 @@ def list_items_recursive_apply(
 
 
 def items_recursive_sort(
-    input_obj: Union[List[Any], Dict[Any, Any]],
-) -> Union[List[Any], Dict[Any, Any]]:
+    input_obj: Union[list[Any], dict[Any, Any]],
+) -> Union[list[Any], dict[Any, Any]]:
     """Recursive sort dict items contained in input object (dict or list)
 
     >>> items_recursive_sort(
@@ -866,7 +903,7 @@ def items_recursive_sort(
         return input_obj
 
 
-def dict_items_recursive_sort(config_dict: Dict[Any, Any]) -> Dict[Any, Any]:
+def dict_items_recursive_sort(config_dict: dict[Any, Any]) -> dict[Any, Any]:
     """Recursive sort dict elements
 
     >>> dict_items_recursive_sort(
@@ -877,7 +914,7 @@ def dict_items_recursive_sort(config_dict: Dict[Any, Any]) -> Dict[Any, Any]:
     :param config_dict: Input nested dictionary
     :returns: Updated dict
     """
-    result_dict: Dict[Any, Any] = deepcopy(config_dict)
+    result_dict: dict[Any, Any] = deepcopy(config_dict)
     for dict_k, dict_v in result_dict.items():
         if isinstance(dict_v, dict):
             result_dict[dict_k] = dict_items_recursive_sort(dict_v)
@@ -889,7 +926,7 @@ def dict_items_recursive_sort(config_dict: Dict[Any, Any]) -> Dict[Any, Any]:
     return dict(sorted(result_dict.items()))
 
 
-def list_items_recursive_sort(config_list: List[Any]) -> List[Any]:
+def list_items_recursive_sort(config_list: list[Any]) -> list[Any]:
     """Recursive sort dicts in list elements
 
     >>> list_items_recursive_sort(["b", {2: 0, 0: 1, 1: 2}])
@@ -898,7 +935,7 @@ def list_items_recursive_sort(config_list: List[Any]) -> List[Any]:
     :param config_list: Input list containing nested lists/dicts
     :returns: Updated list
     """
-    result_list: List[Any] = deepcopy(config_list)
+    result_list: list[Any] = deepcopy(config_list)
     for list_idx, list_v in enumerate(result_list):
         if isinstance(list_v, dict):
             result_list[list_idx] = dict_items_recursive_sort(list_v)
@@ -1024,7 +1061,7 @@ def format_string(key: str, str_to_format: Any, **format_variables: Any) -> Any:
 
 
 def parse_jsonpath(
-    key: str, jsonpath_obj: Union[str, jsonpath.Child], **values_dict: Dict[str, Any]
+    key: str, jsonpath_obj: Union[str, jsonpath.Child], **values_dict: dict[str, Any]
 ) -> Optional[str]:
     """Parse jsonpah in ``jsonpath_obj`` using ``values_dict``
 
@@ -1044,7 +1081,7 @@ def parse_jsonpath(
         return jsonpath_obj
 
 
-def nested_pairs2dict(pairs: Union[List[Any], Any]) -> Union[Any, Dict[Any, Any]]:
+def nested_pairs2dict(pairs: Union[list[Any], Any]) -> Union[Any, dict[Any, Any]]:
     """Create a dict using nested pairs
 
     >>> nested_pairs2dict([["foo", [["bar", "baz"]]]])
@@ -1066,7 +1103,7 @@ def nested_pairs2dict(pairs: Union[List[Any], Any]) -> Union[Any, Dict[Any, Any]
 
 
 def get_geometry_from_various(
-    locations_config: List[Dict[str, Any]] = [], **query_args: Any
+    locations_config: list[dict[str, Any]] = [], **query_args: Any
 ) -> BaseGeometry:
     """Creates a ``shapely.geometry`` using given query kwargs arguments
 
@@ -1242,7 +1279,7 @@ def _mutable_cached_yaml_load(config_path: str) -> Any:
         return yaml.load(fh, Loader=yaml.SafeLoader)
 
 
-def cached_yaml_load(config_path: str) -> Dict[str, Any]:
+def cached_yaml_load(config_path: str) -> dict[str, Any]:
     """Cached :func:`yaml.load`
 
     :param config_path: path to the yaml configuration file
@@ -1252,12 +1289,12 @@ def cached_yaml_load(config_path: str) -> Dict[str, Any]:
 
 
 @functools.lru_cache()
-def _mutable_cached_yaml_load_all(config_path: str) -> List[Any]:
+def _mutable_cached_yaml_load_all(config_path: str) -> list[Any]:
     with open(config_path, "r") as fh:
         return list(yaml.load_all(fh, Loader=yaml.Loader))
 
 
-def cached_yaml_load_all(config_path: str) -> List[Any]:
+def cached_yaml_load_all(config_path: str) -> list[Any]:
     """Cached :func:`yaml.load_all`
 
     Load all configurations stored in the configuration file as separated yaml documents
@@ -1270,7 +1307,7 @@ def cached_yaml_load_all(config_path: str) -> List[Any]:
 
 def get_bucket_name_and_prefix(
     url: str, bucket_path_level: Optional[int] = None
-) -> Tuple[Optional[str], Optional[str]]:
+) -> tuple[Optional[str], Optional[str]]:
     """Extract bucket name and prefix from URL
 
     :param url: (optional) URL to use as product.location
@@ -1283,7 +1320,9 @@ def get_bucket_name_and_prefix(
     subdomain = netloc.split(".")[0]
     path = path.strip("/")
 
-    if scheme and bucket_path_level is None:
+    if "/" in path and scheme and subdomain == "s3" and bucket_path_level is None:
+        bucket, prefix = path.split("/", 1)
+    elif scheme and bucket_path_level is None:
         bucket = subdomain
         prefix = path
     elif not scheme and bucket_path_level is None:
@@ -1329,10 +1368,10 @@ def deepcopy(sth: Any) -> Any:
     :param sth: Object to copy
     :returns: Copied object
     """
-    _dispatcher: Dict[Type[Any], Callable[..., Any]] = {}
+    _dispatcher: dict[type[Any], Callable[..., Any]] = {}
 
     def _copy_list(
-        input_list: List[Any], dispatch: Dict[Type[Any], Callable[..., Any]]
+        input_list: list[Any], dispatch: dict[type[Any], Callable[..., Any]]
     ):
         ret = input_list.copy()
         for idx, item in enumerate(ret):
@@ -1342,7 +1381,7 @@ def deepcopy(sth: Any) -> Any:
         return ret
 
     def _copy_dict(
-        input_dict: Dict[Any, Any], dispatch: Dict[Type[Any], Callable[..., Any]]
+        input_dict: dict[Any, Any], dispatch: dict[type[Any], Callable[..., Any]]
     ):
         ret = input_dict.copy()
         for key, value in ret.items():
@@ -1431,6 +1470,8 @@ def guess_file_type(file: str) -> Optional[str]:
     :returns: guessed mime type
     """
     mime_type, _ = mimetypes.guess_type(file, False)
+    if mime_type == "text/xml":
+        return "application/xml"
     return mime_type
 
 
@@ -1465,7 +1506,7 @@ def get_ssl_context(ssl_verify: bool) -> ssl.SSLContext:
     return ctx
 
 
-def sort_dict(input_dict: Dict[str, Any]) -> Dict[str, Any]:
+def sort_dict(input_dict: dict[str, Any]) -> dict[str, Any]:
     """
     Recursively sorts a dict by keys.
 
@@ -1481,7 +1522,7 @@ def sort_dict(input_dict: Dict[str, Any]) -> Dict[str, Any]:
     }
 
 
-def dict_md5sum(input_dict: Dict[str, Any]) -> str:
+def dict_md5sum(input_dict: dict[str, Any]) -> str:
     """
     Hash nested dictionary
 

eodag/utils/exceptions.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING, Annotated
 
 if TYPE_CHECKING:
-    from typing import Optional, Set
+    from typing import Optional
 
     from typing_extensions import Doc, Self
 
@@ -108,7 +108,7 @@ class RequestError(EodagError):
 class ValidationError(RequestError):
     """Error validating data"""
 
-    def __init__(self, message: str, parameters: Set[str] = set()) -> None:
+    def __init__(self, message: str, parameters: set[str] = set()) -> None:
         self.message = message
         self.parameters = parameters
 

eodag/utils/import_system.py

@@ -21,14 +21,14 @@ import importlib
 import pkgutil
 from contextlib import contextmanager
 from functools import partial
-from typing import TYPE_CHECKING, Any, Generator, Tuple
+from typing import TYPE_CHECKING, Any, Generator
 
 if TYPE_CHECKING:
     from types import ModuleType
 
 
 def import_all_modules(
-    base_package: ModuleType, depth: int = 1, exclude: Tuple[str, ...] = ()
+    base_package: ModuleType, depth: int = 1, exclude: tuple[str, ...] = ()
 ) -> None:
     """Import all modules in base_package, including modules in the sub-packages up to `depth` and excluding modules in
     `exclude`.

eodag/utils/requests.py

@@ -19,7 +19,7 @@ from __future__ import annotations
 
 import logging
 import os
-from typing import Any, Optional, Tuple
+from typing import Any, Optional
 
 import requests
 
@@ -75,7 +75,7 @@ class LocalFileAdapter(requests.adapters.BaseAdapter):
     """
 
     @staticmethod
-    def _chkpath(method: str, path: str) -> Tuple[int, str]:
+    def _chkpath(method: str, path: str) -> tuple[int, str]:
         """Return an HTTP status for the given filesystem path.
 
         :param method: method of the request

eodag/utils/rest.py

@@ -21,7 +21,7 @@ from __future__ import annotations
 
 import datetime
 import re
-from typing import Any, Dict, Optional, Tuple
+from typing import Any, Optional
 
 import dateutil.parser
 from dateutil import tz
@@ -35,7 +35,7 @@ RFC3339_PATTERN = (
 )
 
 
-def get_datetime(arguments: Dict[str, Any]) -> Tuple[Optional[str], Optional[str]]:
+def get_datetime(arguments: dict[str, Any]) -> tuple[Optional[str], Optional[str]]:
     """Get start and end dates from a dict containing `/` separated dates in `datetime` item
 
     :param arguments: dict containing a single date or `/` separated dates in `datetime` item

eodag/utils/s3.py

@@ -0,0 +1,208 @@
+# -*- coding: utf-8 -*-
+# Copyright 2024, CS GROUP - France, https://www.csgroup.eu/
+#
+# This file is part of EODAG project
+#     https://www.github.com/CS-SI/EODAG
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# 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 __future__ import annotations
+
+import io
+import logging
+import os
+import zipfile
+from typing import TYPE_CHECKING, List, Optional
+from urllib.parse import urlparse
+
+import boto3
+import botocore
+
+from eodag.plugins.authentication.aws_auth import AwsAuth
+from eodag.utils import get_bucket_name_and_prefix, guess_file_type
+from eodag.utils.exceptions import (
+    AuthenticationError,
+    MisconfiguredError,
+    NotAvailableError,
+)
+
+if TYPE_CHECKING:
+    from zipfile import ZipInfo
+
+    from mypy_boto3_s3.client import S3Client
+
+    from eodag.api.product import EOProduct  # type: ignore
+
+logger = logging.getLogger("eodag.utils.s3")
+
+
+def fetch(
+    bucket_name: str, key_name: str, start: int, len: int, client_s3: S3Client
+) -> bytes:
+    """
+    Range-fetches a S3 key.
+
+    :param bucket_name: Bucket name of the object to fetch
+    :param key_name: Key name of the object to fetch
+    :param start: Bucket name to fetch
+    :param len: Bucket name to fetch
+    :param client_s3: s3 client used to fetch the object
+    :returns: Object bytes
+    """
+    end = start + len - 1
+    s3_object = client_s3.get_object(
+        Bucket=bucket_name, Key=key_name, Range="bytes=%d-%d" % (start, end)
+    )
+    return s3_object["Body"].read()
+
+
+def parse_int(bytes: bytes) -> int:
+    """
+    Parses 2 or 4 little-endian bits into their corresponding integer value.
+
+    :param bytes: bytes to parse
+    :returns: parsed int
+    """
+    val = (bytes[0]) + ((bytes[1]) << 8)
+    if len(bytes) > 3:
+        val += ((bytes[2]) << 16) + ((bytes[3]) << 24)
+    return val
+
+
+def list_files_in_s3_zipped_object(
+    bucket_name: str, key_name: str, client_s3: S3Client
+) -> List[ZipInfo]:
+    """
+    List files in s3 zipped object, without downloading it.
+
+    See https://stackoverflow.com/questions/41789176/how-to-count-files-inside-zip-in-aws-s3-without-downloading-it;
+    Based on https://stackoverflow.com/questions/51351000/read-zip-files-from-s3-without-downloading-the-entire-file
+
+    :param bucket_name: Bucket name of the object to fetch
+    :param key_name: Key name of the object to fetch
+    :param client_s3: s3 client used to fetch the object
+    :returns: List of files in zip
+    """
+    response = client_s3.head_object(Bucket=bucket_name, Key=key_name)
+    size = response["ContentLength"]
+
+    # End Of Central Directory bytes
+    eocd = fetch(bucket_name, key_name, size - 22, 22, client_s3)
+
+    # start offset and size of the central directory
+    cd_start = parse_int(eocd[16:20])
+    cd_size = parse_int(eocd[12:16])
+
+    # fetch central directory, append EOCD, and open as zipfile
+    cd = fetch(bucket_name, key_name, cd_start, cd_size, client_s3)
+    zip = zipfile.ZipFile(io.BytesIO(cd + eocd))
+
+    logger.debug("Found %s files in %s" % (len(zip.filelist), key_name))
+
+    return zip.filelist
+
+
+def update_assets_from_s3(
+    product: EOProduct,
+    auth: AwsAuth,
+    s3_endpoint: Optional[str] = None,
+    content_url: Optional[str] = None,
+) -> None:
+    """Update ``EOProduct.assets`` using content listed in its ``remote_location`` or given
+    ``content_url``.
+
+    If url points to a zipped archive, its content will also be be listed.
+
+    :param product: product to update
+    :param auth: Authentication plugin
+    :param s3_endpoint: s3 endpoint if not hosted on AWS
+    :param content_url: s3 URL pointing to the content that must be listed (defaults to
+                        ``product.remote_location`` if empty)
+    """
+    required_creds = ["aws_access_key_id", "aws_secret_access_key"]
+
+    if content_url is None:
+        content_url = product.remote_location
+
+    bucket, prefix = get_bucket_name_and_prefix(content_url)
+
+    if bucket is None or prefix is None:
+        logger.debug(f"No s3 prefix could guessed from {content_url}")
+        return None
+
+    try:
+        auth_dict = auth.authenticate()
+
+        if not all(x in auth_dict for x in required_creds):
+            raise MisconfiguredError(
+                f"Incomplete credentials for {product.provider}, missing "
+                f"{[x for x in required_creds if x not in auth_dict]}"
+            )
+        if not getattr(auth, "s3_client", None):
+            auth.s3_client = boto3.client(
+                service_name="s3",
+                endpoint_url=s3_endpoint,
+                aws_access_key_id=auth_dict.get("aws_access_key_id"),
+                aws_secret_access_key=auth_dict.get("aws_secret_access_key"),
+                aws_session_token=auth_dict.get("aws_session_token"),
+            )
+
+        logger.debug("Listing assets in %s", prefix)
+
+        if prefix.endswith(".zip"):
+            # List prefix zip content
+            assets_urls = [
+                f"zip+s3://{bucket}/{prefix}!{f.filename}"
+                for f in list_files_in_s3_zipped_object(bucket, prefix, auth.s3_client)
+            ]
+        else:
+            # List files in prefix
+            assets_urls = [
+                f"s3://{bucket}/{obj['Key']}"
+                for obj in auth.s3_client.list_objects(
+                    Bucket=bucket, Prefix=prefix, MaxKeys=300
+                ).get("Contents", [])
+            ]
+
+        for asset_url in assets_urls:
+            out_of_zip_url = asset_url.split("!")[-1]
+            key, roles = product.driver.guess_asset_key_and_roles(
+                out_of_zip_url, product
+            )
+            parsed_url = urlparse(out_of_zip_url)
+            title = os.path.basename(parsed_url.path)
+
+            if key and key not in product.assets:
+                product.assets[key] = {
+                    "title": title,
+                    "roles": roles,
+                    "href": asset_url,
+                }
+                if mime_type := guess_file_type(asset_url):
+                    product.assets[key]["type"] = mime_type
+
+        # sort assets
+        product.assets.data = dict(sorted(product.assets.data.items()))
+
+        # update driver
+        product.driver = product.get_driver()
+
+    except botocore.exceptions.ClientError as e:
+        if hasattr(auth.config, "auth_error_code") and str(
+            auth.config.auth_error_code
+        ) in str(e):
+            raise AuthenticationError(
+                f"Authentication failed on {s3_endpoint} s3"
+            ) from e
+        raise NotAvailableError(
+            f"assets for product {prefix} could not be found"
+        ) from e

eodag/utils/stac_reader.py

@@ -20,7 +20,7 @@ from __future__ import annotations
 import logging
 import re
 import socket
-from typing import Any, Callable, Dict, List, Optional, Union
+from typing import Any, Callable, Optional, Union
 from urllib.error import URLError
 from urllib.request import urlopen
 
@@ -108,7 +108,7 @@ def fetch_stac_items(
     max_connections: int = 100,
     timeout: int = HTTP_REQ_TIMEOUT,
     ssl_verify: bool = True,
-) -> List[Dict[str, Any]]:
+) -> list[dict[str, Any]]:
     """Fetch STAC item from a single item file or items from a catalog.
 
     :param stac_path: A STAC object filepath
@@ -142,13 +142,13 @@ def _fetch_stac_items_from_catalog(
     recursive: bool,
     max_connections: int,
     _text_opener: Callable[[str, bool], Any],
-) -> List[Any]:
+) -> list[Any]:
     """Fetch items from a STAC catalog"""
-    items: List[Dict[Any, Any]] = []
+    items: list[dict[Any, Any]] = []
 
     # pystac cannot yet return links from a single file catalog, see:
     # https://github.com/stac-utils/pystac/issues/256
-    extensions: Optional[Union[List[str], str]] = getattr(cat, "stac_extensions", None)
+    extensions: Optional[Union[list[str], str]] = getattr(cat, "stac_extensions", None)
     if extensions:
         extensions = extensions if isinstance(extensions, list) else [extensions]
         if "single-file-stac" in extensions:
@@ -157,7 +157,7 @@ def _fetch_stac_items_from_catalog(
 
     # Making the links absolutes allow for both relative and absolute links to be handled.
     if not recursive:
-        hrefs: List[Optional[str]] = [
+        hrefs: list[Optional[str]] = [
             link.get_absolute_href() for link in cat.get_item_links()
         ]
     else:
@@ -188,7 +188,7 @@ def fetch_stac_collections(
     max_connections: int = 100,
     timeout: int = HTTP_REQ_TIMEOUT,
     ssl_verify: bool = True,
-) -> List[Dict[str, Any]]:
+) -> list[dict[str, Any]]:
     """Fetch STAC collection(s) from a catalog.
 
     :param stac_path: A STAC object filepath
@@ -217,12 +217,12 @@ def _fetch_stac_collections_from_catalog(
     collection: Optional[str],
     max_connections: int,
     _text_opener: Callable[[str, bool], Any],
-) -> List[Any]:
+) -> list[Any]:
     """Fetch collections from a STAC catalog"""
-    collections: List[Dict[Any, Any]] = []
+    collections: list[dict[Any, Any]] = []
 
     # Making the links absolutes allow for both relative and absolute links to be handled.
-    hrefs: List[Optional[str]] = [
+    hrefs: list[Optional[str]] = [
         link.get_absolute_href()
         for link in cat.get_child_links()
         if collection is not None and link.title == collection