eodag 2.12.1__py3-none-any.whl → 3.0.0b1__py3-none-any.whl

eodag/types/__init__.py

@@ -18,8 +18,9 @@
 """EODAG types"""
 from __future__ import annotations
 
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import Any, Dict, List, Literal, Optional, Tuple, TypedDict, Union
 
+from annotated_types import Gt, Lt
 from pydantic import Field
 from pydantic.fields import FieldInfo
 
@@ -56,13 +57,51 @@ def json_type_to_python(json_type: Union[str, List[str]]) -> type:
         return type(None)
 
 
-def python_type_to_json(python_type: type) -> Optional[Union[str, List[str]]]:
+def _get_min_or_max(type_info: Union[Lt, Gt, Any]) -> Tuple[str, Any]:
+    """
+    checks if the value from an Annotated object is a minimum or maximum
+    :param type_info: info from Annotated
+    :return: "min" or "max"
+    """
+    if isinstance(type_info, Gt):
+        return "min", type_info.gt
+    if isinstance(type_info, Lt):
+        return "max", type_info.lt
+    return "", None
+
+
+def _get_type_info_from_annotated(
+    annotated_type: Annotated[type, Any]
+) -> Dict[str, Any]:
+    """
+    retrieves type information from an annotated object
+    :param annotated_type: annotated object
+    :return: dict containing type and min/max if available
+    """
+    type_args = get_args(annotated_type)
+    type_data = {
+        "type": list(JSON_TYPES_MAPPING.keys())[
+            list(JSON_TYPES_MAPPING.values()).index(type_args[0])
+        ]
+    }
+    if len(type_args) >= 2:
+        min_or_max, value = _get_min_or_max(type_args[1])
+        type_data[min_or_max] = value
+    if len(type_args) > 2:
+        min_or_max, value = _get_min_or_max(type_args[2])
+        type_data[min_or_max] = value
+    return type_data
+
+
+def python_type_to_json(
+    python_type: type,
+) -> Optional[Union[str, List[Dict[str, Any]]]]:
     """Get json type from python https://spec.openapis.org/oas/v3.1.0#data-types
 
     >>> python_type_to_json(int)
     'integer'
     >>> python_type_to_json(Union[float, str])
-    ['number', 'string']
+    [{'type': 'number'}, {'type': 'string'}]
 
     :param python_type: the python type
     :returns: the json type
@@ -70,18 +109,25 @@ def python_type_to_json(python_type: type) -> Optional[Union[str, List[str]]]:
     if get_origin(python_type) is Union:
         json_type = list()
         for single_python_type in get_args(python_type):
+            type_data = {}
             if single_python_type in JSON_TYPES_MAPPING.values():
                 # JSON_TYPES_MAPPING key from given value
                 single_json_type = list(JSON_TYPES_MAPPING.keys())[
                     list(JSON_TYPES_MAPPING.values()).index(single_python_type)
                 ]
-                json_type.append(single_json_type)
+                type_data["type"] = single_json_type
+                json_type.append(type_data)
+            elif get_origin(single_python_type) == Annotated:
+                type_data = _get_type_info_from_annotated(single_python_type)
+                json_type.append(type_data)
         return json_type
     elif python_type in JSON_TYPES_MAPPING.values():
         # JSON_TYPES_MAPPING key from given value
         return list(JSON_TYPES_MAPPING.keys())[
             list(JSON_TYPES_MAPPING.values()).index(python_type)
         ]
+    elif get_origin(python_type) == Annotated:
+        return [_get_type_info_from_annotated(python_type)]
     else:
         return None
 
@@ -99,7 +145,9 @@ def json_field_definition_to_python(
     ...         'title': 'Foo parameter'
     ...     }
     ... )
-    >>> str(result).replace('_extensions', '') # python3.8 compatibility
+    >>> res_repr = str(result).replace('_extensions', '') # python3.8 compatibility
+    >>> res_repr = res_repr.replace(', default=None', '') # pydantic >= 2.7.0 compatibility
+    >>> res_repr
     "typing.Annotated[bool, FieldInfo(annotation=NoneType, required=False, title='Foo parameter')]"
 
     :param json_field_definition: the json field definition
@@ -159,13 +207,39 @@ def python_field_definition_to_json(
     # enum & type
     if get_origin(python_field_args[0]) is Literal:
         enum_args = get_args(python_field_args[0])
-        json_field_definition["type"] = python_type_to_json(type(enum_args[0]))
+        type_data = python_type_to_json(type(enum_args[0]))
+        if isinstance(type_data, str):
+            json_field_definition["type"] = type_data
+        else:
+            json_field_definition["type"] = [row["type"] for row in type_data]
+            json_field_definition["min"] = [
+                row["min"] if "min" in row else None for row in type_data
+            ]
+            json_field_definition["max"] = [
+                row["max"] if "max" in row else None for row in type_data
+            ]
         json_field_definition["enum"] = list(enum_args)
     # type
     else:
         field_type = python_type_to_json(python_field_args[0])
-        if field_type is not None:
-            json_field_definition["type"] = python_type_to_json(python_field_args[0])
+        if isinstance(field_type, str):
+            json_field_definition["type"] = field_type
+        else:
+            json_field_definition["type"] = [row["type"] for row in field_type]
+            json_field_definition["min"] = [
+                row["min"] if "min" in row else None for row in field_type
+            ]
+            json_field_definition["max"] = [
+                row["max"] if "max" in row else None for row in field_type
+            ]
+    if "min" in json_field_definition and json_field_definition["min"].count(
+        None
+    ) == len(json_field_definition["min"]):
+        json_field_definition.pop("min")
+    if "max" in json_field_definition and json_field_definition["max"].count(
+        None
+    ) == len(json_field_definition["max"]):
+        json_field_definition.pop("max")
 
     if len(python_field_args) < 2:
         return json_field_definition
@@ -204,7 +278,9 @@ def model_fields_to_annotated(
     >>> from pydantic import create_model
     >>> some_model = create_model("some_model", foo=(str, None))
     >>> fields_definitions = model_fields_to_annotated(some_model.model_fields)
-    >>> str(fields_definitions).replace('_extensions', '') # python3.8 compatibility
+    >>> fd_repr = str(fields_definitions).replace('_extensions', '') # python3.8 compatibility
+    >>> fd_repr = fd_repr.replace(', default=None', '') # pydantic >= 2.7.0 compatibility
+    >>> fd_repr
     "{'foo': typing.Annotated[str, FieldInfo(annotation=NoneType, required=False)]}"
 
     :param model_fields: BaseModel.model_fields to convert
@@ -217,3 +293,17 @@ def model_fields_to_annotated(
         new_field_info.annotation = None
         annotated_model_fields[param] = Annotated[field_type, new_field_info]
     return annotated_model_fields
+
+
+class ProviderSortables(TypedDict):
+    """A class representing sortable parameter(s) of a provider and the allowed
+    maximum number of used sortable(s) in a search request with the provider
+
+    :param sortables: The list of sortable parameter(s) of a provider
+    :type sortables: list[str]
+    :param max_sort_params: (optional) The allowed maximum number of sortable(s) in a search request with the provider
+    :type max_sort_params: int
+    """
+
+    sortables: List[str]
+    max_sort_params: Annotated[Optional[int], Gt(0)]

eodag/types/bbox.py

@@ -15,9 +15,9 @@
 # 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 typing import Any, Dict, List, Tuple, Union
+from typing import Dict, List, Tuple, Union
 
-from pydantic import BaseModel, validator
+from pydantic import BaseModel, ValidationInfo, field_validator
 from shapely.geometry.polygon import Polygon
 
 NumType = Union[float, int]
@@ -36,7 +36,7 @@ class BBox(BaseModel):
     lonmax: NumType
     latmax: NumType
 
-    def __init__(__pydantic_self__, bboxArgs: BBoxArgs) -> None:  # type: ignore
+    def __init__(__pydantic_self__, bboxArgs: BBoxArgs) -> None:  # type: ignore  # pylint: disable=no-self-argument
         """
         Constructs all the necessary attributes for the BBox object.
 
