eodag 4.0.0a5__py3-none-any.whl → 4.0.0b1__py3-none-any.whl

eodag/types/stac_metadata.py

@@ -0,0 +1,312 @@
+# -*- coding: utf-8 -*-
+# Copyright 2025, CS GROUP - France, https://www.cs-soprasteria.com
+#
+# This file is part of stac-fastapi-eodag project
+#     https://www.github.com/CS-SI/stac-fastapi-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.
+"""property fields."""
+
+import logging
+from collections.abc import Callable
+from datetime import datetime as dt
+from typing import Annotated, Any, ClassVar, Optional, Type, TypeVar, Union, cast
+
+from pydantic import (
+    AliasChoices,
+    AliasPath,
+    BaseModel,
+    Field,
+    TypeAdapter,
+    ValidationError,
+    create_model,
+    field_serializer,
+    model_validator,
+)
+from pydantic.fields import FieldInfo
+from stac_pydantic.item import ItemProperties
+from stac_pydantic.shared import Provider
+from typing_extensions import Self
+
+from eodag.types.stac_extensions import STAC_EXTENSIONS, BaseStacExtension
+
+logger = logging.getLogger("eodag.types.stac_metadata")
+
+T = TypeVar("T", bound="CommonStacMetadata")
+
+
+class CommonStacMetadata(ItemProperties):
+    """Common STAC properties."""
+
+    # TODO: replace dt by stac_pydantic.shared.UtcDatetime.
+    # Requires timezone to be set in EODAG datetime properties
+    # Tested with EFAS FORECAST
+    datetime: Annotated[dt, Field(None, validation_alias="start_datetime")]
+    start_datetime: Annotated[dt, Field(None)]  # TODO do not set if start = end
+    end_datetime: Annotated[dt, Field(None)]  # TODO do not set if start = end
+    created: Annotated[dt, Field(None)]
+    updated: Annotated[dt, Field(None)]
+    platform: Annotated[str, Field(None)]
+    instruments: Annotated[list[str], Field(None)]
+    constellation: Annotated[str, Field(None)]
+    providers: Annotated[list[Provider], Field(None)]
+    gsd: Annotated[float, Field(None, gt=0)]
+    collection: Annotated[str, Field(None)]
+    title: Annotated[str, Field(None)]
+    description: Annotated[str, Field(None)]
+    license: Annotated[str, Field(None)]
+
+    _conformance_classes: ClassVar[dict[str, str]]
+    get_conformance_classes: ClassVar[Callable[[Any], list[str]]]
+
+    @field_serializer(
+        "datetime", "start_datetime", "end_datetime", "created", "updated"
+    )
+    def format_datetime(self, value: dt):
+        """format datetime properties"""
+        return value.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+
+    @model_validator(mode="before")
+    @classmethod
+    def parse_instruments(cls, values: dict[str, Any]) -> dict[str, Any]:
+        """
+        Convert instrument ``str`` to ``list``.
+        """
+        if instrument := values.get("instruments"):
+            values["instruments"] = (
+                ",".join(instrument.split()).split(",")
+                if isinstance(instrument, str)
+                else instrument
+            )
+            if None in values["instruments"]:
+                values["instruments"].remove(None)
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def parse_platform(cls, values: dict[str, Any]) -> dict[str, Any]:
+        """
+        Convert platform ``list`` to ``str``.
+        TODO: This should be removed after the refactoring of cop_marine because an item should only have one platform
+        """
+        if platform := values.get("platform"):
+            values["platform"] = (
+                ",".join(platform) if isinstance(platform, list) else platform
+            )
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def convert_processing_level(cls, values: dict[str, Any]) -> dict[str, Any]:
+        """Convert processing level to ``str`` if it is ``int`"""
+        if processing_level := values.get("processing:level"):
+            if isinstance(processing_level, int):
+                values["processing:level"] = f"L{processing_level}"
+        return values
+
+    @model_validator(mode="before")
+    @classmethod
+    def remove_id_property(cls, values: dict[str, Any]) -> dict[str, Any]:
+        """
+        Remove "id" property which is not STAC compliant if exists.
+        """
+        values.pop("id", None)
+        return values
+
+    @model_validator(mode="after")
+    def validate_datetime_or_start_end(self) -> Self:
+        """disable validation of datetime.
+
+        This model is used for properties conversion not validation.
+        """
+        return self
+
+    @model_validator(mode="after")
+    def validate_start_end(self) -> Self:
+        """disable validation of datetime.
+
+        This model is used for properties conversion not validation.
+        """
+        return self
+
+    @classmethod
+    def _create_from_stac_map(
+        cls,
+    ) -> dict[str, Optional[Union[str, AliasChoices, AliasPath]]]:
+        """Create mapping to convert fields from STAC to python-style"""
+        return {
+            v.serialization_alias or k: v.validation_alias
+            for k, v in cls.model_fields.items()
+        }
+
+    @classmethod
+    def has_field(cls, field_name: str) -> bool:
+        """Check if a given string is in model fields or validation_alias.
+
+        :param field_name: Field name to check (can be STAC name or python-style name)
+        :returns: True if the field is accepted, False otherwise
+        """
+        # Check if it's a model field name
+        if field_name in cls.model_fields:
+            return True
+
+        # Check if it's a validation alias
+        for field_info in cls.model_fields.values():
+            if field_info.validation_alias == field_name:
+                return True
+
+        return False
+
+    @classmethod
+    def from_stac(cls, field_name: str) -> str:
+        """Convert a STAC parameter to its matching python-style name.
+
+        :param field_name: STAC field name
+        :returns: EODAG field name
+        """
+        field_dict: dict[str, Optional[Union[str, AliasChoices, AliasPath]]] = {
+            stac_name: py_name
+            for stac_name, py_name in cls._create_from_stac_map().items()
+            if field_name == stac_name
+        }
+        if field_dict:
+            if field_dict[field_name] is None:
+                return field_name
+            if isinstance(field_dict[field_name], (AliasChoices, AliasPath)):
+                raise NotImplementedError(
+                    f"Error for stac name {field_name}: AliasChoices and AliasPath are not currently handled to"
+                    "convert stac names to eodag names"
+                )
+            return field_dict[field_name]  # type: ignore
+        return field_name
+
+    @classmethod
+    def to_stac(cls, field_name: str) -> str:
+        """Convert an python-style parameter to its matching STAC name.
+
+        :param field_name: python-style field name
+        :returns: STAC field name
+        """
+        field_dict: dict[str, Optional[Union[str, AliasChoices, AliasPath]]] = {
+            stac_name: py_name
+            for stac_name, py_name in cls._create_from_stac_map().items()
+            if field_name == py_name
+        }
+        if field_dict:
+            return list(field_dict.keys())[0]
+        return field_name
+
+    @classmethod
+    def safe_validate(
+        cls: Type[T],
+        data: dict,
+    ) -> T:
+        """Validate only fields with correct types, drop others with a warning.
+
+        :param data: data to validate
+        :returns: validated model"""
+        valid = {}
+
+        for name, field in cls.model_fields.items():
+            value = data.get(name, data.get(field.validation_alias))
+            if value is None:
+                continue
+            try:
+                TypeAdapter(field.annotation).validate_python(value)
+                valid[name] = value
+            except ValidationError as e:
+                logger.warning(
+                    "Dropped property %s: %s, %s",
+                    name,
+                    value,
+                    e.errors()[0]["msg"],
+                )
+        return cls.model_validate(valid)
+
+
+def create_stac_metadata_model(
+    extensions: list[BaseStacExtension] = STAC_EXTENSIONS,
+    base_models: list[type[BaseModel]] = [CommonStacMetadata],
+    class_name: str = "StacMetadata",
+) -> type[BaseModel]:
+    """Create a pydantic model to validate item properties.
+
+    :param extensions: list of STAC extensions to include in the model
+    :param base_model: base model to extend
+    :param class_name: name of the created model
+    :returns: pydantic model class
+    """
+    extension_models: list[type[BaseModel]] = []
+
+    # Check extensions for additional parameters to include
+    for extension in extensions:
+        if extension_model := extension.FIELDS:
+            extension_models.append(extension_model)
+
+    models = base_models + extension_models
+
+    # check for duplicate field aliases (e.g., start_datetime and start in Queryables)
+    aliases: dict[str, Optional[str]] = dict()
+    duplicates = set()
+    for bm in base_models:
+        for key, field in bm.model_fields.items():
+            if key not in aliases.keys() and key in aliases.values():
+                duplicates.add(key)
+            else:
+                aliases[key] = field.alias
+
+    model = create_model(
+        class_name,
+        __base__=tuple(models),
+        _conformance_classes=(
+            ClassVar[dict[str, str]],
+            {e.__class__.__name__: e.schema_href for e in extensions},
+        ),
+        get_conformance_classes=(
+            ClassVar[Callable[[Any], list[str]]],
+            _get_conformance_classes,
+        ),
+    )
+
+    for key in duplicates:
+        model.model_fields.pop(key)
+
+    return model
+
+
+def _get_conformance_classes(self) -> list[str]:
+    """Extract list of conformance classes from set fields metadata"""
+    conformance_classes: set[str] = set()
+
+    model_fields_by_alias = {
+        field_info.serialization_alias: field_info
+        for name, field_info in self.__class__.model_fields.items()
+        if field_info.serialization_alias
+    }
+
+    for f in self.model_fields_set:
+        mf = model_fields_by_alias.get(f) or self.__class__.model_fields.get(f)
+        if not mf or not isinstance(mf, FieldInfo) or not mf.metadata:
+            continue
+        extension = next(
+            (
+                cast(str, m["extension"])
+                for m in mf.metadata
+                if isinstance(m, dict) and "extension" in m
+            ),
+            None,
+        )
+        if c := self._conformance_classes.get(extension, None):
+            conformance_classes.add(c)
+
+    return list(conformance_classes)

