python类month()的实例源码

def onOffset(self, dt):
        if self.normalize and not _is_normalized(dt):
            return False
        d = datetime(dt.year, dt.month, dt.day, tzinfo=dt.tzinfo)
        return d == self.getOffsetOfMonth(dt)

def getOffsetOfMonth(self, dt):
        m = MonthEnd()
        d = datetime(dt.year, dt.month, 1, dt.hour, dt.minute,
                     dt.second, dt.microsecond, tzinfo=dt.tzinfo)
        eom = m.rollforward(d)
        w = Week(weekday=self.weekday)
        return w.rollback(eom)

def onOffset(self, dt):
        if self.normalize and not _is_normalized(dt):
            return False
        modMonth = (dt.month - self.startingMonth) % 3
        return BMonthEnd().onOffset(dt) and modMonth == 0

def onOffset(self, dt):
        if self.normalize and not _is_normalized(dt):
            return False
        modMonth = (dt.month - self.startingMonth) % 3
        return MonthEnd().onOffset(dt) and modMonth == 0

def __init__(self, n=1, normalize=False, **kwds):
        self.month = kwds.get('month', self._default_month)

        if self.month < 1 or self.month > 12:
            raise ValueError('Month must go from 1 to 12')

        DateOffset.__init__(self, n=n, normalize=normalize, **kwds)

def _from_name(cls, suffix=None):
        kwargs = {}
        if suffix:
            kwargs['month'] = _month_to_int[suffix]
        return cls(**kwargs)

def apply(self, other):
        n = self.n
        wkday, days_in_month = tslib.monthrange(other.year, self.month)
        lastBDay = (days_in_month -
                    max(((wkday + days_in_month - 1) % 7) - 4, 0))

        years = n
        if n > 0:
            if (other.month < self.month or
                    (other.month == self.month and other.day < lastBDay)):
                years -= 1
        elif n <= 0:
            if (other.month > self.month or
                    (other.month == self.month and other.day > lastBDay)):
                years += 1

        other = other + relativedelta(years=years)

        _, days_in_month = tslib.monthrange(other.year, self.month)
        result = datetime(other.year, self.month, days_in_month,
                          other.hour, other.minute, other.second,
                          other.microsecond)

        if result.weekday() > 4:
            result = result - BDay()

        return result

def apply_index(self, i):
        # convert month anchor to annual period tuple
        return self._end_apply_index(i, self.freqstr)

def onOffset(self, dt):
        if self.normalize and not _is_normalized(dt):
            return False
        wkday, days_in_month = tslib.monthrange(dt.year, self.month)
        return self.month == dt.month and dt.day == days_in_month

def apply_index(self, i):
        freq_month = 12 if self.month == 1 else self.month - 1
        freqstr = 'A-%s' % (_int_to_month[freq_month],)
        return self._beg_apply_index(i, freqstr)

def onOffset(self, dt):
        if self.normalize and not _is_normalized(dt):
            return False
        return dt.month == self.month and dt.day == 1

def onOffset(self, dt):
        if self.normalize and not _is_normalized(dt):
            return False
        dt = datetime(dt.year, dt.month, dt.day)
        year_end = self.get_year_end(dt)

        if self.variation == "nearest":
            # We have to check the year end of "this" cal year AND the previous
            return year_end == dt or \
                self.get_year_end(dt - relativedelta(months=1)) == dt
        else:
            return year_end == dt

def apply(self, other):
        base = other
        n = self.n

        if n > 0:
            while n > 0:
                if not self._offset.onOffset(other):
                    qtr_lens = self.get_weeks(other)
                    start = other - self._offset
                else:
                    start = other
                    qtr_lens = self.get_weeks(other + self._offset)

                for weeks in qtr_lens:
                    start += relativedelta(weeks=weeks)
                    if start > other:
                        other = start
                        n -= 1
                        break

        else:
            n = -n
            while n > 0:
                if not self._offset.onOffset(other):
                    qtr_lens = self.get_weeks(other)
                    end = other + self._offset
                else:
                    end = other
                    qtr_lens = self.get_weeks(other)

                for weeks in reversed(qtr_lens):
                    end -= relativedelta(weeks=weeks)
                    if end < other:
                        other = end
                        n -= 1
                        break
        other = datetime(other.year, other.month, other.day,
                         base.hour, base.minute, base.second, base.microsecond)
        return other

def _get_firstbday(wkday):
    """
    wkday is the result of monthrange(year, month)

    If it's a saturday or sunday, increment first business day to reflect this
    """
    first = 1
    if wkday == 5:  # on Saturday
        first = 3
    elif wkday == 6:  # on Sunday
        first = 2
    return first

def from_datetime(date):
    """Return QDate object from datetime.date."""

    return QDate(date.year, date.month, date.day)

def to_datetime(qdate):
    """Return datetime.date object from QDate."""

    return date(day=qdate.day(), month=qdate.month(), year=qdate.year())

def _get_custom_select(params):
    select = {}
    group_by_date_field = params.get('group_by_date_field')
    time_range = params.get('time_range')
    if time_range == 'Day':
        select['day'] = 'date(%s)' % group_by_date_field
    elif time_range == 'Month':
        select['month'] = "extract(month FROM %s)" % group_by_date_field
        select['year'] = "extract(year FROM %s)" % group_by_date_field
    elif time_range == 'Year':
        select['year'] = "extract(year FROM %s)" % group_by_date_field
    elif time_range == 'Week':
        select['week'] = "date_trunc('week', %s)" % group_by_date_field

    return select

def _format_data(data, params):
    time_range = params.get('time_range')
    day = 1
    month = 1

    for item in data:
        if time_range == 'Day':
            date = item.pop('day')
            day = date.day
            month = date.month
            year = date.year
        elif time_range == 'Month':
            month = int(item.pop('month'))
            year = int(item.pop('year'))
        elif time_range == 'Year':
            year = int(item.pop('year'))
        elif time_range == 'Week':
            date = item.pop('week')
            day = date.day
            month = date.month
            year = date.year

        item['label'] = "%d-%02d-%02d" % (year, month, day)
        item['values'] = { 'value': item.pop('value') }

    _sort_data_by_date(data)
    _fill_empty_date(data, params)

def monthdelta(date, delta):
    m = (date.month + delta) % 12
    y = date.year + (date.month + delta - 1) // 12
    if not m:
        m = 12
    d = min(date.day, [31, 29 if y % 4 == 0 and not y % 400 == 0
                       else 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31
                       ][m - 1])
    return date.replace(day=d, month=m, year=y)

def time_filter_between(period, m, df):
    def _filter(o):
        if period == 'm':
            return df(o).year == m.year and df(o).month == m.month and df(o).day == m.day
            return df(o).date() <= m and df(o).date() > (m - timedelta(days=1))
        if period == 'y':
            return df(o).year == m.year and df(o).month == m.month
            return (df(o).date().replace(day=1) <= m and
                    df(o).date().replace(day=1) > (m - timedelta(days=30)))
    return _filter