"""

BIMData API

BIMData API is a tool to interact with your models stored on BIMData’s servers. Through the API, you can manage your projects, the clouds, upload your IFC files and manage them through endpoints. # noqa: E501

The version of the OpenAPI document: v1 (v1)

Contact: support@bimdata.io

Generated by: https://openapi-generator.tech

"""

from datetime import date, datetime # noqa: F401

from copy import deepcopy

import inspect

import io

import os

import pprint

import re

import tempfile

from dateutil.parser import parse

from bimdata_api_client.exceptions import (

ApiKeyError,

ApiAttributeError,

ApiTypeError,

ApiValueError,

)

none_type = type(None)

file_type = io.IOBase

def convert_js_args_to_python_args(fn):

from functools import wraps

@wraps(fn)

def wrapped_init(_self, *args, **kwargs):

"""

An attribute named `self` received from the api will conflicts with the reserved `self`

parameter of a class method. During generation, `self` attributes are mapped

to `_self` in models. Here, we name `_self` instead of `self` to avoid conflicts.

"""

spec_property_naming = kwargs.get('_spec_property_naming', False)

if spec_property_naming:

kwargs = change_keys_js_to_python(kwargs, _self if isinstance(_self, type) else _self.__class__)

return fn(_self, *args, **kwargs)

return wrapped_init

class cached_property(object):

# this caches the result of the function call for fn with no inputs

# use this as a decorator on function methods that you want converted

# into cached properties

result_key = '_results'

def __init__(self, fn):

self._fn = fn

def __get__(self, instance, cls=None):

if self.result_key in vars(self):

return vars(self)[self.result_key]

else:

result = self._fn()

setattr(self, self.result_key, result)

return result

PRIMITIVE_TYPES = (list, float, int, bool, datetime, date, str, file_type)

def allows_single_value_input(cls):

"""

This function returns True if the input composed schema model or any

descendant model allows a value only input

This is true for cases where oneOf contains items like:

oneOf:

- float

- NumberWithValidation

- StringEnum

- ArrayModel

- null

TODO: lru_cache this

"""

if (

issubclass(cls, ModelSimple) or

cls in PRIMITIVE_TYPES

):

return True

elif issubclass(cls, ModelComposed):

if not cls._composed_schemas['oneOf']:

return False

return any(allows_single_value_input(c) for c in cls._composed_schemas['oneOf'])

return False

def composed_model_input_classes(cls):

"""

This function returns a list of the possible models that can be accepted as

inputs.

TODO: lru_cache this

"""

if issubclass(cls, ModelSimple) or cls in PRIMITIVE_TYPES:

return [cls]

elif issubclass(cls, ModelNormal):

if cls.discriminator is None:

return [cls]

else:

return get_discriminated_classes(cls)

elif issubclass(cls, ModelComposed):

if not cls._composed_schemas['oneOf']:

return []

if cls.discriminator is None:

input_classes = []

for c in cls._composed_schemas['oneOf']:

input_classes.extend(composed_model_input_classes(c))

return input_classes

else:

return get_discriminated_classes(cls)

return []

class OpenApiModel(object):

"""The base class for all OpenAPIModels"""

def set_attribute(self, name, value):

# this is only used to set properties on self

path_to_item = []

if self._path_to_item:

path_to_item.extend(self._path_to_item)

path_to_item.append(name)

if name in self.openapi_types:

required_types_mixed = self.openapi_types[name]

elif self.additional_properties_type is None:

raise ApiAttributeError(

"{0} has no attribute '{1}'".format(

type(self).__name__, name),

path_to_item

)

elif self.additional_properties_type is not None:

required_types_mixed = self.additional_properties_type

if get_simple_class(name) != str:

error_msg = type_error_message(

var_name=name,

var_value=name,

valid_classes=(str,),

key_type=True

)

raise ApiTypeError(

error_msg,

path_to_item=path_to_item,

valid_classes=(str,),

key_type=True

)

if self._check_type:

value = validate_and_convert_types(

value, required_types_mixed, path_to_item, self._spec_property_naming,

self._check_type, configuration=self._configuration)

if (name,) in self.allowed_values:

check_allowed_values(

self.allowed_values,

(name,),

value

)

if (name,) in self.validations:

check_validations(

self.validations,

(name,),

value,

self._configuration

)

self.__dict__['_data_store'][name] = value

