eodag 3.0.0b3__py3-none-any.whl → 3.1.0__py3-none-any.whl

eodag/utils/exceptions.py

@@ -17,24 +17,18 @@
 # limitations under the License.
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Annotated
 
 if TYPE_CHECKING:
-    from typing import Optional, Set, Tuple
+    from typing import Optional
+
+    from typing_extensions import Doc, Self
 
 
 class EodagError(Exception):
     """General EODAG error"""
 
 
-class ValidationError(EodagError):
-    """Error validating data"""
-
-    def __init__(self, message: str, parameters: Set[str] = set()) -> None:
-        self.message = message
-        self.parameters = parameters
-
-
 class PluginNotFoundError(EodagError):
     """Error when looking for a plugin class that was not defined"""
 
@@ -72,35 +66,62 @@ class AuthenticationError(EodagError):
     authenticating a user"""
 
 
-class DownloadError(EodagError):
-    """An error indicating something wrong with the download process"""
-
-
 class NotAvailableError(EodagError):
     """An error indicating that the product is not available for download"""
 
 
+class NoMatchingProductType(EodagError):
+    """An error indicating that eodag was unable to derive a product type from a set
+    of search parameters"""
+
+
+class STACOpenerError(EodagError):
+    """An error indicating that a STAC file could not be opened"""
+
+
 class RequestError(EodagError):
     """An error indicating that a request has failed. Usually eodag functions
     and methods should catch and skip this"""
 
-    history: Set[Tuple[str, Exception]] = set()
-    parameters: Set[str] = set()
+    status_code: Annotated[Optional[int], Doc("HTTP status code")] = None
 
-    def __str__(self):
-        repr = super().__str__()
-        for err_tuple in self.history:
-            repr += f"- {str(err_tuple)}"
-        return repr
+    @classmethod
+    def from_error(cls, error: Exception, msg: Optional[str] = None) -> Self:
+        """Generate a RequestError from an Exception"""
+        status_code = getattr(error, "code", None)
+        text = getattr(error, "msg", None)
 
+        response = getattr(error, "response", None)
+        # Explicitly test for None because response objects are considered false if they
+        # have a status code other than 200
+        if response is not None:
+            status_code = response.status_code
+            text = " ".join([text or "", response.text])
 
-class NoMatchingProductType(EodagError):
-    """An error indicating that eodag was unable to derive a product type from a set
-    of search parameters"""
+        text = text or str(error)
 
+        e = cls(msg, text) if msg else cls(text)
+        e.status_code = status_code
+        return e
 
-class STACOpenerError(EodagError):
-    """An error indicating that a STAC file could not be opened"""
+
+class ValidationError(RequestError):
+    """Error validating data"""
+
+    def __init__(self, message: str, parameters: set[str] = set()) -> None:
+        self.message = message
+        self.parameters = parameters
+
+    @classmethod
+    def from_error(cls, error: Exception, msg: Optional[str] = None) -> Self:
+        """Override parent from_error to handle ValidationError specificities."""
+        setattr(error, "msg", msg)
+        validation_error = super().from_error(error)
+        return validation_error
+
+
+class DownloadError(RequestError):
+    """An error indicating something wrong with the download process"""
 
 
 class TimeOutError(RequestError):

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/logging.py

@@ -37,88 +37,48 @@ def setup_logging(verbose: int, no_progress_bar: bool = False) -> None:
     global disable_tqdm
     disable_tqdm = no_progress_bar
 
+    if verbose > 3:
+        raise ValueError("'verbose' must be one of: 0, 1, 2, 3")
+
     if verbose < 1:
         disable_tqdm = True
 
-    if verbose <= 1:
-        logging.config.dictConfig(
-            {
-                "version": 1,
-                "disable_existing_loggers": False,
-                "handlers": {
-                    "null": {"level": "DEBUG", "class": "logging.NullHandler"}
-                },
-                "loggers": {
-                    "eodag": {"handlers": ["null"], "propagate": True, "level": "INFO"}
-                },
-            }
-        )
-    elif verbose == 2:
-        logging.config.dictConfig(
-            {
-                "version": 1,
-                "disable_existing_loggers": False,
-                "formatters": {
-                    "standard": {
-                        "format": "%(asctime)-15s %(name)-32s [%(levelname)-8s] %(message)s"
-                    }
-                },
-                "handlers": {
-                    "console": {
-                        "level": "DEBUG",
-                        "class": "logging.StreamHandler",
-                        "formatter": "standard",
-                    }
-                },
-                "loggers": {
-                    "eodag": {
-                        "handlers": ["console"],
-                        "propagate": True,
-                        "level": "INFO",
-                    },
-                    "sentinelsat": {
-                        "handlers": ["console"],
-                        "propagate": True,
-                        "level": "INFO",
-                    },
-                },
-            }
-        )
-    elif verbose == 3:
-        logging.config.dictConfig(
-            {
-                "version": 1,
-                "disable_existing_loggers": False,
-                "formatters": {
-                    "verbose": {
-                        "format": (
-                            "%(asctime)-15s %(name)-32s [%(levelname)-8s] (tid=%(thread)d) %(message)s"
-                        )
-                    }
-                },
-                "handlers": {
-                    "console": {
-                        "level": "DEBUG",
-                        "class": "logging.StreamHandler",
-                        "formatter": "verbose",
-                    }
+    level = "DEBUG" if verbose == 3 else "INFO"
+
+    handlers = {
+        "console": {
+            "level": level,
+            "class": "logging.StreamHandler",
+            "formatter": "standard",
+        },
+        "null": {"level": level, "class": "logging.NullHandler"},
+    }
+    handler = "console" if verbose > 1 else "null"
+
+    logging.config.dictConfig(
+        {
+            "version": 1,
+            "disable_existing_loggers": False,
+            "formatters": {
+                "standard": {
+                    "format": "%(asctime)-15s %(name)-32s [%(levelname)-8s] %(message)s"
+                }
+            },
+            "handlers": handlers,
+            "loggers": {
+                "eodag": {
+                    "handlers": [handler],
+                    "propagate": True,
+                    "level": f"{level}",
                 },
-                "loggers": {
-                    "eodag": {
-                        "handlers": ["console"],
-                        "propagate": True,
-                        "level": "DEBUG",
-                    },
-                    "sentinelsat": {
-                        "handlers": ["console"],
-                        "propagate": True,
-                        "level": "DEBUG",
-                    },
+                "eodag-cube": {
+                    "handlers": [handler],
+                    "propagate": True,
+                    "level": f"{level}",
                 },
-            }
-        )
-    else:
-        raise ValueError("'verbose' must be one of: 0, 1, 2, 3")
+            },
+        }
+    )
 
 
 def get_logging_verbose() -> Optional[int]:

eodag/utils/repr.py

@@ -18,12 +18,21 @@
 from __future__ import annotations
 
 import collections.abc
+import re
 from typing import Any, Optional
 from urllib.parse import urlparse
 
 
 def str_as_href(link: str) -> str:
-    """URL to html link"""
+    """URL to html link
+
+    :param link: URL to format
+    :returns: HMLT formatted link
+
+    >>> str_as_href("http://foo.bar")
+    "<a href='http://foo.bar' target='_blank'>http://foo.bar</a>"
+
+    """
     if urlparse(link).scheme in ("file", "http", "https", "s3"):
         return f"<a href='{link}' target='_blank'>{link}</a>"
     else:
@@ -31,7 +40,13 @@ def str_as_href(link: str) -> str:
 
 
 def html_table(input: Any, depth: Optional[int] = None) -> str:
-    """Transform input to HTML table"""
+    """Transform input object to HTML table
+
+    :param input: input object to represent
+    :param depth: maximum depth level until which nested objects should be represented
+                  in new tables (unlimited by default)
+    :returns: HTML table
+    """
     if isinstance(input, collections.abc.Mapping):
         return dict_to_html_table(input, depth=depth)
     elif isinstance(input, collections.abc.Sequence) and not isinstance(input, str):
@@ -47,7 +62,14 @@ def dict_to_html_table(
     depth: Optional[int] = None,
     brackets: bool = True,
 ) -> str:
-    """Transform input dict to HTML table"""
+    """Transform input dict to HTML table
+
+    :param input_dict: input dict to represent
+    :param depth: maximum depth level until which nested objects should be represented
+                  in new tables (unlimited by default)
+    :param brackets: whether surrounding brackets should be displayed or not
+    :returns: HTML table
+    """
     opening_bracket = "<span style='color: grey;'>{</span>" if brackets else ""
     closing_bracket = "<span style='color: grey;'>}</span>" if brackets else ""
     indent = "10px" if brackets else "0"
@@ -90,7 +112,13 @@ def dict_to_html_table(
 def list_to_html_table(
     input_list: collections.abc.Sequence, depth: Optional[int] = None
 ) -> str:
-    """Transform input list to HTML table"""
+    """Transform input list to HTML table
+
+    :param input_list: input list to represent
+    :param depth: maximum depth level until which nested objects should be represented
+                  in new tables (unlimited by default)
+    :returns: HTML table
+    """
     if depth is not None:
         depth -= 1
     separator = (
@@ -103,11 +131,42 @@ def list_to_html_table(
         + separator.join(
             [
                 f"""<span style='text-align: left;'>{
-                html_table(v, depth=depth)
-            }</span>
+                    html_table(v, depth=depth)
+                }</span>
             """
                 for v in input_list
             ]
         )
         + "<span style='color: grey;'>]</span>"
     )
+
+
+def remove_class_repr(type_repr: str) -> str:
+    """Removes class tag from type representation
+
+    :param type_repr: input type representation
+    :returns: type without class tag
+
+    >>> remove_class_repr(str(type("foo")))
+    'str'
+    """
+    return re.sub(r"<class '(\w+)'>", r"\1", type_repr)
+
+
+def shorter_type_repr(long_type: str) -> str:
+    """Shorten long type representation
+
+    :param long_type: long type representation
+    :returns: type reprensentation shortened
+
+    >>> import typing
+    >>> shorter_type_repr(str(typing.Literal["foo", "bar"]))
+    "Literal['foo', ...]"
+    """
+    # shorten lists
+    shorter = re.sub(r",[^\[^\]]+\]", ", ...]", str(long_type))
+    # remove class prefix
+    shorter = remove_class_repr(shorter)
+    # remove parent objects
+    shorter = re.sub(r"\w+\.", "", shorter)
+    return shorter

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
 
@@ -30,7 +30,7 @@ logger = logging.getLogger("eodag.utils.requests")
 
 
 def fetch_json(
-    file_url: str,
+    url: str,
     req_session: Optional[requests.Session] = None,
     auth: Optional[requests.auth.AuthBase] = None,
     timeout: float = HTTP_REQ_TIMEOUT,
@@ -38,34 +38,32 @@ def fetch_json(
     """
     Fetches http/distant or local json file
 
