Return the default frequency.
336597
def default_freq(**indexer):
    """"""
    freq = 'AS-JAN'
    if indexer:
        if 'DJF' in indexer.values():
            freq = 'AS-DEC'
        if 'month' in indexer and sorted(indexer.values()) != indexer.values():
            raise (NotImplementedError)

    return freq
985792
def get_default(self):
        """"""
        length = len(self)
        if length == 0:
            return None
        elif length == 1:
            return self[0]
        else:
            return sorted(self, key=attrgetter('id'))[0]
1297565
def c_drop(self, frequency):
        '''
        
        '''
        try:
            return np.interp(frequency,
                             self._c_drop['frequency'],
                             self._c_drop['capacitance']
            )
        except:
            pass
        return self._c_drop
685491
function getRepeatFrequencies() {
		return array(
			Util::FREQUENCY_DAILY => elgg_echo('events_ui:repeat:daily'),
			Util::FREQUENCY_WEEKDAY => elgg_echo('events_ui:repeat:weekday'),
			Util::FREQUENCY_WEEKDAY_ODD => elgg_echo('events_ui:repeat:dailymwf'),
			Util::FREQUENCY_WEEKDAY_EVEN => elgg_echo('events_ui:repeat:dailytt'),
			Util::FREQUENCY_WEEKLY => elgg_echo('events_ui:repeat:weekly'),
			Util::FREQUENCY_MONTHLY => elgg_echo('events_ui:repeat:monthly'),
			Util::FREQUENCY_YEARLY => elgg_echo('events_ui:repeat:yearly'),
		);
	}
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
1069879
def default(self):
        """"""

        if self._default is None or self._default not in self:
            self._default = list(self.keys())[0] if self else None

        return self._default
68627
def frequencyRedefinition(CellChannelDescription_presence=0):
    """"""
    a = TpPd(pd=0x6)
    b = MessageType(mesType=0x14)  # 00010100
    c = ChannelDescription()
    d = MobileAllocation()
    e = StartingTime()
    packet = a / b / c / d / e
    if CellChannelDescription_presence is 1:
        f = CellChannelDescriptionHdr(ieiCCD=0x62, eightBitCCD=0x0)
        packet = packet / f
    return packet
477473
private static synchronized String getDefaultPattern() {
        ULocale defaultLocale = ULocale.getDefault(Category.FORMAT);
        if (!defaultLocale.equals(cachedDefaultLocale)) {
            cachedDefaultLocale = defaultLocale;
            Calendar cal = Calendar.getInstance(cachedDefaultLocale);

            try {
                // Load the calendar data directly.
                ICUResourceBundle rb = (ICUResourceBundle) UResourceBundle.getBundleInstance(
                        ICUData.ICU_BASE_NAME, cachedDefaultLocale);
                String resourcePath = "calendar/" + cal.getType() + "/DateTimePatterns";
                ICUResourceBundle patternsRb= rb.findWithFallback(resourcePath);

                if (patternsRb == null) {
                    patternsRb = rb.findWithFallback("calendar/gregorian/DateTimePatterns");
                }
                if (patternsRb == null || patternsRb.getSize() < 9) {
                    cachedDefaultPattern = FALLBACKPATTERN;
                } else {
                    int defaultIndex = 8;
                    if (patternsRb.getSize() >= 13) {
                        defaultIndex += (SHORT + 1);
                    }
                    String basePattern = patternsRb.getString(defaultIndex);

                    cachedDefaultPattern = SimpleFormatterImpl.formatRawPattern(
                            basePattern, 2, 2,
                            patternsRb.getString(SHORT), patternsRb.getString(SHORT + 4));
                }
            } catch (MissingResourceException e) {
                cachedDefaultPattern = FALLBACKPATTERN;
            }
        }
        return cachedDefaultPattern;
    }
988645
def default_bg(self) -> Tuple[int, int, int]:
        """"""
        color = self._console_data.back
        return color.r, color.g, color.b
1032747
def defaults(self):
        """"""
        # Set default date span to previous week.
        (start, end) = get_week_window(timezone.now() - relativedelta(days=7))
        return {
            'from_date': start,
            'to_date': end,
            'billable': True,
            'non_billable': False,
            'paid_leave': False,
            'trunc': 'day',
            'projects': [],
        }
1288862
def _clean_frequency(frequency):
    
    if isinstance(frequency, int):
        return frequency
    elif isinstance(frequency, datetime.timedelta):
        return int(frequency.total_seconds())

    raise ValueError('Invalid frequency {!r}'.format(frequency))
451668
def freq_from_iterators(cls, iterators):
        
        return {
            set(it): f for f, it in cls.FREQUENCIES.items()}[set(iterators)]
985676
def default(self, obj):  # pylint: disable=method-hidden
        """"""

        if hasattr(obj, 'strftime'):
            return obj.strftime("%Y-%m-%dT%H:%M:%SZ")
        elif hasattr(obj, 'get_public_dict'):
            return obj.get_public_dict()
        else:
            return json.JSONEncoder.default(self, obj)
1180180
def default(self, value):
        """"""
        if isinstance(value, ObjectId):
            return str(value)
        return super(ElasticJSONSerializer, self).default(value)
436080
def defaults(self):
        """"""
        return dict(
            access_right='open',
            description=self.description,
            license='other-open',
            publication_date=self.release['published_at'][:10],
            related_identifiers=list(self.related_identifiers),
            version=self.version,
            title=self.title,
            upload_type='software',
        )
1255970
def _get_default_grid():
    """"""
    s = """
    time,0A 1A,0A   0B,0A   1B,0A
    0A,1A   time,1A 0B,1A   1B,1A
    0A,0B   1A,0B   time,0B 1B,0B
    0A,1B   1A,1B   0B,1B   time,1B
    """.strip()
    dims = [[_ for _ in re.split(' +', line.strip())]
            for line in s.splitlines()]
    return dims
775460
def get_prtflds_default(self):
        """"""
        return self._fldsdefprt[:-1] + \
               ["p_{M}".format(M=m.fieldname) for m in self.method_flds] + \
               [self._fldsdefprt[-1]]