Get expected update frequency (in textual rather than numeric form)

        Returns:
            Optional[str]: Update frequency in textual form or None if the update frequency doesn't exist or is blank.
541972
def get_expected_update_frequency(self):
        # type: () -> Optional[str]
        
        days = self.data.get('data_update_frequency', None)
        if days:
            return Dataset.transform_update_frequency(days)
        else:
            return None
925121
function parseUpdateInfo (node, nodeType, feedType) {
  var updateInfo = {}, temp;

  if (temp = utils.get(node['sy:updatefrequency'])) {
    updateInfo.frequency = temp;
  }
  if (temp = utils.get(node['sy:updateperiod'])) {
    updateInfo.period = temp;
  }
  if (temp = utils.get(node['sy:updatebase'])) {
    updateInfo.base = temp;
  }
  if (temp = utils.get(node.ttl)) {
    updateInfo.ttl = temp;
  }

  return Object.keys(updateInfo).length ? updateInfo : null;
}
1236783
def calculate_perf_counter_bulk_count(previous, current, property_name):
    
    n0 = previous[property_name]
    n1 = current[property_name]
    d0 = previous["Timestamp_Sys100NS"]
    d1 = current["Timestamp_Sys100NS"]
    f = current["Frequency_Sys100NS"]

    if n0 is None or n1 is None:
        return

    return (n1 - n0) / ((d1 - d0) / f)
844398
def get_info_content(go_id, termcounts):
    '''
        
    '''
    # Get the observed frequency of the GO term
    freq = termcounts.get_term_freq(go_id)

    # Calculate the information content (i.e., -log("freq of GO term")
    return -1.0 * math.log(freq) if freq else 0
707142
def _relative_frequency(self, word):
		""""""

		count = self.type_counts.get(word, 0)
		return math.log(count/len(self.type_counts)) if count > 0 else 0
1082340
def most_frequent(lst):
    
    lst = lst[:]
    highest_freq = 0
    most_freq = None

    for val in unique(lst):
        if lst.count(val) > highest_freq:
            most_freq = val
            highest_freq = lst.count(val)
            
    return most_freq
1357559
def updated(self):
        ''
        return dateutil.parser.parse(str(self.f.currentRevision.updated))
1058674
def frequencies_iter(self):
        
        df = self.to_dataframe()
        n = float(len(self))
        for var, sign in it.product(df.columns, [-1, 1]):
            f = len(df[df[var] == sign]) / n
            if f > 0:
                yield Literal(var, sign), f
74162
def _validate_freq(self):
        
        from pandas.tseries.frequencies import to_offset
        try:
            return to_offset(self.window)
        except (TypeError, ValueError):
            raise ValueError("passed window {0} is not "
                             "compatible with a datetimelike "
                             "index".format(self.window))
700254
def ind_zero_freq(self):
        
        ind = np.searchsorted(self.frequencies, 0)
        if ind >= len(self.frequencies):
            raise ValueError("No positive frequencies found")
        return ind
1029310
def getUpdaters(self):
        '''
        
        '''
        how_many_update = int(round(self.UpdatePrb*self.AgentCount))
        base_bool = np.zeros(self.AgentCount,dtype=bool)
        base_bool[0:how_many_update] = True
        self.update = self.RNG.permutation(base_bool)
        self.dont = np.logical_not(self.update)
1082887
def inverse_document_frequency(term)
      df = @model.document_count(term)
      log((documents.size - df + 0.5) / (df + 0.5))
    end
412217
def estimate_frequency_for_one(self, sample_rate: float, nbits=42) -> float:
        
        return self.__estimate_frequency_for_bit(True, sample_rate, nbits)
219990
def time_between_updates(self):
        """"""
        if 'last_updated' not in self._original:
            return 0
        last_update = self._original['last_updated']
        this_update = self.last_updated
        return this_update - last_update
451668
def freq_from_iterators(cls, iterators):
        
        return {
            set(it): f for f, it in cls.FREQUENCIES.items()}[set(iterators)]
1021500
def increase_frequency(self, frequency=None):
        
        if frequency is None:
            javabridge.call(self.jobject, "increaseFrequency", "()V")
        else:
            javabridge.call(self.jobject, "increaseFrequency", "(I)V", frequency)
108731
def update(self, pbar):
        ''

        if pbar.currval == 0:
            return 'ETA:  --:--:--'
        elif pbar.finished:
            return 'Time: %s' % self.format_time(pbar.seconds_elapsed)
        else:
            elapsed = pbar.seconds_elapsed
            eta = elapsed * pbar.maxval / pbar.currval - elapsed
            return 'ETA:  %s' % self.format_time(eta)