@@ -55,11 +55,12 @@ class BBox(BaseModel):
             values = bboxArgs
         else:
             raise ValueError(
-                "Expected a dictionary, list or tuple with 4 values for lonmin, latmin, lonmax, latmax"
+                "Expected a dictionary,",
+                " list or tuple with 4 values for lonmin, latmin, lonmax, latmax",
             )
         super().__init__(**values)
 
-    @validator("lonmin", "lonmax")
+    @field_validator("lonmin", "lonmax")
     @classmethod
     def validate_longitude(cls, v: NumType) -> NumType:
         """
@@ -72,7 +73,7 @@ class BBox(BaseModel):
             raise ValueError("Longitude values must be between -180 and 180")
         return v
 
-    @validator("latmin", "latmax")
+    @field_validator("latmin", "latmax")
     @classmethod
     def validate_latitude(cls, v: NumType) -> NumType:
         """
@@ -85,31 +86,31 @@ class BBox(BaseModel):
             raise ValueError("Latitude values must be between -90 and 90")
         return v
 
-    @validator("lonmax")
+    @field_validator("lonmax")
     @classmethod
-    def validate_lonmax(cls, v: NumType, values: Dict[str, Any]) -> NumType:
+    def validate_lonmax(cls, v: NumType, info: ValidationInfo) -> NumType:
         """
         Validates that lonmax is greater than lonmin.
 
         :param v: The lonmax value to be validated.
-        :param values: A dictionary containing the current attribute values.
+        :param info: Additional validation informations.
         :return: The validated lonmax value.
         """