eodag/utils/__init__.py

@@ -143,6 +143,10 @@ DEFAULT_TOKEN_EXPIRATION_MARGIN = 60
 # knwown next page token keys used to guess key in STAC providers next link responses
 KNOWN_NEXT_PAGE_TOKEN_KEYS = ["token", "next", "page", "skip"]
 
+ONLINE_STATUS = "succeeded"
+
+STAC_VERSION = "1.1.0"
+
 # update missing mimetypes
 mimetypes.add_type("text/xml", ".xsd")
 mimetypes.add_type("application/x-grib", ".grib")
@@ -1162,9 +1166,7 @@ def get_geometry_from_ecmwf_feature(geom: dict[str, Any]) -> BaseGeometry:
     :returns: A Shapely polygon.
     """
     if not isinstance(geom, dict):
-        raise TypeError(
-            "Geometry must be a dictionary, instead it's {}".format(type(geom))
-        )
+        raise TypeError("Geometry must be a dictionary")
     if "type" not in geom or geom["type"] != "polygon":
         raise TypeError("Geometry type must be 'polygon'")
     if "shape" not in geom:
@@ -1193,6 +1195,27 @@ def get_geometry_from_ecmwf_area(area: list[float]) -> Optional[BaseGeometry]:
     return get_geometry_from_various(geometry=bbox)
 
 
+def get_geometry_from_ecmwf_location(
+    location: dict[str, float]
+) -> Optional[BaseGeometry]:
+    """
+    Creates a ``shapely.geometry`` from a single location.
+
+    location format: {"latitude": float, "longitude": float}
+
+    :param location: dictionary with latitude and longitude
+    :returns: A Shapely polygon.
+    """
+    if not isinstance(location, dict):
+        raise TypeError("Location type must be a dictionary")
+    if not all(f in location for f in ("latitude", "longitude")):
+        raise ValueError("The location must contains the latitude and the longitude")
+    lat = location["latitude"]
+    lon = location["longitude"]
+    bbox = [lon, lat, lon, lat]
+    return get_geometry_from_various(geometry=bbox)
+
+
 class MockResponse:
     """Fake requests response"""
 
@@ -1667,8 +1690,23 @@ def format_pydantic_error(e: PydanticValidationError) -> str:
     """
     error_header = f"{e.error_count()} error(s). "
 
