o

�N�g�N�@s�
dZd
dl
Z
d
dlZd
dlZd
dlZd
dlZd
dlZd
dlZd
dlm	Z	
Gdd�d�Z
dZ	dZdZ
d	Zd
Zd
ZdZeeZeeZeeZe
jdd
�
Ze
jedd
�
ZedZeedZe	dd��
Zdd�Zdd�ZdTdd�
ZdTdd�
Zdd�Zdd�Z dd�Z!d d!�Z"d"d#�Z#d$d%�Z$d&d'�Z%d(d)�Z&d*d+�Z'd,d-�Z(id.d/�
d0d/�
d1d/�
d2d/�
d3d/�
d4d5�
d6d5�
d7d5�
d8d9�
d:d9�
d;d<�
d=d<�
d>d?�
d@d?�
dAdB�
dCdB�
dDdE�
dFdFdFdG��
Z)dHdI�Z*dJdK�Z+dLdM�Z,GdNdO�dO�Z-dPdQ�Z.dUdRdS�
Z/dS)Vz:Objects and routines pertaining to date and time (tempora)�N)
�oncec@s0eZ
dZd
ZdZ	d
dd�
Zdd�Zdd	�ZdS)�Parsera�
    *deprecated*

    Datetime parser: parses a date-time string using multiple possible
    formats.

    >>> p = Parser(('%H%M', '%H:%M'))
    >>> tuple(p.parse('1319'))
    (1900, 1, 1, 13, 19, 0, 0, 1, -1)
    >>> dateParser = Parser(('%m/%d/%Y', '%Y-%m-%d', '%d-%b-%Y'))
    >>> tuple(dateParser.parse('2003-12-20'))
    (2003, 12, 20, 0, 0, 0, 5, 354, -1)
    >>> tuple(dateParser.parse('16-Dec-1994'))
    (1994, 12, 16, 0, 0, 0, 4, 350, -1)
    >>> tuple(dateParser.parse('5/19/2003'))
    (2003, 5, 19, 0, 0, 0, 0, 139, -1)
    >>> dtParser = Parser(('%Y-%m-%d %H:%M:%S', '%a %b %d %H:%M:%S %Y'))
    >>> tuple(dtParser.parse('2003-12-20 19:13:26'))
    (2003, 12, 20, 19, 13, 26, 5, 354, -1)
    >>> tuple(dtParser.parse('Tue Jan 20 16:19:33 2004'))
    (2004, 1, 20, 16, 19, 33, 1, 20, -1)

    Be forewarned, a ValueError will be raised if more than one format
    matches:

    >>> Parser(('%H%M', '%H%M%S')).parse('732')
    Traceback (most recent call last):
        ...
    ValueError: More than one format string matched target 732.

    >>> Parser(('%H',)).parse('22:21')
    Traceback (most recent call last):
    ...
    ValueError: No format strings matched the target 22:21.
    )z%m/%d/%Yz%m/%d/%yz%Y-%m-%dz%d-%b-%Yz%d-%b-%yNcCst�
d
t�
|
r
|
|_dSdS)NzUse dateutil.parser)�warnings�warn�DeprecationWarning�formats)�selfr�r	�D/opt/saltstack/salt/lib/python3.10/site-packages/tempora/__init__.py�__init__6s