def __repr__(self):

"""For `print` and `pprint`"""

return self.to_str()

def __ne__(self, other):

"""Returns true if both objects are not equal"""

return not self == other

def __setattr__(self, attr, value):

"""set the value of an attribute using dot notation: `instance.attr = val`"""

self[attr] = value

def __getattr__(self, attr):

"""get the value of an attribute using dot notation: `instance.attr`"""

return self.__getitem__(attr)

def __copy__(self):

cls = self.__class__

if self.get("_spec_property_naming", False):

return cls._new_from_openapi_data(**self.__dict__)

else:

return new_cls.__new__(cls, **self.__dict__)

def __deepcopy__(self, memo):

cls = self.__class__

if self.get("_spec_property_naming", False):

new_inst = cls._new_from_openapi_data()

else:

new_inst = cls.__new__(cls)

for k, v in self.__dict__.items():

setattr(new_inst, k, deepcopy(v, memo))

return new_inst

def __new__(cls, *args, **kwargs):

# this function uses the discriminator to

# pick a new schema/class to instantiate because a discriminator

# propertyName value was passed in

if len(args) == 1:

arg = args[0]

if arg is None and is_type_nullable(cls):

# The input data is the 'null' value and the type is nullable.

return None

if issubclass(cls, ModelComposed) and allows_single_value_input(cls):

model_kwargs = {}

oneof_instance = get_oneof_instance(cls, model_kwargs, kwargs, model_arg=arg)

return oneof_instance

visited_composed_classes = kwargs.get('_visited_composed_classes', ())

if (

cls.discriminator is None or

cls in visited_composed_classes

):

# Use case 1: this openapi schema (cls) does not have a discriminator

# Use case 2: we have already visited this class before and are sure that we

# want to instantiate it this time. We have visited this class deserializing

# a payload with a discriminator. During that process we traveled through

# this class but did not make an instance of it. Now we are making an

# instance of a composed class which contains cls in it, so this time make an instance of cls.

#

# Here's an example of use case 2: If Animal has a discriminator

# petType and we pass in "Dog", and the class Dog

# allOf includes Animal, we move through Animal

# once using the discriminator, and pick Dog.

# Then in the composed schema dog Dog, we will make an instance of the

# Animal class (because Dal has allOf: Animal) but this time we won't travel

# through Animal's discriminator because we passed in

# _visited_composed_classes = (Animal,)

return super(OpenApiModel, cls).__new__(cls)

# Get the name and value of the discriminator property.

# The discriminator name is obtained from the discriminator meta-data

# and the discriminator value is obtained from the input data.

discr_propertyname_py = list(cls.discriminator.keys())[0]

discr_propertyname_js = cls.attribute_map[discr_propertyname_py]

if discr_propertyname_js in kwargs:

discr_value = kwargs[discr_propertyname_js]

elif discr_propertyname_py in kwargs:

discr_value = kwargs[discr_propertyname_py]

else:

# The input data does not contain the discriminator property.

path_to_item = kwargs.get('_path_to_item', ())

raise ApiValueError(

"Cannot deserialize input data due to missing discriminator. "

"The discriminator property '%s' is missing at path: %s" %

(discr_propertyname_js, path_to_item)

)

# Implementation note: the last argument to get_discriminator_class

# is a list of visited classes. get_discriminator_class may recursively

# call itself and update the list of visited classes, and the initial

# value must be an empty list. Hence not using 'visited_composed_classes'

new_cls = get_discriminator_class(

cls, discr_propertyname_py, discr_value, [])

if new_cls is None:

path_to_item = kwargs.get('_path_to_item', ())

disc_prop_value = kwargs.get(

discr_propertyname_js, kwargs.get(discr_propertyname_py))

raise ApiValueError(

"Cannot deserialize input data due to invalid discriminator "

"value. The OpenAPI document has no mapping for discriminator "

"property '%s'='%s' at path: %s" %

(discr_propertyname_js, disc_prop_value, path_to_item)

)

if new_cls in visited_composed_classes:

# if we are making an instance of a composed schema Descendent

# which allOf includes Ancestor, then Ancestor contains

# a discriminator that includes Descendent.

# So if we make an instance of Descendent, we have to make an

# instance of Ancestor to hold the allOf properties.

# This code detects that use case and makes the instance of Ancestor

# For example:

# When making an instance of Dog, _visited_composed_classes = (Dog,)

