U
su]aB � @ s� d Z ddlZddlZddlmZ ddlmZ ddlm Z
ddlm Z dd d
d d gZ eG d
d� de��Z
dd� Zdd� Zdd�dd�Zd*ed�dd�Zd+ed�dd �Zd,ed�d d
�Zed�d d �Zd d � Zd!d"� Zd#d$� Zd%d&� Zd-ed�d)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__�value�NotImplemented)�self�other� r �>/opt/alt/python38/lib/python3.8/site-packages/humanize/time.py�__lt__# s z Unit.__lt__N) �__name__�
__module__� __qualname__� MICROSECONDS� MILLISECONDS�SECONDS�MINUTES�HOURS�DAYS�MONTHS�YEARSr r r r r r s r c C s
t j�� S r )�dt�datetime�nowr r r r �_now) s r* c C s | j dk r t� }||| S | S )z�Return 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| tj�r$| }|| }n\t| tj�r>|| }| }nBz t| �} tj| d�}|| }W n ttfk
r~ d| f Y S X |t|�fS )z�Turn 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( � timedelta�int�
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�|dk�r|t jkr�|j d k r�t d
d |j �|j S |t jks�|t jk�rd |j kr�d k �rn n|j d } t d
d| �| S t
d�S |dk�r,t
d�S |dk �rFt dd|�| S d| k�r^dk �rjn nt
d�S d| k�r�dk �r�n n|d } t dd| �| S d| k�r�dk �r�n nt
d�S d|k �r�|d }
t dd |
�|
S n�|
dk�rR| dk�rt
d �S |�st d d | �| S |�s.t d d | �| S |dk�r@t
d �S t d!d"|�| S n�|
dk�r�|�sp| �spt
d#�S |�s�t d$d%| �| S |�r�|dk�r�t
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. N�m � �>@r r �� �%d microsecond�%d microsecondsi@B �%d millisecond�%d milliseconds�a momentza second�< � %d second�
%d seconds�x 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_unit�whenZtmpr5 r, Z
use_monthsr/ r+ �yearsZ milliseconds�minutes�hoursr r r r S s� !
��
� ��
��
�Fc C s� |pt � }t| |d�\}}|dkr&| S t| tjtjf�r@||k}|rLtd�ntd�}t||||d�}|td�krxtd�S || 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
d�S |j dkr~t
d�S |j dkr�t
d�S | � |�S )z�Return 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 Ztomorrow���Z yesterday) r' r5 �year�month�day�AttributeError�
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 | d�S t | �S )zKLike `naturalday`, but append a year for dates more than ~five months away.g�����c@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 Zdivisor�unitrT �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 k�s�|�s�||k�r�t
| | | �} ||k�r�t�| �d d k�r�| �d |�} |�| | � ||k�rn �q�qnt|�d k�r|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 )�.0�sr r r �
<listcomp>� s z precisedelta.<locals>.<listcomp>r8 r9 i�Q 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 �zip�reversedr �mathZmodf�replace�append�len�joinrR )!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_txt�head�tailr 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 �� *!