�zParser.__init__cCsn|
|_t
tdt|j|j���
}|`|s d
}t|jdit��
�
�
�
t	|�
dks3d}t|jdit��
�
�
�
|dS)Nz.No format strings matched the target {target}.�
z4More than one format string matched target {target}.r
r	)
�target�tuple�filter�map�_parser�
ValueError�format�locals�len)rr
�resultsZtmplr	r	r
�parse;s









zParser.parsecCs.z
t�
|j|
�}W|Sty


d
}Y|Sw)NF)�time�strptimer
r)rr�resultr	r	r
rGs

�

�z
Parser._parse�
N)�__name__�
__module__�__qualname__�__doc__rrrrr	r	r	r
rs
$

rl�_�Kr4 l�m�GriL��
�<���
�days��cCstt
�d
dd��d�
�
dkS)zp
    Some versions of Python render %Y with only three characters :(
    https://bugs.python.org/issue39103
    i�r�%Y�)r�datetime�date�strftimer	r	r	r
�_needs_year_helpesr,c
CsTt|t
j
�r|S|}
}t|t
j�rt
��}t|t
j�r#t
�d
dd�}
t
j
�|
|�S)z�
    Given a datetime or date or time object from the ``datetime``
    module, always return a datetime using default values.
    ilr)�
isinstancer)r*r�combine)�obr*rr	r	r
�ensure_datetimens






r0cs�t|
t
jtf�rtj|
d
d��}
t|
�
}
dd|
jdfdd|
jdff�
t�r4�
dd|
jff
7�
d	d
����
fdd�}d
�	t
||�d
�
��
}|
�|�
S)u�
    Portable strftime.

    In the stdlib, strftime has `known portability problems
    <https://bugs.python.org/issue13305>`_. This function
    aims to smooth over those issues and provide a
    consistent experience across the major platforms.

    >>> strftime('%Y', datetime.datetime(1890, 1, 1))
    '1890'
    >>> strftime('%Y', datetime.datetime(900, 1, 1))
    '0900'

    Supports time.struct_time, tuples, and datetime.datetime objects.

    >>> strftime('%Y-%m-%d', (1976, 5, 7))
    '1976-05-07'

    Also supports date objects

    >>> strftime('%Y', datetime.date(1976, 5, 7))
    '1976'

    Also supports milliseconds using %s.

    >>> strftime('%s', datetime.time(microsecond=20000))
    '020'

    Also supports microseconds (3 digits) using %µ

    >>> strftime('%µ', datetime.time(microsecond=123456))
    '456'

    Historically, %u was used for microseconds, but now
    it honors the value rendered by stdlib.

    >>> strftime('%u', datetime.date(1976, 5, 7))
    '5'

    Also supports microseconds (6 digits) using %f

    >>> strftime('%f', datetime.time(microsecond=23456))
    '023456'

    Even supports time values on date objects (discouraged):

    >>> strftime('%f', datetime.date(1976, 1, 1))
    '000000'
    >>> strftime('%µ', datetime.date(1976, 1, 1))
    '000'
    >>> strftime('%s', datetime.date(1976, 1, 1))
    '000'

    And vice-versa:

    >>> strftime('%Y', datetime.time())
    '1900'
    N�z%sz%03d��u%µr'z%04dcSs
|j|
�Sr)
�replace)�
s�subr	r	r
�doSub�s

zstrftime.<locals>.doSubc

st�
��
|�Sr)�	functools�reduce)
r4�r6Zsubsr	r
�doSubs�s
zstrftime.<locals>.doSubsz%%)
r-r�struct_timerr)r0�microsecondr,�year�joinr�splitr+)�fmt�
tr:r	r9r
r+}s;


�


r+cCs\|d
urtj�
|��t���}||}dd�}t|||
f�\}}
tj||
d�
}||}|S)a�
    Find the time which is the specified date/time truncated to the time delta
    relative to the start date/time.
    By default, the start time is midnight of the same day as the specified
    date/time.

    >>> datetime_mod(datetime.datetime(2004, 1, 2, 3),
    ...     datetime.timedelta(days = 1.5),
    ...     start = datetime.datetime(2004, 1, 1))
    datetime.datetime(2004, 1, 1, 0, 0)
    >>> datetime_mod(datetime.datetime(2004, 1, 2, 13),
    ...     datetime.timedelta(days = 1.5),
    ...     start = datetime.datetime(2004, 1, 1))
    datetime.datetime(2004, 1, 2, 12, 0)
    >>> datetime_mod(datetime.datetime(2004, 1, 2, 13),
    ...     datetime.timedelta(days = 7),
    ...     start = datetime.datetime(2004, 1, 1))
    datetime.datetime(2004, 1, 1, 0, 0)
    >>> datetime_mod(datetime.datetime(2004, 1, 10, 13),
    ...     datetime.timedelta(days = 7),
    ...     start = datetime.datetime(2004, 1, 1))
    datetime.datetime(2004, 1, 8, 0, 0)
    Nc

Ss|jt
|jd
|jS)N�@B)r$�seconds_per_day�seconds�microseconds�
�tdr	r	r
�get_time_delta_microseconds�s
z1datetime_mod.<locals>.get_time_delta_microseconds�
rE)r)r.r*rr�	timedelta)�dt�period�start�deltarH�offsetrr	r	r
�datetime_mod�s

