eodag 3.8.1__py3-none-any.whl → 3.9.1__py3-none-any.whl

eodag/resources/stac_provider.yml

@@ -33,6 +33,9 @@ search:
     auto_discovery: true
     metadata_pattern: '^[a-zA-Z0-9_:-]+$'
     search_param: '{{{{"query":{{{{"{metadata}":{{{{"eq":"{{{metadata}}}" }}}} }}}} }}}}'
+    search_param_unparsed:
+      - filter
+      - query
     metadata_path: '$.properties.*'
   discover_product_types:
     fetch_url: '{api_endpoint}/../collections'
@@ -99,7 +102,7 @@ search:
       - '$.properties."sat:relative_orbit"'
     orbitDirection:
       - '{{"query":{{"sat:orbit_state":{{"eq":"{orbitDirection}"}}}}}}'
-      - '$.properties."sat:orbit_state"'
+      - '{$.properties."sat:orbit_state"#to_lower}'
     cloudCover:
       - '{{"query":{{"eo:cloud_cover":{{"lte":"{cloudCover}"}}}}}}'
       - '$.properties."eo:cloud_cover"'
@@ -137,7 +140,7 @@ search:
       - '$.properties."view:sun_elevation"'
     polarizationChannels:
       - '{{"query":{{"sar:polarizations":{{"eq":"{polarizationChannels}"}}}}}}'
-      - '$.properties."sar:polarizations"'
+      - '{$.properties.sar:polarizations#csv_list(+)}'
     dopplerFrequency:
       - '{{"query":{{"sar:frequency_band":{{"eq":"{dopplerFrequency}"}}}}}}'
       - '$.properties."sar:frequency_band"'

eodag/resources/user_conf_template.yml

@@ -117,11 +117,6 @@ earth_search:
             aws_profile:
     download:
         output_dir:
-earth_search_cog:
-    priority: # Lower value means lower priority (Default: 0)
-    search: # Search parameters configuration
-    download:
-        output_dir:
 earth_search_gcs:
     priority: # Lower value means lower priority (Default: 0)
     search: # Search parameters configuration

eodag/rest/core.py

@@ -21,6 +21,7 @@ import datetime
 import logging
 import os
 import re
+import warnings
 from typing import TYPE_CHECKING, cast
 from unittest.mock import Mock
 from urllib.parse import urlencode
@@ -83,6 +84,13 @@ if TYPE_CHECKING:
     from starlette.responses import Response
 
 
+warnings.warn(
+    "The module `eodag.rest.core` is deprecated since v3.9.0 and will be removed in a future version. "
+    "The STAC server has moved to https://github.com/CS-SI/stac-fastapi-eodag",
+    category=DeprecationWarning,
+    stacklevel=2,
+)
+
 eodag_api = eodag.EODataAccessGateway()
 
 logger = logging.getLogger("eodag.rest.core")

eodag/rest/errors.py

@@ -17,6 +17,7 @@
 # limitations under the License.
 import logging
 import re
+import warnings
 from typing import Union
 
 from fastapi import FastAPI, Request
@@ -53,6 +54,14 @@ EODAG_DEFAULT_STATUS_CODES = {
     ValidationError: status.HTTP_400_BAD_REQUEST,
 }
 
+warnings.warn(
+    "The module `eodag.rest.errors` is deprecated since v3.9.0 and will be removed in a future version. "
+    "The STAC server has moved to https://github.com/CS-SI/stac-fastapi-eodag",
+    category=DeprecationWarning,
+    stacklevel=2,
+)
+
+
 logger = logging.getLogger("eodag.rest.server")
 
 

eodag/rest/server.py

@@ -20,6 +20,7 @@ from __future__ import annotations
 import logging
 import os
 import re
+import warnings
 from contextlib import asynccontextmanager
 from importlib.metadata import version
 from json import JSONDecodeError
@@ -67,6 +68,13 @@ if TYPE_CHECKING:
 
 from starlette.responses import Response as StarletteResponse
 
+warnings.warn(
+    "The module `eodag.rest.server` is deprecated since v3.9.0 and will be removed in a future version. "
+    "The STAC server has moved to https://github.com/CS-SI/stac-fastapi-eodag",
+    category=DeprecationWarning,
+    stacklevel=2,
+)
+
 logger = logging.getLogger("eodag.rest.server")
 
 