# then we make an instance of Animal to include in dog._composed_instances

# so when we are here, cls is Animal

# cls.discriminator != None

# cls not in _visited_composed_classes

# new_cls = Dog

# but we know we know that we already have Dog

# because it is in visited_composed_classes

# so make Animal here

return super(OpenApiModel, cls).__new__(cls)

# Build a list containing all oneOf and anyOf descendants.

oneof_anyof_classes = None

if cls._composed_schemas is not None:

oneof_anyof_classes = (

cls._composed_schemas.get('oneOf', ()) +

cls._composed_schemas.get('anyOf', ()))

oneof_anyof_child = new_cls in oneof_anyof_classes

kwargs['_visited_composed_classes'] = visited_composed_classes + (cls,)

if cls._composed_schemas.get('allOf') and oneof_anyof_child:

# Validate that we can make self because when we make the

# new_cls it will not include the allOf validations in self

self_inst = super(OpenApiModel, cls).__new__(cls)

self_inst.__init__(*args, **kwargs)

if kwargs.get("_spec_property_naming", False):

# when true, implies new is from deserialization

new_inst = new_cls._new_from_openapi_data(*args, **kwargs)

else:

new_inst = new_cls.__new__(new_cls, *args, **kwargs)

new_inst.__init__(*args, **kwargs)

return new_inst

@classmethod

@convert_js_args_to_python_args

def _new_from_openapi_data(cls, *args, **kwargs):

# this function uses the discriminator to

# pick a new schema/class to instantiate because a discriminator

# propertyName value was passed in

if len(args) == 1:

arg = args[0]

if arg is None and is_type_nullable(cls):

# The input data is the 'null' value and the type is nullable.

return None

if issubclass(cls, ModelComposed) and allows_single_value_input(cls):

model_kwargs = {}

oneof_instance = get_oneof_instance(cls, model_kwargs, kwargs, model_arg=arg)

return oneof_instance

visited_composed_classes = kwargs.get('_visited_composed_classes', ())

if (

cls.discriminator is None or

cls in visited_composed_classes

):

# Use case 1: this openapi schema (cls) does not have a discriminator

# Use case 2: we have already visited this class before and are sure that we

# want to instantiate it this time. We have visited this class deserializing

# a payload with a discriminator. During that process we traveled through

# this class but did not make an instance of it. Now we are making an

# instance of a composed class which contains cls in it, so this time make an instance of cls.

#

# Here's an example of use case 2: If Animal has a discriminator

# petType and we pass in "Dog", and the class Dog

# allOf includes Animal, we move through Animal

# once using the discriminator, and pick Dog.

# Then in the composed schema dog Dog, we will make an instance of the

# Animal class (because Dal has allOf: Animal) but this time we won't travel

# through Animal's discriminator because we passed in

# _visited_composed_classes = (Animal,)

return cls._from_openapi_data(*args, **kwargs)

# Get the name and value of the discriminator property.

# The discriminator name is obtained from the discriminator meta-data

# and the discriminator value is obtained from the input data.

discr_propertyname_py = list(cls.discriminator.keys())[0]

discr_propertyname_js = cls.attribute_map[discr_propertyname_py]

if discr_propertyname_js in kwargs:

discr_value = kwargs[discr_propertyname_js]

elif discr_propertyname_py in kwargs:

discr_value = kwargs[discr_propertyname_py]

else:

# The input data does not contain the discriminator property.

path_to_item = kwargs.get('_path_to_item', ())

raise ApiValueError(

"Cannot deserialize input data due to missing discriminator. "

"The discriminator property '%s' is missing at path: %s" %

(discr_propertyname_js, path_to_item)

)

# Implementation note: the last argument to get_discriminator_class

# is a list of visited classes. get_discriminator_class may recursively

# call itself and update the list of visited classes, and the initial

# value must be an empty list. Hence not using 'visited_composed_classes'

new_cls = get_discriminator_class(

cls, discr_propertyname_py, discr_value, [])

if new_cls is None:

path_to_item = kwargs.get('_path_to_item', ())

disc_prop_value = kwargs.get(

discr_propertyname_js, kwargs.get(discr_propertyname_py))

raise ApiValueError(

"Cannot deserialize input data due to invalid discriminator "

"value. The OpenAPI document has no mapping for discriminator "

"property '%s'='%s' at path: %s" %

(discr_propertyname_js, disc_prop_value, path_to_item)

)

