pinecone.openapi_support.model_utils

   1from datetime import date, datetime  # noqa: F401
   2from dateutil.parser import parse
   3
   4import inspect
   5import io
   6import os
   7import pprint
   8import re
   9import tempfile
  10
  11from .exceptions import (
  12    PineconeApiKeyError,
  13    PineconeApiAttributeError,
  14    PineconeApiTypeError,
  15    PineconeApiValueError,
  16)
  17
  18none_type = type(None)
  19file_type = io.IOBase
  20
  21
  22def convert_js_args_to_python_args(fn):
  23    from functools import wraps
  24
  25    @wraps(fn)
  26    def wrapped_init(_self, *args, **kwargs):
  27        """
  28        An attribute named `self` received from the api will conflicts with the reserved `self`
  29        parameter of a class method. During generation, `self` attributes are mapped
  30        to `_self` in models. Here, we name `_self` instead of `self` to avoid conflicts.
  31        """
  32        spec_property_naming = kwargs.get("_spec_property_naming", False)
  33        if spec_property_naming:
  34            kwargs = change_keys_js_to_python(
  35                kwargs, _self if isinstance(_self, type) else _self.__class__
  36            )
  37        return fn(_self, *args, **kwargs)
  38
  39    return wrapped_init
  40
  41
  42class cached_property(object):
  43    # this caches the result of the function call for fn with no inputs
  44    # use this as a decorator on function methods that you want converted
  45    # into cached properties
  46    result_key = "_results"
  47
  48    def __init__(self, fn) -> None:
  49        self._fn = fn
  50
  51    def __get__(self, instance, cls=None):
  52        if self.result_key in vars(self):
  53            return vars(self)[self.result_key]
  54        else:
  55            result = self._fn()
  56            setattr(self, self.result_key, result)
  57            return result
  58
  59
  60PRIMITIVE_TYPES = (list, float, int, bool, str, file_type)
  61
  62
  63def allows_single_value_input(cls):
  64    """
  65    This function returns True if the input composed schema model or any
  66    descendant model allows a value only input
  67    This is true for cases where oneOf contains items like:
  68    oneOf:
  69      - float
  70      - NumberWithValidation
  71      - StringEnum
  72      - ArrayModel
  73      - null
  74    TODO: lru_cache this
  75    """
  76    if issubclass(cls, ModelSimple) or cls in PRIMITIVE_TYPES:
  77        return True
  78    elif issubclass(cls, ModelComposed):
  79        if not cls._composed_schemas["oneOf"]:
  80            return False
  81        return any(allows_single_value_input(c) for c in cls._composed_schemas["oneOf"])
  82    return False
  83
  84
  85def composed_model_input_classes(cls):
  86    """
  87    This function returns a list of the possible models that can be accepted as
  88    inputs.
  89    TODO: lru_cache this
  90    """
  91    if issubclass(cls, ModelSimple) or cls in PRIMITIVE_TYPES:
  92        return [cls]
  93    elif issubclass(cls, ModelNormal):
  94        if cls.discriminator is None:
  95            return [cls]
  96        else:
  97            return get_discriminated_classes(cls)
  98    elif issubclass(cls, ModelComposed):
  99        if not cls._composed_schemas["oneOf"]:
 100            return []
 101        if cls.discriminator is None:
 102            input_classes = []
 103            for c in cls._composed_schemas["oneOf"]:
 104                input_classes.extend(composed_model_input_classes(c))
 105            return input_classes
 106        else:
 107            return get_discriminated_classes(cls)
 108    return []
 109
 110
 111class OpenApiModel(object):
 112    """The base class for all OpenAPIModels"""
 113
 114    def set_attribute(self, name, value):
 115        # this is only used to set properties on self
 116
 117        path_to_item = []
 118        if self._path_to_item:
 119            path_to_item.extend(self._path_to_item)
 120        path_to_item.append(name)
 121
 122        if name in self.openapi_types:
 123            required_types_mixed = self.openapi_types[name]
 124        elif self.additional_properties_type is None:
 125            raise PineconeApiAttributeError(
 126                "{0} has no attribute '{1}'".format(type(self).__name__, name), path_to_item
 127            )
 128        elif self.additional_properties_type is not None:
 129            required_types_mixed = self.additional_properties_type
 130
 131        if get_simple_class(name) is not str:
 132            error_msg = type_error_message(
 133                var_name=name, var_value=name, valid_classes=(str,), key_type=True
 134            )
 135            raise PineconeApiTypeError(
 136                error_msg, path_to_item=path_to_item, valid_classes=(str,), key_type=True
 137            )
 138
 139        if self._check_type:
 140            value = validate_and_convert_types(
 141                value,
 142                required_types_mixed,
 143                path_to_item,
 144                self._spec_property_naming,
 145                self._check_type,
 146                configuration=self._configuration,
 147            )
 148        if (name,) in self.allowed_values:
 149            check_allowed_values(self.allowed_values, (name,), value)
 150        if (name,) in self.validations:
 151            check_validations(self.validations, (name,), value, self._configuration)
 152        self.__dict__["_data_store"][name] = value
 153
 154    def __repr__(self):
 155        """For `print` and `pprint`"""
 156        return self.to_str()
 157
 158    def __ne__(self, other):
 159        """Returns true if both objects are not equal"""
 160        return not self == other
 161
 162    def __setattr__(self, attr, value):
 163        """set the value of an attribute using dot notation: `instance.attr = val`"""
 164        self[attr] = value
 165
 166    def __getattr__(self, attr):
 167        """get the value of an attribute using dot notation: `instance.attr`"""
 168        return self.get(attr)
 169
 170    def __new__(cls, *args, **kwargs):
 171        # this function uses the discriminator to
 172        # pick a new schema/class to instantiate because a discriminator
 173        # propertyName value was passed in
 174
 175        if len(args) == 1:
 176            arg = args[0]
 177            if arg is None and is_type_nullable(cls):
 178                # The input data is the 'null' value and the type is nullable.
 179                return None
 180
 181            if issubclass(cls, ModelComposed) and allows_single_value_input(cls):
 182                model_kwargs = {}
 183                oneof_instance = get_oneof_instance(cls, model_kwargs, kwargs, model_arg=arg)
 184                return oneof_instance
 185
 186        visited_composed_classes = kwargs.get("_visited_composed_classes", ())
 187        if cls.discriminator is None or cls in visited_composed_classes:
 188            # Use case 1: this openapi schema (cls) does not have a discriminator
 189            # Use case 2: we have already visited this class before and are sure that we
 190            # want to instantiate it this time. We have visited this class deserializing
 191            # a payload with a discriminator. During that process we traveled through
 192            # this class but did not make an instance of it. Now we are making an
 193            # instance of a composed class which contains cls in it, so this time make an instance of cls.
 194            #
 195            # Here's an example of use case 2: If Animal has a discriminator
 196            # petType and we pass in "Dog", and the class Dog
 197            # allOf includes Animal, we move through Animal
 198            # once using the discriminator, and pick Dog.
 199            # Then in the composed schema dog Dog, we will make an instance of the
 200            # Animal class (because Dal has allOf: Animal) but this time we won't travel
 201            # through Animal's discriminator because we passed in
 202            # _visited_composed_classes = (Animal,)
 203
 204            return super(OpenApiModel, cls).__new__(cls)
 205
 206        # Get the name and value of the discriminator property.
 207        # The discriminator name is obtained from the discriminator meta-data
 208        # and the discriminator value is obtained from the input data.
 209        discr_propertyname_py = list(cls.discriminator.keys())[0]
 210        discr_propertyname_js = cls.attribute_map[discr_propertyname_py]
 211        if discr_propertyname_js in kwargs:
 212            discr_value = kwargs[discr_propertyname_js]
 213        elif discr_propertyname_py in kwargs:
 214            discr_value = kwargs[discr_propertyname_py]
 215        else:
 216            # The input data does not contain the discriminator property.
 217            path_to_item = kwargs.get("_path_to_item", ())
 218            raise PineconeApiValueError(
 219                "Cannot deserialize input data due to missing discriminator. "
 220                "The discriminator property '%s' is missing at path: %s"
 221                % (discr_propertyname_js, path_to_item)
 222            )
 223
 224        # Implementation note: the last argument to get_discriminator_class
 225        # is a list of visited classes. get_discriminator_class may recursively
 226        # call itself and update the list of visited classes, and the initial
 227        # value must be an empty list. Hence not using 'visited_composed_classes'
 228        new_cls = get_discriminator_class(cls, discr_propertyname_py, discr_value, [])
 229        if new_cls is None:
 230            path_to_item = kwargs.get("_path_to_item", ())
 231            disc_prop_value = kwargs.get(discr_propertyname_js, kwargs.get(discr_propertyname_py))
 232            raise PineconeApiValueError(
 233                "Cannot deserialize input data due to invalid discriminator "
 234                "value. The OpenAPI document has no mapping for discriminator "
 235                "property '%s'='%s' at path: %s"
 236                % (discr_propertyname_js, disc_prop_value, path_to_item)
 237            )
 238
 239        if new_cls in visited_composed_classes:
 240            # if we are making an instance of a composed schema Descendent
 241            # which allOf includes Ancestor, then Ancestor contains
 242            # a discriminator that includes Descendent.
 243            # So if we make an instance of Descendent, we have to make an
 244            # instance of Ancestor to hold the allOf properties.
 245            # This code detects that use case and makes the instance of Ancestor
 246            # For example:
 247            # When making an instance of Dog, _visited_composed_classes = (Dog,)
 248            # then we make an instance of Animal to include in dog._composed_instances
 249            # so when we are here, cls is Animal
 250            # cls.discriminator != None
 251            # cls not in _visited_composed_classes
 252            # new_cls = Dog
 253            # but we know we know that we already have Dog
 254            # because it is in visited_composed_classes
 255            # so make Animal here
 256            return super(OpenApiModel, cls).__new__(cls)
 257
 258        # Build a list containing all oneOf and anyOf descendants.
 259        oneof_anyof_classes = None
 260        if cls._composed_schemas is not None:
 261            oneof_anyof_classes = cls._composed_schemas.get(
 262                "oneOf", ()
 263            ) + cls._composed_schemas.get("anyOf", ())
 264        oneof_anyof_child = new_cls in oneof_anyof_classes
 265        kwargs["_visited_composed_classes"] = visited_composed_classes + (cls,)
 266
 267        if cls._composed_schemas.get("allOf") and oneof_anyof_child:
 268            # Validate that we can make self because when we make the
 269            # new_cls it will not include the allOf validations in self
 270            self_inst = super(OpenApiModel, cls).__new__(cls)
 271            self_inst.__init__(*args, **kwargs)
 272
 273        new_inst = new_cls.__new__(new_cls, *args, **kwargs)
 274        new_inst.__init__(*args, **kwargs)
 275        return new_inst
 276
 277    @classmethod
 278    @convert_js_args_to_python_args
 279    def _new_from_openapi_data(cls, *args, **kwargs):
 280        # this function uses the discriminator to
 281        # pick a new schema/class to instantiate because a discriminator
 282        # propertyName value was passed in
 283
 284        if len(args) == 1:
 285            arg = args[0]
 286            if arg is None and is_type_nullable(cls):
 287                # The input data is the 'null' value and the type is nullable.
 288                return None
 289
 290            if issubclass(cls, ModelComposed) and allows_single_value_input(cls):
 291                model_kwargs = {}
 292                oneof_instance = get_oneof_instance(cls, model_kwargs, kwargs, model_arg=arg)
 293                return oneof_instance
 294
 295        visited_composed_classes = kwargs.get("_visited_composed_classes", ())
 296        if cls.discriminator is None or cls in visited_composed_classes:
 297            # Use case 1: this openapi schema (cls) does not have a discriminator
 298            # Use case 2: we have already visited this class before and are sure that we
 299            # want to instantiate it this time. We have visited this class deserializing
 300            # a payload with a discriminator. During that process we traveled through
 301            # this class but did not make an instance of it. Now we are making an
 302            # instance of a composed class which contains cls in it, so this time make an instance of cls.
 303            #
 304            # Here's an example of use case 2: If Animal has a discriminator
 305            # petType and we pass in "Dog", and the class Dog
 306            # allOf includes Animal, we move through Animal
 307            # once using the discriminator, and pick Dog.
 308            # Then in the composed schema dog Dog, we will make an instance of the
 309            # Animal class (because Dal has allOf: Animal) but this time we won't travel
 310            # through Animal's discriminator because we passed in
 311            # _visited_composed_classes = (Animal,)
 312
 313            return cls._from_openapi_data(*args, **kwargs)
 314
 315        # Get the name and value of the discriminator property.
 316        # The discriminator name is obtained from the discriminator meta-data
 317        # and the discriminator value is obtained from the input data.
 318        discr_propertyname_py = list(cls.discriminator.keys())[0]
 319        discr_propertyname_js = cls.attribute_map[discr_propertyname_py]
 320        if discr_propertyname_js in kwargs:
 321            discr_value = kwargs[discr_propertyname_js]
 322        elif discr_propertyname_py in kwargs:
 323            discr_value = kwargs[discr_propertyname_py]
 324        else:
 325            # The input data does not contain the discriminator property.
 326            path_to_item = kwargs.get("_path_to_item", ())
 327            raise PineconeApiValueError(
 328                "Cannot deserialize input data due to missing discriminator. "
 329                "The discriminator property '%s' is missing at path: %s"
 330                % (discr_propertyname_js, path_to_item)
 331            )
 332
 333        # Implementation note: the last argument to get_discriminator_class
 334        # is a list of visited classes. get_discriminator_class may recursively
 335        # call itself and update the list of visited classes, and the initial
 336        # value must be an empty list. Hence not using 'visited_composed_classes'
 337        new_cls = get_discriminator_class(cls, discr_propertyname_py, discr_value, [])
 338        if new_cls is None:
 339            path_to_item = kwargs.get("_path_to_item", ())
 340            disc_prop_value = kwargs.get(discr_propertyname_js, kwargs.get(discr_propertyname_py))
 341            raise PineconeApiValueError(
 342                "Cannot deserialize input data due to invalid discriminator "
 343                "value. The OpenAPI document has no mapping for discriminator "
 344                "property '%s'='%s' at path: %s"
 345                % (discr_propertyname_js, disc_prop_value, path_to_item)
 346            )
 347
 348        if new_cls in visited_composed_classes:
 349            # if we are making an instance of a composed schema Descendent
 350            # which allOf includes Ancestor, then Ancestor contains
 351            # a discriminator that includes Descendent.
 352            # So if we make an instance of Descendent, we have to make an
 353            # instance of Ancestor to hold the allOf properties.
 354            # This code detects that use case and makes the instance of Ancestor
 355            # For example:
 356            # When making an instance of Dog, _visited_composed_classes = (Dog,)
 357            # then we make an instance of Animal to include in dog._composed_instances
 358            # so when we are here, cls is Animal
 359            # cls.discriminator != None
 360            # cls not in _visited_composed_classes
 361            # new_cls = Dog
 362            # but we know we know that we already have Dog
 363            # because it is in visited_composed_classes
 364            # so make Animal here
 365            return cls._from_openapi_data(*args, **kwargs)
 366
 367        # Build a list containing all oneOf and anyOf descendants.
 368        oneof_anyof_classes = None
 369        if cls._composed_schemas is not None:
 370            oneof_anyof_classes = cls._composed_schemas.get(
 371                "oneOf", ()
 372            ) + cls._composed_schemas.get("anyOf", ())
 373        oneof_anyof_child = new_cls in oneof_anyof_classes
 374        kwargs["_visited_composed_classes"] = visited_composed_classes + (cls,)
 375
 376        if cls._composed_schemas.get("allOf") and oneof_anyof_child:
 377            # Validate that we can make self because when we make the
 378            # new_cls it will not include the allOf validations in self
 379            self_inst = cls._from_openapi_data(*args, **kwargs)  # noqa: F841
 380
 381        new_inst = new_cls._new_from_openapi_data(*args, **kwargs)
 382        return new_inst
 383
 384
 385class ModelSimple(OpenApiModel):
 386    """the parent class of models whose type != object in their
 387    swagger/openapi"""
 388
 389    def __setitem__(self, name, value):
 390        """set the value of an attribute using square-bracket notation: `instance[attr] = val`"""
 391        if name in self.required_properties:
 392            self.__dict__[name] = value
 393            return
 394
 395        self.set_attribute(name, value)
 396
 397    def get(self, name, default=None):
 398        """returns the value of an attribute or some default value if the attribute was not set"""
 399        if name in self.required_properties:
 400            return self.__dict__[name]
 401
 402        return self.__dict__["_data_store"].get(name, default)
 403
 404    def __getitem__(self, name):
 405        """get the value of an attribute using square-bracket notation: `instance[attr]`"""
 406        if name in self:
 407            return self.get(name)
 408
 409        raise PineconeApiAttributeError(
 410            "{0} has no attribute '{1}'".format(type(self).__name__, name),
 411            [e for e in [self._path_to_item, name] if e],
 412        )
 413
 414    def __contains__(self, name):
 415        """used by `in` operator to check if an attrbute value was set in an instance: `'attr' in instance`"""
 416        if name in self.required_properties:
 417            return name in self.__dict__
 418
 419        return name in self.__dict__["_data_store"]
 420
 421    def to_str(self):
 422        """Returns the string representation of the model"""
 423        return str(self.value)
 424
 425    def __eq__(self, other):
 426        """Returns true if both objects are equal"""
 427        if not isinstance(other, self.__class__):
 428            return False
 429
 430        this_val = self._data_store["value"]
 431        that_val = other._data_store["value"]
 432        types = set()
 433        types.add(this_val.__class__)
 434        types.add(that_val.__class__)
 435        vals_equal = this_val == that_val
 436        return vals_equal
 437
 438
 439class ModelNormal(OpenApiModel):
 440    """the parent class of models whose type == object in their
 441    swagger/openapi"""
 442
 443    def __setitem__(self, name, value):
 444        """set the value of an attribute using square-bracket notation: `instance[attr] = val`"""
 445        if name in self.required_properties:
 446            self.__dict__[name] = value
 447            return
 448
 449        self.set_attribute(name, value)
 450
 451    def get(self, name, default=None):
 452        """returns the value of an attribute or some default value if the attribute was not set"""
 453        if name in self.required_properties:
 454            return self.__dict__[name]
 455
 456        return self.__dict__["_data_store"].get(name, default)
 457
 458    def __getitem__(self, name):
 459        """get the value of an attribute using square-bracket notation: `instance[attr]`"""
 460        if name in self:
 461            return self.get(name)
 462
 463        raise PineconeApiAttributeError(
 464            "{0} has no attribute '{1}'".format(type(self).__name__, name),
 465            [e for e in [self._path_to_item, name] if e],
 466        )
 467
 468    def __contains__(self, name):
 469        """used by `in` operator to check if an attrbute value was set in an instance: `'attr' in instance`"""
 470        if name in self.required_properties:
 471            return name in self.__dict__
 472
 473        return name in self.__dict__["_data_store"]
 474
 475    def to_dict(self):
 476        """Returns the model properties as a dict"""
 477        return model_to_dict(self, serialize=False)
 478
 479    def to_str(self):
 480        """Returns the string representation of the model"""
 481        return pprint.pformat(self.to_dict())
 482
 483    def __eq__(self, other):
 484        """Returns true if both objects are equal"""
 485        if not isinstance(other, self.__class__):
 486            return False
 487
 488        if not set(self._data_store.keys()) == set(other._data_store.keys()):
 489            return False
 490        for _var_name, this_val in self._data_store.items():
 491            that_val = other._data_store[_var_name]
 492            types = set()
 493            types.add(this_val.__class__)
 494            types.add(that_val.__class__)
 495            vals_equal = this_val == that_val
 496            if not vals_equal:
 497                return False
 498        return True
 499
 500
 501class ModelComposed(OpenApiModel):
 502    """the parent class of models whose type == object in their
 503    swagger/openapi and have oneOf/allOf/anyOf
 504
 505    When one sets a property we use var_name_to_model_instances to store the value in
 506    the correct class instances + run any type checking + validation code.
 507    When one gets a property we use var_name_to_model_instances to get the value
 508    from the correct class instances.
 509    This allows multiple composed schemas to contain the same property with additive
 510    constraints on the value.
 511
 512    _composed_schemas (dict) stores the anyOf/allOf/oneOf classes
 513    key (str): allOf/oneOf/anyOf
 514    value (list): the classes in the XOf definition.
 515        Note: none_type can be included when the openapi document version >= 3.1.0
 516    _composed_instances (list): stores a list of instances of the composed schemas
 517    defined in _composed_schemas. When properties are accessed in the self instance,
 518    they are returned from the self._data_store or the data stores in the instances
 519    in self._composed_schemas
 520    _var_name_to_model_instances (dict): maps between a variable name on self and
 521    the composed instances (self included) which contain that data
 522    key (str): property name
 523    value (list): list of class instances, self or instances in _composed_instances
 524    which contain the value that the key is referring to.
 525    """
 526
 527    def __setitem__(self, name, value):
 528        """set the value of an attribute using square-bracket notation: `instance[attr] = val`"""
 529        if name in self.required_properties:
 530            self.__dict__[name] = value
 531            return
 532
 533        """
 534        Use cases:
 535        1. additional_properties_type is None (additionalProperties == False in spec)
 536            Check for property presence in self.openapi_types
 537            if not present then throw an error
 538            if present set in self, set attribute
 539            always set on composed schemas
 540        2.  additional_properties_type exists
 541            set attribute on self
 542            always set on composed schemas
 543        """
 544        if self.additional_properties_type is None:
 545            """
 546            For an attribute to exist on a composed schema it must:
 547            - fulfill schema_requirements in the self composed schema not considering oneOf/anyOf/allOf schemas AND
 548            - fulfill schema_requirements in each oneOf/anyOf/allOf schemas
 549
 550            schema_requirements:
 551            For an attribute to exist on a schema it must:
 552            - be present in properties at the schema OR
 553            - have additionalProperties unset (defaults additionalProperties = any type) OR
 554            - have additionalProperties set
 555            """
 556            if name not in self.openapi_types:
 557                raise PineconeApiAttributeError(
 558                    "{0} has no attribute '{1}'".format(type(self).__name__, name),
 559                    [e for e in [self._path_to_item, name] if e],
 560                )
 561        # attribute must be set on self and composed instances
 562        self.set_attribute(name, value)
 563        for model_instance in self._composed_instances:
 564            setattr(model_instance, name, value)
 565        if name not in self._var_name_to_model_instances:
 566            # we assigned an additional property
 567            self.__dict__["_var_name_to_model_instances"][name] = self._composed_instances + [self]
 568        return None
 569
 570    __unset_attribute_value__ = object()
 571
 572    def get(self, name, default=None):
 573        """returns the value of an attribute or some default value if the attribute was not set"""
 574        if name in self.required_properties:
 575            return self.__dict__[name]
 576
 577        # get the attribute from the correct instance
 578        model_instances = self._var_name_to_model_instances.get(name)
 579        values = []
 580        # A composed model stores self and child (oneof/anyOf/allOf) models under
 581        # self._var_name_to_model_instances.
 582        # Any property must exist in self and all model instances
 583        # The value stored in all model instances must be the same
 584        if model_instances:
 585            for model_instance in model_instances:
 586                if name in model_instance._data_store:
 587                    v = model_instance._data_store[name]
 588                    if v not in values:
 589                        values.append(v)
 590        len_values = len(values)
 591        if len_values == 0:
 592            return default
 593        elif len_values == 1:
 594            return values[0]
 595        elif len_values > 1:
 596            raise PineconeApiValueError(
 597                "Values stored for property {0} in {1} differ when looking "
 598                "at self and self's composed instances. All values must be "
 599                "the same".format(name, type(self).__name__),
 600                [e for e in [self._path_to_item, name] if e],
 601            )
 602
 603    def __getitem__(self, name):
 604        """get the value of an attribute using square-bracket notation: `instance[attr]`"""
 605        value = self.get(name, self.__unset_attribute_value__)
 606        if value is self.__unset_attribute_value__:
 607            raise PineconeApiAttributeError(
 608                "{0} has no attribute '{1}'".format(type(self).__name__, name),
 609                [e for e in [self._path_to_item, name] if e],
 610            )
 611        return value
 612
 613    def __contains__(self, name):
 614        """used by `in` operator to check if an attrbute value was set in an instance: `'attr' in instance`"""
 615
 616        if name in self.required_properties:
 617            return name in self.__dict__
 618
 619        model_instances = self._var_name_to_model_instances.get(
 620            name, self._additional_properties_model_instances
 621        )
 622
 623        if model_instances:
 624            for model_instance in model_instances:
 625                if name in model_instance._data_store:
 626                    return True
 627
 628        return False
 629
 630    def to_dict(self):
 631        """Returns the model properties as a dict"""
 632        return model_to_dict(self, serialize=False)
 633
 634    def to_str(self):
 635        """Returns the string representation of the model"""
 636        return pprint.pformat(self.to_dict())
 637
 638    def __eq__(self, other):
 639        """Returns true if both objects are equal"""
 640        if not isinstance(other, self.__class__):
 641            return False
 642
 643        if not set(self._data_store.keys()) == set(other._data_store.keys()):
 644            return False
 645        for _var_name, this_val in self._data_store.items():
 646            that_val = other._data_store[_var_name]
 647            types = set()
 648            types.add(this_val.__class__)
 649            types.add(that_val.__class__)
 650            vals_equal = this_val == that_val
 651            if not vals_equal:
 652                return False
 653        return True
 654
 655
 656COERCION_INDEX_BY_TYPE = {
 657    ModelComposed: 0,
 658    ModelNormal: 1,
 659    ModelSimple: 2,
 660    none_type: 3,  # The type of 'None'.
 661    list: 4,
 662    dict: 5,
 663    float: 6,
 664    int: 7,
 665    bool: 8,
 666    datetime: 9,
 667    # date: 10,
 668    str: 11,
 669    file_type: 12,  # 'file_type' is an alias for the built-in 'file' or 'io.IOBase' type.
 670}
 671
 672# these are used to limit what type conversions we try to do
 673# when we have a valid type already and we want to try converting
 674# to another type
 675UPCONVERSION_TYPE_PAIRS = (
 676    (str, datetime),
 677    # (str, date),
 678    (int, float),  # A float may be serialized as an integer, e.g. '3' is a valid serialized float.
 679    (list, ModelComposed),
 680    (dict, ModelComposed),
 681    (str, ModelComposed),
 682    (int, ModelComposed),
 683    (float, ModelComposed),
 684    (list, ModelComposed),
 685    (list, ModelNormal),
 686    (dict, ModelNormal),
 687    (str, ModelSimple),
 688    (int, ModelSimple),
 689    (float, ModelSimple),
 690    (list, ModelSimple),
 691)
 692
 693COERCIBLE_TYPE_PAIRS = {
 694    False: (  # client instantiation of a model with client data
 695        # (dict, ModelComposed),
 696        # (list, ModelComposed),
 697        # (dict, ModelNormal),
 698        # (list, ModelNormal),
 699        # (str, ModelSimple),
 700        # (int, ModelSimple),
 701        # (float, ModelSimple),
 702        # (list, ModelSimple),
 703        # (str, int),
 704        # (str, float),
 705        # (str, datetime),
 706        # (str, date),
 707        # (int, str),
 708        # (float, str),
 709    ),
 710    True: (  # server -> client data
 711        (dict, ModelComposed),
 712        (list, ModelComposed),
 713        (dict, ModelNormal),
 714        (list, ModelNormal),
 715        (str, ModelSimple),
 716        (int, ModelSimple),
 717        (float, ModelSimple),
 718        (list, ModelSimple),
 719        # (str, int),
 720        # (str, float),
 721        # (str, datetime),
 722        # (str, date),
 723        # (int, str),
 724        # (float, str),
 725        (str, file_type),
 726    ),
 727}
 728
 729
 730def get_simple_class(input_value):
 731    """Returns an input_value's simple class that we will use for type checking
 732    Python2:
 733    float and int will return int, where int is the python3 int backport
 734    str and unicode will return str, where str is the python3 str backport
 735    Note: float and int ARE both instances of int backport
 736    Note: str_py2 and unicode_py2 are NOT both instances of str backport
 737
 738    Args:
 739        input_value (class/class_instance): the item for which we will return
 740                                            the simple class
 741    """
 742    if isinstance(input_value, type):
 743        # input_value is a class
 744        return input_value
 745    elif isinstance(input_value, tuple):
 746        return tuple
 747    elif isinstance(input_value, list):
 748        return list
 749    elif isinstance(input_value, dict):
 750        return dict
 751    elif input_value is None:
 752        return none_type
 753    elif isinstance(input_value, file_type):
 754        return file_type
 755    elif isinstance(input_value, bool):
 756        # this must be higher than the int check because
 757        # isinstance(True, int) == True
 758        return bool
 759    elif isinstance(input_value, int):
 760        return int
 761    elif isinstance(input_value, datetime):
 762        # this must be higher than the date check because
 763        # isinstance(datetime_instance, date) == True
 764        return datetime
 765    elif isinstance(input_value, date):
 766        return date
 767    elif isinstance(input_value, str):
 768        return str
 769    return type(input_value)
 770
 771
 772def check_allowed_values(allowed_values, input_variable_path, input_values):
 773    """Raises an exception if the input_values are not allowed
 774
 775    Args:
 776        allowed_values (dict): the allowed_values dict
 777        input_variable_path (tuple): the path to the input variable
 778        input_values (list/str/int/float/date/datetime): the values that we
 779            are checking to see if they are in allowed_values
 780    """
 781    these_allowed_values = list(allowed_values[input_variable_path].values())
 782    if isinstance(input_values, list) and not set(input_values).issubset(set(these_allowed_values)):
 783        invalid_values = (", ".join(map(str, set(input_values) - set(these_allowed_values))),)
 784        raise PineconeApiValueError(
 785            "Invalid values for `%s` [%s], must be a subset of [%s]"
 786            % (input_variable_path[0], invalid_values, ", ".join(map(str, these_allowed_values)))
 787        )
 788    elif isinstance(input_values, dict) and not set(input_values.keys()).issubset(
 789        set(these_allowed_values)
 790    ):
 791        invalid_values = ", ".join(map(str, set(input_values.keys()) - set(these_allowed_values)))
 792        raise PineconeApiValueError(
 793            "Invalid keys in `%s` [%s], must be a subset of [%s]"
 794            % (input_variable_path[0], invalid_values, ", ".join(map(str, these_allowed_values)))
 795        )
 796    elif not isinstance(input_values, (list, dict)) and input_values not in these_allowed_values:
 797        raise PineconeApiValueError(
 798            "Invalid value for `%s` (%s), must be one of %s"
 799            % (input_variable_path[0], input_values, these_allowed_values)
 800        )
 801
 802
 803def is_json_validation_enabled(schema_keyword, configuration=None):
 804    """Returns true if JSON schema validation is enabled for the specified
 805    validation keyword. This can be used to skip JSON schema structural validation
 806    as requested in the configuration.
 807
 808    Args:
 809        schema_keyword (string): the name of a JSON schema validation keyword.
 810        configuration (Configuration): the configuration class.
 811    """
 812
 813    return (
 814        configuration is None
 815        or not hasattr(configuration, "_disabled_client_side_validations")
 816        or schema_keyword not in configuration._disabled_client_side_validations
 817    )
 818
 819
 820def check_validations(validations, input_variable_path, input_values, configuration=None):
 821    """Raises an exception if the input_values are invalid
 822
 823    Args:
 824        validations (dict): the validation dictionary.
 825        input_variable_path (tuple): the path to the input variable.
 826        input_values (list/str/int/float/date/datetime): the values that we
 827            are checking.
 828        configuration (Configuration): the configuration class.
 829    """
 830
 831    if input_values is None:
 832        return
 833
 834    current_validations = validations[input_variable_path]
 835    if (
 836        is_json_validation_enabled("multipleOf", configuration)
 837        and "multiple_of" in current_validations
 838        and isinstance(input_values, (int, float))
 839        and not (float(input_values) / current_validations["multiple_of"]).is_integer()
 840    ):
 841        # Note 'multipleOf' will be as good as the floating point arithmetic.
 842        raise PineconeApiValueError(
 843            "Invalid value for `%s`, value must be a multiple of "
 844            "`%s`" % (input_variable_path[0], current_validations["multiple_of"])
 845        )
 846
 847    if (
 848        is_json_validation_enabled("maxLength", configuration)
 849        and "max_length" in current_validations
 850        and len(input_values) > current_validations["max_length"]
 851    ):
 852        raise PineconeApiValueError(
 853            "Invalid value for `%s`, length must be less than or equal to "
 854            "`%s`" % (input_variable_path[0], current_validations["max_length"])
 855        )
 856
 857    if (
 858        is_json_validation_enabled("minLength", configuration)
 859        and "min_length" in current_validations
 860        and len(input_values) < current_validations["min_length"]
 861    ):
 862        raise PineconeApiValueError(
 863            "Invalid value for `%s`, length must be greater than or equal to "
 864            "`%s`" % (input_variable_path[0], current_validations["min_length"])
 865        )
 866
 867    if (
 868        is_json_validation_enabled("maxItems", configuration)
 869        and "max_items" in current_validations
 870        and len(input_values) > current_validations["max_items"]
 871    ):
 872        raise PineconeApiValueError(
 873            "Invalid value for `%s`, number of items must be less than or "
 874            "equal to `%s`" % (input_variable_path[0], current_validations["max_items"])
 875        )
 876
 877    if (
 878        is_json_validation_enabled("minItems", configuration)
 879        and "min_items" in current_validations
 880        and len(input_values) < current_validations["min_items"]
 881    ):
 882        raise ValueError(
 883            "Invalid value for `%s`, number of items must be greater than or "
 884            "equal to `%s`" % (input_variable_path[0], current_validations["min_items"])
 885        )
 886
 887    items = ("exclusive_maximum", "inclusive_maximum", "exclusive_minimum", "inclusive_minimum")
 888    if any(item in current_validations for item in items):
 889        if isinstance(input_values, list):
 890            max_val = max(input_values)
 891            min_val = min(input_values)
 892        elif isinstance(input_values, dict):
 893            max_val = max(input_values.values())
 894            min_val = min(input_values.values())
 895        else:
 896            max_val = input_values
 897            min_val = input_values
 898
 899    if (
 900        is_json_validation_enabled("exclusiveMaximum", configuration)
 901        and "exclusive_maximum" in current_validations
 902        and max_val >= current_validations["exclusive_maximum"]
 903    ):
 904        raise PineconeApiValueError(
 905            "Invalid value for `%s`, must be a value less than `%s`"
 906            % (input_variable_path[0], current_validations["exclusive_maximum"])
 907        )
 908
 909    if (
 910        is_json_validation_enabled("maximum", configuration)
 911        and "inclusive_maximum" in current_validations
 912        and max_val > current_validations["inclusive_maximum"]
 913    ):
 914        raise PineconeApiValueError(
 915            "Invalid value for `%s`, must be a value less than or equal to "
 916            "`%s`" % (input_variable_path[0], current_validations["inclusive_maximum"])
 917        )
 918
 919    if (
 920        is_json_validation_enabled("exclusiveMinimum", configuration)
 921        and "exclusive_minimum" in current_validations
 922        and min_val <= current_validations["exclusive_minimum"]
 923    ):
 924        raise PineconeApiValueError(
 925            "Invalid value for `%s`, must be a value greater than `%s`"
 926            % (input_variable_path[0], current_validations["exclusive_maximum"])
 927        )
 928
 929    if (
 930        is_json_validation_enabled("minimum", configuration)
 931        and "inclusive_minimum" in current_validations
 932        and min_val < current_validations["inclusive_minimum"]
 933    ):
 934        raise PineconeApiValueError(
 935            "Invalid value for `%s`, must be a value greater than or equal "
 936            "to `%s`" % (input_variable_path[0], current_validations["inclusive_minimum"])
 937        )
 938    flags = current_validations.get("regex", {}).get("flags", 0)
 939    if (
 940        is_json_validation_enabled("pattern", configuration)
 941        and "regex" in current_validations
 942        and not re.search(current_validations["regex"]["pattern"], input_values, flags=flags)
 943    ):
 944        err_msg = r"Invalid value for `%s`, must match regular expression `%s`" % (
 945            input_variable_path[0],
 946            current_validations["regex"]["pattern"],
 947        )
 948        if flags != 0:
 949            # Don't print the regex flags if the flags are not
 950            # specified in the OAS document.
 951            err_msg = r"%s with flags=`%s`" % (err_msg, flags)
 952        raise PineconeApiValueError(err_msg)
 953
 954
 955def order_response_types(required_types):
 956    """Returns the required types sorted in coercion order
 957
 958    Args:
 959        required_types (list/tuple): collection of classes or instance of
 960            list or dict with class information inside it.
 961
 962    Returns:
 963        (list): coercion order sorted collection of classes or instance
 964            of list or dict with class information inside it.
 965    """
 966
 967    def index_getter(class_or_instance):
 968        if isinstance(class_or_instance, list):
 969            return COERCION_INDEX_BY_TYPE[list]
 970        elif isinstance(class_or_instance, dict):
 971            return COERCION_INDEX_BY_TYPE[dict]
 972        elif inspect.isclass(class_or_instance) and issubclass(class_or_instance, ModelComposed):
 973            return COERCION_INDEX_BY_TYPE[ModelComposed]
 974        elif inspect.isclass(class_or_instance) and issubclass(class_or_instance, ModelNormal):
 975            return COERCION_INDEX_BY_TYPE[ModelNormal]
 976        elif inspect.isclass(class_or_instance) and issubclass(class_or_instance, ModelSimple):
 977            return COERCION_INDEX_BY_TYPE[ModelSimple]
 978        elif class_or_instance in COERCION_INDEX_BY_TYPE:
 979            return COERCION_INDEX_BY_TYPE[class_or_instance]
 980        raise PineconeApiValueError("Unsupported type: %s" % class_or_instance)
 981
 982    sorted_types = sorted(
 983        required_types, key=lambda class_or_instance: index_getter(class_or_instance)
 984    )
 985    return sorted_types
 986
 987
 988def remove_uncoercible(
 989    required_types_classes, current_item, spec_property_naming, must_convert=True
 990):
 991    """Only keeps the type conversions that are possible
 992
 993    Args:
 994        required_types_classes (tuple): tuple of classes that are required
 995                          these should be ordered by COERCION_INDEX_BY_TYPE
 996        spec_property_naming (bool): True if the variable names in the input
 997            data are serialized names as specified in the OpenAPI document.
 998            False if the variables names in the input data are python
 999            variable names in PEP-8 snake case.
1000        current_item (any): the current item (input data) to be converted
1001
1002    Keyword Args:
1003        must_convert (bool): if True the item to convert is of the wrong
1004                          type and we want a big list of coercibles
1005                          if False, we want a limited list of coercibles
1006
1007    Returns:
1008        (list): the remaining coercible required types, classes only
1009    """
1010    current_type_simple = get_simple_class(current_item)
1011
1012    results_classes = []
1013    for required_type_class in required_types_classes:
1014        # convert our models to OpenApiModel
1015        required_type_class_simplified = required_type_class
1016        if isinstance(required_type_class_simplified, type):
1017            if issubclass(required_type_class_simplified, ModelComposed):
1018                required_type_class_simplified = ModelComposed
1019            elif issubclass(required_type_class_simplified, ModelNormal):
1020                required_type_class_simplified = ModelNormal
1021            elif issubclass(required_type_class_simplified, ModelSimple):
1022                required_type_class_simplified = ModelSimple
1023
1024        if required_type_class_simplified == current_type_simple:
1025            # don't consider converting to one's own class
1026            continue
1027
1028        class_pair = (current_type_simple, required_type_class_simplified)
1029        if must_convert and class_pair in COERCIBLE_TYPE_PAIRS[spec_property_naming]:
1030            results_classes.append(required_type_class)
1031        elif class_pair in UPCONVERSION_TYPE_PAIRS:
1032            results_classes.append(required_type_class)
1033    return results_classes
1034
1035
1036def get_discriminated_classes(cls):
1037    """
1038    Returns all the classes that a discriminator converts to
1039    TODO: lru_cache this
1040    """
1041    possible_classes = []
1042    key = list(cls.discriminator.keys())[0]
1043    if is_type_nullable(cls):
1044        possible_classes.append(cls)
1045    for discr_cls in cls.discriminator[key].values():
1046        if hasattr(discr_cls, "discriminator") and discr_cls.discriminator is not None:
1047            possible_classes.extend(get_discriminated_classes(discr_cls))
1048        else:
1049            possible_classes.append(discr_cls)
1050    return possible_classes
1051
1052
1053def get_possible_classes(cls, from_server_context):
1054    # TODO: lru_cache this
1055    possible_classes = [cls]
1056    if from_server_context:
1057        return possible_classes
1058    if hasattr(cls, "discriminator") and cls.discriminator is not None:
1059        possible_classes = []
1060        possible_classes.extend(get_discriminated_classes(cls))
1061    elif issubclass(cls, ModelComposed):
1062        possible_classes.extend(composed_model_input_classes(cls))
1063    return possible_classes
1064
1065
1066def get_required_type_classes(required_types_mixed, spec_property_naming):
1067    """Converts the tuple required_types into a tuple and a dict described
1068    below
1069
1070    Args:
1071        required_types_mixed (tuple/list): will contain either classes or
1072            instance of list or dict
1073        spec_property_naming (bool): if True these values came from the
1074            server, and we use the data types in our endpoints.
1075            If False, we are client side and we need to include
1076            oneOf and discriminator classes inside the data types in our endpoints
1077
1078    Returns:
1079        (valid_classes, dict_valid_class_to_child_types_mixed):
1080            valid_classes (tuple): the valid classes that the current item
1081                                   should be
1082            dict_valid_class_to_child_types_mixed (dict):
1083                valid_class (class): this is the key
1084                child_types_mixed (list/dict/tuple): describes the valid child
1085                    types
1086    """
1087    valid_classes = []
1088    child_req_types_by_current_type = {}
1089
1090    for required_type in required_types_mixed:
1091        if isinstance(required_type, list):
1092            valid_classes.append(list)
1093            child_req_types_by_current_type[list] = required_type
1094        elif isinstance(required_type, tuple):
1095            valid_classes.append(tuple)
1096            child_req_types_by_current_type[tuple] = required_type
1097        elif isinstance(required_type, dict):
1098            valid_classes.append(dict)
1099            child_req_types_by_current_type[dict] = required_type[str]
1100        else:
1101            valid_classes.extend(get_possible_classes(required_type, spec_property_naming))
1102    return tuple(valid_classes), child_req_types_by_current_type
1103
1104
1105def change_keys_js_to_python(input_dict, model_class):
1106    """
1107    Converts from javascript_key keys in the input_dict to python_keys in
1108    the output dict using the mapping in model_class.
1109    If the input_dict contains a key which does not declared in the model_class,
1110    the key is added to the output dict as is. The assumption is the model_class
1111    may have undeclared properties (additionalProperties attribute in the OAS
1112    document).
1113    """
1114
1115    if getattr(model_class, "attribute_map", None) is None:
1116        return input_dict
1117    output_dict = {}
1118    reversed_attr_map = {value: key for key, value in model_class.attribute_map.items()}
1119    for javascript_key, value in input_dict.items():
1120        python_key = reversed_attr_map.get(javascript_key)
1121        if python_key is None:
1122            # if the key is unknown, it is in error or it is an
1123            # additionalProperties variable
1124            python_key = javascript_key
1125        output_dict[python_key] = value
1126    return output_dict
1127
1128
1129def get_type_error(var_value, path_to_item, valid_classes, key_type=False):
1130    error_msg = type_error_message(
1131        var_name=path_to_item[-1],
1132        var_value=var_value,
1133        valid_classes=valid_classes,
1134        key_type=key_type,
1135    )
1136    return PineconeApiTypeError(
1137        error_msg, path_to_item=path_to_item, valid_classes=valid_classes, key_type=key_type
1138    )
1139
1140
1141def deserialize_primitive(data, klass, path_to_item):
1142    """Deserializes string to primitive type.
1143
1144    :param data: str/int/float
1145    :param klass: str/class the class to convert to
1146
1147    :return: int, float, str, bool
1148    """
1149    additional_message = ""
1150    try:
1151        if klass in {datetime, date}:
1152            additional_message = (
1153                "If you need your parameter to have a fallback "
1154                "string value, please set its type as `type: {}` in your "
1155                "spec. That allows the value to be any type. "
1156            )
1157            if klass == datetime:
1158                if len(data) < 8:
1159                    raise ValueError("This is not a datetime")
1160                # The string should be in iso8601 datetime format.
1161                parsed_datetime = parse(data)
1162                date_only = (
1163                    parsed_datetime.hour == 0
1164                    and parsed_datetime.minute == 0
1165                    and parsed_datetime.second == 0
1166                    and parsed_datetime.tzinfo is None
1167                    and 8 <= len(data) <= 10
1168                )
1169                if date_only:
1170                    raise ValueError("This is a date, not a datetime")
1171                return parsed_datetime
1172            elif klass == date:
1173                if len(data) < 8:
1174                    raise ValueError("This is not a date")
1175                return parse(data).date()
1176        else:
1177            converted_value = klass(data)
1178            if isinstance(data, str) and klass is float:
1179                if str(converted_value) != data:
1180                    # '7' -> 7.0 -> '7.0' != '7'
1181                    raise ValueError("This is not a float")
1182            return converted_value
1183    except (OverflowError, ValueError) as ex:
1184        # parse can raise OverflowError
1185        raise PineconeApiValueError(
1186            "{0}Failed to parse {1} as {2}".format(additional_message, repr(data), klass.__name__),
1187            path_to_item=path_to_item,
1188        ) from ex
1189
1190
1191def get_discriminator_class(model_class, discr_name, discr_value, cls_visited):
1192    """Returns the child class specified by the discriminator.
1193
1194    Args:
1195        model_class (OpenApiModel): the model class.
1196        discr_name (string): the name of the discriminator property.
1197        discr_value (any): the discriminator value.
1198        cls_visited (list): list of model classes that have been visited.
1199            Used to determine the discriminator class without
1200            visiting circular references indefinitely.
1201
1202    Returns:
1203        used_model_class (class/None): the chosen child class that will be used
1204            to deserialize the data, for example dog.Dog.
1205            If a class is not found, None is returned.
1206    """
1207
1208    if model_class in cls_visited:
1209        # The class has already been visited and no suitable class was found.
1210        return None
1211    cls_visited.append(model_class)
1212    used_model_class = None
1213    if discr_name in model_class.discriminator:
1214        class_name_to_discr_class = model_class.discriminator[discr_name]
1215        used_model_class = class_name_to_discr_class.get(discr_value)
1216    if used_model_class is None:
1217        # We didn't find a discriminated class in class_name_to_discr_class.
1218        # So look in the ancestor or descendant discriminators
1219        # The discriminator mapping may exist in a descendant (anyOf, oneOf)
1220        # or ancestor (allOf).
1221        # Ancestor example: in the GrandparentAnimal -> ParentPet -> ChildCat
1222        #   hierarchy, the discriminator mappings may be defined at any level
1223        #   in the hierarchy.
1224        # Descendant example:  mammal -> whale/zebra/Pig -> BasquePig/DanishPig
1225        #   if we try to make BasquePig from mammal, we need to travel through
1226        #   the oneOf descendant discriminators to find BasquePig
1227        descendant_classes = model_class._composed_schemas.get(
1228            "oneOf", ()
1229        ) + model_class._composed_schemas.get("anyOf", ())
1230        ancestor_classes = model_class._composed_schemas.get("allOf", ())
1231        possible_classes = descendant_classes + ancestor_classes
1232        for cls in possible_classes:
1233            # Check if the schema has inherited discriminators.
1234            if hasattr(cls, "discriminator") and cls.discriminator is not None:
1235                used_model_class = get_discriminator_class(
1236                    cls, discr_name, discr_value, cls_visited
1237                )
1238                if used_model_class is not None:
1239                    return used_model_class
1240    return used_model_class
1241
1242
1243def deserialize_model(
1244    model_data, model_class, path_to_item, check_type, configuration, spec_property_naming
1245):
1246    """Deserializes model_data to model instance.
1247
1248    Args:
1249        model_data (int/str/float/bool/none_type/list/dict): data to instantiate the model
1250        model_class (OpenApiModel): the model class
1251        path_to_item (list): path to the model in the received data
1252        check_type (bool): whether to check the data tupe for the values in
1253            the model
1254        configuration (Configuration): the instance to use to convert files
1255        spec_property_naming (bool): True if the variable names in the input
1256            data are serialized names as specified in the OpenAPI document.
1257            False if the variables names in the input data are python
1258            variable names in PEP-8 snake case.
1259
1260    Returns:
1261        model instance
1262
1263    Raise:
1264        PineconeApiTypeError
1265        PineconeApiValueError
1266        PineconeApiKeyError
1267    """
1268
1269    kw_args = dict(
1270        _check_type=check_type,
1271        _path_to_item=path_to_item,
1272        _configuration=configuration,
1273        _spec_property_naming=spec_property_naming,
1274    )
1275
1276    if issubclass(model_class, ModelSimple):
1277        return model_class._new_from_openapi_data(model_data, **kw_args)
1278    elif isinstance(model_data, list):
1279        return model_class._new_from_openapi_data(*model_data, **kw_args)
1280    if isinstance(model_data, dict):
1281        kw_args.update(model_data)
1282        return model_class._new_from_openapi_data(**kw_args)
1283    elif isinstance(model_data, PRIMITIVE_TYPES):
1284        return model_class._new_from_openapi_data(model_data, **kw_args)
1285
1286
1287def deserialize_file(response_data, configuration, content_disposition=None):
1288    """Deserializes body to file
1289
1290    Saves response body into a file in a temporary folder,
1291    using the filename from the `Content-Disposition` header if provided.
1292
1293    Args:
1294        param response_data (str):  the file data to write
1295        configuration (Configuration): the instance to use to convert files
1296
1297    Keyword Args:
1298        content_disposition (str):  the value of the Content-Disposition
1299            header
1300
1301    Returns:
1302        (file_type): the deserialized file which is open
1303            The user is responsible for closing and reading the file
1304    """
1305    fd, path = tempfile.mkstemp(dir=configuration.temp_folder_path)
1306    os.close(fd)
1307    os.remove(path)
1308
1309    if content_disposition:
1310        filename = re.search(r'filename=[\'"]?([^\'"\s]+)[\'"]?', content_disposition).group(1)
1311        path = os.path.join(os.path.dirname(path), filename)
1312
1313    with open(path, "wb") as f:
1314        if isinstance(response_data, str):
1315            # change str to bytes so we can write it
1316            response_data = response_data.encode("utf-8")
1317        f.write(response_data)
1318
1319    f = open(path, "rb")
1320    return f
1321
1322
1323def attempt_convert_item(
1324    input_value,
1325    valid_classes,
1326    path_to_item,
1327    configuration,
1328    spec_property_naming,
1329    key_type=False,
1330    must_convert=False,
1331    check_type=True,
1332):
1333    """
1334    Args:
1335        input_value (any): the data to convert
1336        valid_classes (any): the classes that are valid
1337        path_to_item (list): the path to the item to convert
1338        configuration (Configuration): the instance to use to convert files
1339        spec_property_naming (bool): True if the variable names in the input
1340            data are serialized names as specified in the OpenAPI document.
1341            False if the variables names in the input data are python
1342            variable names in PEP-8 snake case.
1343        key_type (bool): if True we need to convert a key type (not supported)
1344        must_convert (bool): if True we must convert
1345        check_type (bool): if True we check the type or the returned data in
1346            ModelComposed/ModelNormal/ModelSimple instances
1347
1348    Returns:
1349        instance (any) the fixed item
1350
1351    Raises:
1352        PineconeApiTypeError
1353        PineconeApiValueError
1354        PineconeApiKeyError
1355    """
1356    valid_classes_ordered = order_response_types(valid_classes)
1357    valid_classes_coercible = remove_uncoercible(
1358        valid_classes_ordered, input_value, spec_property_naming
1359    )
1360    if not valid_classes_coercible or key_type:
1361        # we do not handle keytype errors, json will take care
1362        # of this for us
1363        if configuration is None or not configuration.discard_unknown_keys:
1364            raise get_type_error(input_value, path_to_item, valid_classes, key_type=key_type)
1365    for valid_class in valid_classes_coercible:
1366        try:
1367            if issubclass(valid_class, OpenApiModel):
1368                return deserialize_model(
1369                    input_value,
1370                    valid_class,
1371                    path_to_item,
1372                    check_type,
1373                    configuration,
1374                    spec_property_naming,
1375                )
1376            elif valid_class == file_type:
1377                return deserialize_file(input_value, configuration)
1378            return deserialize_primitive(input_value, valid_class, path_to_item)
1379        except (PineconeApiTypeError, PineconeApiValueError, PineconeApiKeyError) as conversion_exc:
1380            if must_convert:
1381                raise conversion_exc
1382            # if we have conversion errors when must_convert == False
1383            # we ignore the exception and move on to the next class
1384            continue
1385    # we were unable to convert, must_convert == False
1386    return input_value
1387
1388
1389def is_type_nullable(input_type):
1390    """
1391    Returns true if None is an allowed value for the specified input_type.
1392
1393    A type is nullable if at least one of the following conditions is true:
1394    1. The OAS 'nullable' attribute has been specified,
1395    1. The type is the 'null' type,
1396    1. The type is a anyOf/oneOf composed schema, and a child schema is
1397       the 'null' type.
1398    Args:
1399        input_type (type): the class of the input_value that we are
1400            checking
1401    Returns:
1402        bool
1403    """
1404    if input_type is none_type:
1405        return True
1406    if issubclass(input_type, OpenApiModel) and input_type._nullable:
1407        return True
1408    if issubclass(input_type, ModelComposed):
1409        # If oneOf/anyOf, check if the 'null' type is one of the allowed types.
1410        for t in input_type._composed_schemas.get("oneOf", ()):
1411            if is_type_nullable(t):
1412                return True
1413        for t in input_type._composed_schemas.get("anyOf", ()):
1414            if is_type_nullable(t):
1415                return True
1416    return False
1417
1418
1419def is_valid_type(input_class_simple, valid_classes):
1420    """
1421    Args:
1422        input_class_simple (class): the class of the input_value that we are
1423            checking
1424        valid_classes (tuple): the valid classes that the current item
1425            should be
1426    Returns:
1427        bool
1428    """
1429    valid_type = input_class_simple in valid_classes
1430    if not valid_type and (
1431        issubclass(input_class_simple, OpenApiModel) or input_class_simple is none_type
1432    ):
1433        for valid_class in valid_classes:
1434            if input_class_simple is none_type and is_type_nullable(valid_class):
1435                # Schema is oneOf/anyOf and the 'null' type is one of the allowed types.
1436                return True
1437            if not (issubclass(valid_class, OpenApiModel) and valid_class.discriminator):
1438                continue
1439            discr_propertyname_py = list(valid_class.discriminator.keys())[0]
1440            discriminator_classes = valid_class.discriminator[discr_propertyname_py].values()
1441            valid_type = is_valid_type(input_class_simple, discriminator_classes)
1442            if valid_type:
1443                return True
1444    return valid_type
1445
1446
1447def validate_and_convert_types(
1448    input_value,
1449    required_types_mixed,
1450    path_to_item,
1451    spec_property_naming,
1452    _check_type,
1453    configuration=None,
1454):
1455    """Raises a TypeError is there is a problem, otherwise returns value
1456
1457    Args:
1458        input_value (any): the data to validate/convert
1459        required_types_mixed (list/dict/tuple): A list of
1460            valid classes, or a list tuples of valid classes, or a dict where
1461            the value is a tuple of value classes
1462        path_to_item: (list) the path to the data being validated
1463            this stores a list of keys or indices to get to the data being
1464            validated
1465        spec_property_naming (bool): True if the variable names in the input
1466            data are serialized names as specified in the OpenAPI document.
1467            False if the variables names in the input data are python
1468            variable names in PEP-8 snake case.
1469        _check_type: (boolean) if true, type will be checked and conversion
1470            will be attempted.
1471        configuration: (Configuration): the configuration class to use
1472            when converting file_type items.
1473            If passed, conversion will be attempted when possible
1474            If not passed, no conversions will be attempted and
1475            exceptions will be raised
1476
1477    Returns:
1478        the correctly typed value
1479
1480    Raises:
1481        PineconeApiTypeError
1482    """
1483    results = get_required_type_classes(required_types_mixed, spec_property_naming)
1484    valid_classes, child_req_types_by_current_type = results
1485
1486    input_class_simple = get_simple_class(input_value)
1487    valid_type = is_valid_type(input_class_simple, valid_classes)
1488    if not valid_type:
1489        if configuration:
1490            # if input_value is not valid_type try to convert it
1491            converted_instance = attempt_convert_item(
1492                input_value,
1493                valid_classes,
1494                path_to_item,
1495                configuration,
1496                spec_property_naming,
1497                key_type=False,
1498                must_convert=True,
1499                check_type=_check_type,
1500            )
1501            return converted_instance
1502        else:
1503            raise get_type_error(input_value, path_to_item, valid_classes, key_type=False)
1504
1505    # input_value's type is in valid_classes
1506    if len(valid_classes) > 1 and configuration:
1507        # there are valid classes which are not the current class
1508        valid_classes_coercible = remove_uncoercible(
1509            valid_classes, input_value, spec_property_naming, must_convert=False
1510        )
1511        if valid_classes_coercible:
1512            converted_instance = attempt_convert_item(
1513                input_value,
1514                valid_classes_coercible,
1515                path_to_item,
1516                configuration,
1517                spec_property_naming,
1518                key_type=False,
1519                must_convert=False,
1520                check_type=_check_type,
1521            )
1522            return converted_instance
1523
1524    if child_req_types_by_current_type == {}:
1525        # all types are of the required types and there are no more inner
1526        # variables left to look at
1527        return input_value
1528    inner_required_types = child_req_types_by_current_type.get(type(input_value))
1529    if inner_required_types is None:
1530        # for this type, there are not more inner variables left to look at
1531        return input_value
1532    if isinstance(input_value, list):
1533        if input_value == []:
1534            # allow an empty list
1535            return input_value
1536        for index, inner_value in enumerate(input_value):
1537            inner_path = list(path_to_item)
1538            inner_path.append(index)
1539            input_value[index] = validate_and_convert_types(
1540                inner_value,
1541                inner_required_types,
1542                inner_path,
1543                spec_property_naming,
1544                _check_type,
1545                configuration=configuration,
1546            )
1547    elif isinstance(input_value, dict):
1548        if input_value == {}:
1549            # allow an empty dict
1550            return input_value
1551        for inner_key, inner_val in input_value.items():
1552            inner_path = list(path_to_item)
1553            inner_path.append(inner_key)
1554            if get_simple_class(inner_key) is not str:
1555                raise get_type_error(inner_key, inner_path, valid_classes, key_type=True)
1556            input_value[inner_key] = validate_and_convert_types(
1557                inner_val,
1558                inner_required_types,
1559                inner_path,
1560                spec_property_naming,
1561                _check_type,
1562                configuration=configuration,
1563            )
1564    return input_value
1565
1566
1567def model_to_dict(model_instance, serialize=True):
1568    """Returns the model properties as a dict
1569
1570    Args:
1571        model_instance (one of your model instances): the model instance that
1572            will be converted to a dict.
1573
1574    Keyword Args:
1575        serialize (bool): if True, the keys in the dict will be values from
1576            attribute_map
1577    """
1578    result = {}
1579
1580    model_instances = [model_instance]
1581    if hasattr(model_instance, "_composed_schemas") and model_instance._composed_schemas:
1582        model_instances.extend(model_instance._composed_instances)
1583    seen_json_attribute_names = set()
1584    used_fallback_python_attribute_names = set()
1585    py_to_json_map = {}
1586    for model_instance in model_instances:
1587        for attr, value in model_instance._data_store.items():
1588            if serialize:
1589                # we use get here because additional property key names do not
1590                # exist in attribute_map
1591                try:
1592                    attr = model_instance.attribute_map[attr]
1593                    py_to_json_map.update(model_instance.attribute_map)
1594                    seen_json_attribute_names.add(attr)
1595                except KeyError:
1596                    used_fallback_python_attribute_names.add(attr)
1597            if isinstance(value, list):
1598                if not value:
1599                    # empty list or None
1600                    result[attr] = value
1601                else:
1602                    res = []
1603                    for v in value:
1604                        if isinstance(v, PRIMITIVE_TYPES) or v is None:
1605                            res.append(v)
1606                        elif isinstance(v, ModelSimple):
1607                            res.append(v.value)
1608                        else:
1609                            res.append(model_to_dict(v, serialize=serialize))
1610                    result[attr] = res
1611            elif isinstance(value, dict):
1612                result[attr] = dict(
1613                    map(
1614                        lambda item: (
1615                            (item[0], model_to_dict(item[1], serialize=serialize))
1616                            if hasattr(item[1], "_data_store")
1617                            else item
1618                        ),
1619                        value.items(),
1620                    )
1621                )
1622            elif isinstance(value, ModelSimple):
1623                result[attr] = value.value
1624            elif hasattr(value, "_data_store"):
1625                result[attr] = model_to_dict(value, serialize=serialize)
1626            else:
1627                result[attr] = value
1628    if serialize:
1629        for python_key in used_fallback_python_attribute_names:
1630            json_key = py_to_json_map.get(python_key)
1631            if json_key is None:
1632                continue
1633            if python_key == json_key:
1634                continue
1635            json_key_assigned_no_need_for_python_key = json_key in seen_json_attribute_names
1636            if json_key_assigned_no_need_for_python_key:
1637                del result[python_key]
1638
1639    return result
1640
1641
1642def type_error_message(var_value=None, var_name=None, valid_classes=None, key_type=None):
1643    """
1644    Keyword Args:
1645        var_value (any): the variable which has the type_error
1646        var_name (str): the name of the variable which has the typ error
1647        valid_classes (tuple): the accepted classes for current_item's
1648                                  value
1649        key_type (bool): False if our value is a value in a dict
1650                         True if it is a key in a dict
1651                         False if our item is an item in a list
1652    """
1653    key_or_value = "value"
1654    if key_type:
1655        key_or_value = "key"
1656    valid_classes_phrase = get_valid_classes_phrase(valid_classes)
1657    msg = "Invalid type for variable '{0}'. Required {1} type {2} and passed type was {3}".format(
1658        var_name, key_or_value, valid_classes_phrase, type(var_value).__name__
1659    )
1660    return msg
1661
1662
1663def get_valid_classes_phrase(input_classes):
1664    """Returns a string phrase describing what types are allowed"""
1665    all_classes = list(input_classes)
1666    all_classes = sorted(all_classes, key=lambda cls: cls.__name__)
1667    all_class_names = [cls.__name__ for cls in all_classes]
1668    if len(all_class_names) == 1:
1669        return "is {0}".format(all_class_names[0])
1670    return "is one of [{0}]".format(", ".join(all_class_names))
1671
1672
1673def get_allof_instances(self, model_args, constant_args):
1674    """
1675    Args:
1676        self: the class we are handling
1677        model_args (dict): var_name to var_value
1678            used to make instances
1679        constant_args (dict):
1680            metadata arguments:
1681            _check_type
1682            _path_to_item
1683            _spec_property_naming
1684            _configuration
1685            _visited_composed_classes
1686
1687    Returns
1688        composed_instances (list)
1689    """
1690    composed_instances = []
1691    for allof_class in self._composed_schemas["allOf"]:
1692        try:
1693            allof_instance = allof_class(**model_args, **constant_args)
1694            composed_instances.append(allof_instance)
1695        except Exception as ex:
1696            raise PineconeApiValueError(
1697                "Invalid inputs given to generate an instance of '%s'. The "
1698                "input data was invalid for the allOf schema '%s' in the composed "
1699                "schema '%s'. Error=%s"
1700                % (allof_class.__name__, allof_class.__name__, self.__class__.__name__, str(ex))
1701            ) from ex
1702    return composed_instances
1703
1704
1705def get_oneof_instance(cls, model_kwargs, constant_kwargs, model_arg=None):
1706    """
1707    Find the oneOf schema that matches the input data (e.g. payload).
1708    If exactly one schema matches the input data, an instance of that schema
1709    is returned.
1710    If zero or more than one schema match the input data, an exception is raised.
1711    In OAS 3.x, the payload MUST, by validation, match exactly one of the
1712    schemas described by oneOf.
1713
1714    Args:
1715        cls: the class we are handling
1716        model_kwargs (dict): var_name to var_value
1717            The input data, e.g. the payload that must match a oneOf schema
1718            in the OpenAPI document.
1719        constant_kwargs (dict): var_name to var_value
1720            args that every model requires, including configuration, server
1721            and path to item.
1722
1723    Kwargs:
1724        model_arg: (int, float, bool, str, ModelSimple, None):
1725            the value to assign to a primitive class or ModelSimple class
1726            Notes:
1727            - this is only passed in when oneOf includes types which are not object
1728            - None is used to suppress handling of model_arg, nullable models are handled in __new__
1729
1730    Returns
1731        oneof_instance (instance)
1732    """
1733    if len(cls._composed_schemas["oneOf"]) == 0:
1734        return None
1735
1736    oneof_instances = []
1737    # Iterate over each oneOf schema and determine if the input data
1738    # matches the oneOf schemas.
1739    for oneof_class in cls._composed_schemas["oneOf"]:
1740        # The composed oneOf schema allows the 'null' type and the input data
1741        # is the null value. This is a OAS >= 3.1 feature.
1742        if oneof_class is none_type:
1743            # skip none_types because we are deserializing dict data.
1744            # none_type deserialization is handled in the __new__ method
1745            continue
1746
1747        single_value_input = allows_single_value_input(oneof_class)
1748
1749        try:
1750            if not single_value_input:
1751                oneof_instance = oneof_class(**model_kwargs, **constant_kwargs)
1752            else:
1753                if issubclass(oneof_class, ModelSimple):
1754                    oneof_instance = oneof_class(model_arg, **constant_kwargs)
1755                elif oneof_class in PRIMITIVE_TYPES:
1756                    oneof_instance = validate_and_convert_types(
1757                        model_arg,
1758                        (oneof_class,),
1759                        constant_kwargs["_path_to_item"],
1760                        constant_kwargs["_spec_property_naming"],
1761                        constant_kwargs["_check_type"],
1762                        configuration=constant_kwargs["_configuration"],
1763                    )
1764            oneof_instances.append(oneof_instance)
1765        except Exception:
1766            pass
1767    if len(oneof_instances) == 0:
1768        raise PineconeApiValueError(
1769            "Invalid inputs given to generate an instance of %s. None "
1770            "of the oneOf schemas matched the input data." % cls.__name__
1771        )
1772    elif len(oneof_instances) > 1:
1773        raise PineconeApiValueError(
1774            "Invalid inputs given to generate an instance of %s. Multiple "
1775            "oneOf schemas matched the inputs, but a max of one is allowed." % cls.__name__
1776        )
1777    return oneof_instances[0]
1778
1779
1780def get_anyof_instances(self, model_args, constant_args):
1781    """
1782    Args:
1783        self: the class we are handling
1784        model_args (dict): var_name to var_value
1785            The input data, e.g. the payload that must match at least one
1786            anyOf child schema in the OpenAPI document.
1787        constant_args (dict): var_name to var_value
1788            args that every model requires, including configuration, server
1789            and path to item.
1790
1791    Returns
1792        anyof_instances (list)
1793    """
1794    anyof_instances = []
1795    if len(self._composed_schemas["anyOf"]) == 0:
1796        return anyof_instances
1797
1798    for anyof_class in self._composed_schemas["anyOf"]:
1799        # The composed oneOf schema allows the 'null' type and the input data
1800        # is the null value. This is a OAS >= 3.1 feature.
1801        if anyof_class is none_type:
1802            # skip none_types because we are deserializing dict data.
1803            # none_type deserialization is handled in the __new__ method
1804            continue
1805
1806        try:
1807            anyof_instance = anyof_class(**model_args, **constant_args)
1808            anyof_instances.append(anyof_instance)
1809        except Exception:
1810            pass
1811    if len(anyof_instances) == 0:
1812        raise PineconeApiValueError(
1813            "Invalid inputs given to generate an instance of %s. None of the "
1814            "anyOf schemas matched the inputs." % self.__class__.__name__
1815        )
1816    return anyof_instances
1817
1818
1819def get_discarded_args(self, composed_instances, model_args):
1820    """
1821    Gathers the args that were discarded by configuration.discard_unknown_keys
1822    """
1823    model_arg_keys = model_args.keys()
1824    discarded_args = set()
1825    # arguments passed to self were already converted to python names
1826    # before __init__ was called
1827    for instance in composed_instances:
1828        if instance.__class__ in self._composed_schemas["allOf"]:
1829            try:
1830                keys = instance.to_dict().keys()
1831                discarded_keys = model_args - keys
1832                discarded_args.update(discarded_keys)
1833            except Exception:
1834                # allOf integer schema will throw exception
1835                pass
1836        else:
1837            try:
1838                all_keys = set(model_to_dict(instance, serialize=False).keys())
1839                js_keys = model_to_dict(instance, serialize=True).keys()
1840                all_keys.update(js_keys)
1841                discarded_keys = model_arg_keys - all_keys
1842                discarded_args.update(discarded_keys)
1843            except Exception:
1844                # allOf integer schema will throw exception
1845                pass
1846    return discarded_args
1847
1848
1849def validate_get_composed_info(constant_args, model_args, self):
1850    """
1851    For composed schemas, generate schema instances for
1852    all schemas in the oneOf/anyOf/allOf definition. If additional
1853    properties are allowed, also assign those properties on
1854    all matched schemas that contain additionalProperties.
1855    Openapi schemas are python classes.
1856
1857    Exceptions are raised if:
1858    - 0 or > 1 oneOf schema matches the model_args input data
1859    - no anyOf schema matches the model_args input data
1860    - any of the allOf schemas do not match the model_args input data
1861
1862    Args:
1863        constant_args (dict): these are the args that every model requires
1864        model_args (dict): these are the required and optional spec args that
1865            were passed in to make this model
1866        self (class): the class that we are instantiating
1867            This class contains self._composed_schemas
1868
1869    Returns:
1870        composed_info (list): length three
1871            composed_instances (list): the composed instances which are not
1872                self
1873            var_name_to_model_instances (dict): a dict going from var_name
1874                to the model_instance which holds that var_name
1875                the model_instance may be self or an instance of one of the
1876                classes in self.composed_instances()
1877            additional_properties_model_instances (list): a list of the
1878                model instances which have the property
1879                additional_properties_type. This list can include self
1880    """
1881    # create composed_instances
1882    composed_instances = []
1883    allof_instances = get_allof_instances(self, model_args, constant_args)
1884    composed_instances.extend(allof_instances)
1885    oneof_instance = get_oneof_instance(self.__class__, model_args, constant_args)
1886    if oneof_instance is not None:
1887        composed_instances.append(oneof_instance)
1888    anyof_instances = get_anyof_instances(self, model_args, constant_args)
1889    composed_instances.extend(anyof_instances)
1890    """
1891    set additional_properties_model_instances
1892    additional properties must be evaluated at the schema level
1893    so self's additional properties are most important
1894    If self is a composed schema with:
1895    - no properties defined in self
1896    - additionalProperties: False
1897    Then for object payloads every property is an additional property
1898    and they are not allowed, so only empty dict is allowed
1899
1900    Properties must be set on all matching schemas
1901    so when a property is assigned toa composed instance, it must be set on all
1902    composed instances regardless of additionalProperties presence
1903    keeping it to prevent breaking changes in v5.0.1
1904    TODO remove cls._additional_properties_model_instances in 6.0.0
1905    """
1906    additional_properties_model_instances = []
1907    if self.additional_properties_type is not None:
1908        additional_properties_model_instances = [self]
1909
1910    """
1911    no need to set properties on self in here, they will be set in __init__
1912    By here all composed schema oneOf/anyOf/allOf instances have their properties set using
1913    model_args
1914    """
1915    discarded_args = get_discarded_args(self, composed_instances, model_args)
1916
1917    # map variable names to composed_instances
1918    var_name_to_model_instances = {}
1919    for prop_name in model_args:
1920        if prop_name not in discarded_args:
1921            var_name_to_model_instances[prop_name] = [self] + composed_instances
1922
1923    return [
1924        composed_instances,
1925        var_name_to_model_instances,
1926        additional_properties_model_instances,
1927        discarded_args,
1928    ]