+    def concat_loc_names(location: tuple):
+        """Concatenate location names, excluding list indexes.
+
+        :param location: Location components
+        :returns: Concatenation of the string elements of the location
+
+        Examples:
+            >>> concat_loc_names(("variable", 0))
+            'variable'
+            >>> concat_loc_names(("location", "latitude"))
+            'location.latitude'
+        """
+        str_loc = (loc for loc in location if type(loc) is str)
+        return ".".join(str_loc)
+
     error_messages = [
-        f'{err["loc"][0]}: {err["msg"]}' if err["loc"] else err["msg"]
+        f'{concat_loc_names(err["loc"])}: {err["msg"]}' if err["loc"] else err["msg"]
         for err in e.errors()
     ]
     return error_header + "; ".join(set(error_messages))

eodag/utils/dates.py

@@ -19,8 +19,10 @@
 
 import datetime
 import re
+from datetime import date
 from datetime import datetime as dt
-from typing import Any, Iterator, Optional
+from datetime import timezone
+from typing import Any, Iterator, Optional, Union
 
 import dateutil.parser
 from dateutil import tz
@@ -35,6 +37,18 @@ RFC3339_PATTERN = (
     r"(Z|([+-])(\d{2}):(\d{2}))?)?$"
 )
 
+# yyyy-mm-dd
+DATE_PATTERN = r"\d{4}-(0[1-9]|1[0-2])-([0-2][0-9]|3[0-1])"
+
+# yyyymmdd
+COMPACT_DATE_PATTERN = r"\d{4}(0[1-9]|1[0-2])([0-2][0-9]|3[0-1])"
+
+# yyyy-mm-dd/yyyy-mm-dd, yyyy-mm-dd/to/yyyy-mm-dd
+DATE_RANGE_PATTERN = DATE_PATTERN + r"(/to/|/)" + DATE_PATTERN
+
+# yyyymmdd/yyyymmdd, yyyymmdd/to/yyyymmdd
+COMPACT_DATE_RANGE_PATTERN = COMPACT_DATE_PATTERN + r"(/to/|/)" + COMPACT_DATE_PATTERN
+
 
 def get_timestamp(date_time: str) -> float:
     """Return the Unix timestamp of an ISO8601 date/datetime in seconds.
@@ -59,7 +73,26 @@ def get_timestamp(date_time: str) -> float:
 
 
 def datetime_range(start: dt, end: dt) -> Iterator[dt]:
-    """Generator function for all dates in-between ``start`` and ``end`` date."""
+    """Generator function for all dates in-between ``start`` and ``end`` date.
+
+    :param start: Start date
+    :param end: End date
+    :returns: Generator of dates
+
+    Examples:
+        >>> from datetime import datetime
+        >>> dtr = datetime_range(datetime(2020, 12, 31), datetime(2021, 1, 2))
+        >>> next(dtr)
+        datetime.datetime(2020, 12, 31, 0, 0)
+        >>> next(dtr)
+        datetime.datetime(2021, 1, 1, 0, 0)
+        >>> next(dtr)
+        datetime.datetime(2021, 1, 2, 0, 0)
+        >>> next(dtr)
+        Traceback (most recent call last):
+        ...
+        StopIteration
+    """
     delta = end - start
     for nday in range(delta.days + 1):
         yield start + datetime.timedelta(days=nday)
@@ -150,6 +183,9 @@ def get_date(date: Optional[str]) -> Optional[str]:
     """
     Check if the input date can be parsed as a date
 