eodag/rest/stac.py

@@ -19,6 +19,7 @@ from __future__ import annotations
 
 import logging
 import os
+import warnings
 from collections import defaultdict
 from datetime import datetime, timezone
 from typing import TYPE_CHECKING, Any, Optional
@@ -68,6 +69,13 @@ if TYPE_CHECKING:
     from eodag.api.search_result import SearchResult
 
 
+warnings.warn(
+    "The module `eodag.rest.stac` is deprecated since v3.9.0 and will be removed in a future version. "
+    "The STAC server has moved to https://github.com/CS-SI/stac-fastapi-eodag",
+    category=DeprecationWarning,
+    stacklevel=2,
+)
+
 logger = logging.getLogger("eodag.rest.stac")
 
 # fields not to put in item properties

eodag/rest/utils/__init__.py

@@ -34,8 +34,8 @@ from eodag.plugins.crunch.filter_latest_intersect import FilterLatestIntersect
 from eodag.plugins.crunch.filter_latest_tpl_name import FilterLatestByName
 from eodag.plugins.crunch.filter_overlap import FilterOverlap
 from eodag.utils import StreamResponse
+from eodag.utils.dates import get_date, get_datetime
 from eodag.utils.exceptions import ValidationError
-from eodag.utils.rest import get_date, get_datetime
 
 if TYPE_CHECKING:
     from eodag.rest.types.stac_search import SearchPostRequest
