eodag 2.12.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

eodag/utils/exceptions.py

@@ -20,80 +20,97 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from typing import Optional, Set, Tuple
+    from typing import Optional, Set
 
+    from typing_extensions import Annotated, Doc
 
-class ValidationError(Exception):
+
+class EodagError(Exception):
+    """General EODAG error"""
+
+
+class ValidationError(EodagError):
     """Error validating data"""
 
-    def __init__(self, message: str) -> None:
+    def __init__(self, message: str, parameters: Set[str] = set()) -> None:
         self.message = message
+        self.parameters = parameters
 
 
-class PluginNotFoundError(Exception):
+class PluginNotFoundError(EodagError):
     """Error when looking for a plugin class that was not defined"""
 
 
-class PluginImplementationError(Exception):
+class PluginImplementationError(EodagError):
     """Error when a plugin does not behave as expected"""
 
 
-class MisconfiguredError(Exception):
+class MisconfiguredError(EodagError):
     """An error indicating a Search Plugin that is not well configured"""
 
 
-class AddressNotFound(Exception):
+class AddressNotFound(EodagError):
     """An error indicating the address of a subdataset was not found"""
 
 
-class UnsupportedProvider(Exception):
+class UnsupportedProvider(EodagError):
     """An error indicating that eodag does not support a provider"""
 
 
-class UnsupportedProductType(Exception):
+class UnsupportedProductType(EodagError):
     """An error indicating that eodag does not support a product type"""
 
     def __init__(self, product_type: str) -> None:
         self.product_type = product_type
 
 
-class UnsupportedDatasetAddressScheme(Exception):
+class UnsupportedDatasetAddressScheme(EodagError):
     """An error indicating that eodag does not yet support an address scheme for
     accessing raster subdatasets"""
 
 
-class AuthenticationError(Exception):
+class AuthenticationError(EodagError):
     """An error indicating that an authentication plugin did not succeeded
     authenticating a user"""
 
 
-class DownloadError(Exception):
+class DownloadError(EodagError):
     """An error indicating something wrong with the download process"""
 
 
-class NotAvailableError(Exception):
+class NotAvailableError(EodagError):
     """An error indicating that the product is not available for download"""
 
 
-class RequestError(Exception):
+class RequestError(EodagError):
     """An error indicating that a request has failed. Usually eodag functions
     and methods should catch and skip this"""
 
-    history: Set[Tuple[Exception, str]] = set()
+    status_code: Annotated[Optional[int], Doc("HTTP status code")] = None
+
+    @classmethod
+    def from_error(cls, error: Exception, msg: Optional[str] = None):
+        """Generate a RequestError from an Exception"""
+        status_code = getattr(error, "code", None)
+        text = getattr(error, "msg", None)
+
+        if response := getattr(error, "response", None):
+            status_code = response.status_code
+            text = response.text
+
+        text = text or str(error)
 
-    def __str__(self):
-        repr = super().__str__()
-        for err_tuple in self.history:
-            repr += f"\n- {str(err_tuple)}"
-        return repr
+        e = cls(msg, text) if msg else cls(text)
+        e.status_code = status_code
+        return e
 
 
-class NoMatchingProductType(Exception):
+class NoMatchingProductType(EodagError):
     """An error indicating that eodag was unable to derive a product type from a set
     of search parameters"""
 
 
-class STACOpenerError(Exception):
+class STACOpenerError(EodagError):
     """An error indicating that a STAC file could not be opened"""
 
 

eodag/utils/import_system.py

@@ -52,12 +52,9 @@ def import_all_modules(
         import_all_modules(base_package)
 
     :param base_package: The package from where we must import all the modules
-    :type base_package: `module`
     :param depth: (optional) If `base_package` has sub packages, import all the modules recursively up to this level.
                   Defaults to 1 (limits to the level of `base_package`)
-    :type depth: int
     :param exclude: (optional) The sub packages and modules to ignore while importing. Empty by default
-    :type exclude: tuple(str, ...)
 
     .. note::
         if `package` and `subpackage` have a module of the same name and this name is included in the exclude
@@ -88,7 +85,6 @@ def patch_owslib_requests(verify: bool = True) -> Generator[None, Any, None]:
     these functions in `owslib <https://geopython.github.io/OWSLib/>`_.
 
     :param verify: (optional) Whether to verify the use of https or not
-    :type verify: bool
     """
     from owslib.util import requests
 

eodag/utils/logging.py

@@ -32,95 +32,53 @@ def setup_logging(verbose: int, no_progress_bar: bool = False) -> None:
                     * 1: no logging but still displays progress bars
                     * 2: INFO level
                     * 3: DEBUG level
-    :type verbose: int
     :param no_progress_bar: (optional) Disable progress bars
-    :type no_progress_bar: bool
     """
     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]:
@@ -142,7 +100,6 @@ def get_logging_verbose() -> Optional[int]:
     3
 
     :returns: Verbose level in ``[0, 1, 2, 3]`` or None if not set