+    :param date: The date to parse
+    :returns: The datetime represented with ISO format
+
     Examples:
         >>> from eodag.utils.exceptions import ValidationError
         >>> get_date("2023-09-23")
@@ -202,3 +238,167 @@ def rfc3339_str_to_datetime(s: str) -> datetime.datetime:
         raise ValidationError("Invalid RFC3339 datetime.")
 
     return dateutil.parser.isoparse(s).replace(tzinfo=datetime.timezone.utc)
+
+
+def get_min_max(
+    value: Optional[Union[str, list[str]]] = None,
+) -> tuple[Optional[str], Optional[str]]:
+    """Returns the min and max from a list of strings or the same string if a single string is given.
+
+    :param value: a single string or a list of strings
+    :returns: a tuple with the min and max values
+
+    Examples:
+        >>> get_min_max(["a", "c", "b"])
+        ('a', 'c')
+        >>> get_min_max(["a"])
+        ('a', 'a')
+        >>> get_min_max("a")
+        ('a', 'a')
+    """
+    if isinstance(value, list):
+        sorted_values = sorted(value)
+        return sorted_values[0], sorted_values[-1]
+    return value, value
+
+
+def append_time(input_date: date, time: Optional[str] = None) -> dt:
+    """Appends a string-formatted time to a date.
+
+    :param input_date: Date to combine with the time
+    :param time: (optional) time string in format HHMM, HH:MM or HH_MM
+    :returns: Datetime obtained by appenting the time to the date
+
+    Examples:
+        >>> from eodag.utils.dates import append_time
+        >>> from datetime import date
+        >>> append_time(date(2020, 12, 13))
+        datetime.datetime(2020, 12, 13, 0, 0)
+        >>> append_time(date(2020, 12, 13), "")
+        datetime.datetime(2020, 12, 13, 0, 0)
+        >>> append_time(date(2020, 12, 13), "2400")
+        datetime.datetime(2020, 12, 13, 0, 0)
+        >>> append_time(date(2020, 12, 13), "14_31")
+        datetime.datetime(2020, 12, 13, 14, 31)
+    """
+    if not time:
+        time = "0000"
+    time = re.sub(":|_", "", time)
+    if time == "2400":
+        time = "0000"
+    combined_dt = dt.combine(input_date, dt.strptime(time, "%H%M").time())
+    combined_dt.replace(tzinfo=timezone.utc)
+    return combined_dt
+
+
+def parse_date(
+    date: str, time: Optional[Union[str, list[str]]] = None
+) -> tuple[dt, dt]:
+    """Parses a date string in formats YYYY-MM-DD, YYYMMDD, solo or in start/end or start/to/end intervals.
+
+    :param date: Single or interval date string
+    :returns: A tuple with the start and end datetime
+
+    Examples:
+        >>> parse_date("2020-12-15")
+        (datetime.datetime(2020, 12, 15, 0, 0), datetime.datetime(2020, 12, 15, 0, 0))
+        >>> parse_date("2020-12-15/to/20201230")
+        (datetime.datetime(2020, 12, 15, 0, 0), datetime.datetime(2020, 12, 30, 0, 0))
+    """
+    if "to" in date:
+        start_date_str, end_date_str = date.split("/to/")
+    elif "/" in date:
+        dates = date.split("/")
+        start_date_str = dates[0]
+        end_date_str = dates[-1]
+    else:
+        start_date_str = end_date_str = date
+
+    # Update YYYYMMDD formatted dates
+    if re.match(r"^\d{8}$", start_date_str):
+        start_date_str = (
+            f"{start_date_str[:4]}-{start_date_str[4:6]}-{start_date_str[6:]}"
+        )
+    if re.match(r"^\d{8}$", end_date_str):
+        end_date_str = f"{end_date_str[:4]}-{end_date_str[4:6]}-{end_date_str[6:]}"
+
+    start_date = dt.fromisoformat(start_date_str.rstrip("Z"))
+    end_date = dt.fromisoformat(end_date_str.rstrip("Z"))
+
+    if time:
+        start_t, end_t = get_min_max(time)
+        start_date = append_time(start_date.date(), start_t)
+        end_date = append_time(end_date.date(), end_t)
+
+    return start_date, end_date
+
+
+def parse_year_month_day(
+    year: Union[str, list[str]],
+    month: Optional[Union[str, list[str]]] = None,
+    day: Optional[Union[str, list[str]]] = None,
+    time: Optional[Union[str, list[str]]] = None,
+) -> tuple[dt, dt]:
+    """Returns minimum and maximum datetimes from given lists of years, months, days, times.
+
+    :param year: List of years or a single one
+    :param month: (optional) List of months or a single one
+    :param day: (optional) List of days or a single one
+    :param time: (optional) List of times or a single one in the format HHMM, HH:MM or HH_MM
+    :returns: A tuple with the start and end datetime
+
+    Examples:
+        >>> parse_year_month_day(["2020", "2021", "2022"], ["01", "03", "05"], "01", ["0000", "1200"])
+        (datetime.datetime(2020, 1, 1, 0, 0), datetime.datetime(2022, 5, 1, 12, 0))
+    """
+
+    def build_date(year, month=None, day=None, time=None) -> dt:
+        """Datetime from default_date with updated year, month, day and time."""
+        updated_date = dt(int(year), 1, 1).replace(
+            month=int(month) if month is not None else 1,
+            day=int(day) if day is not None else 1,
+        )
+        if time is not None:
+            updated_date = append_time(updated_date.date(), time)
+        return updated_date
+
+    start_y, end_y = get_min_max(year)
+    start_m, end_m = get_min_max(month)
+    start_d, end_d = get_min_max(day)
+    start_t, end_t = get_min_max(time)
+
+    start_date = build_date(start_y, start_m, start_d, start_t)
+    end_date = build_date(end_y, end_m, end_d, end_t)
+
+    return start_date, end_date
+
+
+def format_date(date: dt) -> str:
+    """Format a ``datetime`` with the format 'YYYY-MM-DD'.
+
+    :param date: Datetime to format
+    :returns: Date string in the format 'YYYY-MM-DD'
+
+    Examples:
+        >>> from datetime import datetime
+        >>> format_date(datetime(2020, 12, 2))
+        '2020-12-02'
+        >>> format_date(datetime(2020, 12, 2, 11, 22, 33))
+        '2020-12-02'
+    """
+    return date.isoformat()[:10]
+
+
+def format_date_range(start: dt, end: dt) -> str:
+    """Format a range with the format 'YYYY-MM-DD/YYYY-MM-DD'.
+
+    :param start: Start datetime
+    :param end: End datetime
+    :returns: Date range in the format 'YYYY-MM-DD/YYYY-MM-DD'
+
+    Examples:
+        >>> from datetime import datetime
+        >>> format_date_range(datetime(2020, 12, 2, 11, 22, 33), datetime(2020, 12, 31))
+        '2020-12-02/2020-12-31'
+    """
+    return f"{format_date(start)}/{format_date(end)}"

