File Manager

Editing File: /opt/alt/python38/lib/python3.8/site-packages/humanize/pycache/number.cpython-38.pyc

����su]a,0��ã�������������������@���s��d�Z�ddlZddlZddlmZ�ddlmZ�ddlmZ�ddlm	Z
�ddlmZ�dd	lm
Z
�d-dd„Zd.d
d„Zdd„�dD�ƒZe
ddƒe
ddƒe
ddƒe
ddƒe
ddƒe
ddƒe
ddƒe
ddƒe
ddƒe
ddƒe
ddƒe
ddƒfZd/dd „Zd!d"„�Zd#d$„�Zd0d&d'„Zd1d+d,„ZdS�)2z!Humanizing functions for numbers.é����N)ÚFractioné���)Úgettext)Úngettext)Ú
ngettext_noop)Úpgettext)Úthousands_separatorÚmalec�����������������C���s��zt�|�ƒ}�W�n�ttfk
r(���|��Y�S�X�|dkrˆtddƒtddƒtddƒtdd	ƒtd
dƒtddƒtddƒtd
dƒtddƒtddƒf
}nTtddƒtddƒtddƒtdd	ƒtddƒtddƒtddƒtddƒtddƒtddƒf
}|�d�dkrø|�›�|d�›�S�|�›�||�d��›�S�)a]��Converts an integer to its ordinal as a string.

For example, 1 is "1st", 2 is "2nd", 3 is "3rd", etc. Works for any integer or
    anything `int()` will turn into an integer. Anything other value will have nothing
    done to it.

Examples:
        ```pycon
        >>> ordinal(1)
        '1st'
        >>> ordinal(1002)
        '1002nd'
        >>> ordinal(103)
        '103rd'
        >>> ordinal(4)
        '4th'
        >>> ordinal(12)
        '12th'
        >>> ordinal(101)
        '101st'
        >>> ordinal(111)
        '111th'
        >>> ordinal("something else")
        'something else'
        >>> ordinal(None) is None
        True

```
    Args:
        value (int, str, float): Integer to convert.
        gender (str): Gender for translations. Accepts either "male" or "female".

Returns:
        str: Ordinal string.
    r	���z0 (male)Zthz1 (male)Ústz2 (male)Zndz3 (male)Zrdz4 (male)z5 (male)z6 (male)z7 (male)z8 (male)z9 (male)z
0 (female)z
1 (female)z
2 (female)z
3 (female)z
4 (female)z
5 (female)z
6 (female)z
7 (female)z
8 (female)z
9 (female)éd���)é���é���é
���r���é
���)ÚintÚ	TypeErrorÚ
ValueErrorÚP_)ÚvalueZgenderÚt©�r���ú@/opt/alt/python38/lib/python3.8/site-packages/humanize/number.pyÚordinal���s<����$
öör���c��������������	���C���s”���t�ƒ�}z(t|�tƒr$t|� |d¡ƒ�nt|�ƒ�W�n�ttfk
rJ���|��Y�S�X�|r^d |�|¡}nt|�ƒ}t 	dd|›�d|¡}||krˆ|S�t
|ƒS�dS�)ab��Converts an integer to a string containing commas every three digits.

For example, 3000 becomes "3,000" and 45000 becomes "45,000". To maintain some
    compatibility with Django's `intcomma`, this function also accepts floats.

Examples:
        ```pycon
        >>> intcomma(100)
        '100'
        >>> intcomma("1000")
        '1,000'
        >>> intcomma(1_000_000)
        '1,000,000'
        >>> intcomma(1_234_567.25)
        '1,234,567.25'
        >>> intcomma(1234.5454545, 2)
        '1,234.55'
        >>> intcomma(14308.40, 1)
        '14,308.4'
        >>> intcomma(None) is None
        True

```
    Args:
        value (int, float, str): Integer or float to convert.
        ndigits (int, None): Digits of precision for rounding after the decimal point.

Returns:
        str: string containing commas every three digits.
    Ú�z	{0:.{1}f}z^(-?\d+)(\d{3})z\g<1>z\g<2>N)r���Ú
isinstanceÚstrÚfloatÚreplacer���r���ÚformatÚreÚsubÚintcomma)r���ZndigitsÚsepZorigÚnewr���r���r���r!���V���s����

r!���c�����������������C���s���g�|�]}d�|�‘qS�)r���r���)Ú.0Úxr���r���r���Ú
<listcomp>Š���s�����r&���)é���é���é	���r
���é���é���é���é���é���é���é!���r���ZthousandZmillionZbillionZtrillionZquadrillionZquintillionZ
sextillionZ
septillionZ	octillionZ	nonillionZ	decillionZgoogolú%.1fc��������������
���C���s��zt�|�ƒ}�W�n�ttfk
r(���|��Y�S�X�|�td�k�r>t|�ƒS�ttdd…�dƒD�]¬\}}|�|k�rP|�tt|d��ƒ�}t||�ƒtdƒkrÈ|�tt|�ƒ�}t|�\}}d |t	||t
 |¡ƒg¡|���S�t|d��\}}d |t	||t
 |¡ƒg¡|���S�qPt|�ƒS�)a��Converts a large integer to a friendly text representation.

Works best for numbers over 1 million. For example, 1_000_000 becomes "1.0 million",
    1200000 becomes "1.2 million" and "1_200_000_000" becomes "1.2 billion". Supports up
    to decillion (33 digits) and googol (100 digits).

Examples:
        ```pycon
        >>> intword("100")
        '100'
        >>> intword("12400")
        '12.4 thousand'
        >>> intword("1000000")
        '1.0 million'
        >>> intword(1_200_000_000)
        '1.2 billion'
        >>> intword(8100000000000000000000000000000000)
        '8.1 decillion'
        >>> intword(None) is None
        True
        >>> intword("1234000", "%0.3f")
        '1.234 million'

```
    Args:
        value (int, float, str): Integer to convert.
        format (str): To change the number of decimal or general format of the number
            portion.

Returns:
        str: Friendly text representation as a string, unless the value passed could not
        be coaxed into an `int`.
    r���r���Néè��ú )r���r���r���Úpowersr���Ú	enumerater���Úhuman_powersÚjoinr���ÚmathÚceil)r���r���r���ZpowerZchoppedZsingularZpluralr���r���r���Úintword›���s(����"
þþ
r:���c�����������������C���sŒ���zt�|�ƒ}�W�n�ttfk
r(���|��Y�S�X�d|���kr>dk�sHn�t|�ƒS�tdƒtdƒtdƒtdƒtdƒtdƒtd	ƒtd
ƒtdƒtdƒf
|��S�)
a:��Converts an integer to Associated Press style.

Examples:
      ```pycon
      >>> apnumber(0)
      'zero'
      >>> apnumber(5)
      'five'
      >>> apnumber(10)
      '10'
      >>> apnumber("7")
      'seven'
      >>> apnumber("foo")
      'foo'
      >>> apnumber(None) is None
      True

```
    Args:
        value (int, float, str): Integer to convert.

Returns:
        str: For numbers 0-9, the number spelled out. Otherwise, the number. This always
        returns a string unless the value was not `int`-able, unlike the Django filter.
    r���r���ZzeroZoneZtwoZthreeZfourZfiveZsixZsevenZeightZnine)r���r���r���r���Ú_)r���r���r���r���ÚapnumberÕ���s&����
öõr<���c��������������	���C���sœ���zt�|�ƒ}W�n�ttfk
r(���|��Y�S�X�t|ƒ}t||�ƒ d¡}|j}|j}|rh|sh|dkrh|d›S�|s~|d›d|d›S�|d›d|d›d|d›S�dS�)aZ��Convert to fractional number.

There will be some cases where one might not want to show ugly decimal places for
    floats and decimals.

This function returns a human-readable fractional number in form of fractions and
    mixed fractions.

Pass in a string, or a number or a float, and this function returns:

* a string representation of a fraction
    * or a whole number
    * or a mixed fraction

Examples:
        ```pycon
        >>> fractional(0.3)
        '3/10'
        >>> fractional(1.3)
        '1 3/10'
        >>> fractional(float(1/3))
        '1/3'
        >>> fractional(1)
        '1'
        >>> fractional("ten")
        'ten'
        >>> fractional(None) is None
        True

```
    Args:
        value (int, float, str): Integer to convert.

Returns:
        str: Fractional number as a string.
    r2���r���z.0fú/r3���N)r���r���r���r���r���Zlimit_denominatorZ