@@ -203,7 +203,5 @@ def file_to_stream(
     filename = os.path.basename(filepath_to_stream)
     return StreamResponse(
         content=read_file_chunks_and_delete(open(filepath_to_stream, "rb")),
-        headers={
-            "content-disposition": f"attachment; filename={filename}",
-        },
+        filename=filename,
     )

eodag/rest/utils/rfc3339.py

@@ -18,7 +18,7 @@
 import datetime
 from typing import Optional
 
-from eodag.utils.rest import rfc3339_str_to_datetime
+from eodag.utils.dates import rfc3339_str_to_datetime
 
 
 def str_to_interval(

eodag/utils/__init__.py

@@ -24,7 +24,6 @@ this package should go here
 from __future__ import annotations
 
 import ast
-import datetime
 import errno
 import functools
 import hashlib
@@ -43,8 +42,7 @@ import unicodedata
 import warnings
 from collections import defaultdict
 from copy import deepcopy as copy_deepcopy
-from dataclasses import dataclass
-from datetime import datetime as dt
+from dataclasses import dataclass, field
 from email.message import Message
 from glob import glob
 from importlib.metadata import metadata
@@ -75,8 +73,6 @@ import orjson
 import shapefile
 import shapely.wkt
 import yaml
-from dateutil.parser import isoparse
-from dateutil.tz import UTC
 from jsonpath_ng import jsonpath
 from jsonpath_ng.ext import parse
 from jsonpath_ng.jsonpath import Child, Fields, Index, Root, Slice
@@ -414,54 +410,6 @@ def maybe_generator(obj: Any) -> Iterator[Any]:
         yield obj
 
 
-def get_timestamp(date_time: str) -> float:
-    """Return the Unix timestamp of an ISO8601 date/datetime in seconds.
-
-    If the datetime has no offset, it is assumed to be an UTC datetime.
-
-    :param date_time: The datetime string to return as timestamp
-    :returns: The timestamp corresponding to the ``date_time`` string in seconds
-    """
-    dt = isoparse(date_time)
-    if not dt.tzinfo:
-        dt = dt.replace(tzinfo=UTC)
-    return dt.timestamp()
-
-
-def datetime_range(start: dt, end: dt) -> Iterator[dt]:
-    """Generator function for all dates in-between ``start`` and ``end`` date."""
-    delta = end - start
-    for nday in range(delta.days + 1):
-        yield start + datetime.timedelta(days=nday)
-
-
-def is_range_in_range(valid_range: str, check_range: str) -> bool:
-    """Check if the check_range is completely within the valid_range.
-
-    This function checks if both the start and end dates of the check_range
-    are within the start and end dates of the valid_range.
-
-    :param valid_range: The valid date range in the format 'YYYY-MM-DD/YYYY-MM-DD'.
-    :param check_range: The date range to check in the format 'YYYY-MM-DD/YYYY-MM-DD'.
-    :returns: True if check_range is within valid_range, otherwise False.
-    """
-    if "/" not in valid_range or "/" not in check_range:
-        return False
-
-    # Split the date ranges into start and end dates
-    start_valid, end_valid = valid_range.split("/")
-    start_check, end_check = check_range.split("/")
-
-    # Convert the strings to datetime objects using fromisoformat
-    start_valid_dt = datetime.datetime.fromisoformat(start_valid)
-    end_valid_dt = datetime.datetime.fromisoformat(end_valid)
-    start_check_dt = datetime.datetime.fromisoformat(start_check)
-    end_check_dt = datetime.datetime.fromisoformat(end_check)
-
-    # Check if check_range is within valid_range
-    return start_valid_dt <= start_check_dt and end_valid_dt >= end_check_dt
-
-
 class DownloadedCallback:
     """Example class for callback after each download in :meth:`~eodag.api.core.EODataAccessGateway.download_all`"""
 
@@ -1457,9 +1405,76 @@ class StreamResponse:
     """Represents a streaming response"""
 
     content: Iterable[bytes]
-    headers: Optional[Mapping[str, str]] = None
+    _filename: Optional[str] = field(default=None, repr=False, init=False)
+    _size: Optional[int] = field(default=None, repr=False, init=False)
+    headers: dict[str, str] = field(default_factory=dict)
     media_type: Optional[str] = None
     status_code: Optional[int] = None
+    arcname: Optional[str] = None
+
+    def __init__(
+        self,
+        content: Iterable[bytes],
+        filename: Optional[str] = None,
+        size: Optional[int] = None,
+        headers: Optional[Mapping[str, str]] = None,
+        media_type: Optional[str] = None,
+        status_code: Optional[int] = None,
+        arcname: Optional[str] = None,
+    ):
+        self.content = content
+        self.headers = dict(headers) if headers else {}
+        self.media_type = media_type
+        self.status_code = status_code
+        self.arcname = arcname
+        # use property setters to update headers
+        self.filename = filename
+        self.size = size
+
+    # filename handling
+    @property
+    def filename(self) -> Optional[str]:
+        """Get the filename for the streaming response.
+
+        :returns: The filename, or None if not set
+        """
+        return self._filename
+
+    @filename.setter
+    def filename(self, value: Optional[str]) -> None:
+        """Set the filename and update the content-disposition header accordingly.
+
+        :param value: The filename to set, or None to clear it
+        """
+        self._filename = value
+        if value:
+            outputs_filename = os.path.basename(value)
+            self.headers[
+                "content-disposition"
+            ] = f'attachment; filename="{outputs_filename}"'
+        elif "content-disposition" in self.headers:
+            del self.headers["content-disposition"]
+
+    # size handling
+    @property
+    def size(self) -> Optional[int]:
+        """Get the content size for the streaming response.
+
+        :returns: The content size in bytes, or None if not set
+        """
+        return self._size
+
+    @size.setter
+    def size(self, value: Optional[int]) -> None:
+        """Set the content size and update the content-length header accordingly.
+
+        :param value: The content size in bytes, or None to clear it
+        """
+        self._size = value
+        if value is not None:
+            self.headers["content-length"] = str(value)
+        elif "content-length" in self.headers:
+            del self.headers["content-length"]
 
 
 def guess_file_type(file: str) -> Optional[str]:

eodag/utils/dates.py

@@ -0,0 +1,204 @@
+# -*- coding: utf-8 -*-
+# Copyright 2025, 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.dates methods that must be importable without eodag[server] installeds"""
+
+import datetime
+import re
+from datetime import datetime as dt
+from typing import Any, Iterator, Optional
+
+import dateutil.parser
+from dateutil import tz
+from dateutil.parser import isoparse
+from dateutil.tz import UTC
+
+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_timestamp(date_time: str) -> float:
+    """Return the Unix timestamp of an ISO8601 date/datetime in seconds.
+
+    If the datetime has no offset, it is assumed to be an UTC datetime.
+
+    :param date_time: The datetime string to return as timestamp
+    :returns: The timestamp corresponding to the ``date_time`` string in seconds
+
+    Examples:
+        >>> get_timestamp("2023-09-23T12:34:56Z")  # doctest: +ELLIPSIS
+        1695472496.0
+        >>> get_timestamp("2023-09-23T12:34:56+02:00")  # doctest: +ELLIPSIS
+        1695465296.0
+        >>> get_timestamp("2023-09-23")  # doctest: +ELLIPSIS
+        1695427200.0
+    """
+    dt = isoparse(date_time)
+    if not dt.tzinfo:
+        dt = dt.replace(tzinfo=UTC)
+    return dt.timestamp()
+
+
+def datetime_range(start: dt, end: dt) -> Iterator[dt]:
+    """Generator function for all dates in-between ``start`` and ``end`` date."""
+    delta = end - start
+    for nday in range(delta.days + 1):
+        yield start + datetime.timedelta(days=nday)
+
+
+def is_range_in_range(valid_range: str, check_range: str) -> bool:
+    """Check if the check_range is completely within the valid_range.
+
+    This function checks if both the start and end dates of the check_range
+    are within the start and end dates of the valid_range.
+
+    :param valid_range: The valid date range in the format 'YYYY-MM-DD/YYYY-MM-DD'.
+    :param check_range: The date range to check in the format 'YYYY-MM-DD/YYYY-MM-DD'.
+    :returns: True if check_range is within valid_range, otherwise False.
+
+    Examples:
+        >>> is_range_in_range("2023-01-01/2023-12-31", "2023-03-01/2023-03-31")
+        True
+        >>> is_range_in_range("2023-01-01/2023-12-31", "2022-12-01/2023-03-31")
+        False
+        >>> is_range_in_range("2023-01-01/2023-12-31", "2023-11-01/2024-01-01")
+        False
+        >>> is_range_in_range("2023-01-01/2023-12-31", "invalid-range")
+        False
+        >>> is_range_in_range("invalid-range", "2023-03-01/2023-03-31")
+        False
+    """
+    if "/" not in valid_range or "/" not in check_range:
+        return False
+
+    # Split the date ranges into start and end dates
+    start_valid, end_valid = valid_range.split("/")
+    start_check, end_check = check_range.split("/")
+
+    # Convert the strings to datetime objects using fromisoformat
+    start_valid_dt = datetime.datetime.fromisoformat(start_valid)
+    end_valid_dt = datetime.datetime.fromisoformat(end_valid)
+    start_check_dt = datetime.datetime.fromisoformat(start_check)
+    end_check_dt = datetime.datetime.fromisoformat(end_check)
+
+    # Check if check_range is within valid_range
+    return start_valid_dt <= start_check_dt and end_valid_dt >= end_check_dt
+
+
+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)
+
+    Examples:
+        >>> get_datetime({"datetime": "2023-03-01/2023-03-31"})
+        ('2023-03-01T00:00:00', '2023-03-31T00:00:00')
+        >>> get_datetime({"datetime": "2023-03-01"})
+        ('2023-03-01T00:00:00', '2023-03-01T00:00:00')
+        >>> get_datetime({"datetime": "../2023-03-31"})
+        (None, '2023-03-31T00:00:00')
+        >>> get_datetime({"datetime": "2023-03-01/.."})
+        ('2023-03-01T00:00:00', None)
+        >>> get_datetime({"dtstart": "2023-03-01", "dtend": "2023-03-31"})
+        ('2023-03-01T00:00:00', '2023-03-31T00:00:00')
+        >>> get_datetime({})
+        (None, None)
+    """
+    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
+
+    Examples:
+        >>> from eodag.utils.exceptions import ValidationError
+        >>> get_date("2023-09-23")
+        '2023-09-23T00:00:00'
+        >>> get_date(None) is None
+        True
+        >>> get_date("invalid-date")  # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+            ...
+        ValidationError
+    """
+
+    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`
+
+    Examples:
+        >>> from eodag.utils.exceptions import ValidationError
+        >>> rfc3339_str_to_datetime("2023-09-23T12:34:56Z")
+        datetime.datetime(2023, 9, 23, 12, 34, 56, tzinfo=datetime.timezone.utc)
+
+        >>> rfc3339_str_to_datetime("invalid-date")  # doctest: +IGNORE_EXCEPTION_DETAIL
+        Traceback (most recent call last):
+            ...
+        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)