{eodag-4.0.0a5.dist-info → eodag-4.0.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: eodag
-Version: 4.0.0a5
+Version: 4.0.0b1
 Summary: Earth Observation Data Access Gateway
 Home-page: https://github.com/CS-SI/eodag
 Author: CS GROUP - France
@@ -23,6 +23,7 @@ Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Internet :: WWW/HTTP :: Indexing/Search
 Classifier: Topic :: Scientific/Engineering :: GIS
@@ -40,7 +41,7 @@ Requires-Dist: importlib_metadata>=5.0
 Requires-Dist: jsonpath-ng
 Requires-Dist: lxml
 Requires-Dist: orjson
-Requires-Dist: pydantic!=2.10.0,<2.12.0,>=2.1.0
+Requires-Dist: pydantic!=2.10.0,>=2.1.0
 Requires-Dist: pydantic_core
 Requires-Dist: PyJWT[crypto]>=2.5.0
 Requires-Dist: pyproj>=2.1.0
@@ -56,7 +57,7 @@ Requires-Dist: typing_extensions>=4.8.0
 Requires-Dist: urllib3
 Requires-Dist: zipstream-ng
 Provides-Extra: all
-Requires-Dist: eodag[all-providers,csw,server,tutorials]; extra == "all"
+Requires-Dist: eodag[all-providers,csw,tutorials]; extra == "all"
 Provides-Extra: all-providers
 Requires-Dist: eodag[ecmwf,usgs]; extra == "all-providers"
 Provides-Extra: csw
@@ -65,13 +66,6 @@ Provides-Extra: ecmwf
 Requires-Dist: ecmwf-api-client; extra == "ecmwf"
 Provides-Extra: usgs
 Requires-Dist: usgs>=0.3.6; extra == "usgs"
-Provides-Extra: server
-Requires-Dist: fastapi>=0.93.0; extra == "server"
-Requires-Dist: pygeofilter; extra == "server"
-Requires-Dist: starlette; extra == "server"
-Requires-Dist: uvicorn[standard]; extra == "server"
-Requires-Dist: pydantic-settings; extra == "server"
-Requires-Dist: cachetools; extra == "server"
 Provides-Extra: notebook
 Requires-Dist: tqdm[notebook]; extra == "notebook"
 Provides-Extra: tutorials
@@ -88,7 +82,7 @@ Requires-Dist: netcdf4; extra == "tutorials"
 Requires-Dist: cartopy; extra == "tutorials"
 Requires-Dist: covjsonkit; extra == "tutorials"
 Provides-Extra: dev
-Requires-Dist: eodag[all-providers,csw,server,stubs]; extra == "dev"
+Requires-Dist: eodag[all-providers,csw,stubs]; extra == "dev"
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: pytest-cov; extra == "dev"
 Requires-Dist: py>=1.8.2; extra == "dev"
@@ -105,7 +99,7 @@ Requires-Dist: wheel; extra == "dev"
 Requires-Dist: flake8; extra == "dev"
 Requires-Dist: prek; extra == "dev"
 Requires-Dist: responses!=0.24.0; extra == "dev"
-Requires-Dist: fastapi[all]; extra == "dev"
+Requires-Dist: stac-validator; extra == "dev"
 Requires-Dist: stdlib-list; extra == "dev"
 Requires-Dist: mypy; extra == "dev"
 Provides-Extra: stubs
@@ -123,7 +117,7 @@ Provides-Extra: docs
 Requires-Dist: eodag[all,stubs]; extra == "docs"
 Requires-Dist: autodoc_pydantic; extra == "docs"
 Requires-Dist: nbsphinx; extra == "docs"
-Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx<9.0.0; extra == "docs"
 Requires-Dist: sphinx-autodoc-typehints; extra == "docs"
 Requires-Dist: sphinx-book-theme>=1.0.0; extra == "docs"
 Requires-Dist: sphinx-copybutton; extra == "docs"