Baoding-FenShuaJiang
/
Green_GoodERP18_FSJ_Standard
보기 1
좋아요 0
위키 捐赠
gooderp18绿色标准版
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
브렌치: master
브랜치 태그
${ item.name }
Create branch ${ searchTerm }
from 'master'
${ noResults }
Green_GoodERP18_FSJ_Standard/gooderp18/server/odoo/tools/date_utils.py

292 lines
11KB
Raw 고유링크 Blame 히스토리 

  1. # -*- coding: utf-8 -*-

  2. import calendar

  3. import math

  4. from datetime import date, datetime, time

  5. from typing import Tuple, TypeVar, Literal, Iterator, Type

  6. 

  7. import babel

  8. import pytz

  9. from dateutil.relativedelta import relativedelta, weekdays

  10. 

  11. from .func import lazy

  12. 

  13. D = TypeVar('D', date, datetime)

  14. 

  15. __all__ = [

  16.     'date_range',

  17.     'get_fiscal_year',

  18.     'get_month',

  19.     'get_quarter',

  20.     'get_quarter_number',

  21.     'get_timedelta',

  22. ]

  23. 

  24. def date_type(value: D) -> Type[D]:

  25.     ''' Return either the datetime.datetime class or datetime.date type whether `value` is a datetime or a date.

  26. 

  27.     :param value: A datetime.datetime or datetime.date object.

  28.     :return: datetime.datetime or datetime.date

  29.     '''

  30.     return datetime if isinstance(value, datetime) else date

  31. 

  32. 

  33. def get_month(date: D) -> Tuple[D, D]:

  34.     ''' Compute the month dates range on which the 'date' parameter belongs to.

  35.     '''

  36.     return date.replace(day=1), date.replace(day=calendar.monthrange(date.year, date.month)[1])

  37. 

  38. 

  39. def get_quarter_number(date: date) -> int:

  40.     ''' Get the number of the quarter on which the 'date' parameter belongs to.

  41.     '''

  42.     return math.ceil(date.month / 3)

  43. 

  44. 

  45. def get_quarter(date: D) -> Tuple[D, D]:

  46.     ''' Compute the quarter dates range on which the 'date' parameter belongs to.

  47.     '''

  48.     quarter_number = get_quarter_number(date)

  49.     month_from = ((quarter_number - 1) * 3) + 1

  50.     date_from = date.replace(month=month_from, day=1)

  51.     date_to = date_from + relativedelta(months=2)

  52.     date_to = date_to.replace(day=calendar.monthrange(date_to.year, date_to.month)[1])

  53.     return date_from, date_to

  54. 

  55. 

  56. def get_fiscal_year(date: D, day: int = 31, month: int = 12) -> Tuple[D, D]:

  57.     ''' Compute the fiscal year dates range on which the 'date' parameter belongs to.

  58.     A fiscal year is the period used by governments for accounting purposes and vary between countries.

  59.     By default, calling this method with only one parameter gives the calendar year because the ending date of the

  60.     fiscal year is set to the YYYY-12-31.

  61. 

  62.     :param date: A date belonging to the fiscal year

  63.     :param day:     The day of month the fiscal year ends.

  64.     :param month:   The month of year the fiscal year ends.

  65.     :return: The start and end dates of the fiscal year.

  66.     '''

  67. 

  68.     def fix_day(year, month, day):

  69.         max_day = calendar.monthrange(year, month)[1]

  70.         if month == 2 and day in (28, max_day):

  71.             return max_day

  72.         return min(day, max_day)

  73. 

  74.     date_to = date.replace(month=month, day=fix_day(date.year, month, day))

  75. 

  76.     if date <= date_to:

  77.         date_from = date_to - relativedelta(years=1)

  78.         day = fix_day(date_from.year, date_from.month, date_from.day)

  79.         date_from = date_from.replace(day=day)

  80.         date_from += relativedelta(days=1)

  81.     else:

  82.         date_from = date_to + relativedelta(days=1)

  83.         date_to = date_to + relativedelta(years=1)

  84.         day = fix_day(date_to.year, date_to.month, date_to.day)

  85.         date_to = date_to.replace(day=day)

  86.     return date_from, date_to

  87. 

  88. 

  89. def get_timedelta(qty: int, granularity: Literal['hour', 'day', 'week', 'month', 'year']):

  90.     """ Helper to get a `relativedelta` object for the given quantity and interval unit.

  91.     """

  92.     switch = {

  93.         'hour': relativedelta(hours=qty),

  94.         'day': relativedelta(days=qty),

  95.         'week': relativedelta(weeks=qty),

  96.         'month': relativedelta(months=qty),

  97.         'year': relativedelta(years=qty),

  98.     }

  99.     return switch[granularity]

  100. 

  101. 

  102. Granularity = Literal['year', 'quarter', 'month', 'week', 'day', 'hour']

  103. 

  104. 

  105. def start_of(value: D, granularity: Granularity) -> D:

  106.     """

  107.     Get start of a time period from a date or a datetime.

  108. 

  109.     :param value: initial date or datetime.

  110.     :param granularity: type of period in string, can be year, quarter, month, week, day or hour.

  111.     :return: a date/datetime object corresponding to the start of the specified period.

  112.     """

  113.     is_datetime = isinstance(value, datetime)

  114.     if granularity == "year":

  115.         result = value.replace(month=1, day=1)

  116.     elif granularity == "quarter":

  117.         # Q1 = Jan 1st

  118.         # Q2 = Apr 1st

  119.         # Q3 = Jul 1st

  120.         # Q4 = Oct 1st

  121.         result = get_quarter(value)[0]

  122.     elif granularity == "month":

  123.         result = value.replace(day=1)

  124.     elif granularity == 'week':

  125.         # `calendar.weekday` uses ISO8601 for start of week reference, this means that

  126.         # by default MONDAY is the first day of the week and SUNDAY is the last.

  127.         result = value - relativedelta(days=calendar.weekday(value.year, value.month, value.day))

  128.     elif granularity == "day":

  129.         result = value

  130.     elif granularity == "hour" and is_datetime:

  131.         return datetime.combine(value, time.min).replace(hour=value.hour)

  132.     elif is_datetime:

  133.         raise ValueError(

  134.             "Granularity must be year, quarter, month, week, day or hour for value %s" % value

  135.         )

  136.     else:

  137.         raise ValueError(

  138.             "Granularity must be year, quarter, month, week or day for value %s" % value

  139.         )

  140. 

  141.     return datetime.combine(result, time.min) if is_datetime else result

  142. 

  143. 

  144. def end_of(value: D, granularity: Granularity) -> D:

  145.     """

  146.     Get end of a time period from a date or a datetime.

  147. 

  148.     :param value: initial date or datetime.

  149.     :param granularity: Type of period in string, can be year, quarter, month, week, day or hour.

  150.     :return: A date/datetime object corresponding to the start of the specified period.

  151.     """

  152.     is_datetime = isinstance(value, datetime)

  153.     if granularity == "year":

  154.         result = value.replace(month=12, day=31)

  155.     elif granularity == "quarter":

  156.         # Q1 = Mar 31st

  157.         # Q2 = Jun 30th

  158.         # Q3 = Sep 30th

  159.         # Q4 = Dec 31st

  160.         result = get_quarter(value)[1]

  161.     elif granularity == "month":

  162.         result = value + relativedelta(day=1, months=1, days=-1)

  163.     elif granularity == 'week':

  164.         # `calendar.weekday` uses ISO8601 for start of week reference, this means that

  165.         # by default MONDAY is the first day of the week and SUNDAY is the last.

  166.         result = value + relativedelta(days=6-calendar.weekday(value.year, value.month, value.day))

  167.     elif granularity == "day":

  168.         result = value

  169.     elif granularity == "hour" and is_datetime:

  170.         return datetime.combine(value, time.max).replace(hour=value.hour)

  171.     elif is_datetime:

  172.         raise ValueError(

  173.             "Granularity must be year, quarter, month, week, day or hour for value %s" % value

  174.         )

  175.     else:

  176.         raise ValueError(

  177.             "Granularity must be year, quarter, month, week or day for value %s" % value

  178.         )

  179. 

  180.     return datetime.combine(result, time.max) if is_datetime else result

  181. 

  182. 

  183. def add(value: D, *args, **kwargs) -> D:

  184.     """

  185.     Return the sum of ``value`` and a :class:`relativedelta`.

  186. 

  187.     :param value: initial date or datetime.

  188.     :param args: positional args to pass directly to :class:`relativedelta`.

  189.     :param kwargs: keyword args to pass directly to :class:`relativedelta`.

  190.     :return: the resulting date/datetime.

  191.     """

  192.     return value + relativedelta(*args, **kwargs)

  193. 

  194. 

  195. def subtract(value: D, *args, **kwargs) -> D:

  196.     """

  197.     Return the difference between ``value`` and a :class:`relativedelta`.

  198. 

  199.     :param value: initial date or datetime.

  200.     :param args: positional args to pass directly to :class:`relativedelta`.

  201.     :param kwargs: keyword args to pass directly to :class:`relativedelta`.

  202.     :return: the resulting date/datetime.

  203.     """

  204.     return value - relativedelta(*args, **kwargs)

  205. 

  206. 

  207. def date_range(start: D, end: D, step: relativedelta = relativedelta(months=1)) -> Iterator[datetime]:

  208.     """Date range generator with a step interval.

  209. 

  210.     :param start: beginning date of the range.

  211.     :param end: ending date of the range.

  212.     :param step: interval of the range.

  213.     :return: a range of datetime from start to end.

  214.     """

  215. 

  216.     if isinstance(start, datetime) and isinstance(end, datetime):

  217.         are_naive = start.tzinfo is None and end.tzinfo is None

  218.         are_utc = start.tzinfo == pytz.utc and end.tzinfo == pytz.utc

  219. 

  220.         # Cases with miscellenous timezone are more complexe because of DST.

  221.         are_others = start.tzinfo and end.tzinfo and not are_utc

  222. 

  223.         if are_others and start.tzinfo.zone != end.tzinfo.zone:

  224.             raise ValueError("Timezones of start argument and end argument seem inconsistent")

  225. 

  226.         if not are_naive and not are_utc and not are_others:

  227.             raise ValueError("Timezones of start argument and end argument mismatch")

  228. 

  229.         dt = start.replace(tzinfo=None)

  230.         end_dt = end.replace(tzinfo=None)

  231.         post_process = start.tzinfo.localize if start.tzinfo else lambda dt: dt

  232. 

  233.     elif isinstance(start, date) and isinstance(end, date):

  234.         # FIXME: not correctly typed, and will break if the step is a fractional

  235.         #        day: `relativedelta` will return a datetime, which can't be

  236.         #        compared with a `date`

  237.         dt, end_dt = start, end

  238.         post_process = lambda dt: dt

  239. 

  240.     else:

  241.         raise ValueError("start/end should be both date or both datetime type")

  242. 

  243.     if start > end:

  244.         raise ValueError("start > end, start date must be before end")

  245. 

  246.     if start == start + step:

  247.         raise ValueError("Looks like step is null")

  248. 

  249.     while dt <= end_dt:

  250.         yield post_process(dt)

  251.         dt = dt + step

  252. 

  253. 

  254. def weeknumber(locale: babel.Locale, date: date) -> Tuple[int, int]:

  255.     """Computes the year and weeknumber of `date`. The week number is 1-indexed

  256.     (so the first week is week number 1).

  257. 

  258.     For ISO locales (first day of week = monday, min week days = 4) the concept

  259.     is clear and the Python stdlib implements it directly.

  260. 

  261.     For other locales, it's basically nonsensical as there is no actual

  262.     definition. For now we will implement non-split first-day-of-year, that is

  263.     the first week of the year is the one which contains the first day of the

  264.     year (taking first day of week in account), and the days of the previous

  265.     year which are part of that week are considered to be in the next year for

  266.     calendaring purposes.

  267. 

  268.     That is December 27, 2015 is in the first week of 2016.

  269. 

  270.     An alternative is to split the week in two, so the week from December 27,

  271.     2015 to January 2, 2016 would be *both* W53/2015 and W01/2016.

  272.     """

  273.     if locale.first_week_day == 0 and locale.min_week_days == 4:

  274.         # woohoo nothing to do

  275.         return date.isocalendar()[:2]

  276. 

  277.     # first find the first day of the first week of the next year, if the

  278.     # reference date is after that then it must be in the first week of the next

  279.     # year, remove this if we decide to implement split weeks instead

  280.     fdny = date.replace(year=date.year + 1, month=1, day=1) \

  281.        - relativedelta(weekday=weekdays[locale.first_week_day](-1))

  282.     if date >= fdny:

  283.         return date.year + 1, 1

  284. 

  285.     # otherwise get the number of periods of 7 days between the first day of the

  286.     # first week and the reference

  287.     fdow = date.replace(month=1, day=1) \

  288.        - relativedelta(weekday=weekdays[locale.first_week_day](-1))

  289.     doy = (date - fdow).days

  290. 

  291.     return date.year, (doy // 7 + 1)
上海开阖软件有限公司 沪ICP备12045867号-1