-    :param file_url: url from which the file can be fetched
+    :param url: url from which the file can be fetched
     :param req_session: (optional) requests session
     :param auth: (optional) authenticated object if request needs authentication
     :param timeout: (optional) authenticated object
     :returns: json file content
     """
     if req_session is None:
-        req_session = requests.Session()
+        req_session = requests.sessions.Session()
     try:
-        if not file_url.lower().startswith("http"):
-            file_url = path_to_uri(os.path.abspath(file_url))
+        if not url.lower().startswith("http"):
+            url = path_to_uri(os.path.abspath(url))
             req_session.mount("file://", LocalFileAdapter())
 
         headers = USER_AGENT
-        logger.debug(f"fetching {file_url}")
+        logger.debug(f"fetching {url}")
         res = req_session.get(
-            file_url,
+            url,
             headers=headers,
             auth=auth,
             timeout=timeout,
         )
         res.raise_for_status()
     except requests.exceptions.Timeout as exc:
-        raise TimeOutError(exc, timeout=HTTP_REQ_TIMEOUT) from exc
+        raise TimeOutError(exc, timeout=timeout) from exc
     except requests.exceptions.RequestException as exc:
-        raise RequestError(
-            f"Unable to fetch {file_url}: {str(exc)}",
-        ) from exc
+        raise RequestError.from_error(exc, f"Unable to fetch {url}") from exc
     else:
         return res.json()
 
@@ -77,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
@@ -102,8 +100,8 @@ class LocalFileAdapter(requests.adapters.BaseAdapter):
     ) -> requests.Response:
         """Wraps a file, described in request, in a Response object.
 
-        :param req: The PreparedRequest being "sent".
-        :param kwargs: (not used) additionnal arguments of the request
+        :param request: The PreparedRequest being "sent".
+        :param kwargs: (not used) additional arguments of the request
         :returns: a Response object containing the file
         """
         response = requests.Response()

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