code: def _build_params_from_kwargs(self, **kwargs):
          
          api_methods = self.get_api_params()
          required_methods = self.get_api_required_params()
          ret_kwargs = {}
          for key, val in kwargs.items():
              if key not in api_methods:
                  warnings.warn(
                      'Passed uknown parameter [{}]'.format(key),
                      Warning
                  )
                  continue
              if key not in required_methods and val is None:
                  continue
              if type(val) != api_methods[key]['type']:
                  raise ValueError(
                      "Invalid type specified to param: {}".format(key)
                  )
              if 'max_len' in api_methods[key]:
                  if len(val) > api_methods[key]['max_len']:
                      raise ValueError(
                          "Lenght of parameter [{}] more than "
                          "allowed length".format(key)
                      )
              ret_kwargs[api_methods[key]['param']] = val
  
          for item in required_methods:
              if item not in ret_kwargs:
                  raise pushalot.exc.PushalotException(
                      "Parameter [{}] required, but not set".format(item)
                  )
  
          return ret_kwargs
docs: Builds parameters from passed arguments
  
          Search passed parameters in available methods,
          prepend specified API key, and return dictionary
          which can be sent directly to API server.
  
  
          :param kwargs:
          :type param: dict
          :raises ValueError: If type of specified parameter doesn't match
                              the expected type. Also raised if some basic
                              validation of passed parameter fails.
          :raises PushalotException: If required parameter not set.
          :return: Dictionary with params which can be
                   sent to API server
          :rtype: dict