if new_cls in visited_composed_classes:

# if we are making an instance of a composed schema Descendent

# which allOf includes Ancestor, then Ancestor contains

# a discriminator that includes Descendent.

# So if we make an instance of Descendent, we have to make an

# instance of Ancestor to hold the allOf properties.

# This code detects that use case and makes the instance of Ancestor

# For example:

# When making an instance of Dog, _visited_composed_classes = (Dog,)

# then we make an instance of Animal to include in dog._composed_instances

# so when we are here, cls is Animal

# cls.discriminator != None

# cls not in _visited_composed_classes

# new_cls = Dog

# but we know we know that we already have Dog

# because it is in visited_composed_classes

# so make Animal here

return cls._from_openapi_data(*args, **kwargs)

# Build a list containing all oneOf and anyOf descendants.

oneof_anyof_classes = None

if cls._composed_schemas is not None:

oneof_anyof_classes = (

cls._composed_schemas.get('oneOf', ()) +

cls._composed_schemas.get('anyOf', ()))

oneof_anyof_child = new_cls in oneof_anyof_classes

kwargs['_visited_composed_classes'] = visited_composed_classes + (cls,)

if cls._composed_schemas.get('allOf') and oneof_anyof_child:

# Validate that we can make self because when we make the

# new_cls it will not include the allOf validations in self

self_inst = cls._from_openapi_data(*args, **kwargs)

new_inst = new_cls._new_from_openapi_data(*args, **kwargs)

return new_inst

class ModelSimple(OpenApiModel):

"""the parent class of models whose type != object in their

swagger/openapi"""

def __setitem__(self, name, value):

"""set the value of an attribute using square-bracket notation: `instance[attr] = val`"""

if name in self.required_properties:

self.__dict__[name] = value

return

self.set_attribute(name, value)

def get(self, name, default=None):

"""returns the value of an attribute or some default value if the attribute was not set"""

if name in self.required_properties:

return self.__dict__[name]

return self.__dict__['_data_store'].get(name, default)

def __getitem__(self, name):

"""get the value of an attribute using square-bracket notation: `instance[attr]`"""

if name in self:

return self.get(name)

raise ApiAttributeError(

"{0} has no attribute '{1}'".format(

type(self).__name__, name),

[e for e in [self._path_to_item, name] if e]

)

def __contains__(self, name):

"""used by `in` operator to check if an attribute value was set in an instance: `'attr' in instance`"""

if name in self.required_properties:

return name in self.__dict__

return name in self.__dict__['_data_store']

def to_str(self):

"""Returns the string representation of the model"""

return str(self.value)

def __eq__(self, other):

"""Returns true if both objects are equal"""

if not isinstance(other, self.__class__):

return False

this_val = self._data_store['value']

that_val = other._data_store['value']

types = set()

types.add(this_val.__class__)

types.add(that_val.__class__)

vals_equal = this_val == that_val

return vals_equal

class ModelNormal(OpenApiModel):

"""the parent class of models whose type == object in their

swagger/openapi"""

def __setitem__(self, name, value):

"""set the value of an attribute using square-bracket notation: `instance[attr] = val`"""

if name in self.required_properties:

self.__dict__[name] = value

return

self.set_attribute(name, value)

def get(self, name, default=None):

"""returns the value of an attribute or some default value if the attribute was not set"""

if name in self.required_properties:

return self.__dict__[name]

return self.__dict__['_data_store'].get(name, default)

def __getitem__(self, name):

"""get the value of an attribute using square-bracket notation: `instance[attr]`"""

if name in self:

return self.get(name)

raise ApiAttributeError(

"{0} has no attribute '{1}'".format(

type(self).__name__, name),

[e for e in [self._path_to_item, name] if e]

)

def __contains__(self, name):

"""used by `in` operator to check if an attribute value was set in an instance: `'attr' in instance`"""

if name in self.required_properties:

return name in self.__dict__

return name in self.__dict__['_data_store']

def to_dict(self):

"""Returns the model properties as a dict"""

return model_to_dict(self, serialize=False)

def to_str(self):

"""Returns the string representation of the model"""

return pprint.pformat(self.to_dict())

def __eq__(self, other):

"""Returns true if both objects are equal"""

if not isinstance(other, self.__class__):

return False

