Returns the count of Contentful entries.
548569
public function getContentfulEntriesCount(?Client $client = null, ?Query $query = null): int
    {
        $client = $client ?? $this->defaultClient;

        return count($client->getEntries($query));
    }
293746
def objectcount(data, key):
    """"""
    objkey = key.upper()
    return len(data.dt[objkey])
527902
def count(self, with_limit_and_skip=False):
        ''' 
        '''
        return self.__get_query_result().cursor.count(with_limit_and_skip=with_limit_and_skip)
280316
public long calcEntryCount() {
    long _count = 0;
    for (Entry e : entries) {
      while (e != null) {
        _count++;
        e = e.another;
      }
    }
    return _count;
  }
114468
def column_count(self, ):
        
        if self.child_count():
            return self.childItems[0]._data.column_count()
        else:
            return self._data.column_count() if self._data else 0
1220117
public int getCount (K key)
    {
        CountEntry<K> entry = _backing.get(key);
        return (entry == null) ? 0 : entry.count;
    }
1310497
def entry_stats(entries, top_n=10):
    """"""

    wc = Counter()  # A Word counter
    for content in entries.values_list("rendered_content", flat=True):
        # Do a little cleanup
        content = strip_tags(content)  # remove all html tags
        content = re.sub('\s+', ' ', content)  # condense all whitespace
        content = re.sub('[^A-Za-z ]+', '', content)  # remove non-alpha chars

        words = [w.lower() for w in content.split()]
        wc.update([w for w in words if w not in IGNORE_WORDS])

    return {
        "total_words": len(wc.values()),
        "most_common": wc.most_common(top_n),
    }
193454
public function countAllContents($contentVisibility = true)
    {
        $children = FolderQuery::findAllChild($this->getId());
        array_push($children, $this);


        $query = ContentQuery::create()->filterByFolder(new ObjectCollection($children), Criteria::IN);

        if ($contentVisibility !== '*') {
            $query->filterByVisible($contentVisibility);
        }

        return $query->count();
    }
1073787
public function count_entries() {
        global $DB;
        if ($this->totalentries === null) {
            if ($sqlarray = $this->get_entry_fetch_sql(true)) {
                $this->totalentries = $DB->count_records_sql($sqlarray['sql'], $sqlarray['params']);
            } else {
                $this->totalentries = 0;
            }
        }
        return $this->totalentries;
    }
1266688
def count(self, q='*:*', fq=None):
        """"""
        params = {'q': q, 'rows': '0'}
        if fq is not None:
            params['fq'] = fq
        res = self.search(params)
        hits = res['response']['numFound']
        return hits
1070603
function countNumMatches(contents, queryExpr) {
    if (!contents) {
        return 0;
    }
    var matches = contents.match(queryExpr);
    return matches ? matches.length : 0;
}
1065329
def column_count(index = Celerity.index_offset)
      assert_exists
      @object.getRow(index - Celerity.index_offset).getCells.length
    end
916958
def entries(self):
        
        entries_list = self._timesheets_callback('entries')()

        return reduce(lambda x, y: x + y, entries_list)
238082
def count_partitions(self, topic):
        """"""
        return sum(1 for p in topic.partitions if p in self.partitions)
1143481
def count(self, elem):
        
        return self._left_list.count(elem) + self._right_list.count(elem)
875266
def count(self):
        
        self.request_params.update({'sysparm_count': True})
        response = self.session.get(self._get_stats_url(),
                                    params=self._get_formatted_query(fields=list(),
                                                                     limit=None,
                                                                     order_by=list(),
                                                                     offset=None))

        content = self._get_content(response)

        return int(content['stats']['count'])
356197
def count_of_certain_kind(kind):
        '''
        
        '''

        recs = TabPost.select().where(TabPost.kind == kind)

        return recs.count()