ClickUp Operator

� lMg�#��x�dd
lm
Z

Gd�d�ZGd�de�ZGd�de�ZGd�d e�Ze�x
ZZy )�)
�wrapsc�|�eZ
dZd
Zdd�
Zd�Zd�Zd�Zd�Zd�Z d �Z d �Zdd�
Zdd�
Z d �Zd�Zd�Zd�Zedd�
�Zy)�Callbacka� Base class and interface for callback mechanism This class can be used directly for monitoring file transfers by providing ``callback=Callback(hooks=...)`` (see the ``hooks`` argument, below), or subclassed for more specialised behaviour. Parameters ---------- size: int (optional) Nominal quantity for the value that corresponds to a complete transfer, e.g., total number of tiles or total number of bytes value: int (0) Starting internal counter value hooks: dict or None A dict of named functions to be called on each update. The signature of these must be ``f(size, value, **kwargs)`` Nc�D�|
|_||_
|x
s
i|_||_y�
N)�size�value�hooks�kw)�selfrr r �kwargss �\C:\Users\noahv\Documents\GitHub\clickup-operator\.venv\Lib\site-packages\fsspec/callbacks.py�__init__zCallback.__init__s"���� ��� ��[�b�� ����c

��|Sr��
rs
r� __enter__zCallback.__enter__s���rc
�$�|j
�
yr�
�close)r�exc_argss r�__exit__zCallback.__exit__"s��� � �rc
��y
)zClose callback.Nrrs
rrzCallback.close%s�rc�T�|j
|
||�
|jd
t�S)a� Return callback for child transfers If this callback is operating at a higher level, e.g., put, which may trigger transfers that can also be monitored. The function returns a callback that has to be passed to the child method, e.g., put_file, as `callback=` argument. The implementation uses `callback.branch` for compatibility. When implementing callbacks, it is recommended to override this function instead of `branch` and avoid calling `super().branched(...)`. Prefer using this function over `branch`. Parameters ---------- path_1: str Child's source path path_2: str Child's destination path **kwargs: Arbitrary keyword arguments Returns ------- callback: Callback A callback instance to be passed to the child method �callback)�branch�pop�DEFAULT_CALLBACK�r�path_1�path_2r s r�branchedzCallback.branched(s&��: ���F�F�F�+��z�z�*�&6�7�7rc�@��
�t
�
�
d
tf�
�fd��}|S)zI Wraps a coroutine, and pass a new child callback to it. �path2c���K
��j||
fi|�
�
5}�||
fd
|i
|�
�
�d{���cddd�
S7� #1s
w
Y

yxYw
�w
)Nr)
r#)�path1r%r �child�fnrs ��r�funcz"Callback.branch_coro.<locals>.funcNsM���������u�e�6�v�6�%���u�G�u�G��G�G�
H
�
H
�G��7�6�s$�A
�8�
6�8� A
�
8�A
�A
)r�str)rr)r*s`` r�branch_corozCallback.branch_coroIs,��� �r�� H
�S� H
� � H
��rc�2�|
|_|j�
y
)z� Set the internal maximum size attribute Usually called if not initially set at instantiation. Note that this triggers a ``call()``. Parameters ---------- size: int N)r�call)rrs r�set_sizezCallback.set_sizeUs���� �� � �rc�2�|
|_|j�
y
)z� Set the internal value state Triggers ``call()`` Parameters ---------- value: int N�r r.)rr s r�absolute_updatezCallback.absolute_updatecs���� �� � �rc�N�|x
j|
z c_|j�
y
)z� Delta increment the internal counter Triggers ``call()`` Parameters ---------- inc: int Nr1)r�incs r�relative_updatezCallback.relative_updateps�� � � �c�� �� � �rc�n
�|js
y
|jj�}|j|�

|
r:|
|jv
r
y
|j|
|j|j fi|�
�
S|jj �x
s
gD] }||j|j fi|�
�

�"y
)a
Execute hook(s) with current state Each function is passed the internal size and current value Parameters ---------- hook_name: str or None If given, execute on this hook kwargs: passed on to (all) hook(s) N)r r�copy�updaterr �values)r� hook_namer r�hooks rr.z Callback.call}s����z�z�� �W�W�\�\�^�� � � �&����� � �*��(�4�:�:�i�(����D�J�J�E�"�E�E��J�J�%�%�'�-�2�-�D�����D�J�J�-�"�-�.rc#�BK
�|
D]}|j
�
|�
�

�y
�w
)z� Wrap an iterable to call ``relative_update`` on each iterations Parameters ---------- iterable: Iterable The iterable that is being wrapped N)
r5)r�iterable�items r�wrapz Callback.wrap�s#�����D�� � �"��J��s�
c��y
)a; Set callbacks for child transfers If this callback is operating at a higher level, e.g., put, which may trigger transfers that can also be monitored. The passed kwargs are to be *mutated* to add ``callback=``, if this class supports branching to children. Parameters ---------- path_1: str Child's source path path_2: str Child's destination path kwargs: dict arguments passed to child method, e.g., put_file. Returns ------- Nrr s rrzCallback.branch�s��,rc
��yrr)r�
_�__s r�no_opzCallback.no_op�s��rc
��|jS)
zP If undefined methods are called on this class, nothing happens )
rD)rr>s r�__getattr__zCallback.__getattr__�s���z�z�rc
��|
�tS|
S)
a
Transform callback=... into Callback instance For the special value of ``None``, return the global instance of ``NoOpCallback``. This is an alternative to including ``callback=DEFAULT_CALLBACK`` directly in a method signature. )
r)�cls�maybe_callbacks r�as_callbackzCallback.as_callback�s���!�#�#��r)NrN)
�
r)�__name__� __module__�__qualname__�__doc__rrrrr#r,r/r2r5r.r?rrDrF�classmethodrJrrrrrsb���(�
�
�
�8�B
����.�.��0
 ��� �� rrc
��eZ
dZd
Zd�Zy)�NoOpCallbackz> This implementation of Callback does exactly nothing c
��yrr�r�argsr s rr.zNoOpCallback.call�s��rN)rLrMrNrOr.rrrrRrR�s���
rrRc�0��eZ
dZd
Zd�f
d� Zd�Zd�Z�x
ZS)�DotPrinterCallbackz� Simple example Callback implementation Almost identical to Callback with a hook that prints a char; here we demonstrate how the outer layer may print "#" and the inner layer "." c�2�
�|
|_t�|�d
i|�
�

y)Nr)�chr�superr)r�chr_to_printr � __class__s �rrzDotPrinterCallback.__init__�s������ ���"�6�"rc� �t
d
�
|d<y)z;Mutate kwargs to add new instance with different print char�
.rN)
rWr s rrzDotPrinterCallback.branch�s��/��4��z�rc
�2�t
|jd
��
y)zJust outputs a character�)
�endN)�printrY)rr s rr.zDotPrinterCallback.call�s�� �d�h�h�B�r)
�
#)rLrMrNrOrrr.� __classcell__�
r\s
@rrWrW�s����#�5� rrWc�6��eZ
dZd
Zd�f
d� Zd�Zd�Zd�Z�x
ZS)�TqdmCallbacka� A callback to display a progress bar using tqdm Parameters ---------- tqdm_kwargs : dict, (optional) Any argument accepted by the tqdm constructor. See the `tqdm doc <https://tqdm.github.io/docs/tqdm/#__init__>`_. Will be forwarded to `tqdm_cls`. tqdm_cls: (optional) subclass of `tqdm.tqdm`. If not passed, it will default to `tqdm.tqdm`. Examples -------- >>> import fsspec >>> from fsspec.callbacks import TqdmCallback >>> fs = fsspec.filesystem("memory") >>> path2distant_data = "/your-path" >>> fs.upload( ".", path2distant_data, recursive=True, callback=TqdmCallback(), ) You can forward args to tqdm using the ``tqdm_kwargs`` parameter. >>> fs.upload( ".", path2distant_data, recursive=True, callback=TqdmCallback(tqdm_kwargs={"desc": "Your tqdm description"}), ) You can also customize the progress bar by passing a subclass of `tqdm`. .. code-block:: python class TqdmFormat(tqdm): '''Provides a `total_time` format parameter''' @property def format_dict(self): d = super().format_dict total_time = d["elapsed"] * (d["total"] or 0) / max(d["n"], 1) d.update(total_time=self.format_interval(total_time) + " in total") return d >>> with TqdmCallback( tqdm_kwargs={ "desc": "desc", "bar_format": "{total_time}: {percentage:.0f}%|{bar}{r_bar}", }, tqdm_cls=TqdmFormat, ) as callback: fs.upload(".", path2distant_data, recursive=True, callback=callback) c��
� d
dlm}
|jd|�|_|
x
s
i|_d|_t�|�|i|�
�

y#t$r}td�
|�d}~w
wxYw
)Nr)
�tqdmz0Using TqdmCallback requires tqdm to be installed�tqdm_cls)ri�ImportErrorr� _tqdm_cls�_tqdm_kwargsrZr)r�tqdm_kwargsrUr ri�excer\s �rrzTqdmCallback.__init__'
sj��� �!� ���J��5���'�-�2����� � ���$�)�&�)��� ��B��� �� �s�A� A�A�Ac
�$
�|j�-|jdd
|ji
|j�
�
|_|j|j_|jj|j|jjz �

y)N�totalr)rirlrrmrqr8r �
nrTs rr.zTqdmCallback.call5
sb���9�9��&����L�T�Y�Y�L�$�:K�:K�L�D�I��)�)�� � ��� � ������d�i�i�k�k�1�2rc
�`�|j�"|jj�
d|_yyr)rirrs
rrzTqdmCallback.close;
s&���9�9� ��I�I�O�O���D�I�!rc
�"�|j
�Srrrs
r�__del__zTqdmCallback.__del__@
s���z�z�|�rr) rLrMrNrOrr.rrurdres
@rrgrg�s���7�r
*�3��
rrgN)� functoolsrrrRrWrgr�_DEFAULT_CALLBACKrrr�<module>rx
sL�


��H
�H
�V
�8�
�
��
�*T

�8�T

�n(4�~�5��$r