https://developer.zendesk.com/rest_api/docs/core/requests#list-requests
495925
def user_requests(self, id, **kwargs):
        ""
        api_path = "/api/v2/users/{id}/requests.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, **kwargs)
299942
def list(self, list_id):
        

        r = requests.get(
            "https://kippt.com/api/users/%s/lists/%s" % (self.id, list_id),
            headers=self.kippt.header
        )
        return (r.json())
643732
def get_requests(self):
        

        requests = self.derived_get_requests()

        for request in requests:
            request.url = URLHelper.remove_hash(request.url)

        return requests
966418
def organization_requests(self, id, **kwargs):
        ""
        api_path = "/api/v2/organizations/{id}/requests.json"
        api_path = api_path.format(id=id)
        return self.call(api_path, **kwargs)
75182
def list(self):
        

        # We have to open this queue before we make the request, to ensure we don't miss the response.
        queue = self._pebble.get_endpoint_queue(DataLogging)

        self._pebble.send_packet(DataLogging(data=DataLoggingReportOpenSessions(sessions=[])))

        sessions = []
        while True:
            try:
                result = queue.get(timeout=2).data
            except TimeoutError:
                break
            if isinstance(result, DataLoggingDespoolOpenSession):
                self._pebble.send_packet(DataLogging(data=DataLoggingACK(
                                                     session_id=result.session_id)))
                sessions.append(result.__dict__)

        queue.close()
        return sessions
200847
def list_endpoints(app_id, custom_headers:nil)
      response = list_endpoints_async(app_id, custom_headers:custom_headers).value!
      response.body unless response.nil?
    end
552061
def list_user_requests_view(request, targetUsername):
    '''
    
    '''
    if targetUsername == request.user.username:
        return list_my_requests_view(request)

    targetUser = get_object_or_404(User, username=targetUsername)
    targetProfile = get_object_or_404(UserProfile, user=targetUser)
    page_name = "{0}'s Requests".format(targetUsername)
    requests = Request.objects.filter(owner=targetProfile).exclude(
        ~Q(owner__user=request.user), private=True,
        )
    return render_to_response('list_requests.html', {
        'page_name': page_name,
        'requests': requests,
        'targetUsername': targetUsername,
        }, context_instance=RequestContext(request))
1007751
def get_list(
        self,
        search='',
        start=0,
        limit=0,
        order_by='',
        order_by_dir='ASC',
        published_only=False,
        minimal=False
    ):
        

        parameters = {}
        args = ['search', 'start', 'limit', 'minimal']
        for arg in args:
            if arg in locals() and locals()[arg]:
                parameters[arg] = locals()[arg]
        if order_by:
            parameters['orderBy'] = order_by
        if order_by_dir:
            parameters['orderByDir'] = order_by_dir
        if published_only:
            parameters['publishedOnly'] = 'true'
        response = self._client.session.get(
            self.endpoint_url, params=parameters
        )
        return self.process_response(response)
334557
def make_inaturalist_api_get_call(endpoint: str, params: Dict, **kwargs) -> requests.Response:
    
    headers = {'Accept': 'application/json'}

    response = requests.get(urljoin(INAT_NODE_API_BASE_URL, endpoint), params, headers=headers, **kwargs)
    return response
768709
def group_list(self, params=None):
        ''' 
        '''
        params = params if params else dict()
        return self.request('/v1/firewall/group_list', params, 'GET')