-        if "lonmin" in values and v < values["lonmin"]:
+        if "lonmin" in info.data and v < info.data["lonmin"]:
             raise ValueError("lonmax must be greater than lonmin")
         return v
 
-    @validator("latmax")
+    @field_validator("latmax")
     @classmethod
-    def validate_latmax(cls, v: NumType, values: Dict[str, Any]) -> NumType:
+    def validate_latmax(cls, v: NumType, info: ValidationInfo) -> NumType:
         """
         Validates that latmax is greater than latmin.
 
         :param v: The latmax value to be validated.
-        :param values: A dictionary containing the current attribute values.
+        :param info: Additional validation informations.
         :return: The validated latmax value.
         """
-        if "latmin" in values and v < values["latmin"]:
+        if "latmin" in info.data and v < info.data["latmin"]:
             raise ValueError("latmax must be greater than latmin")
         return v
 

eodag/types/download_args.py

@@ -0,0 +1,31 @@
+# -*- 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
+
+from typing import Dict, TypedDict
+
+
+class DownloadConf(TypedDict, total=False):
+    """Download configuration"""
+
+    outputs_prefix: str
+    outputs_extension: str
+    extract: bool
+    dl_url_params: Dict[str, str]
+    delete_archive: bool
+    asset: str

eodag/types/search_args.py

@@ -15,9 +15,11 @@
 # 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.
+import re
 from datetime import datetime
-from typing import Dict, List, Optional, Tuple, Union, cast
+from typing import Any, Dict, List, Optional, Tuple, Union, cast
 
+from annotated_types import MinLen
 from pydantic import BaseModel, ConfigDict, Field, conint, field_validator
 from shapely import wkt
 from shapely.errors import GEOSException
@@ -25,12 +27,14 @@ from shapely.geometry import Polygon, shape
 from shapely.geometry.base import GEOMETRY_TYPES, BaseGeometry
 
 from eodag.types.bbox import BBox
-from eodag.utils import DEFAULT_ITEMS_PER_PAGE, DEFAULT_PAGE
+from eodag.utils import DEFAULT_ITEMS_PER_PAGE, DEFAULT_PAGE, Annotated
+from eodag.utils.exceptions import ValidationError
 
 NumType = Union[float, int]
 GeomArgs = Union[List[NumType], Tuple[NumType], Dict[str, NumType], str, BaseGeometry]
 
 PositiveInt = conint(gt=0)