rPcCs,t||
|�}t
||�
|
d
kr||
7}|S)a
    Find the nearest even period for the specified date/time.

    >>> datetime_round(datetime.datetime(2004, 11, 13, 8, 11, 13),
    ...     datetime.timedelta(hours = 1))
    datetime.datetime(2004, 11, 13, 8, 0)
    >>> datetime_round(datetime.datetime(2004, 11, 13, 8, 31, 13),
    ...     datetime.timedelta(hours = 1))
    datetime.datetime(2004, 11, 13, 9, 0)
    >>> datetime_round(datetime.datetime(2004, 11, 13, 8, 30),
    ...     datetime.timedelta(hours = 1))
    datetime.datetime(2004, 11, 13, 9, 0)
    r%)rP�abs)rKrLrMrr	r	r
�datetime_round�s


rRc
Cs>t�
�}
|
j}||
jd
kr|d8}|
j|d
kr|d7}|S)aF

    Returns the nearest year to now inferred from a Julian date.

    >>> freezer = getfixture('freezer')
    >>> freezer.move_to('2019-05-20')
    >>> get_nearest_year_for_day(20)
    2019
    >>> get_nearest_year_for_day(340)
    2018
    >>> freezer.move_to('2019-12-15')
    >>> get_nearest_year_for_day(20)
    2020
    �r)r�gmtime�tm_year�tm_yday)�day�nowrr	r	r
�get_nearest_year_for_day
s



rYcCs&t�
|d
d
�}|tj|
d
d�
7}|S)z�
    Gregorian Date is defined as a year and a julian day (1-based
    index into the days of the year).

    >>> gregorian_date(2007, 15)
    datetime.date(2007, 1, 15)
    rr#)r)r*rJ)r=Z
julian_dayrr	r	r
�gregorian_date%
s

rZc
Cs�t|t
�r!zd
|��}
t�|
}W|Sty 


d}t|�
�
wt|tj�r+|}|St|tj	�r=|j
td�
|j}|St
d�
�
)a�

    return the number of seconds in the specified period

    >>> get_period_seconds('day')
    86400
    >>> get_period_seconds(86400)
    86400
    >>> get_period_seconds(datetime.timedelta(hours=24))
    86400
    >>> get_period_seconds('day + os.system("rm -Rf *")')
    Traceback (most recent call last):
    ...
    ValueError: period not in (second, minute, hour, day, month, year)
    Zseconds_per_z6period not in (second, minute, hour, day, month, year)rWz"period must be a string or integer)r-�str�lower�globals�KeyErrorr�numbers�Numberr)rJr$�get_period_secondsrD�	TypeError)rL�namer�msgr	r	r
ra2
s 




�

�
�
�rac
snt|t
�r
|��d
kr
dSt|�
�d}
d}tttt|f}tt	�f
dd�|��
}|
d|�
d�
d�}
d	�|
�
S)
a�
    For a given period (e.g. 'month', 'day', or some numeric interval
    such as 3600 (in secs)), return the format string that can be
    used with strftime to format that time to specify the times
    across that interval, but no more detailed.
    For example,

    >>> get_date_format_string('month')
    '%Y-%m'
    >>> get_date_format_string(3600)
    '%Y-%m-%d %H'
    >>> get_date_format_string('hour')
    '%Y-%m-%d %H'
    >>> get_date_format_string(None)
    Traceback (most recent call last):
        ...
    TypeError: period must be a string or integer
    >>> get_date_format_string('garbage')
    Traceback (most recent call last):
        ...
    ValueError: period not in (second, minute, hour, day, month, year)
    �monthz%Y-%m)r'z-%m-%dz %Hz-%Mz-%Src

s�|Srr	)
�interval�
Zfile_period_secsr	r
�<lambda>v
sz(get_date_format_string.<locals>.<lambda>Nr
�)r-r[r\ra�seconds_per_yearrC�seconds_per_hour�seconds_per_minute�listr�indexr>)rLZ
format_pieces�seconds_per_secondZ	intervals�modsr	rgr
�get_date_format_stringQ
s







�


rqcC�t�
d
t�
||
S)a

    Divide a timedelta by a float value

    >>> one_day = datetime.timedelta(days=1)
    >>> half_day = datetime.timedelta(days=.5)
    >>> divide_timedelta_float(one_day, 2.0) == half_day
    True
    >>> divide_timedelta_float(one_day, 2) == half_day
    True
    �Use native division�rrr)rGZdivisorr	r	r
�divide_timedelta_float{
s
rucCs4td
�
}t
|�
D]\}
}tdjdit��
�
�

qdS)a*

    >>> monkeypatch = getfixture('monkeypatch')
    >>> import builtins
    >>> monkeypatch.setattr(builtins, 'input', lambda prompt: '3/hour')
    >>> calculate_prorated_values()
    per minute: 0.05
    per hour: 3.0
    per day: 72.0
    per month: 2191.454166666667
    per year: 26297.45
    z#Enter the rate (3/hour, 50/month)> zper {period}: {value}Nr	)�input�_prorated_values�printrr)�raterL�valuer	r	r