269088
function list (req, res, next) {
    // Resource chain
    var chain = db.get(name)

    // Remove q, _start, _end, ... from req.query to avoid filtering using those
    // parameters
    var _q = req.query._q
    var _offset = req.query._offset
    var _end = req.query._end
    var _page = req.query._page
    var _sort = req.query._sort
    var _limit = req.query._limit
    var _embed = req.query._embed
    var _expand = req.query._expand
    var _fields = req.query._fields
    var _filter = req.query._filter
    delete req.query._q
    delete req.query._offset
    delete req.query._end
    delete req.query._sort
    delete req.query._limit
    delete req.query._embed
    delete req.query._expand
    delete req.query._fields

    // Automatically delete query parameters that can't be found
    // in the database
    Object.keys(req.query).forEach(function (query) {
      var arr = db.get(name).value()
      for (var i in arr) {
        if (
          _.has(arr[i], query) ||
          query === 'callback' ||
          query === '_' ||
          query.indexOf('_lte') !== -1 ||
          query.indexOf('_gte') !== -1 ||
          query.indexOf('_ne') !== -1 ||
          query.indexOf('_like') !== -1
        ) return
      }
      delete req.query[query]
    })

    if (_q) {
      // Full-text search
      _q = _q.toLowerCase()

      chain = chain.filter(function (obj) {
        for (var key in obj) {
          var value = obj[key]
          if (db._.deepQuery(value, _q)) {
            return true
          }
        }
      })
    }

    var filterMapping = {}

    if (_filter) {
      var filters = _filter.split(',')
      filters.forEach(function (filter) {
        var filterParts = filter.split(operatorsRegex)
        if (filterParts.length !== 3) {
          return
        }
        var key = filterParts[0]
        var op = filterParts[1]
        var value = filterParts[2]

        if (!filterMapping[key + op]) {
          filterMapping[key + op] = {value: []}
        }

        filterMapping[key + op].value.push(value)
        filterMapping[key + op].op = op
      })
    }

    Object.keys(filterMapping).forEach(function (key) {
      var values = filterMapping[key].value

      chain = chain.filter(function (element) {
        return values
            .map(utils.toNative)
            .map(function (value) {
              var op = filterMapping[key].op
              var isDifferent = key.indexOf('!=') !== -1 // op === '!='
              var isRange = key.indexOf('<') !== -1 || key.indexOf('>') !== -1 || key.indexOf('<=') !== -1 || key.indexOf('>=') !== -1 //     op === '<' || op === '>' || op === '<=' || op === '>='
              var isLike = key.indexOf('~') !== -1 || key.indexOf('~=') !== -1 || key.indexOf('=~') !== -1  // op === '~' || op === "~=" || op === '=~'
              var isIn = key.indexOf('|=') !== -1
              var path = key.replace(operatorsRegex, '')
              var elementValue = _.get(element, path)

              if (isRange) {
                switch (op) {
                  case '<':
                    return elementValue < value
                  case '>':
                    return elementValue > value
                  case '<=':
                    return elementValue <= value
                  case '>=':
                    return elementValue >= value
                  default:
                    return false
                }
              } else if (isDifferent) {
                return value !== elementValue
              } else if (isLike) {
                return new RegExp(value, 'i').test(elementValue)
              } else if (isIn) {
                var inValues = value.toString().split('|')
                inValues = _.map(inValues, function (val) {
                  return utils.toNative(val)
                })
                if (Array.isArray(elementValue)) {
                  return _.intersection(elementValue, inValues).length > 0
                } else {
                  return _.includes(inValues, elementValue)
                }
              } else {
                return _.matchesProperty(path, value)(element)
              }
            }).reduce(function (a, b) {
              return a || b
            })
      })
    })

    // Sort
    if (_sort) {
      var sortsParams = _sort.split(',')

      var sortMapping = {}
      sortsParams.forEach(function (sortParam) {
        var order = sortParam[0] === '-' ? 'desc' : 'asc'
        var sortField = sortParam.substring(1)
        sortMapping[sortField] = order
      })

      chain = chain.orderBy(_.keys(sortMapping), _.values(sortMapping)) // TODO iteration order is not guaranteed
    }

    // Slice result
    if (_end || _limit || _page) {
      res.setHeader('X-Total-Count', chain.size())
      res.setHeader('Access-Control-Expose-Headers', 'X-Total-Count')
    }

    if (_page) {
      _page = parseInt(_page, 10)
      _page = _page >= 1 ? _page : 1
      _limit = parseInt(_limit, 10) || 10
      var page = utils.getPage(chain.value(), _page, _limit)
      var links = {}
      var fullURL = getFullURL(req)

      if (page.first) {
        links.first = fullURL.replace('page=' + page.current, 'page=' + page.first)
      }

      if (page.prev) {
        links.prev = fullURL.replace('page=' + page.current, 'page=' + page.prev)
      }

      if (page.next) {
        links.next = fullURL.replace('page=' + page.current, 'page=' + page.next)
      }

      if (page.last) {
        links.last = fullURL.replace('page=' + page.current, 'page=' + page.last)
      }

      res.links(links)
      chain = _.chain(page.items)
    } else if (_end) {
      _offset = parseInt(_offset, 10) || 0
      _end = parseInt(_end, 10)
      chain = chain.slice(_offset, _end)
    } else if (_limit) {
      _offset = parseInt(_offset, 10) || 0
      _limit = parseInt(_limit, 10)
      chain = chain.slice(_offset, _offset + _limit)
    }

    if (_fields) {
      chain = chain.map(function (element) {
        return _.pick(element, _fields.split(','))
      })
    }
    // embed and expand
    chain = chain
      .cloneDeep()
      .forEach(function (element) {
        embed(element, _embed)
        expand(element, _expand)
      })

    res.locals.data = chain.value()
    next()
  }
940524
def do_list_port(self, line):
        

        def f(p, args):
            o = p.get()
            for p in o.resources.port:
                print('%s %s %s' % (p.resource_id, p.name, p.number))

        self._request(line, f)
317320
def file_list_projects(object_id, input_params={}, always_retry=True, **kwargs):
    
    return DXHTTPRequest('/%s/listProjects' % object_id, input_params, always_retry=always_retry, **kwargs)
935697
def list(self, id=None):
        
        args = {'id': id}
        self._job_chk.check(args)
        return self._client.json('job.list', args)
296913
def project_list(self, limit=None):
        
        params = {}
        if limit:
            params['limit'] = limit
        return (self.get('rest/api/1.0/projects', params=params) or {}).get('values')
314215
def list(self, verbose=False):
        

        response=api(url=self.__url+"/list", method="POST", verbose=verbose)
        return response
462922
def list(offset = 0, limit = 100, unread_only = true)
      api.get('', offset: offset, limit: limit, unreadOnly: unread_only)
    end