Retrieve all the new request that were found in this request.

        Returns:
            list(:class:`nyawc.http.Request`): A list of request objects.
764660
def get_new_requests(self):
        

        content_type = self.__queue_item.response.headers.get('content-type')
        scrapers = self.__get_all_scrapers()
        new_requests = []

        for scraper in scrapers:
            instance = scraper(self.__options, self.__queue_item)
            if self.__content_type_matches(content_type, instance.content_types):
                new_requests.extend(instance.get_requests())

        return new_requests
652518
def _list(self, uri, obj_class=None, list_all=False):
        
        resp, resp_body = self._retry_get(uri)
        if obj_class is None:
            obj_class = self.resource_class

        data = resp_body[self.plural_response_key]
        ret = [obj_class(self, res, loaded=False)
                for res in data if res]
        self._reset_paging("domain", resp_body)
        if list_all:
            dom_paging = self._paging.get("domain", {})
            while dom_paging.get("next_uri"):
                next_uri = dom_paging.get("next_uri")
                ret.extend(self._list(uri=next_uri, obj_class=obj_class,
                        list_all=False))
        return ret
675914
def ListClients(self, request, timeout=None):
    
    return self._RetryLoop(
        lambda t: self._stub.ListClients(request, timeout=t))
676098
def flows(self):
        
        if self._flows is None:
            self._flows = FlowList(self)
        return self._flows
443324
def get_items(self):
        
        url = self.build_url(self._endpoints.get('get_items'))

        response = self.con.get(url)

        if not response:
            return []

        data = response.json()

        return [self.list_item_constructor(parent=self,
                                           **{self._cloud_data_key: item})
                for item in data.get('value', [])]
984736
def paginate(self, request, collection):
        
        p = Paginator(request, self, collection)
        return p.paginator and p or UpdatedList(collection)
420673
def all(self, query=None):
        

        if query is None:
            query = {}
        return self.client._get(
            self._url(),
            query
        )
307482
def get_requests(self):
        
        safe = self.get_safe_struct()

        self.download_list = []
        self.structure_recursion(safe, self.parent_folder)
        self.sort_download_list()
        return self.download_list, self.folder_list
298339
def get_list_subtasks(self, list_id, completed=False):
        '''  '''
        return subtasks_endpoint.get_list_subtasks(self, list_id, completed=completed)
667461
def all(self):
        

        response = self._get_json(HTTPMethods.GET, self.saved_query_url, self._get_master_key())

        return response
262843
def get_list(client, list_id):
    '''  '''
    endpoint = '/'.join([client.api.Endpoints.LISTS, str(list_id)])
    response = client.authenticated_request(endpoint)
    return response.json()
52266
def all(self, instance):
        
        url = self._url.format(instance=instance)
        response = requests.get(url, **self._default_request_kwargs)
        data = self._get_response_data(response)
        return self._concrete_acl_list(data)
842376
def get_activities(self):
        
        if self.retrieved:
            raise errors.IllegalState('List has already been retrieved.')
        self.retrieved = True
        return objects.ActivityList(self._results, runtime=self._runtime)
899074
def derived_get_requests(self):
        

        host = self.queue_item.response.url
        content = self.queue_item.response.text

        found_requests = []

        for expression in self.__expressions:
            matches = re.findall(expression["raw"], content)

            for match in matches:
                found_url = match[expression["group"]]
                absolute_url = URLHelper.make_absolute(host, found_url)
                found_requests.append(Request(absolute_url))

        return found_requests
323538
def read_list(self, request):
        
        request_filters = request.context_params.get(
            self.request_filters_property, {})
        request_filters.update(**self.get_limit_and_offset(request_filters))
        entities = self.get_entity_list(request, **request_filters)
        request.context_params[self.list_property_name] = entities

        # offset and limit don't make sense to get aggregates
        count_request_filters = request_filters.copy()
        count_request_filters.pop('offset', None)
        count_request_filters.pop('limit', None)
        count_request_filters.pop('order_by', None)
        total_count = self.get_entity_list_total_count(request,
                                                       **count_request_filters)

        request.context_params[self.entity_list_total_count_property_name] = \
            total_count
        return request
833513
def populate_items(self, request):
        ''''''
        self._items = self.get_items(request)
        return self.items
99753
def all(self, **args):
        
        limit = args['limit'] if 'limit' in args else 20
        offset = args['offset'] if 'offset' in args else 0

        r = requests.get(
            "https://kippt.com/api/lists?limit=%s&offset=%s" % (limit, offset),
            headers=self.kippt.header
        )
        return (r.json())