_numeratorZ_denominator)r���ZnumberZwhole_numberZfracÚ	numeratorÚdenominatorr���r���r���Ú
fractional��s����%
r@���é���c��������������
���C���s
��ddddddddd	d
ddd
œ}d}zPdt�|�ƒkrDt�|�ƒ dd¡}�d}t|�t�ƒrVt|�ƒ}�dt�t|ƒƒ�}| |�¡}W�n�ttfk
rŽ���|��Y�S�X�| d¡\}}d|kr²| dd¡}d|krÆ| dd¡}g�}|rÜ| 	|d�¡�|D�]}	| 	||	�¡�qà|d�d 
|¡�}
|
S�)uÜ��Return number in string scientific notation z.wq x 10â¿.

Examples:
        ```pycon
        >>> scientific(float(0.3))
        '3.00 x 10â»Â¹'
        >>> scientific(int(500))
        '5.00 x 10Â²'
        >>> scientific(-1000)
        '1.00 x 10â»Â³'
        >>> scientific(1000, 1)
        '1.0 x 10Â³'
        >>> scientific(1000, 3)
        '1.000 x 10Â³'
        >>> scientific("99")
        '9.90 x 10Â¹'
        >>> scientific("foo")
        'foo'
        >>> scientific(None) is None
        True

```

Args:
        value (int, float, str): Input number.
        precision (int): Number of decimal for first part of the number.

Returns:
        str: Number in scientific notation z.wq x 10â¿.
    u���â°õ���Â¹õ���Â²õ���Â³u���â´u���âµu���â¶u���â·u���â¸u���â¹u���âºu���â»)Ú0Ú1Ú2Ú3Ú4Ú5Ú6Ú7Ú8Ú9ú+ú-FrP���r���Tz{:.%se}Úez-0z+0z x 10)r���r���r���r���r���r���r���r���ÚsplitÚappendr7���)r���Z	precisionZ	exponentsÚnegativeZfmtÚnZpart1Zpart2Z	new_part2ÚcharZ	final_strr���r���r���Ú
scientific:��sH���� ô

rW���ú{:}ú<ú>c�����������������C���s|���|�dkrdS�|dk	r&|�|k�r&|}�|}n|dk	r@|�|kr@|}�|}nd}t�|tƒr\|| |�¡�S�t|ƒrp|||�ƒ�S�tdƒ‚dS�)a��Returns number with the specified format, clamped between floor and ceil.

If the number is larger than ceil or smaller than floor, then the respective limit
    will be returned, formatted and prepended with a token specifying as such.

Examples:
        ```pycon
        >>> clamp(123.456)
        '123.456'
        >>> clamp(0.0001, floor=0.01)
        '<0.01'
        >>> clamp(0.99, format="{:.0%}", ceil=0.99)
        '99%'
        >>> clamp(0.999, format="{:.0%}", ceil=0.99)
        '>99%'
        >>> clamp(1, format=intword, floor=1e6, floor_token="under ")
        'under 1.0 million'
        >>> clamp(None) is None
        True

```

Args:
        value (int, float): Input number.
        format (str OR callable): Can either be a formatting string, or a callable
        function than receives value and returns a string.
        floor (int, float): Smallest value before clamping.
        ceil (int, float): Largest value before clamping.
        floor_token (str): If value is smaller than floor, token will be prepended
        to output.
        ceil_token (str): If value is larger than ceil, token will be prepended
        to output.

Returns:
        str: Formatted number. The output is clamped between the indicated floor and
        ceil. If the number if larger than ceil or smaller than floor, the output will
        be prepended with a token indicating as such.

Nr���zpInvalid format. Must be either a valid formatting string, or a function that accepts value and returns a string.)r���r���r���Úcallabler���)r���r���Zfloorr9���Zfloor_tokenZ
ceil_tokenÚtokenr���r���r���Úclamp‰��s ����(
ÿr]���)r	���)N)r1���)rA���)rX���NNrY���rZ���)Ú__doc__r8���r���Z	fractionsr���Zi18nr���r;���r���r���ZNS_r���r���r���r���r!���r4���r6���r:���r<���r@���rW���r]���r���r���r���r���Ú<module>���s:���
G
4ô
:.7
O

Back to Directory File Manager

Editing File: /opt/alt/python38/lib/python3.8/site-packages/humanize/__pycache__/number.cpython-38.pyc

Editing File: /opt/alt/python38/lib/python3.8/site-packages/humanize/pycache/number.cpython-38.pyc