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

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
@@ -50,12 +55,15 @@ from typing import (
     Any,
     Callable,
     Dict,
+    Iterable,
     Iterator,
     List,
+    Mapping,
     Optional,
     Tuple,
     Type,
     Union,
+    cast,
 )
 
 # All modules using these should import them from utils package
@@ -71,12 +79,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
@@ -87,9 +99,9 @@ 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
-from requests import HTTPError
+from requests import HTTPError, Response
 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 +140,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.
@@ -307,9 +322,7 @@ def mutate_dict_in_place(func: Callable[[Any], Any], mapping: Dict[Any, Any]) ->
     mapping.
 
     :param func: A function to apply to each value of mapping which is not a dict object
-    :type func: func
     :param mapping: A Python dict object
-    :type mapping: dict
     :returns: None
     """
     for key, value in mapping.items():
@@ -335,10 +348,8 @@ def merge_mappings(mapping1: Dict[Any, Any], mapping2: Dict[Any, Any]) -> None:
     to mapping1 as is.
 
     :param mapping1: The mapping containing values to be overridden
-    :type mapping1: dict
     :param mapping2: The mapping containing values that will override the
                      first mapping
-    :type mapping2: dict
     """
     # A mapping between mapping1 keys as lowercase strings and original mapping1 keys
     m1_keys_lowercase = {key.lower(): key for key in mapping1}
@@ -405,9 +416,7 @@ def get_timestamp(date_time: str) -> float:
     If the datetime has no offset, it is assumed to be an UTC datetime.
 
     :param date_time: The datetime string to return as timestamp
-    :type date_time: str
     :returns: The timestamp corresponding to the date_time string in seconds
-    :rtype: float
     """
     dt = isoparse(date_time)
     if not dt.tzinfo:
@@ -429,7 +438,6 @@ class DownloadedCallback:
         """Callback
 
         :param product: The downloaded EO product
-        :type product: :class:`~eodag.api.product._product.EOProduct`
         """
         logger.debug("Download finished for the product %s", product)
 
@@ -469,9 +477,7 @@ class ProgressCallback(tqdm):
         """Update the progress bar.
 
         :param increment: Amount of data already processed
-        :type increment: int
         :param total: (optional) Maximum amount of data to be processed
-        :type total: int
         """
         if total is not None and total != self.total:
             self.reset(total=total)
@@ -524,9 +530,7 @@ def rename_subfolder(dirpath: str, name: str) -> None:
     raise RuntimeError if no subfolder can be found
 
     :param dirpath: path to the directory containing the subfolder
-    :type dirpath: str
     :param name: new name of the subfolder
-    :type name: str
     :raises: RuntimeError
 
     Example:
@@ -574,12 +578,9 @@ def format_dict_items(
     ... ) == {"foo": {"bar": "qux"}, "baz": ["quux?", "quux!"]}
     True
 
-    :param config_dict: Dictionnary having values that need to be parsed
-    :type config_dict: dict
+    :param config_dict: Dictionary having values that need to be parsed
     :param format_variables: Variables used as args for parsing
-    :type format_variables: dict
     :returns: Updated dict
-    :rtype: dict
     """
     return dict_items_recursive_apply(config_dict, format_string, **format_variables)
 
@@ -596,12 +597,9 @@ def jsonpath_parse_dict_items(
     ... ) == {'foo': {'bar': 'baz'}, 'qux': ['quux', 'quux']}
     True
 
-    :param jsonpath_dict: Dictionnary having values that need to be parsed
-    :type jsonpath_dict: dict
+    :param jsonpath_dict: Dictionary having values that need to be parsed
     :param values_dict: Values dict used as args for parsing
-    :type values_dict: dict
     :returns: Updated dict
-    :rtype: dict
     """
     return dict_items_recursive_apply(jsonpath_dict, parse_jsonpath, **values_dict)
 
@@ -647,15 +645,10 @@ def update_nested_dict(
     True
 
     :param old_dict: Dict to be updated
-    :type old_dict: dict
     :param new_dict: Incomming dict
-    :type new_dict: dict
     :param extend_list_values: (optional) Extend old_dict value if both old/new values are lists
-    :type extend_list_values: bool
     :param allow_empty_values: (optional) Allow update with empty values
-    :type allow_empty_values: bool
     :returns: Updated dict
-    :rtype: dict
     """
     for k, v in new_dict.items():
         if k in old_dict.keys():
