Get Verification Count.  Uses HEAD to /verifications interface.

        :Returns: (int) Number of verifications
482577
def verification_count(self):
        
        response = self._head(url.verifications)
        self._check_response(response, 200)
        return int(response.headers.get('x-verification-count', -1))
120420
def tracked_coordinator_count(self, count_ascps=False):
        '''  '''
        with self._lock:
            _count = 0
            if count_ascps:
                for _coordinator in self._tracked_transfer_coordinators:
                    _count += _coordinator.session_count
            else:
                _count = len(self._tracked_transfer_coordinators)
            return _count
780522
def get_copies_count(self):
        
        setup = api.get_setup()
        default_num = setup.getDefaultNumberOfCopies()
        request_num = self.request.form.get("copies_count")
        return to_int(request_num, default_num)
458209
def count_peaks(ts):
    

    on_toggles = ts.diff() > 3000
    shifted = np.logical_not(on_toggles.shift(1))
    result = on_toggles & shifted
    count = result.sum()
    return count
657099
def cmd_status_codes_counter(self):
        
        status_codes = defaultdict(int)
        for line in self._valid_lines:
            status_codes[line.status_code] += 1
        return status_codes
615114
def count_remaining
      count = @executables_inputs.values.map { |a| a.values.count { |p| not p.is_a?(RightScale::SecureDocument) } }
      return count.inject { |sum,x| sum + x } || 0
    end
673255
def device_count(self):
        
        device_count = get_device_count(self.corsair_sdk)
        if device_count == -1:
            self._raise_corsair_error()
        return device_count
252647
def success_count(self):
        
        return len([i for i, result in enumerate(self.data) if result.success])
1188706
def count(self):
        '''
        
        '''
        args = self.format_args
        if args is None or \
                (isinstance(args, dict) and self.count_field not in args):
            raise TypeError("count is required")
        return args[self.count_field] if isinstance(args, dict) else args
1066328
def hasInfo(self):
        
        count = len([None
                     for (fromUUID, size)
                     in Diff.theKnownSizes[self.uuid].iteritems()
                     if size is not None and fromUUID is not None
                     ])
        return count > 0
1094415
def get_release_count(self, package_name: str) -> int:
        
        validate_package_name(package_name)
        self._validate_set_registry()
        return self.registry._num_release_ids(package_name)
1052051
def verification_list(self, limit=10):
        

        # TODO add arguments for paging and stuff
        params = {}
        params["limit"] = limit

        response = self._get(url.verifications, params=params)
        self._check_response(response, 200)
        return self._create_response(response).get("verifications")
419874
def count(self):
        
        result = 0
        bits = self._bits
        while bits:
            result += bits % 2
            bits >>= 1
        return result
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'])
90012
def get_count(self):
        
        params = self.get_params()
        params["offset"] = self.low_mark
        params["limit"] = 1

        r = self.resource._meta.api.http_resource("GET", self.resource._meta.resource_name, params=params)
        data = self.resource._meta.api.resource_deserialize(r.text)

        number = data["meta"]["total_count"]

        # Apply offset and limit constraints manually, since using limit/offset
        # in the API doesn't change the total_count output.
        number = max(0, number - self.low_mark)
        if self.high_mark is not None:
            number = min(number, self.high_mark - self.low_mark)

        return number
454311
def is_verified(self):
        
        resource_list = self.traffic_incident()
        verified = namedtuple('verified', 'verified')
        if len(resource_list) == 1 and resource_list[0] is None:
            return None
        else:
            try:
                return [verified(resource['verified'])
                        for resource in resource_list]
            except (KeyError, TypeError):
                return [verified(resource['Verified'])
                        for resource in resource_list]
237135
def get_count(self, prefix=''):
        """"""
        return sum([self.counters[key]
                    for key in self.messages if key.startswith(prefix)])