+SortByList = Annotated[List[Tuple[str, str]], MinLen(1)]
 
 
 class SearchArgs(BaseModel):
@@ -47,6 +51,7 @@ class SearchArgs(BaseModel):
     locations: Optional[Dict[str, str]] = Field(None)
     page: Optional[int] = Field(DEFAULT_PAGE, gt=0)  # type: ignore
     items_per_page: Optional[PositiveInt] = Field(DEFAULT_ITEMS_PER_PAGE)  # type: ignore
+    sortBy: Optional[SortByList] = Field(None)  # type: ignore
 
     @field_validator("start", "end", mode="before")
     @classmethod
@@ -60,24 +65,70 @@ class SearchArgs(BaseModel):
 
     @field_validator("geom", mode="before")
     @classmethod
-    def check_geom(cls, v: GeomArgs) -> BaseGeometry:
+    def check_geom(cls, v: Any) -> BaseGeometry:
         """Validate geom"""
         # GeoJSON geometry
-        if isinstance(v, dict) and v.get("type") in GEOMETRY_TYPES:
+        if isinstance(v, dict) and v.get("type") in GEOMETRY_TYPES:  # type: ignore
             return cast(BaseGeometry, shape(v))
 
         # Bounding Box
         if isinstance(v, (list, tuple, dict)):
-            return BBox(v).to_polygon()
+            return BBox(v).to_polygon()  # type: ignore
 
         if isinstance(v, str):
             # WKT geometry
             try:
-                return cast(Polygon, wkt.loads(v))
-            except GEOSException as e:
+                return cast(Polygon, wkt.loads(v))  # type: ignore
+            except GEOSException as e:  # type: ignore
                 raise ValueError(f"Invalid geometry WKT string: {v}") from e
 
         if isinstance(v, BaseGeometry):
             return v
 
         raise TypeError(f"Invalid geometry type: {type(v)}")
+
+    @field_validator("sortBy", mode="before")
+    @classmethod
+    def check_sort_by_arg(
+        cls, sort_by_arg: Optional[SortByList]  # type: ignore
+    ) -> Optional[SortByList]:  # type: ignore
+        """Check if the sortBy argument is correct
+
+        :param sort_by_arg: The sortBy argument
+        :type sort_by_arg: str
+        :returns: The sortBy argument with sorting order parsed (whitespace(s) are
+                  removed and only the 3 first letters in uppercase are kept)
+        :rtype: str
+        """
+        if sort_by_arg is None:
+            return None
+
+        assert isinstance(
+            sort_by_arg, list
+        ), f"Sort argument must be a list of tuple(s), got a '{type(sort_by_arg)}' instead"
+        sort_order_pattern = r"^(ASC|DES)[a-zA-Z]*$"
+        for i, sort_by_tuple in enumerate(sort_by_arg):
+            assert isinstance(
+                sort_by_tuple, tuple
+            ), f"Sort argument must be a list of tuple(s), got a list of '{type(sort_by_tuple)}' instead"
+            # get sorting elements by removing leading and trailing whitespace(s) if exist
+            sort_param = sort_by_tuple[0].strip()
+            sort_order = sort_by_tuple[1].strip().upper()
+            assert re.match(sort_order_pattern, sort_order) is not None, (
+                "Sorting order must be set to 'ASC' (ASCENDING) or 'DESC' (DESCENDING), "
+                f"got '{sort_order}' with '{sort_param}' instead"
+            )
+            sort_by_arg[i] = (sort_param, sort_order[:3])
+        # remove duplicates
+        pruned_sort_by_arg: SortByList = list(set(sort_by_arg))  # type: ignore
+        for i, sort_by_tuple in enumerate(pruned_sort_by_arg):
+            for j, sort_by_tuple_tmp in enumerate(pruned_sort_by_arg):
+                # since duplicated tuples or dictionnaries have been removed, if two sorting parameters are equal,
+                # then their sorting order is different and there is a contradiction that would raise an error
+                if i != j and sort_by_tuple[0] == sort_by_tuple_tmp[0]:
+                    raise ValidationError(
+                        f"'{sort_by_tuple[0]}' parameter is called several times to sort results with different "
+                        "sorting orders. Please set it to only one ('ASC' (ASCENDING) or 'DESC' (DESCENDING))",
+                        set([sort_by_tuple[0]]),
+                    )
+        return pruned_sort_by_arg

