U
su]aB @ s d Z ddlZddlZddlmZ ddlmZ ddlm Z
ddlm Z dd d
d d gZ eG d
d deZ
dd Zdd ZddddZd*edddZd+eddd Zd,edd d
Zedd d Zd d Zd!d" Zd#d$ Zd%d& Zd-edd)d ZdS ).zYTime humanizing functions.
These are largely borrowed from Django's `contrib.humanize`.
N)Enum)total_ordering )gettext)ngettext naturaldelta naturaltime
naturalday naturaldate precisedeltac @ s4 e Zd ZdZdZdZdZdZdZdZ dZ
d d
Z d S ) Unitr r c C s | j |j kr| j|jk S tS N) __class__valueNotImplemented)selfother r >/opt/alt/python38/lib/python3.8/site-packages/humanize/time.py__lt__# s z Unit.__lt__N) __name__
__module__ __qualname__ MICROSECONDS MILLISECONDSSECONDSMINUTESHOURSDAYSMONTHSYEARSr r r r r r s r c C s
t j S r )dtdatetimenowr r r r _now) s r* c C s | j dk r t }||| S | S )zReturn an "absolute" value for a timedelta, always representing a time distance.
Args:
delta (datetime.timedelta): Input timedelta.
Returns:
datetime.timedelta: Absolute timedelta.
r )daysr* )deltar) r r r
abs_timedelta- s
r- r) c C s |s
t }t| tjr$| }|| }n\t| tjr>|| }| }nBz t| } tj| d}|| }W n ttfk
r~ d| f Y S X |t|fS )zTurn a value into a date and a timedelta which represents how long ago it was.
If that's not possible, return `(None, value)`.
)secondsN) r*
isinstancer' r( timedeltaint
ValueError TypeErrorr- )r r) dater, r r r date_and_delta< s
r6 Tr/ )returnc C s t | }|t jt jt jfkr0td| d|}t| |d\}}|dkrP| S |}t|j}t|j } | d }
| d } t
| d }|
s| dk r|dkr|t jkr|j d k rt d
d |j |j S |t jks|t jkrd |j krd k rn n|j d } t d
d| | S t
dS |dkr,t
dS |dk rFt dd|| S d| kr^dk rjn nt
dS d| krdk rn n|d } t dd| | S d| krdk rn nt
dS d|k r|d }
t dd |
|
S n|
dkrR| dkrt
d S |st d d | | S |s.t d d | | S |dkr@t
d S t d!d"|| S n|
dkr|sp| spt
d#S |st d$d%| | S |r|dkrt
d&S t d'd(|| S nt d$d%| | S nt d)d*|
|
S dS )+a Return a natural representation of a timedelta or number of seconds.
This is similar to `naturaltime`, but does not add tense to the result.
Args:
value (datetime.timedelta): A timedelta or a number of seconds.
months (bool): If `True`, then a number of months (based on 30.5 days) will be
used for fuzziness between years.
minimum_unit (str): The lowest unit that can be used.
when (datetime.datetime): Point in time relative to which _value_ is
interpreted. Defaults to the current time in the local timezone.
Returns:
str: A natural representation of the amount of time elapsed.
Examples
Compare two timestamps in a custom local timezone::
import datetime as dt
from dateutil.tz import gettz
berlin = gettz("Europe/Berlin")
now = dt.datetime.now(tz=berlin)
later = now + dt.timedelta(minutes=30)
assert naturaldelta(later, when=now) == "30 minutes"
zMinimum unit 'z' not supportedr. Nm >@r r %d microsecond%d microsecondsi@B %d millisecond%d millisecondsa momentza second< %d second
%d secondsx za minute %d minute
%d minutesi zan hour%d hour%d hoursza day%d day%d daysza month%d month %d monthsza yearz1 year, %d dayz1 year, %d daysz1 year, 1 monthz1 year, %d monthz1 year, %d months%d year%d years)r upperr! r r r3 r6 absr/ r+ r2 microsecondsr _)r months minimum_unitwhenZtmpr5 r, Z
use_monthsr/ r+ yearsZ millisecondsminuteshoursr r r r S s !
Fc C s |pt }t| |d\}}|dkr&| S t| tjtjfr@||k}|rLtdntd}t||||d}|tdkrxtdS || S )a Return a natural representation of a time in a resolution that makes sense.
This is more or less compatible with Django's `naturaltime` filter.
Args:
value (datetime.datetime, int): A `datetime` or a number of seconds.
future (bool): Ignored for `datetime`s, where the tense is always figured out
based on the current time. For integers, the return value will be past tense
by default, unless future is `True`.
months (bool): If `True`, then a number of months (based on 30.5 days) will be
used for fuzziness between years.
minimum_unit (str): The lowest unit that can be used.
when (datetime.datetime): Point in time relative to which _value_ is
interpreted. Defaults to the current time in the local timezone.
Returns:
str: A natural representation of the input in a resolution that makes sense.
r. Nz %s from nowz%s ago)rU r? r) )r* r6 r0 r' r( r1 rR r ) r ZfuturerS rT rU r) r5 r, Zagor r r r s
%b %dc C s zt | j| j| j} W n2 tk
r0 | Y S ttfk
rJ | Y S X | t j }|j dkrlt
dS |j dkr~t
dS |j dkrt
dS | |S )zReturn a natural day.
For date values that are tomorrow, today or yesterday compared to
present day return representing string. Otherwise, return a string
formatted according to `format`.
r todayr ZtomorrowZ yesterday) r' r5 yearmonthdayAttributeError
OverflowErrorr3 rZ r+ rR strftime)r formatr, r r r r s
c C sz zt | j| j| j} W n2 tk
r0 | Y S ttfk
rJ | Y S X t| t j }|j
dkrrt | dS t | S )zKLike `naturalday`, but append a year for dates more than ~five months away.gc@z%b %d %Y) r' r5 r\ r] r^ r_ r` r3 r- rZ r+ r )r r, r r r r
s
c C s2 ||kr| | dfS ||kr$d| fS t | |S dS )a Divide `value` by `divisor` returning the quotient and remainder.
If `unit` is `minimum_unit`, makes the quotient a float number and the remainder
will be zero. The rational is that if `unit` is the unit of the quotient, we cannot
represent the remainder because it would require a unit smaller than the
`minimum_unit`.
>>> from humanize.time import _quotient_and_remainder, Unit
>>> _quotient_and_remainder(36, 24, Unit.DAYS, Unit.DAYS, [])
(1.5, 0)
If unit is in `suppress`, the quotient will be zero and the remainder will be the
initial value. The idea is that if we cannot use `unit`, we are forced to use a
lower unit so we cannot do the division.
>>> _quotient_and_remainder(36, 24, Unit.DAYS, Unit.HOURS, [Unit.DAYS])
(0, 36)
In other case return quotient and remainder as `divmod` would do it.
>>> _quotient_and_remainder(36, 24, Unit.DAYS, Unit.HOURS, [])
(1, 12)
r N)divmod)r ZdivisorunitrT suppressr r r _quotient_and_remainder s
rf c C s< ||kr| || dfS ||kr0d|| | fS | |fS dS )a Return a tuple with two values.
If the unit is in `suppress`, multiply `value1` by `ratio` and add it to `value2`
(carry to right). The idea is that if we cannot represent `value1` we need to
represent it in a lower unit.
>>> from humanize.time import _carry, Unit
>>> _carry(2, 6, 24, Unit.DAYS, Unit.SECONDS, [Unit.DAYS])
(0, 54)
If the unit is the minimum unit, `value2` is divided by `ratio` and added to
`value1` (carry to left). We assume that `value2` has a lower unit so we need to
carry it to `value1`.
>>> _carry(2, 6, 24, Unit.DAYS, Unit.DAYS, [])
(2.25, 0)
Otherwise, just return the same input:
>>> _carry(2, 6, 24, Unit.DAYS, Unit.SECONDS, [])
(2, 6)
r Nr )Zvalue1Zvalue2Zratiord min_unitre r r r _carry7 s
rh c C s6 | |kr2t D ] }|| kr ||kr | S q td| S )a Return a minimum unit suitable that is not suppressed.
If not suppressed, return the same unit:
>>> from humanize.time import _suitable_minimum_unit, Unit
>>> _suitable_minimum_unit(Unit.HOURS, []).name
'HOURS'
But if suppressed, find a unit greather than the original one that is not
suppressed:
>>> _suitable_minimum_unit(Unit.HOURS, [Unit.HOURS]).name
'DAYS'
>>> _suitable_minimum_unit(Unit.HOURS, [Unit.HOURS, Unit.DAYS]).name
'MONTHS'
z@Minimum unit is suppressed and no suitable replacement was found)r r3 )rg re rd r r r _suitable_minimum_unitV s
ri c C s, t |}tD ]}|| kr q(|| q |S )a Extend suppressed units (if any) with all units lower than the minimum unit.
>>> from humanize.time import _suppress_lower_units, Unit
>>> [x.name for x in sorted(_suppress_lower_units(Unit.SECONDS, [Unit.DAYS]))]
['MICROSECONDS', 'MILLISECONDS', 'DAYS']
)setr add)rg re ur r r _suppress_lower_unitst s rm r %0.2fc !
C s2 t | \}}|dkr| S dd |D }t| }t||}~t||}|j}|j}|j} tt\}
} } }
}}}}t |d|||\}}t |d|||\}}t
||d|||\}}t |d|||\}}t |d|
||\}}t
|| d | ||\}} t | d
| ||\}} t
| d d |
||\} }d
d|fdd|fdd|fdd|fdd|fdd|fdd|fdd | fg}g }t t t|D ]\}}|\} } } | d ks|s||krt
| | | } ||krt| d d kr| d |} || | ||krn qqnt|d kr|d S d |dd } |d } td | | f S )!a% Return a precise representation of a timedelta.
```pycon
>>> import datetime as dt
>>> from humanize.time import precisedelta
>>> delta = dt.timedelta(seconds=3633, days=2, microseconds=123000)
>>> precisedelta(delta)
'2 days, 1 hour and 33.12 seconds'
```
A custom `format` can be specified to control how the fractional part
is represented:
```pycon
>>> precisedelta(delta, format="%0.4f")
'2 days, 1 hour and 33.1230 seconds'
```
Instead, the `minimum_unit` can be changed to have a better resolution;
the function will still readjust the unit to use the greatest of the
units that does not lose precision.
For example setting microseconds but still representing the date with milliseconds:
```pycon
>>> precisedelta(delta, minimum_unit="microseconds")
'2 days, 1 hour, 33 seconds and 123 milliseconds'
```
If desired, some units can be suppressed: you will not see them represented and the
time of the other units will be adjusted to keep representing the same timedelta:
```pycon
>>> precisedelta(delta, suppress=['days'])
'49 hours and 33.12 seconds'
```
Note that microseconds precision is lost if the seconds and all
the units below are suppressed:
```pycon
>>> delta = dt.timedelta(seconds=90, microseconds=100)
>>> precisedelta(delta, suppress=['seconds', 'milliseconds', 'microseconds'])
'1.50 minutes'
```
If the delta is too small to be represented with the minimum unit,
a value of zero will be returned:
```pycon
>>> delta = dt.timedelta(seconds=1)
>>> precisedelta(delta, minimum_unit="minutes")
'0.02 minutes'
>>> delta = dt.timedelta(seconds=0.1)
>>> precisedelta(delta, minimum_unit="minutes")
'0 minutes'
```
Nc S s g | ]}t | qS r )r rO ).0sr r r
<listcomp> s z precisedelta.<locals>.<listcomp>r8 r9 iQ rD r@ g .Ar: r r rM rN rK rL rI rJ rG rH rE rF rA rB r= r> r; r< z%dz, r[ z %s and %s)r6 r rO ri rm r+ r/ rQ listrf rh zipreversedr mathZmodfreplaceappendlenjoinrR )!r rT re rb r5 r, rg r+ ZsecsZusecsr r r! r" r# r$ r% r& rV rS rX rW ZmsecsZ_unusedZfmtsZtextsrd ZfmtZ singular_txtZ
plural_txtZfmt_txtheadtailr r r r sh C
)Tr/ N)FTr/ N)rY )r/ r rn )__doc__r( r' ru enumr functoolsr Zi18nr rR r __all__r r* r- r6 strr r r r
rf rh ri rm r r r r r <module> sJ q *!