if not set(self._data_store.keys()) == set(other._data_store.keys()):

return False

for _var_name, this_val in self._data_store.items():

that_val = other._data_store[_var_name]

types = set()

types.add(this_val.__class__)

types.add(that_val.__class__)

vals_equal = this_val == that_val

if not vals_equal:

return False

return True

class ModelComposed(OpenApiModel):

"""the parent class of models whose type == object in their

swagger/openapi and have oneOf/allOf/anyOf

When one sets a property we use var_name_to_model_instances to store the value in

the correct class instances + run any type checking + validation code.

When one gets a property we use var_name_to_model_instances to get the value

from the correct class instances.

This allows multiple composed schemas to contain the same property with additive

constraints on the value.

_composed_schemas (dict) stores the anyOf/allOf/oneOf classes

key (str): allOf/oneOf/anyOf

value (list): the classes in the XOf definition.

Note: none_type can be included when the openapi document version >= 3.1.0

_composed_instances (list): stores a list of instances of the composed schemas

defined in _composed_schemas. When properties are accessed in the self instance,

they are returned from the self._data_store or the data stores in the instances

in self._composed_schemas

_var_name_to_model_instances (dict): maps between a variable name on self and

the composed instances (self included) which contain that data

key (str): property name

value (list): list of class instances, self or instances in _composed_instances

which contain the value that the key is referring to.

"""

def __setitem__(self, name, value):

"""set the value of an attribute using square-bracket notation: `instance[attr] = val`"""

if name in self.required_properties:

self.__dict__[name] = value

return

"""

Use cases:

1. additional_properties_type is None (additionalProperties == False in spec)

Check for property presence in self.openapi_types

if not present then throw an error

if present set in self, set attribute

always set on composed schemas

2. additional_properties_type exists

set attribute on self

always set on composed schemas

"""

if self.additional_properties_type is None:

"""

For an attribute to exist on a composed schema it must:

- fulfill schema_requirements in the self composed schema not considering oneOf/anyOf/allOf schemas AND

- fulfill schema_requirements in each oneOf/anyOf/allOf schemas

schema_requirements:

For an attribute to exist on a schema it must:

- be present in properties at the schema OR

- have additionalProperties unset (defaults additionalProperties = any type) OR

- have additionalProperties set

"""

if name not in self.openapi_types:

raise ApiAttributeError(

"{0} has no attribute '{1}'".format(

type(self).__name__, name),

[e for e in [self._path_to_item, name] if e]

)

# attribute must be set on self and composed instances

self.set_attribute(name, value)

for model_instance in self._composed_instances:

setattr(model_instance, name, value)

if name not in self._var_name_to_model_instances:

# we assigned an additional property

self.__dict__['_var_name_to_model_instances'][name] = self._composed_instances + [self]

return None

__unset_attribute_value__ = object()

def get(self, name, default=None):

"""returns the value of an attribute or some default value if the attribute was not set"""

if name in self.required_properties:

return self.__dict__[name]

# get the attribute from the correct instance

model_instances = self._var_name_to_model_instances.get(name)

values = []

# A composed model stores self and child (oneof/anyOf/allOf) models under

# self._var_name_to_model_instances.

# Any property must exist in self and all model instances

# The value stored in all model instances must be the same

if model_instances:

for model_instance in model_instances:

if name in model_instance._data_store:

v = model_instance._data_store[name]

if v not in values:

values.append(v)

len_values = len(values)

if len_values == 0:

return default

elif len_values == 1:

return values[0]

elif len_values > 1:

raise ApiValueError(

"Values stored for property {0} in {1} differ when looking "

"at self and self's composed instances. All values must be "

"the same".format(name, type(self).__name__),

[e for e in [self._path_to_item, name] if e]

)

def __getitem__(self, name):

"""get the value of an attribute using square-bracket notation: `instance[attr]`"""

value = self.get(name, self.__unset_attribute_value__)

if value is self.__unset_attribute_value__:

raise ApiAttributeError(

"{0} has no attribute '{1}'".format(

type(self).__name__, name),

[e for e in [self._path_to_item, name] if e]

)

return value

def __contains__(self, name):

"""used by `in` operator to check if an attribute value was set in an instance: `'attr' in instance`"""

if name in self.required_properties:

return name in self.__dict__

model_instances = self._var_name_to_model_instances.get(

name, self._additional_properties_model_instances)

