docs: def deserialize(cls, value, trusted=False, strict=False,                   #pylint: disable=too-many-locals
                      assert_valid=False, **kwargs):
          """Creates **HasProperties** instance from serialized dictionary
  
          This uses the Property deserializers to deserialize all
          JSON-compatible dictionary values into their corresponding Property
          values on a new instance of a **HasProperties** class. Extra keys
          in the dictionary that do not correspond to Properties will be
          ignored.
  
          **Parameters**:
  
          * **value** - Dictionary to deserialize new instance from.
          * **trusted** - If True (and if the input dictionary has
            :code:`'__class__'` keyword and this class is in the registry), the
            new **HasProperties** class will come from the dictionary.
            If False (the default), only the **HasProperties** class this
            method is called on will be constructed.
          * **strict** - Requires :code:`'__class__'`, if present on the input
            dictionary, to match the deserialized instance's class. Also
            disallows unused properties in the input dictionary. Default
            is False.
          * **assert_valid** - Require deserialized instance to be valid.
            Default is False.
          * Any other keyword arguments will be passed through to the Property
            deserializers.
          """
          if not isinstance(value, dict):
              raise ValueError(
                  'HasProperties class {} must deserialize from dictionary, '
                  'not input of type {}'.format(
                      cls.__name__, value.__class__.__name__
                  )
              )
          output_cls = cls._deserialize_class(
              input_cls_name=value.get('__class__'),
              trusted=trusted,
              strict=strict,
          )
          instance = kwargs.pop('_instance', None)
          if instance is not None and not isinstance(instance, output_cls):
              raise ValueError(
                  'Input _instance must be of class {}, not {}'.format(
                      output_cls.__name__, instance.__class__.__name__
                  )
              )
          state, unused = utils.filter_props(output_cls, value, True)
          unused.pop('__class__', None)
          if unused and strict:
              raise ValueError(
                  'Unused properties during deserialization: {}'.format(
                      ', '.join(unused)
                  )
              )
          kwargs.update({'trusted': trusted, 'strict': strict})
          newstate = {}
          for key, val in iteritems(state):
              newstate[key] = output_cls._props[key].deserialize(val, **kwargs)
          mutable, immutable = utils.filter_props(output_cls, newstate, False)
          with handlers.listeners_disabled():
              if instance is None:
                  instance = output_cls(**mutable)
              else:
                  for key, val in iteritems(mutable):
                      setattr(instance, key, val)
          for key, val in iteritems(immutable):
              valid_val = output_cls._props[key].validate(instance, val)
              instance._backend[key] = valid_val
          if assert_valid and not instance.validate():
              raise utils.ValidationError('Deserialized instance is not valid')
          return instance