eodag/types/whoosh.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+# Copyright 2024, CS Systemes d'Information, 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 typing import List
+
+from whoosh.fields import Schema
+from whoosh.matching import NullMatcher
+from whoosh.qparser import OrGroup, QueryParser, plugins
+from whoosh.query.positional import Phrase
+from whoosh.query.qcore import QueryError
+
+
+class RobustPhrase(Phrase):
+    """
+    Matches documents containing a given phrase.
+    """
+
+    def matcher(self, searcher, context=None):
+        """
+        Override the default to not raise error on match exception but simply return not found
+        Needed to handle phrase search in whoosh.fields.IDLIST
+        """
+        try:
+            return super().matcher(searcher, context)
+        except QueryError:
+            return NullMatcher()
+
+
+class EODAGQueryParser(QueryParser):
+    """
+    A hand-written query parser built on modular plug-ins.
+
+    Override the default to include specific EODAG configuration
+    """
+
+    def __init__(
+        self,
+        filters: List[str],
+        schema: Schema,
+    ):
+        """
+        EODAG QueryParser initialization
+
+        :param filters: list of fieldnames to filter on
+        :type filters: List[str]
+        :param schema: Whoosh Schema
+        :type schma: :class:whoosh.fields.Schema
+        """
+        super().__init__(
+            None,
+            schema=schema,
+            plugins=[
+                plugins.SingleQuotePlugin(),
+                plugins.FieldsPlugin(),
+                plugins.WildcardPlugin(),
+                plugins.PhrasePlugin(),
+                plugins.GroupPlugin(),
+                plugins.OperatorsPlugin(),
+                plugins.BoostPlugin(),
+                plugins.EveryPlugin(),
+                plugins.RangePlugin(),
+                plugins.PlusMinusPlugin(),
+                plugins.MultifieldPlugin(filters, fieldboosts=None),
+            ],
+            phraseclass=RobustPhrase,
+            group=OrGroup,
+        )

eodag/utils/__init__.py

@@ -20,6 +20,7 @@
 Everything that does not fit into one of the specialised categories of utilities in
 this package should go here
 """
+
 from __future__ import annotations
 
 import ast
@@ -29,15 +30,19 @@ import functools
 import hashlib
 import inspect
 import logging as py_logging
+import mimetypes
 import os
 import re
 import shutil
+import ssl
 import string
+import sys
 import types
 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 email.message import Message
 from glob import glob
@@ -52,10 +57,12 @@ from typing import (
     Dict,
     Iterator,
     List,
+    Mapping,
     Optional,
     Tuple,
     Type,
     Union,
+    cast,
 )
 
 # All modules using these should import them from utils package
@@ -71,12 +78,16 @@ from urllib.parse import (  # noqa; noqa
 )
 from urllib.request import url2pathname
 
-try:
+if sys.version_info >= (3, 9):
     from typing import Annotated, get_args, get_origin  # noqa
-except ImportError:
-    # for python < 3.9
+else:
     from typing_extensions import Annotated, get_args, get_origin  # type: ignore # noqa
 
+if sys.version_info >= (3, 12):
+    from typing import Unpack  # type: ignore # noqa
+else:
+    from typing_extensions import Unpack  # noqa
+
 import click
 import orjson
 import shapefile
@@ -89,7 +100,7 @@ from jsonpath_ng.ext import parse
 from jsonpath_ng.jsonpath import Child, Fields, Index, Root, Slice
 from requests import HTTPError
 from shapely.geometry import Polygon, shape
-from shapely.geometry.base import BaseGeometry
+from shapely.geometry.base import GEOMETRY_TYPES, BaseGeometry
 from tqdm.auto import tqdm
 
 from eodag.utils import logging as eodag_logging
@@ -128,6 +139,9 @@ DEFAULT_ITEMS_PER_PAGE = 20
 # (DEFAULT_ITEMS_PER_PAGE) to increase it to the known and current minimum value (mundi)
 DEFAULT_MAX_ITEMS_PER_PAGE = 50
 
+# default product-types start date
+DEFAULT_MISSION_START_DATE = "2015-01-01T00:00:00Z"
+
 
 def _deprecated(reason: str = "", version: Optional[str] = None) -> Callable[..., Any]:
     """Simple decorator to mark functions/methods/classes as deprecated.