if model_instances:

for model_instance in model_instances:

if name in model_instance._data_store:

return True

return False

def to_dict(self):

"""Returns the model properties as a dict"""

return model_to_dict(self, serialize=False)

def to_str(self):

"""Returns the string representation of the model"""

return pprint.pformat(self.to_dict())

def __eq__(self, other):

"""Returns true if both objects are equal"""

if not isinstance(other, self.__class__):

return False

if not set(self._data_store.keys()) == set(other._data_store.keys()):

return False

for _var_name, this_val in self._data_store.items():

that_val = other._data_store[_var_name]

types = set()

types.add(this_val.__class__)

types.add(that_val.__class__)

vals_equal = this_val == that_val

if not vals_equal:

return False

return True

COERCION_INDEX_BY_TYPE = {

ModelComposed: 0,

ModelNormal: 1,

ModelSimple: 2,

none_type: 3, # The type of 'None'.

list: 4,

dict: 5,

float: 6,

int: 7,

bool: 8,

datetime: 9,

date: 10,

str: 11,

file_type: 12, # 'file_type' is an alias for the built-in 'file' or 'io.IOBase' type.

}

# these are used to limit what type conversions we try to do

# when we have a valid type already and we want to try converting

# to another type

UPCONVERSION_TYPE_PAIRS = (

(str, datetime),

(str, date),

(int, float), # A float may be serialized as an integer, e.g. '3' is a valid serialized float.

(list, ModelComposed),

(dict, ModelComposed),

(str, ModelComposed),

(int, ModelComposed),

(float, ModelComposed),

(list, ModelComposed),

(list, ModelNormal),

(dict, ModelNormal),

(str, ModelSimple),

(int, ModelSimple),

(float, ModelSimple),

(list, ModelSimple),

)

COERCIBLE_TYPE_PAIRS = {

False: ( # client instantiation of a model with client data

# (dict, ModelComposed),

# (list, ModelComposed),

# (dict, ModelNormal),

# (list, ModelNormal),

# (str, ModelSimple),

# (int, ModelSimple),

# (float, ModelSimple),

# (list, ModelSimple),

# (str, int),

# (str, float),

# (str, datetime),

# (str, date),

# (int, str),

# (float, str),

),

True: ( # server -> client data

(dict, ModelComposed),

(list, ModelComposed),

(dict, ModelNormal),

(list, ModelNormal),

(str, ModelSimple),

(int, ModelSimple),

(float, ModelSimple),

(list, ModelSimple),

# (str, int),

# (str, float),

(str, datetime),

(str, date),

# (int, str),

# (float, str),

(str, file_type)

),

}

def get_simple_class(input_value):

"""Returns an input_value's simple class that we will use for type checking

Python2:

float and int will return int, where int is the python3 int backport

str and unicode will return str, where str is the python3 str backport

Note: float and int ARE both instances of int backport

Note: str_py2 and unicode_py2 are NOT both instances of str backport

Args:

input_value (class/class_instance): the item for which we will return

the simple class

"""

if isinstance(input_value, type):

# input_value is a class

return input_value

elif isinstance(input_value, tuple):

return tuple

elif isinstance(input_value, list):

return list

elif isinstance(input_value, dict):

return dict

elif isinstance(input_value, none_type):

return none_type

elif isinstance(input_value, file_type):

return file_type

elif isinstance(input_value, bool):

# this must be higher than the int check because

# isinstance(True, int) == True

return bool

elif isinstance(input_value, int):

return int

elif isinstance(input_value, datetime):

# this must be higher than the date check because

# isinstance(datetime_instance, date) == True

return datetime

elif isinstance(input_value, date):

return date

elif isinstance(input_value, str):

return str

return type(input_value)

def check_allowed_values(allowed_values, input_variable_path, input_values):

"""Raises an exception if the input_values are not allowed

Args:

allowed_values (dict): the allowed_values dict

input_variable_path (tuple): the path to the input variable

input_values (list/str/int/float/date/datetime): the values that we

are checking to see if they are in allowed_values

"""

these_allowed_values = list(allowed_values[input_variable_path].values())

if (isinstance(input_values, list)

and not set(input_values).issubset(

set(these_allowed_values))):

invalid_values = ", ".join(

map(str, set(input_values) - set(these_allowed_values))),

