Filter the counted records.

        Returns: List with record numbers.
511750
def filter_counter(self, counter, min=2, max=100000000):
        
        records_filterd = {}
        counter_all_records = 0
        for item in counter:
            counter_all_records += 1
            if max > counter[item] >= min:
                records_filterd[item] = counter[item]

        self.stat['user_record_events'] = counter_all_records
        self.stat['records_filtered'] = len(records_filterd)
        return records_filterd
527902
def count(self, with_limit_and_skip=False):
        ''' 
        '''
        return self.__get_query_result().cursor.count(with_limit_and_skip=with_limit_and_skip)
276216
def search(self, filters):
        
        records = self.__model__.search(self.__five9__, filters)
        return self.__class__(
            self.__five9__, self.__model__, records,
        )
1280556
def records(self):
        """"""
        compounds = ModelList()
        seen_labels = set()
        # Ensure no control characters are sent to a parser (need to be XML compatible)
        tagged_tokens = [(CONTROL_RE.sub('', token), tag) for token, tag in self.tagged_tokens]
        for parser in self.parsers:
            for record in parser.parse(tagged_tokens):
                p = record.serialize()
                if not p:  # TODO: Potential performance issues?
                    continue
                # Skip duplicate records
                if record in compounds:
                    continue
                # Skip just labels that have already been seen (bit of a hack)
                if all(k in {'labels', 'roles'} for k in p.keys()) and set(record.labels).issubset(seen_labels):
                    continue
                seen_labels.update(record.labels)
                compounds.append(record)
        return compounds
1175147
def records(self):
		''''''
		if self._records == None:
			self._records = self._get_records()
		return self._records
194005
def filter(self, record):
        
        if self._exists:
            return int(getattr(record, 'correlation_id', None) is not None)
        return int(getattr(record, 'correlation_id', None) is None)
1126345
def _list_records(self, rtype=None, name=None, content=None):
        
        opts = {'domain': self._domain}
        if rtype is not None:
            opts['type'] = rtype.upper()
        if name is not None:
            opts['name'] = self._full_name(name)
        if content is not None:
            opts['content'] = content
        opts.update(self._auth)

        response = self._api.nameserver.info(opts)
        self._validate_response(
            response=response, message='Failed to get records')

        records = []
        if 'record' in response['resData']:
            for record in response['resData']['record']:
                processed_record = {
                    'type': record['type'],
                    'name': record['name'],
                    'ttl': record['ttl'],
                    'content': record['content'],
                    'id': record['id']
                }
                records.append(processed_record)

        return records
89426
def records(self, data=None):
        
        if data:
            return self._session.post(
                self.__v1() + "/records", data=data).json()
        else:
            return self._session.get(self.__v1() + "/records").json()
40045
def term_counts(self):

        

        counts = OrderedDict()
        for term in self.terms:
            counts[term] = len(self.terms[term])

        return utils.sort_dict(counts)
552661
def collectRecords(self, parent=None):
        
        out = []
        if not parent:
            for i in range(self.topLevelItemCount()):
                item = self.topLevelItem(i)
                try:
                    out.append(item.record())
                except AttributeError:
                    pass
                
                out += self.collectRecords(item)
        else:
            for c in range(parent.childCount()):
                item = parent.child(c)
                try:
                    out.append(item.record())
                except AttributeERror:
                    pass
                
                out += self.collectRecords(item)
        
        return out
769020
def records(self):
        
        records = self._records
        next_record = records.popleft
        while records:
            yield next_record()
        attached = self.attached
        if attached():
            self._session.send()
        while attached():
            self._session.fetch()
            while records:
                yield next_record()
735749
def filter_record(self, record):
        
        nloc = record.seq.find('N')
        if nloc == -1:
            return record
        elif self.action == 'truncate':
            return record[:nloc]
        elif self.action == 'drop':
            raise FailedFilter()
        else:
            assert False
129389
def list_records(self, limit=None, offset=None):
        
        return self.manager.list_records(self, limit=limit, offset=offset)
197455
def checkedRecords(self, column=0, parent=None, recurse=True):
        
        output = []
        for item in self.checkedItems(column, parent, recurse):
            try:
                record = item.record()
                if record is not None:
                    output.append(record)
            except AttributeError:
                continue
        return output
1240889
def records(self):
        
        import ns1.rest.records
        return ns1.rest.records.Records(self.config)
36058
def getFilteredRecords( dbid, fieldNames, query = nil, qid = nil, qname = nil, clist = nil, slist = nil, fmt = "structured", options = nil )
      filteredRecords = []
      iterateFilteredRecords(dbid, fieldNames, query, qid, qname, clist, slist, fmt, options){ |filteredRecord| 
         filteredRecords << filteredRecord 
      }
      filteredRecords
   end
789033
def count(self, cls, filters, quick=True, sort_by=None, select=None):
        
        query = "select count(*) from `%s` %s" % (self.domain.name, self._build_filter_part(cls, filters, sort_by, select))
        count = 0
        for row in self.domain.select(query):
            count += int(row['Count'])
            if quick:
                return count
        return count