docs: def make_call(self, func, params, extra_kwargs):
          """This is a helper function that checks the validity of ``params``
          dictionary by matching it with ``allowed_params`` of a ``func``
          attribute, and then performs a call.  Will issue a
          ``wepay.exceptions.WePayWarning`` in case of unrecognized parameter, and
          raise a `WePayError` after making a call, in case if it is in fact
          unrecognized.  If ``batch_mode`` is set to ``True`` instead of making a
          call it will construct a dictionary that is ready to be used in
          :func:`WePay.batch.create` later on, while ``refernce_id`` can also be
          added to it later, as specified by WePay Documentation, see
          :meth:`batch.create<wepay.calls.batch.Batch.create>`
  
          :param func callable: function making the call
          :param dict params: parameters to include in the call
          :param dict extra_kwargs: extra kwargs passed to a call
          :returns: dict -- depending on ``batch_mode`` flag, either WePay response 
              through calling :func:`call` or a dictionary that is ready 
              to be appended to ``calls`` list that is passed to 
              :meth:`batch.create<wepay.calls.batch.Batch.create`>
          :raises: :exception:`wepay.exceptions.WePayError`
  
          """
          if hasattr(func, '__name__'):
              uri = '/%s/%s' % (self.call_name, func.__name__[2:])
          else:
              uri = '/%s' % self.call_name
          control_kwargs = self._update_params(
              params, extra_kwargs, getattr(func, 'control_keywords', None))
          if not self._api.silent:
              unrecognized_params = set(params) - set(func.allowed_params)
              if unrecognized_params:
                  err_msg = (
                      "At least one of the parameters to the api call: '%s' is "
                      "unrecognized. Allowed parameters are: '%s'. Unrecognized "
                      "parameters are: '%s'." % (uri, ', '.join(func.allowed_params), 
                                                 ', '.join(unrecognized_params)))
                  if self._api.production and self._api.silent is None:
                      warnings.warn(err_msg, WePayWarning)
                  else:
                      raise WePayWarning(err_msg)
          
          # in case if param is Decimal
          for name in self.floating:
              if name in params:
                  params[name] = float(params[name])
          if control_kwargs.pop('batch_mode', False):
              call = {
                  'call': uri
              }
              access_token = control_kwargs.get('access_token', None)
              if access_token is not None:
                  call['authorization'] = access_token
              if params:
                  call['parameters'] = params
              if control_kwargs.get('reference_id', None) is not None:
                  call['reference_id'] = control_kwargs['reference_id']
              return call
          return self._api.call(uri, params=params, **control_kwargs)