raise ApiValueError(

"Invalid values for `%s` [%s], must be a subset of [%s]" %

(

input_variable_path[0],

invalid_values,

", ".join(map(str, these_allowed_values))

)

)

elif (isinstance(input_values, dict)

and not set(

input_values.keys()).issubset(set(these_allowed_values))):

invalid_values = ", ".join(

map(str, set(input_values.keys()) - set(these_allowed_values)))

raise ApiValueError(

"Invalid keys in `%s` [%s], must be a subset of [%s]" %

(

input_variable_path[0],

invalid_values,

", ".join(map(str, these_allowed_values))

)

)

elif (not isinstance(input_values, (list, dict))

and input_values not in these_allowed_values):

raise ApiValueError(

"Invalid value for `%s` (%s), must be one of %s" %

(

input_variable_path[0],

input_values,

these_allowed_values

)

)

def is_json_validation_enabled(schema_keyword, configuration=None):

"""Returns true if JSON schema validation is enabled for the specified

validation keyword. This can be used to skip JSON schema structural validation

as requested in the configuration.

Args:

schema_keyword (string): the name of a JSON schema validation keyword.

configuration (Configuration): the configuration class.

"""

return (configuration is None or

not hasattr(configuration, '_disabled_client_side_validations') or

schema_keyword not in configuration._disabled_client_side_validations)

def check_validations(

validations, input_variable_path, input_values,

configuration=None):

"""Raises an exception if the input_values are invalid

Args:

validations (dict): the validation dictionary.

input_variable_path (tuple): the path to the input variable.

input_values (list/str/int/float/date/datetime): the values that we

are checking.

configuration (Configuration): the configuration class.

"""

if input_values is None:

return

current_validations = validations[input_variable_path]

if (is_json_validation_enabled('multipleOf', configuration) and

'multiple_of' in current_validations and

isinstance(input_values, (int, float)) and

not (float(input_values) / current_validations['multiple_of']).is_integer()):

# Note 'multipleOf' will be as good as the floating point arithmetic.

raise ApiValueError(

"Invalid value for `%s`, value must be a multiple of "

"`%s`" % (

input_variable_path[0],

current_validations['multiple_of']

)

)

if (is_json_validation_enabled('maxLength', configuration) and

'max_length' in current_validations and

len(input_values) > current_validations['max_length']):

raise ApiValueError(

"Invalid value for `%s`, length must be less than or equal to "

"`%s`" % (

input_variable_path[0],

current_validations['max_length']

)

)

if (is_json_validation_enabled('minLength', configuration) and

'min_length' in current_validations and

len(input_values) < current_validations['min_length']):

raise ApiValueError(

"Invalid value for `%s`, length must be greater than or equal to "

"`%s`" % (

input_variable_path[0],

current_validations['min_length']

)

)

if (is_json_validation_enabled('maxItems', configuration) and

'max_items' in current_validations and

len(input_values) > current_validations['max_items']):

raise ApiValueError(

"Invalid value for `%s`, number of items must be less than or "

"equal to `%s`" % (

input_variable_path[0],

current_validations['max_items']

)

)

if (is_json_validation_enabled('minItems', configuration) and

'min_items' in current_validations and

len(input_values) < current_validations['min_items']):

raise ValueError(

"Invalid value for `%s`, number of items must be greater than or "

"equal to `%s`" % (

input_variable_path[0],

current_validations['min_items']

)

)

items = ('exclusive_maximum', 'inclusive_maximum', 'exclusive_minimum',

'inclusive_minimum')

if (any(item in current_validations for item in items)):

if isinstance(input_values, list):

max_val = max(input_values)

min_val = min(input_values)

elif isinstance(input_values, dict):

max_val = max(input_values.values())

min_val = min(input_values.values())

else:

max_val = input_values

min_val = input_values

if (is_json_validation_enabled('exclusiveMaximum', configuration) and

'exclusive_maximum' in current_validations and

max_val >= current_validations['exclusive_maximum']):

raise ApiValueError(

"Invalid value for `%s`, must be a value less than `%s`" % (

input_variable_path[0],

current_validations['exclusive_maximum']

)

)

if (is_json_validation_enabled('maximum', configuration) and

'inclusive_maximum' in current_validations and

max_val > current_validations['inclusive_maximum']):

raise ApiValueError(

"Invalid value for `%s`, must be a value less than or equal to "

"`%s`" % (