-    :rtype: int or None
     """
     global disable_tqdm
     logger = logging.getLogger("eodag")

eodag/utils/notebook.py

@@ -23,7 +23,7 @@ from typing import Any, Optional
 def check_ipython() -> bool:
     """Check if called from ipython"""
     try:
-        __IPYTHON__
+        __IPYTHON__  # type: ignore[name-defined]
         return True
     except NameError:
         return False
@@ -32,7 +32,7 @@ def check_ipython() -> bool:
 def check_notebook() -> bool:
     """Check if called from a notebook"""
     try:
-        shell = get_ipython().__class__.__name__
+        shell = get_ipython().__class__.__name__  # type: ignore[name-defined]
         if shell == "ZMQInteractiveShell":
             return True  # Jupyter notebook or qtconsole
         elif shell == "TerminalInteractiveShell":
@@ -69,7 +69,7 @@ class NotebookWidgets:
         if not self.is_notebook:
             return None
 
-        self.html_box.data = html_value
+        setattr(self.html_box, "data", html_value)
 
         if not self.html_box_shown:
             self._html_handle = self.display(self.html_box, display_id=True)
@@ -83,5 +83,5 @@ class NotebookWidgets:
         if not self.is_notebook:
             return None
 
-        self.html_box.data = ""
+        setattr(self.html_box, "data", "")
         self._update_display(self.html_box, display_id=self._html_handle.display_id)

eodag/utils/repr.py

@@ -0,0 +1,113 @@
+# -*- 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 collections.abc
+from typing import Any, Optional
+from urllib.parse import urlparse
+
+
+def str_as_href(link: str) -> str:
+    """URL to html link"""
+    if urlparse(link).scheme in ("file", "http", "https", "s3"):
+        return f"<a href='{link}' target='_blank'>{link}</a>"
+    else:
+        return link
+
+
+def html_table(input: Any, depth: Optional[int] = None) -> str:
+    """Transform input to 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):
+        return list_to_html_table(input, depth=depth)
+    elif isinstance(input, str):
+        return f"'{str_as_href(input)}'"
+    else:
+        return str_as_href(str(input))
+
+
+def dict_to_html_table(
+    input_dict: collections.abc.Mapping,
+    depth: Optional[int] = None,
+    brackets: bool = True,
+) -> str:
+    """Transform input dict to 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"
+
+    if depth is not None:
+        depth -= 1
+
+    if depth is None or depth >= 0:
+        return (
+            f"{opening_bracket}<table style='margin: 0;'>"
+            + "".join(
+                [
+                    f"""<tr style='background-color: transparent;'>
+                    <td style='padding: 5px 0 0 {indent}; text-align: left; color: grey; vertical-align:top;'>{k}:</td>
+                    <td style='padding: 5px 0 0 10px; text-align: left;'>{
+                        html_table(v, depth=depth)
+                    },</td>
+                </tr>
+                """
+                    for k, v in input_dict.items()
+                ]
+            )
+            + f"</table>{closing_bracket}"
+        )
+    else:
+        return (
+            f"{opening_bracket}"
+            + ", ".join(
+                [
+                    f"""<span style='text-align: left;'>
+                    '{k}': {html_table(v, depth=depth)}
+                </span>"""
+                    for k, v in input_dict.items()
+                ]
+            )
+            + f"{closing_bracket}"
+        )
+
+
+def list_to_html_table(
+    input_list: collections.abc.Sequence, depth: Optional[int] = None
+) -> str:
+    """Transform input list to HTML table"""
+    if depth is not None:
+        depth -= 1
+    separator = (
+        ",<br />"
+        if any(isinstance(v, collections.abc.Mapping) for v in input_list)
+        else ", "
+    )
+    return (
+        "<span style='color: grey;'>[</span>"
+        + separator.join(
+            [
+                f"""<span style='text-align: left;'>{
+                html_table(v, depth=depth)
+            }</span>
+            """
+                for v in input_list
+            ]
+        )
+        + "<span style='color: grey;'>]</span>"
+    )

eodag/utils/requests.py

@@ -0,0 +1,128 @@
+# -*- 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 logging
+import os
+from typing import Any, Optional, Tuple
+
+import requests
+
+from eodag.utils import HTTP_REQ_TIMEOUT, USER_AGENT, path_to_uri, uri_to_path
+from eodag.utils.exceptions import RequestError, TimeOutError
+
+logger = logging.getLogger("eodag.utils.requests")
+
+
+def fetch_json(
+    file_url: str,
+    req_session: Optional[requests.Session] = None,
+    auth: Optional[requests.auth.AuthBase] = None,
+    timeout: float = HTTP_REQ_TIMEOUT,
+) -> Any:
+    """
+    Fetches http/distant or local json file
+
+    :param file_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()
+    try:
+        if not file_url.lower().startswith("http"):
+            file_url = path_to_uri(os.path.abspath(file_url))
+            req_session.mount("file://", LocalFileAdapter())
+
+        headers = USER_AGENT
+        logger.debug(f"fetching {file_url}")
+        res = req_session.get(
+            file_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
+    except requests.exceptions.RequestException as exc:
+        raise RequestError.from_error(exc, f"Unable to fetch {file_url}") from exc
+    else:
+        return res.json()
+
+
+class LocalFileAdapter(requests.adapters.BaseAdapter):
+    """Protocol Adapter to allow Requests to GET file:// URLs inspired
+    by https://stackoverflow.com/questions/10123929/fetch-a-file-from-a-local-url-with-python-requests/27786580
+    `LocalFileAdapter` class available for the moment (on the 2024-04-22)
+    """
+
+    @staticmethod
+    def _chkpath(method: str, path: str) -> Tuple[int, str]:
+        """Return an HTTP status for the given filesystem path.
+
+        :param method: method of the request
+        :param path: path of the given file
+        :returns: HTTP status and its associated message
+        """
+        if method.lower() in ("put", "delete"):
+            return 501, "Not Implemented"  # TODO
+        elif method.lower() not in ("get", "head"):
+            return 405, "Method Not Allowed"
+        elif os.path.isdir(path):
+            return 400, "Path Not A File"
+        elif not os.path.isfile(path):
+            return 404, "File Not Found"
+        elif not os.access(path, os.R_OK):
+            return 403, "Access Denied"
+        else:
+            return 200, "OK"
+
+    def send(
+        self, request: requests.PreparedRequest, *args: Any, **kwargs: Any
+    ) -> 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
+        :returns: a Response object containing the file
+        """
+        response = requests.Response()
+
+        if request.method is None or request.url is None:
+            raise RequestError("Method or url of the request is missing")
+
+        path_url = uri_to_path(request.url)
+
+        response.status_code, response.reason = self._chkpath(request.method, path_url)
+        if response.status_code == 200 and request.method.lower() != "head":
+            try:
+                response.raw = open(path_url, "rb")
+            except (OSError, IOError) as err:
+                response.status_code = 500
+                response.reason = str(err)
+        response.url = request.url
+        response.request = request
+
+        return response
+
+    def close(self):
+        """Closes without cleaning up adapter specific items."""
+        pass

eodag/utils/rest.py

@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+# Copyright 2018, 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.
+"""eodag.rest.utils methods that must be importable without eodag[server] installed"""
+
+from __future__ import annotations
+
+import datetime
+import re
+from typing import Any, Dict, Optional, Tuple
+
+import dateutil.parser
+from dateutil import tz
+
+from eodag.utils.exceptions import ValidationError
+
+RFC3339_PATTERN = (
+    r"^(\d{4})-(\d{2})-(\d{2})"
+    r"(?:T(\d{2}):(\d{2}):(\d{2})(\.\d+)?"
+    r"(Z|([+-])(\d{2}):(\d{2}))?)?$"
+)
+
+
+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
+    :returns: Start date and end date from datetime string (duplicate value if only one date as input)
+    """
+    datetime_str = arguments.pop("datetime", None)
+
+    if datetime_str:
+        datetime_split = datetime_str.split("/")
+        if len(datetime_split) > 1:
+            dtstart = datetime_split[0] if datetime_split[0] != ".." else None
+            dtend = datetime_split[1] if datetime_split[1] != ".." else None
+        elif len(datetime_split) == 1:
+            # same time for start & end if only one is given
+            dtstart, dtend = datetime_split[0:1] * 2
+        else:
+            return None, None
+
+        return get_date(dtstart), get_date(dtend)
+
+    else:
+        # return already set (dtstart, dtend) or None
+        dtstart = get_date(arguments.pop("dtstart", None))
+        dtend = get_date(arguments.pop("dtend", None))
+        return get_date(dtstart), get_date(dtend)
+
+
+def get_date(date: Optional[str]) -> Optional[str]:
+    """Check if the input date can be parsed as a date"""
+
+    if not date:
+        return None
+    try:
+        return (
+            dateutil.parser.parse(date)
+            .replace(tzinfo=tz.UTC)
+            .isoformat()
+            .replace("+00:00", "")
+        )
+    except ValueError as e:
+        exc = ValidationError("invalid input date: %s" % e)
+        raise exc
+
+
+def rfc3339_str_to_datetime(s: str) -> datetime.datetime:
+    """Convert a string conforming to RFC 3339 to a :class:`datetime.datetime`.
+
+    :param s: The string to convert to :class:`datetime.datetime`
+
+    :returns: The datetime represented by the ISO8601 (RFC 3339) formatted string
+
+    raises: :class:`ValidationError`
+    """
+    # Uppercase the string
+    s = s.upper()
+
+    # Match against RFC3339 regex.
+    result = re.match(RFC3339_PATTERN, s)
+    if not result:
+        raise ValidationError("Invalid RFC3339 datetime.")
+
+    return dateutil.parser.isoparse(s).replace(tzinfo=datetime.timezone.utc)