
    g#                     x    d dl mZ  G d d      Z G d de      Z G d de      Z G d d	e      Z e       xZZy
)    )wrapsc                   |    e Zd ZdZddZd Zd Zd Zd Zd Z	d	 Z
d
 ZddZddZd Zd Zd Zd Zedd       Zy)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)selfr   r	   r
   kwargss        E/var/www/openai/venv/lib/python3.12/site-packages/fsspec/callbacks.py__init__zCallback.__init__   s"    	
[b
    c                     | S r    r   s    r   	__enter__zCallback.__enter__   s    r   c                 $    | j                          y r   close)r   exc_argss     r   __exit__zCallback.__exit__"   s    

r   c                      y)zClose callback.Nr   r   s    r   r   zCallback.close%   s    r   c                 T    | j                  |||       |j                  d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   branchedzCallback.branched(   s&    : 	FFF+zz*&677r   c                 @     t              dt        f fd       }|S )zI
        Wraps a coroutine, and pass a new child callback to it.
        path2c                    K    j                   | |fi |5 } | |fd|i| d {   cd d d        S 7 # 1 sw Y   y xY ww)Nr   )r#   )path1r%   r   childfnr   s       r   funcz"Callback.branch_coro.<locals>.funcN   sI     ue6v6%uGuGGG 76G 76s$   A868
A8AA)r   str)r   r)   r*   s   `` r   branch_corozCallback.branch_coroI   s,    
 
r	HS 	H 
	H r   c                 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   r   s     r   set_sizezCallback.set_sizeU   s     			r   c                 2    || _         | j                          y)z
        Set the internal value state

        Triggers ``call()``

        Parameters
        ----------
        value: int
        Nr	   r.   )r   r	   s     r   absolute_updatezCallback.absolute_updatec   s     
		r   c                 N    | xj                   |z  c_         | j                          y)z
        Delta increment the internal counter

        Triggers ``call()``

        Parameters
        ----------
        inc: int
        Nr1   )r   incs     r   relative_updatezCallback.relative_updatep   s     	

c
		r   c                 n   | j                   sy| j                  j                         }|j                  |       |r:|| j                   vry | j                   |   | j                  | j
                  fi |S | j                   j                         xs g D ]   } || j                  | j
                  fi | " 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updater   r	   values)r   	hook_namer   r   hooks        r   r.   zCallback.call}   s     zzWW\\^
		&

*(4::i(DJJE"EEJJ%%'-2-DDJJ-"- .r   c              #   B   K   |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
        -------

        Nr   r    s       r   r   zCallback.branch   s    , r   c                      y r   r   )r   ___s      r   no_opzCallback.no_op   s    r   c                     | j                   S )zP
        If undefined methods are called on this class, nothing happens
        )rD   )r   r>   s     r   __getattr__zCallback.__getattr__   s     zzr   c                     |t         S |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_callbackzCallback.as_callback   s     !##r   )Nr   N)   r   )__name__
__module____qualname____doc__r   r   r   r   r#   r,   r/   r2   r5   r.   r?   r   rD   rF   classmethodrJ   r   r   r   r   r      sb    (8B
..0 	 	r   r   c                       e Zd ZdZd Zy)NoOpCallbackz>
    This implementation of Callback does exactly nothing
    c                      y r   r   r   argsr   s      r   r.   zNoOpCallback.call   s    r   N)rL   rM   rN   rO   r.   r   r   r   rR   rR      s    r   rR   c                   0     e Zd ZdZd fd	Zd Zd Z xZS )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      r   r   zDotPrinterCallback.__init__   s    "6"r   c                      t        d      |d<   y)z;Mutate kwargs to add new instance with different print char.r   N)rW   r    s       r   r   zDotPrinterCallback.branch   s    /4zr   c                 2    t        | j                  d       y)zJust outputs a character )endN)printrY   )r   r   s     r   r.   zDotPrinterCallback.call   s    dhhBr   )#)rL   rM   rN   rO   r   r   r.   __classcell__r\   s   @r   rW   rW      s    #5 r   rW   c                   6     e Zd ZdZd fd	Zd Zd Zd Z xZS )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dl m } |j                  d|      | _        |xs i | _        d | _         t        |   |i | y # t        $ r}t        d      |d }~ww xY w)Nr   )tqdmz0Using TqdmCallback requires tqdm to be installedtqdm_cls)ri   ImportErrorr   	_tqdm_cls_tqdm_kwargsrZ   r   )r   tqdm_kwargsrU   r   ri   excer\   s         r   r   zTqdmCallback.__init__'  sj    	!  J5'-2	$)&)  	B	s   A 	AAAc                 $   | j                   - | j                  dd| j                  i| j                  | _         | j                  | j                   _        | j                   j                  | j                  | j                   j                  z
         y )Ntotalr   )ri   rl   r   rm   rq   r8   r	   nrT   s      r   r.   zTqdmCallback.call5  sb    99&LTYYL$:K:KLDI))				diikk12r   c                 `    | j                   "| j                   j                          d | _         y y r   )ri   r   r   s    r   r   zTqdmCallback.close;  s&    99 IIOODI !r   c                 "    | j                         S r   r   r   s    r   __del__zTqdmCallback.__del__@  s    zz|r   r   )	rL   rM   rN   rO   r   r.   r   ru   rd   re   s   @r   rg   rg      s    7r*3
r   rg   N)	functoolsr   r   rR   rW   rg   r   _DEFAULT_CALLBACKr   r   r   <module>rx      sL    H HV8    *T8 Tn (4~ 5 $r   