code: def call(self, op_name, query=None, **kwargs):
          
          LOG.debug(kwargs)
          if query:
              query = jmespath.compile(query)
          if self._client.can_paginate(op_name):
              paginator = self._client.get_paginator(op_name)
              results = paginator.paginate(**kwargs)
              data = results.build_full_result()
          else:
              op = getattr(self._client, op_name)
              done = False
              data = {}
              while not done:
                  try:
                      data = op(**kwargs)
                      done = True
                  except ClientError as e:
                      LOG.debug(e, kwargs)
                      if 'Throttling' in str(e):
                          time.sleep(1)
                      elif 'AccessDenied' in str(e):
                          done = True
                      elif 'NoSuchTagSet' in str(e):
                          done = True
                  except Exception:
                      done = True
          if query:
              data = query.search(data)
          return data
docs: Make a request to a method in this client.  The response data is
          returned from this call as native Python data structures.
  
          This method differs from just calling the client method directly
          in the following ways:
  
            * It automatically handles the pagination rather than
              relying on a separate pagination method call.
            * You can pass an optional jmespath query and this query
              will be applied to the data returned from the low-level
              call.  This allows you to tailor the returned data to be
              exactly what you want.
  
          :type op_name: str
          :param op_name: The name of the request you wish to make.
  
          :type query: str
          :param query: A jmespath query that will be applied to the
              data returned by the operation prior to returning
              it to the user.
  
          :type kwargs: keyword arguments
          :param kwargs: Additional keyword arguments you want to pass
              to the method when making the request.