File: //usr/local/lib/python3.9/site-packages/celery/utils/__pycache__/functional.cpython-39.pyc
a
X>h�. � @ s� d Z ddlZddlmZ ddlmZ ddlmZmZm Z ddl
m Z m Z ddl
mZmZmZmZmZmZmZ ddlmZ dd lmZ ee�Zd
Zd Z G d d
� d
�Z G dd� de�Z dd� Z dd� Z dd� Z!dd� Z"d>dd�Z#dd� Z$d?d d �Z%d d � Z&d d!� Z'd"d#� Z(d$d%� Z)G d&d'� d'ee*�Z+d@d)d*�Z,dAe d,e f e-e.d-�d.d/�Z/d0d1� Z0dBd2d3�Z1d4d5� Z2d6d7� Z3d8d9� Z4d:d;� Z5d<d=� Z6dS )CzFunctional-style utilities.� N)�UserList)�partial)�islice�tee� zip_longest)�Any�Callable)�LRUCache�
dictfilter�is_list�lazy�maybe_evaluate�
maybe_list�memoize)�promise)�
get_logger)r r r r �mlazy�noop�first� firstmethod�chunks�padlist� mattrgetter�uniq�regenr
r r
�
head_from_fun�maybe�fun_accepts_kwargsz4
def {fun_name}({fun_args}):
return {fun_value}
c @ s e Zd Zdd� Zdd� ZdS )� DummyContextc C s | S �N� ��selfr r �A/usr/local/lib/python3.9/site-packages/celery/utils/functional.py� __enter__ s zDummyContext.__enter__c G s d S r r )r" �exc_infor r r# �__exit__! s zDummyContext.__exit__N)�__name__�
__module__� __qualname__r$ r& r r r r# r s r c s( e Zd ZdZdZdZ� fdd�Z� ZS )r z�Memoized lazy evaluation.
The function is only evaluated once, every subsequent access
will return the same value.
FNc s | j st� �� | _d| _ | jS �NT)� evaluated�super�evaluate�_valuer! �� __class__r r# r- 0 s zmlazy.evaluate)r' r( r) �__doc__r+ r. r- �
__classcell__r r r/ r# r % s r c O s dS )zONo operation.
Takes any arguments/keyword arguments and does nothing.
Nr )�args�kwargsr r r# r 7 s r c O s | S )z%Return the first positional argument.r )�argr3 r4 r r r# �pass1> s r6 c c s$ | D ]}t |t�r|� }|V qd S r )�
isinstancer )�it�valuer r r# �evaluate_promisesC s
r: c s t � fdd�t|�D �d�S )z�Return the first element in ``it`` that ``predicate`` accepts.
If ``predicate`` is None it will return the first item that's not
:const:`None`.
c 3 s, | ]$}� d ur� |�rn|d ur|V qd S r r )�.0�v�� predicater r# � <genexpr>Q s �zfirst.<locals>.<genexpr>N)�nextr: )r> r8 r r= r# r J s �r c s � �fdd�}|S )z�Multiple dispatch.
Return a function that with a list of instances,
finds the first instance that gives a value for the given method.
The list can also contain lazy instances
(:class:`~kombu.utils.functional.lazy`.)
c sl | D ]b}z:t t|�� �}�r2�|g|�R i |��n ||i |��}W n tyT Y q0 |d ur| S qd S r )�getattrr
�AttributeError)r8 r3 r4 �obj�methZreply��method�on_callr r# �_matchera s � z firstmethod.<locals>._matcherr )rF rG rH r rE r# r W s
r c c s( | D ] }|gt t| |d �� V qdS )as Split an iterator into chunks with `n` elements each.
Warning:
``it`` must be an actual iterator, if you pass this a
concrete sequence will get you repeating elements.
So ``chunks(iter(range(1000)), 10)`` is fine, but
``chunks(range(1000), 10)`` is not.
Example:
# n == 2
>>> x = chunks(iter([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), 2)
>>> list(x)
[[0, 1], [2, 3], [4, 5], [6, 7], [8, 9], [10]]
# n == 3
>>> x = chunks(iter([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]), 3)
>>> list(x)
[[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10]]
� N)�listr )r8 �n�itemr r r# r p s r c C s" t | �d|� |g|t| � S )a� Pad list with default elements.
Example:
>>> first, last, city = padlist(['George', 'Costanza', 'NYC'], 3)
('George', 'Costanza', 'NYC')
>>> first, last, city = padlist(['George', 'Costanza'], 3)
('George', 'Costanza', None)
>>> first, last, city, planet = padlist(
... ['George', 'Costanza', 'NYC'], 4, default='Earth',
... )
('George', 'Costanza', 'NYC', 'Earth')
N)rJ �len)� container�size�defaultr r r# r � s
r c s � fdd�S )z�Get attributes, ignoring attribute errors.
Like :func:`operator.itemgetter` but return :const:`None` on missing
attributes instead of raising :exc:`AttributeError`.
c s � fdd��D �S )Nc s i | ]}|t � |d ��qS r )rA )r; �attr�rC r r# �
<dictcomp>� � z1mattrgetter.<locals>.<lambda>.<locals>.<dictcomp>r rR ��attrsrR r# �<lambda>� rT z mattrgetter.<locals>.<lambda>r rU r rU r# r � s r c s t � � � fdd�| D �S )z7Return all unique elements in ``it``, preserving order.c 3 s$ | ] }|� vr� � |�p|V qd S r )�add)r; rC ��seenr r# r? � rT zuniq.<locals>.<genexpr>)�set�r8 r rY r# r � s r c C s t | �\}}t|d� t||�S )z�Yield pairs of (current, next) items in `it`.
`next` is None if `current` is the last item.
Example:
>>> list(lookahead(x for x in range(6)))
[(0, 1), (1, 2), (2, 3), (3, 4), (4, 5), (5, None)]
N)r r@ r )r8 �a�br r r# � lookahead� s
r_ c C s t | ttf�r| S t| �S )z�Convert iterator to an object that can be consumed multiple times.
``Regen`` takes any iterable, and if the object is an
generator it will cache the evaluated list on first access,
so that the generator can be "consumed" multiple times.
)r7 rJ �tuple�_regenr\ r r r# r � s r c @ sb e Zd Zdd� Zdd� Zdd� Zdd� Zdd
d �Zd d
� Zdd� Z dd� Z
e dd� �Z dd� Z
d S )ra c C s || _ g | _d| _d S )NF)�
_regen__it�_regen__consumed� _regen__done)r" r8 r r r# �__init__� s z_regen.__init__c C s t | jffS r )rJ �datar! r r r# �
__reduce__� s z_regen.__reduce__c s( � fdd�| j D �| _ t� | j�| _d S )Nc s g | ] }� |��qS r r )r; �el��funcr r# �
<listcomp>� rT z _regen.map.<locals>.<listcomp>)rc �maprb )r" rj r ri r# rl � s z
_regen.mapc C s
| j �� S r )rb �__length_hint__r! r r r# rm � s z_regen.__length_hint__Nc c s� | j s�|d u s|dkr�t| j�}z t|�}W n ty@ Y d S 0 | j�|� | j s�zHzt|�}| j�|� W n$ ty� d| _ Y W |V q�Y n0 W |V n|V 0 |}|d urN|d8 }|dkrNq�qNd S )Nr TrI )rd �iterrb r@ �
StopIterationrc �append)r" �limitr8 �nowZnext_r r r# Z__lookahead_consume� s,
�
z_regen.__lookahead_consumec c s | j E d H | �� E d H d S r )rc �_regen__lookahead_consumer! r r r# �__iter__� s z_regen.__iter__c C s@ |dk r| j | S |t| j� d }| j|d�D ]}q0| j| S )Nr rI )rq )rf rM rc rs )r" �indexZ
consume_count�_r r r# � __getitem__� s
z_regen.__getitem__c C s< t | j�rdS ztt| �� W n ty2 Y dS 0 dS d S )NTF)rM rc r@ rn ro r! r r r# �__bool__� s
z_regen.__bool__c C s | j s| j�| j� d| _ | jS r* )rd rc �extendrb r! r r r# rf s z _regen.datac C s. d� | jjd�dd� | jD ��| js(dnd�S )Nz <{}: [{}{}]>�, c s s | ]}t |�V qd S r )�repr)r; �er r r# r? rT z"_regen.__repr__.<locals>.<genexpr>z...� )�formatr0 r' �joinrc rd r! r r r# �__repr__ s
�z_regen.__repr__)N)r' r( r) re rg rl rm rs rt rw rx �propertyrf r� r r r r# ra � s
ra Tc
C sP | j rXt| j �}|r&ttt| j ���n| j }| jd | � }tt| j| d � |��}n | jg }}| j}| j}| jr�t | j
�t | j� � � }|r�dd� t | j� � �D �} q�t| j�
� �} n | j
g }} d�td d�|�d�dd� |D ��|r�d|� �nd |�s| �r|�sdnd |�r"d�|�nd d�dd� | D ��|�rFd|� �nd g��S ) Nc S s g | ]\}}||f�qS r r )r; �i�kwr r r# rk ' s z!_argsfromspec.<locals>.<listcomp>rz c s s | ]\}}|� d |� �V qdS )�=Nr �r; �kr< r r r# r? 1 rT z _argsfromspec.<locals>.<genexpr>�*c s s" | ]\}}|� d |� d�V qdS )z="�"Nr r� r r r# r? 5 rT z**)�defaultsrM rJ �ranger3 �zip�varargs�varkw�kwonlydefaultsr[ �
kwonlyargs�keys� enumerate�itemsr �filter)
�specZreplace_defaults�splitr� �
positional�optionalr� r� r� Zkwonlyargs_optionalr r r# �
_argsfromspec s6
� � �r� F.)�fun�bound�returnc
C s� t �| �}t| �}| jjdk}t �| �}|sJ|rJ|sJ|sJ| jj| j }} n| j}tj|t t �
| ��dd�}t � |� d| j
i}t||� || } || _|r�t| t� �S | S )z1Generate signature function from actual function.Zcython_function_or_methodrI )Zfun_nameZfun_argsZ fun_valuer' )�inspect�
isfunction�callabler0 r' �ismethod�__call__�FUNHEAD_TEMPLATEr~ r� �getfullargspec�logger�debugr( �exec�_sourcer �object)
r� r� Z is_functionZ is_callableZ is_cythonZ is_method�nameZ
definition� namespace�resultr r r# r : s(
�
r c C s t �| �}|jp t|j�|kS r )r� r� r� rM r3 )r� rK Zargspecr r r# �
arity_greater[ s
r� c C s2 t �|�}|jp0|jp0|r(t|j�|kS | |jv S r )r� r� r� r� rM r3 )r� r� �positionr� r r r# �fun_takes_argument` s
�r� c C s t dd� t�| �j�� D ��S )z<Return true if function accepts arbitrary keyword arguments.c s s | ]}|j |jkr|V qd S r )�kind� VAR_KEYWORD)r; �pr r r# r? j s �z%fun_accepts_kwargs.<locals>.<genexpr>)�anyr� � signature�
parameters�values)r� r r r# r h s �r c C s |dur| |�S |S )z$Call typ on value if val is defined.Nr )�typ�valr r r# r p s r c C s t | t�r| |f S | |g S )z�Return copy of sequence seq with item added.
Returns:
Sequence: if seq is a tuple, the result will be a tuple,
otherwise it depends on the implementation of ``__add__``.
)r7 r` )�seqrL r r r# �seq_concat_itemu s r� c C s@ t t| |gtd��}t| |�s&|| �} t||�s8||�}| | S )a Concatenate two sequences: ``a + b``.
Returns:
Sequence: The return value will depend on the largest sequence
- if b is larger and is a tuple, the return value will be a tuple.
- if a is larger and is a list, the return value will be a list,
)�key)�type�maxrM r7 )r] r^ Zpreferr r r# �seq_concat_seq s
r� c C s t | ttf�ot | t� S r )r7 �int�float�bool)r9 r r r# �is_numeric_value� s r� )N)N)T)F)N)7r1 r� � collectionsr � functoolsr � itertoolsr r r �typingr r Zkombu.utils.functionalr r
r r r
r r Zviner Zcelery.utils.logr r' r� �__all__r� r r r r6 r: r r r r r r r_ r rJ ra r� r� �strr r� r� r r r� r� r� r r r r# �<module> sD $
W
" !