@@ -720,13 +713,9 @@ def items_recursive_apply(
     'foo'
 
     :param input_obj: Input object (dict or list)
-    :type input_obj: Union[dict,list]
     :param apply_method: Method to be applied to dict elements
-    :type apply_method: :func:`apply_method`
     :param apply_method_parameters: Optional parameters passed to the method
-    :type apply_method_parameters: dict
     :returns: Updated object
-    :rtype: Union[dict, list]
     """
     if isinstance(input_obj, dict):
         return dict_items_recursive_apply(
@@ -754,14 +743,10 @@ def dict_items_recursive_apply(
     ... ) == {'foo': {'bar': 'BAZ!'}, 'qux': ['A!', 'B!']}
     True
 
-    :param config_dict: Input nested dictionnary
-    :type config_dict: dict
+    :param config_dict: Input nested dictionary
     :param apply_method: Method to be applied to dict elements
-    :type apply_method: :func:`apply_method`
     :param apply_method_parameters: Optional parameters passed to the method
-    :type apply_method_parameters: dict
     :returns: Updated dict
-    :rtype: dict
     """
     result_dict: Dict[Any, Any] = deepcopy(config_dict)
     for dict_k, dict_v in result_dict.items():
@@ -795,13 +780,9 @@ def list_items_recursive_apply(
     [{'foo': {'bar': 'BAZ!'}}, 'QUX!']
 
     :param config_list: Input list containing nested lists/dicts
-    :type config_list: list
     :param apply_method: Method to be applied to list elements
-    :type apply_method: :func:`apply_method`
     :param apply_method_parameters: Optional parameters passed to the method
-    :type apply_method_parameters: dict
     :returns: Updated list
-    :rtype: list
     """
     result_list = deepcopy(config_list)
     for list_idx, list_v in enumerate(result_list):
@@ -822,7 +803,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)
 
@@ -836,9 +817,7 @@ def items_recursive_sort(
     'foo'
 
     :param input_obj: Input object (dict or list)
-    :type input_obj: Union[dict,list]
     :returns: Updated object
-    :rtype: Union[dict, list]
     """
     if isinstance(input_obj, dict):
         return dict_items_recursive_sort(input_obj)
@@ -857,10 +836,8 @@ def dict_items_recursive_sort(config_dict: Dict[Any, Any]) -> Dict[Any, Any]:
     ... ) == {"a": ["b", {0: 1, 1: 2, 2: 0}], "b": {"a": 0, "b": "c"}}
     True
 
-    :param config_dict: Input nested dictionnary
-    :type config_dict: dict
+    :param config_dict: Input nested dictionary
     :returns: Updated dict
-    :rtype: dict
     """
     result_dict: Dict[Any, Any] = deepcopy(config_dict)
     for dict_k, dict_v in result_dict.items():
@@ -881,9 +858,7 @@ def list_items_recursive_sort(config_list: List[Any]) -> List[Any]:
     ['b', {0: 1, 1: 2, 2: 0}]
 
     :param config_list: Input list containing nested lists/dicts
-    :type config_list: list
     :returns: Updated list
-    :rtype: list
     """
     result_list: List[Any] = deepcopy(config_list)
     for list_idx, list_v in enumerate(result_list):
@@ -912,11 +887,8 @@ def string_to_jsonpath(*args: Any, force: bool = False) -> Union[str, JSONPath]:
     Fields('foo')
 
     :param args: Last arg as input string value, to be converted
-    :type args: str
     :param force: force conversion even if input string is not detected as a jsonpath
-    :type force: bool
     :returns: Parsed value
-    :rtype: str or Child or Root
     """
     path_str: str = args[-1]
     if JSONPATH_MATCH.match(str(path_str)) or force:
@@ -984,11 +956,8 @@ def format_string(key: str, str_to_format: Any, **format_variables: Any) -> Any:
     'foo qux, quux ?'
 
     :param key: Input item key
-    :type key: str
     :param str_to_format: Input item value, to be parsed
-    :type str_to_format: str
     :returns: Parsed value
-    :rtype: str
     """
     if not isinstance(str_to_format, str):
         return str_to_format
@@ -1026,13 +995,9 @@ def parse_jsonpath(
     'baz'
 
     :param key: Input item key
-    :type key: str
     :param jsonpath_obj: Input item value, to be parsed
-    :type jsonpath_obj: str or jsonpath.Child
     :param values_dict: Values used as args for parsing
-    :type values_dict: dict
     :returns: Parsed value
-    :rtype: str
     """
     if isinstance(jsonpath_obj, jsonpath.Child):
         match = jsonpath_obj.find(values_dict)
@@ -1048,9 +1013,7 @@ def nested_pairs2dict(pairs: Union[List[Any], Any]) -> Union[Any, Dict[Any, Any]
     {'foo': {'bar': 'baz'}}
 
     :param pairs: Pairs of key / value
-    :type pairs: list or Any
     :returns: Created dict
-    :rtype: dict or Any
     """
     d = {}
     try:
@@ -1070,11 +1033,8 @@ def get_geometry_from_various(
     """Creates a shapely geometry using given query kwargs arguments
 
     :param locations_config: (optional) EODAG locations configuration
-    :type locations_config: list
     :param query_args: Query kwargs arguments from core.search() method
-    :type query_args: dict
     :returns: shapely Geometry found
-    :rtype: :class:`shapely.geometry.BaseGeometry`
     :raises: :class:`ValueError`
     """
     geom = None
@@ -1083,7 +1043,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(
                 (
@@ -1133,11 +1096,11 @@ def get_geometry_from_various(
     for arg in query_locations.keys():
         if arg in locations_dict.keys():
             found = False
-            pattern = query_locations[arg]
+            pattern = rf"{query_locations[arg]}"
             attr = locations_dict[arg]["attr"]
             with shapefile.Reader(locations_dict[arg]["path"]) as shp:
                 for shaperec in shp.shapeRecords():
-                    if re.search(pattern, shaperec.record[attr]):
+                    if re.search(pattern, str(shaperec.record[attr])):
                         found = True
                         new_geom = shape(shaperec.shape)
                         # get geoms union
@@ -1166,7 +1129,7 @@ class MockResponse:
     def raise_for_status(self) -> None:
         """raises an exception when the status is not ok"""
         if self.status_code != 200:
-            raise HTTPError()
+            raise HTTPError(response=Response())
 
 
 def md5sum(file_path: str) -> str:
@@ -1177,9 +1140,7 @@ def md5sum(file_path: str) -> str:
     'd41d8cd98f00b204e9800998ecf8427e'
 
     :param file_path: input file path
-    :type file_path: str
     :returns: MD5 checksum
-    :rtype: str
     """
     hash_md5 = hashlib.md5()
     with open(file_path, "rb") as f:
@@ -1195,9 +1156,7 @@ def obj_md5sum(data: Any) -> str:
     '37a6259cc0c1dae299a7866489dff0bd'
 
     :param data: JSON serializable input object
-    :type data: Any
     :returns: MD5 checksum
-    :rtype: str
     """
     return hashlib.md5(orjson.dumps(data, option=orjson.OPT_SORT_KEYS)).hexdigest()
 
@@ -1221,16 +1180,16 @@ def cached_parse(str_to_parse: str) -> JSONPath:
     CacheInfo(hits=1, misses=2, maxsize=128, currsize=2)
 
     :param str_to_parse: string to parse as jsonpath
-    :type str_to_parse: str
     :returns: parsed jsonpath
-    :rtype: :class:`jsonpath_ng.JSONPath`
     """
     return parse(str_to_parse)
 
 
 @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)
 
 
@@ -1238,9 +1197,7 @@ def cached_yaml_load(config_path: str) -> Dict[str, Any]:
     """Cached yaml.load
 
     :param config_path: path to the yaml configuration file
-    :type config_path: str
     :returns: loaded yaml configuration
-    :rtype: dict
     """
     return copy_deepcopy(_mutable_cached_yaml_load(config_path))
 
@@ -1257,9 +1214,7 @@ def cached_yaml_load_all(config_path: str) -> List[Any]:
     Load all configurations stored in the configuration file as separated yaml documents
 
     :param config_path: path to the yaml configuration file
-    :type config_path: str
     :returns: list of configurations
-    :rtype: list
     """
     return copy_deepcopy(_mutable_cached_yaml_load_all(config_path))
 
@@ -1270,11 +1225,8 @@ def get_bucket_name_and_prefix(
     """Extract bucket name and prefix from URL
 
     :param url: (optional) URL to use as product.location
-    :type url: str
     :param bucket_path_level: (optional) bucket location index in path.split('/')
-    :type bucket_path_level: int
     :returns: bucket_name and prefix as str
-    :rtype: tuple
     """
     bucket, prefix = None, None
 
@@ -1289,8 +1241,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
@@ -1302,9 +1255,7 @@ def flatten_top_directories(
     """Flatten directory structure, removing common empty sub-directories
 
     :param nested_dir_root: Absolute path of the directory structure to flatten
-    :type nested_dir_root: str
     :param common_subdirs_path: (optional) Absolute path of the desired subdirectory to remove
-    :type common_subdirs_path: str
     """
     if not common_subdirs_path:
         subpaths_list = [p for p in Path(nested_dir_root).glob("**/*") if p.is_file()]
@@ -1326,9 +1277,7 @@ def deepcopy(sth: Any) -> Any:
     `_copy_list` and `_copy_dict` available for the moment
 
     :param sth: Object to copy
-    :type sth: Any
     :returns: Copied object
-    :rtype: Any
     """
     _dispatcher: Dict[Type[Any], Callable[..., Any]] = {}
 
@@ -1371,9 +1320,7 @@ def parse_header(header: str) -> Message:
     'example.txt'
 
     :param header: header to parse
-    :type header: str
     :returns: parsed header
-    :rtype: :class:`~email.message.Message`
     """
     m = Message()
     m["content-type"] = header
@@ -1409,3 +1356,75 @@ 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: Iterable[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
+    :returns: An SSL context object.
+    """
+    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
+
+
+def sort_dict(input_dict: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Recursively sorts a dict by keys.
+
+    :param input_dict: input dict
+    :returns: sorted dict
+
+    >>> sort_dict({"b": {"c": 1, "a": 2, "b": 3}, "a": 4})
+    {'a': 4, 'b': {'a': 2, 'b': 3, 'c': 1}}
+    """
+    return {
+        k: sort_dict(v) if isinstance(v, dict) else v
+        for k, v in sorted(input_dict.items())
+    }
+
+
+def dict_md5sum(input_dict: Dict[str, Any]) -> str:
+    """
+    Hash nested dictionary
+
+    :param input_dict: input dict
+    :returns: hash
+
+    >>> hd = dict_md5sum({"b": {"c": 1, "a": 2, "b": 3}, "a": 4})
+    >>> hd
+    'a195bcef1bb3b419e9e74b7cc5db8098'
+    >>> assert(dict_md5sum({"a": 4, "b": {"b": 3, "c": 1, "a": 2}}) == hd)
+    """
+    return obj_md5sum(sort_dict(input_dict))

eodag/utils/constraints.py

@@ -19,13 +19,14 @@ import copy
 import logging
 from typing import Any, Dict, List, Set, Union
 
-import requests
+from requests.auth import AuthBase
 
 from eodag.api.product.metadata_mapping import get_provider_queryable_key
 from eodag.plugins.apis.base import Api
 from eodag.plugins.search.base import Search
-from eodag.utils import HTTP_REQ_TIMEOUT, USER_AGENT, deepcopy
-from eodag.utils.exceptions import TimeOutError, ValidationError
+from eodag.utils import deepcopy
+from eodag.utils.exceptions import RequestError, ValidationError
+from eodag.utils.requests import fetch_json
 
 logger = logging.getLogger("eodag.constraints")
 
@@ -40,15 +41,10 @@ def get_constraint_queryables_with_additional_params(
     gets the queryables from the constraints using the given parameters
     For all queryables only values matching the given parameters based on the constraints will be returned
     :param constraints: list of constraints fetched from the provider
-    :type constraints: List[Any]
     :param input_params: conditions the constraints should fulfil
-    :type input_params: dict
     :param plugin: search or api plugin that is used
-    :type plugin: Union[Search, Api]
     :param product_type: product type for which the data should be fetched
-    :type product_type: str
     :returns: dict containing queryable data
-    :rtype: Dict[str, Dict[str, Set[Any]]]
     """
     defaults = copy.deepcopy(input_params)
     constraint_matches = {}
@@ -73,8 +69,20 @@ def get_constraint_queryables_with_additional_params(
             if provider_key and provider_key in constraint:
                 eodag_provider_key_mapping[provider_key] = param
                 params_available[param] = True
-                if value in constraint[provider_key]:
+                if (
+                    isinstance(value, list)
+                    and all([v in constraint[provider_key] for v in value])
+                    or not isinstance(value, list)
+                    and value in constraint[provider_key]
+                ):
                     params_matched[param] = True
+                elif isinstance(value, str):
+                    # for Copernicus providers, values can be multiple and represented with a string
+                    # separated by slashes (example: time = "0000/0100/0200")
+                    values = value.split("/")
+                    params_matched[param] = all(
+                        [v in constraint[provider_key] for v in values]
+                    )
                 values_available[param].update(constraint[provider_key])
         # match with default values of params
         for default_param, default_value in defaults.items():
@@ -161,48 +169,32 @@ def fetch_constraints(
     """
     fetches the constraints from a provider
     :param constraints_url: url from which the constraints can be fetched
-    :type constraints_url: str
     :param plugin: api or search plugin of the provider
-    :type plugin: Union[Search, Api]
     :returns: list of constraints fetched from the provider
-    :rtype: List[Dict[Any, Any]]
     """
+    auth = (
+        plugin.auth
+        if hasattr(plugin, "auth") and isinstance(plugin.auth, AuthBase)
+        else None
+    )
     try:
-        headers = USER_AGENT
-        logger.debug("fetching constraints from %s", constraints_url)
-        if hasattr(plugin, "auth"):
-            res = requests.get(
-                constraints_url,
-                headers=headers,
-                auth=plugin.auth,
-                timeout=HTTP_REQ_TIMEOUT,
-            )
-        else:
-            res = requests.get(
-                constraints_url, headers=headers, timeout=HTTP_REQ_TIMEOUT
-            )
-        res.raise_for_status()
-    except requests.exceptions.Timeout as exc:
-        raise TimeOutError(exc, timeout=HTTP_REQ_TIMEOUT) from exc
-    except requests.exceptions.HTTPError as err:
-        logger.error(
-            "constraints could not be fetched from %s, error: %s",
-            constraints_url,
-            str(err),
-        )
+        constraints_data = fetch_json(constraints_url, auth=auth)
+    except RequestError as err:
+        logger.error(str(err))
+        return []
+
+    config = plugin.config.__dict__
+    if (
+        "constraints_entry" in config
+        and config["constraints_entry"]
+        and config["constraints_entry"] in constraints_data
+    ):
+        constraints = constraints_data[config["constraints_entry"]]
+    elif config.get("stop_without_constraints_entry_key", False):
         return []
     else:
-        constraints_data = res.json()
-        config = plugin.config.__dict__
-        if (
-            "constraints_entry" in config
-            and config["constraints_entry"]
-            and config["constraints_entry"] in constraints_data
-        ):
-            constraints = constraints_data[config["constraints_entry"]]
-        else:
-            constraints = constraints_data
-        return constraints
+        constraints = constraints_data
+    return constraints
 
 
 def _get_other_possible_values_for_values_with_defaults(