�calculate_prorated_values�
s

�r{c
csR�t�
d
|���}
t|
d�
}|t|
d�
}dD]
}|t|�
}||fV
qdS)aJ

    Given a rate (a string in units per unit time), and return that same
    rate for various time periods.

    >>> for period, value in _prorated_values('20/hour'):
    ...     print('{period}: {value:0.3f}'.format(**locals()))
    minute: 0.333
    hour: 20.000
    day: 480.000
    month: 14609.694
    year: 175316.333

    z"(?P<value>[\d.]+)/(?P<period>\w+)$rzrL)�minute�hourrWrer=N)�re�match�	groupdict�floatra)ry�resrzZvalue_per_secondrLZperiod_valuer	r	r
rw�
s�




�rwc

Cst|�
�
�S)
u;
    Take a string representing a span of time and parse it to a time delta.
    Accepts any string of comma-separated numbers each with a unit indicator.

    >>> parse_timedelta('1 day')
    datetime.timedelta(days=1)

    >>> parse_timedelta('1 day, 30 seconds')
    datetime.timedelta(days=1, seconds=30)

    >>> parse_timedelta('47.32 days, 20 minutes, 15.4 milliseconds')
    datetime.timedelta(days=47, seconds=28848, microseconds=15400)

    Supports weeks, months, years

    >>> parse_timedelta('1 week')
    datetime.timedelta(days=7)

    >>> parse_timedelta('1 year, 1 month')
    datetime.timedelta(days=395, seconds=58685)

    Note that months and years strict intervals, not aligned
    to a calendar:

    >>> now = datetime.datetime.now()
    >>> later = now + parse_timedelta('1 year')
    >>> diff = later.replace(year=now.year) - now
    >>> diff.seconds
    20940

    >>> parse_timedelta('14 seconds foo')
    Traceback (most recent call last):
    ...
    ValueError: Unexpected 'foo'

    Supports abbreviations:

    >>> parse_timedelta('1s')
    datetime.timedelta(seconds=1)

    >>> parse_timedelta('1sec')
    datetime.timedelta(seconds=1)

    >>> parse_timedelta('5min1sec')
    datetime.timedelta(seconds=301)

    >>> parse_timedelta('1 ms')
    datetime.timedelta(microseconds=1000)

    >>> parse_timedelta('1 µs')
    datetime.timedelta(microseconds=1)

    >>> parse_timedelta('1 us')
    datetime.timedelta(microseconds=1)

    And supports the common colon-separated duration:

    >>> parse_timedelta('14:00:35.362')
    datetime.timedelta(seconds=50435, microseconds=362000)

    TODO: Should this be 14 hours or 14 minutes?
    >>> parse_timedelta('14:00')
    datetime.timedelta(seconds=50400)

    >>> parse_timedelta('14:00 minutes')
    Traceback (most recent call last):
    ...
    ValueError: Cannot specify units with composite delta

    Nanoseconds get rounded to the nearest microsecond:

    >>> parse_timedelta('600 ns')
    datetime.timedelta(microseconds=1)

    >>> parse_timedelta('.002 µs, 499 ns')
    datetime.timedelta(microseconds=1)
    )�_parse_timedelta_nanos�resolve)
r[r	r	r
�parse_timedelta�
sNr�c
Cs,t�
d
|�}
t|
|�}tt|�}t|t��S)Nz)(?P<value>[\d.:]+)\s?(?P<unit>[^\W\d_]+)?)r~�finditer�_check_unmatchedr�_parse_timedelta_part�sum�	_Saved_NS)r[�partsZ	chk_partsZdeltasr	r	r
r�s





r�ccsR�d
d�}d}|D]}||
||����

|V
|�
�}q	||
|�
�d��

dS)z3
    Ensure no words appear in unmatched text.
    c
Ss(t�
d
|�}
|
rtd|
�d�
���
�
dS)Nz\w+zUnexpected r
)r~�searchr�group)Z	unmatched�foundr	r	r
�check_unmatcheds


�z)_check_unmatched.<locals>.check_unmatchedr
N)rM�end)�matches�textr��posrr	r	r
r�	s�





r�uµsr<uµsec�usZusecZmicros�msZmillisecondZmsecZmillisr4�secondZsec�
hr}�hr�
mr|�min�
w�weekZwk�
drWZ
nanosecond)�nsZnsecZnanosc
Cs |durd
S|��}
t
�|
|
�S)Nr�)r\�_unit_lookup�get)Z	raw_matchr�r	r	r
�
_resolve_unit3s



r�cCs@|
d
krtd�
�
|�
d�
}d}d�dd�t||�D�
�
}t|�
S)NrDz)Cannot specify units with composite delta�
:)�hours�minutesrD�
 c
ss"�|]\}
}|
�d|��V
qd
S)r�Nr	)�.0rz�unitr	r	r
�	<genexpr>?s� z-_parse_timedelta_composite.<locals>.<genexpr>)rr?r>�zipr�)�	raw_valuer��valuesZunitsZcomposedr	r	r
�_parse_timedelta_composite:s






r�c
Csxt|�
d
�
�
}
|
�d�
s|
d7}
|�
d�
}d|vrt||
�St|�
}|
dkr,d}
|d}|
dkr6d}
|t}t�|
|�S)	Nr�r4rzr��monthsZyearsr&r$)r�r��endswithr�r��
days_per_yearr��derive)rr�r�rzr	r	r
r�Cs
















r�c@sVeZ
dZd
Ze��ZdZedddd�Z	dd�Z
ed	d
��
Zdd�Z
d
d�Zdd�ZdS)r�z�
    Bundle a timedelta with nanoseconds.

    >>> _Saved_NS.derive('microseconds', .001)
    _Saved_NS(td=datetime.timedelta(0), nanoseconds=1)
    r
iʚ;rBr2)rDZmillisecondsrEc
Kst|�
�
|
�

dSr)�vars�update)r�kwargsr	r	r
rds
z_Saved_NS.__init__cCst|
d
kr	t|d�
Stt
jdi|
|i
�
�
d�
}t�t�
�
t||j|
�
d|_Wd�
|S1s3w



Y
|S)N�nanoseconds)
r�rFr2r	)	r�r)rJ�
contextlib�suppressr^�int�
multiplierr�)�clsr�rzr�r	r	r
r�gs




��z_Saved_NS.derivecCst|j
|
j
|j|
jd
�S)N�rGr�)r�rGr�)r�otherr	r	r
�__add__qs

�z_Saved_NS.__add__c
Cs t|j
d
�
}
|jtj|
d�
S)z�
        Resolve any nanoseconds into the microseconds field,
        discarding any nanosecond resolution (but honoring partial
        microseconds).
        r2rI)�roundr�rGr)rJ)rZaddl_microsr	r	r
r�vs
z_Saved_NS.resolvec

Csd
|j�d|j
�d�S)Nz
_Saved_NS(td=z, nanoseconds=�
)r�)
rr	r	r
�__repr__s
z_Saved_NS.__repr__N)rrrrr)rJrGr��dictr�r�classmethodr�r�r�r�r	r	r	r
r�Ts





�

		r�cCrr)z�
    Get the ratio of two timedeltas

    >>> one_day = datetime.timedelta(days=1)
    >>> one_hour = datetime.timedelta(hours=1)
    >>> divide_timedelta(one_hour, one_day) == 1 / 24
    True
    rsrt)Ztd1Ztd2r	r	r
�divide_timedelta�s	
r�ccsN�|d
urtj
dd�
}|d
urtj��}||
kr%|V
||7}||
ksd
Sd
S)a
    Much like the built-in function range, but works with dates

    >>> range_items = date_range(
    ...     datetime.datetime(2005,12,21),
    ...     datetime.datetime(2005,12,25),
    ... )
    >>> my_range = tuple(range_items)
    >>> datetime.datetime(2005,12,21) in my_range
    True
    >>> datetime.datetime(2005,12,22) in my_range
    True
    >>> datetime.datetime(2005,12,25) in my_range
    False
    >>> from_now = date_range(stop=datetime.datetime(2099, 12, 31))
    >>> next(from_now)
    datetime.datetime(...)
    Nrr#)r)rJrX)rM�stop�stepr	r	r
�
date_range�s�






�r�r)NNN)0rr)rr~r_r7rr�Zjaraco.functoolsrrZosc_per_yearZosc_per_secondrorjrlZminutes_per_hourZ
hours_per_dayrkrCr�rJZthirty_daysZ
six_monthsZseconds_per_monthZhours_per_monthr,r0r+rPrRrYrZrarqrur{rwr�r�r�r�r�r�r�r�r�r�r	r	r	r
�<module>
s�





B














O
,
*Q
��������	�
���
�����

�	/