@@ -822,7 +836,7 @@ def list_items_recursive_apply(
 
 
 def items_recursive_sort(
-    input_obj: 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)
 
@@ -1083,7 +1097,10 @@ def get_geometry_from_various(
         geom_arg = query_args["geometry"]
 
         bbox_keys = ["lonmin", "latmin", "lonmax", "latmax"]
-        if isinstance(geom_arg, dict) and all(k in geom_arg for k in bbox_keys):
+        if isinstance(geom_arg, dict) and geom_arg.get("type") in GEOMETRY_TYPES:
+            # geojson geometry
+            geom = cast(BaseGeometry, shape(geom_arg))
+        elif isinstance(geom_arg, dict) and all(k in geom_arg for k in bbox_keys):
             # bbox dict
             geom = Polygon(
                 (
@@ -1230,7 +1247,9 @@ def cached_parse(str_to_parse: str) -> JSONPath:
 
 @functools.lru_cache()
 def _mutable_cached_yaml_load(config_path: str) -> Any:
-    with open(os.path.abspath(os.path.realpath(config_path)), "r") as fh:
+    with open(
+        os.path.abspath(os.path.realpath(config_path)), mode="r", encoding="utf-8"
+    ) as fh:
         return yaml.load(fh, Loader=yaml.SafeLoader)
 
 
@@ -1289,8 +1308,9 @@ def get_bucket_name_and_prefix(
         prefix = path
     elif bucket_path_level is not None:
         parts = path.split("/")
-        bucket, prefix = parts[bucket_path_level], "/".join(
-            parts[(bucket_path_level + 1) :]
+        bucket, prefix = (
+            parts[bucket_path_level],
+            "/".join(parts[(bucket_path_level + 1) :]),
         )
 
     return bucket, prefix
@@ -1409,3 +1429,46 @@ def cast_scalar_value(value: Any, new_type: Any) -> Any:
         return eval(value.capitalize())
 
     return new_type(value)
+
+
+@dataclass
+class StreamResponse:
+    """Represents a streaming response"""
+
+    content: Iterator[bytes]
+    headers: Optional[Mapping[str, str]] = None
+    media_type: Optional[str] = None
+    status_code: Optional[int] = None
+
+
+def guess_file_type(file: str) -> Optional[str]:
+    """guess the mime type of a file or URL based on its extension"""
+    mimetypes.add_type("text/xml", ".xsd")
+    mimetypes.add_type("application/x-grib", ".grib")
+    mime_type, _ = mimetypes.guess_type(file, False)
+    return mime_type
+
+
+def guess_extension(type: str) -> Optional[str]:
+    """guess extension from mime type"""
+    mimetypes.add_type("text/xml", ".xsd")
+    mimetypes.add_type("application/x-grib", ".grib")
+    return mimetypes.guess_extension(type, strict=False)
+
+
+def get_ssl_context(ssl_verify: bool) -> ssl.SSLContext:
+    """
+    Returns an SSL context based on ssl_verify argument.
+    :param ssl_verify: ssl_verify parameter
+    :type ssl_verify: bool
+    :returns: An SSL context object.
+    :rtype: ssl.SSLContext
+    """
+    ctx = ssl.create_default_context()
+    if not ssl_verify:
+        ctx.check_hostname = False
+        ctx.verify_mode = ssl.CERT_NONE
+    else:
+        ctx.check_hostname = True
+        ctx.verify_mode = ssl.CERT_REQUIRED
+    return ctx