
    g                        d dl Z d dlZd dlZd dlZd dlZd dlZd dlmZ d dlm	Z	 d dl
mZmZmZmZmZmZmZmZ d dlmZ d dlmZ d dlmZmZ dd	lmZmZ dd
lmZ ddlm Z m!Z!m"Z"m#Z#m$Z$m%Z% ddl&m'Z'  e"j(        e)          Z* G d d          Z+dee,e	f         de-fdZ.dee,e	f         de,de-fdZ/dee,e	f         de-fdZ0dee,e	f         de-fdZ1dee,e	f         de-fdZ2d#de,dee,e	df         dee,         fdZ3dee,e	f         de-fdZ4d$dee,e	f         dee,         de5fdZ6 G d de          Z7ed              Z8 G d! d"          Z9dS )%    N)contextmanager)Path)CallableDictIteratorListOptionalTuple	TypedDictUnion)urlparse)	constants)metadata_loadmetadata_save   )HfApirepo_type_and_id_from_hf_id)LFS_MULTIPART_UPLOAD_COMMAND)SoftTemporaryDirectory	get_tokenloggingrun_subprocesstqdmvalidate_hf_hub_args)_deprecate_methodc                       e Zd ZdZ	 ddedededej        dee         f
dZ	e
d	efd
            Ze
d	efd            Ze
d	efd            Ze
d	efd            Ze
d	efd            Zd ZdS )CommandInProgressz=
    Utility to follow commands launched asynchronously.
    Ntitleis_done_methodstatus_methodprocesspost_methodc                 h    || _         || _        || _        || _        d| _        d| _        || _        d S )N )r   _is_done_status_process_stderr_stdout_post_method)selfr   r   r    r!   r"   s         V/var/www/html/ai-engine/env/lib/python3.11/site-packages/huggingface_hub/repository.py__init__zCommandInProgress.__init__$   s<     
&$'    returnc                 v    |                                  }|r"| j        |                                  d| _        |S )z.
        Whether the process is done.
        N)r%   r*   )r+   results     r,   is_donezCommandInProgress.is_done4   s@    
  	%d'3 $Dr.   c                 *    |                                  S )z
        The exit code/status of the current action. Will return `0` if the
        command has completed successfully, and a number between 1 and 255 if
        the process errored-out.

        Will return -1 if the command is still ongoing.
        )r&   r+   s    r,   statuszCommandInProgress.statusA   s     ||~~r.   c                     | j         dk    S )z2
        Whether the process errored-out.
        r   r5   r4   s    r,   failedzCommandInProgress.failedL   s    
 {Qr.   c                     | j         j        ,| xj        | j         j                                        z  c_        | j        S )zC
        The current output message on the standard error.
        )r'   stderrr(   readr4   s    r,   r:   zCommandInProgress.stderrS   8    
 =+LLDM055777LL|r.   c                     | j         j        ,| xj        | j         j                                        z  c_        | j        S )zD
        The current output message on the standard output.
        )r'   stdoutr)   r;   r4   s    r,   r>   zCommandInProgress.stdout\   r<   r.   c           	      n    | j         }|dk    rd}d| j         d| d| j        sdnd d| j        j         d		S )
Nrunning[z command, status code: z, zin progress.z	finished.z PID: ])r5   r   r2   r'   pid)r+   r5   s     r,   __repr__zCommandInProgress.__repr__e   sj    R<<F%
 % %6 % %&*lC% %!% % %	
r.   N)__name__
__module____qualname____doc__strr   
subprocessPopenr	   r-   propertyboolr2   intr5   r8   r:   r>   rE    r.   r,   r   r      sF         +/( (( !(  	(
 !( h'( ( ( (  
 
 
 
 X
     X     X     X     X

 

 

 

 

r.   r   folderr/   c                    t           j                            t           j                            | d                    }t	          j        d                                | t          j        t          j                  }|o
|j        dk    S )a  
    Check if the folder is the root or part of a git repository

    Args:
        folder (`str`):
            The folder in which to run the command.

    Returns:
        `bool`: `True` if the repository is part of a repository, `False`
        otherwise.
    z.gitz
git branch)cwdr>   r:   r   )	ospathexistsjoinrL   runsplitPIPE
returncode)rR   folder_exists
git_branchs      r,   is_git_repor_   r   sd     GNN27<<#?#?@@M 2 2 4 4&akapqqqJ7Z2a77r.   
remote_urlc                     t          |           sdS t          d|           j        }t          j        dd|          }d |                                D             }||v S )am  
    Check if the folder is a local clone of the remote_url

    Args:
        folder (`str` or `Path`):
            The folder in which to run the command.
        remote_url (`str`):
            The url of a git repository.

    Returns:
        `bool`: `True` if the repository is a local clone of the remote
        repository specified, `False` otherwise.
    Fzgit remote -vhttps://.*@https://c                 :    g | ]}t          j        d d|          S )rb   rc   )resub).0remotes     r,   
<listcomp>z"is_local_clone.<locals>.<listcomp>   s&    XXXfrvnj&99XXXr.   )r_   r   r>   re   rf   rZ   )rR   r`   remotess      r,   is_local_clonerk      sf     v u_f55<G 
J??JXXXXXG  r.   filenamec                 D   t          |           j        }t          |           j        } 	 t          d                                | gz   |          }|j                                        }n@# t          j        $ r.}t          |          sY d}~dS t          |j                  d}~ww xY wt          |          dk    rdS dddd}|                    d          D ]&}|                                D ]}||v r	d|v rd||<   't          |                                          S )	z
    Check if the file passed is tracked with git-lfs.

    Args:
        filename (`str` or `Path`):
            The filename to check.

    Returns:
        `bool`: `True` if the file passed is tracked with git-lfs, `False`
        otherwise.
    zgit check-attr -aNFr   )diffmergefilter
lfsT)r   parentnamer   rZ   r>   striprL   CalledProcessErrorr_   OSErrorr:   lenkeysallvalues)rl   rR   p
attributesexcfound_lfs_tag	attributetags           r,   is_tracked_with_lfsr      sJ    (^^"FH~~"H&.4466(CVLLX^^%%

( & & &6"" 	&55555#*%%%	& :!u"UeDDM%%d++ * *	 %%'' 	* 	*CiEY$6$6%)c"	* }##%%&&&s   ?A* *B'9B"B""B'c                 *   t          |           j        }t          |           j        } 	 t          d                                | gz   |d          }t          |j                   }n+# t          j        $ r}t          |j
                  d}~ww xY w|S )a  
    Check if file is git-ignored. Supports nested .gitignore files.

    Args:
        filename (`str` or `Path`):
            The filename to check.

    Returns:
        `bool`: `True` if the file passed is ignored by `git`, `False`
        otherwise.
    zgit check-ignoreFcheckN)r   rs   rt   r   rZ   rO   r\   rL   rv   rw   r:   )rl   rR   r|   
is_ignoredr~   s        r,   is_git_ignoredr      s     (^^"FH~~"H"-3355
BFRWXXXal+++

( " " "cj!!!" s   =A( (B7BBc           	      L   	 t          | d          5 }|                    d          }ddd           n# 1 swxY w Y   t          h dt          t	          dd                    dhz
  z            }t          |                    d|                    S # t          $ r Y dS w xY w)	z
    Check if file is a binary file.

    Args:
        filename (`str` or `Path`):
            The filename to check.

    Returns:
        `bool`: `True` if the file passed is a binary file, `False` otherwise.
    rbi   N>         	   
                      T)openr;   	bytearraysetrangerO   	translateUnicodeDecodeError)rl   fcontent
text_charss       r,   is_binary_filer      s    	(D!! 	-Qff^,,G	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	- 	-
 8883uT5?Q?Q;R;RVZU[;[[\\
G%%dJ77888   tts-   B 4B 8B 8AB 
B#"B#.patternc                 V   	 t          d                                | gz   |          }t          |j                                                  r-|j                                                            d          }ng }n+# t
          j        $ r}t          |j                  d}~ww xY w|S )aQ  
    Returns a list of filenames that are to be staged.

    Args:
        pattern (`str` or `Path`):
            The pattern of filenames to check. Put `.` to get all files.
        folder (`str` or `Path`):
            The folder in which to run the command.

    Returns:
        `List[str]`: List of files that are to be staged.
    z#git ls-files --exclude-standard -morq   N)	r   rZ   rx   r>   ru   rL   rv   EnvironmentErrorr:   )r   rR   r|   filesr~   s        r,   files_to_be_stagedr      s    +@FFHHG9TV\]]qx~~   	HNN$$**400EEE( + + +sz***+ Ls   A;A> >B&B!!B&c                     	 t          d|            dS # t          j        $ r#}d|j        v rt	          d          Y d}~dS d}~ww xY w)a  
    Check if the current checked-out branch is tracked upstream.

    Args:
        folder (`str` or `Path`):
            The folder in which to run the command.

    Returns:
        `bool`: `True` if the current checked-out branch is tracked upstream,
        `False` otherwise.
    z4git rev-parse --symbolic-full-name --abbrev-ref @{u}THEADzNo branch checked outNF)r   rL   rv   r:   rw   )rR   r~   s     r,   is_tracked_upstreamr   
  sh    MvVVVt(   SZ1222uuuuu	s    AAAupstreamc                     	 t          d|pd |           }t          |j                            d                    dz
  S # t          j        $ r}t          |j                  d}~ww xY w)a  
        Check the number of commits that would be pushed upstream

        Args:
            folder (`str` or `Path`):
                The folder in which to run the command.
            upstream (`str`, *optional*):
    The name of the upstream repository with which the comparison should be
    made.

        Returns:
            `int`: Number of commits that would be pushed upstream were a `git
            push` to proceed.
    zgit cherry -v r$   rq   r   N)r   rx   r>   rZ   rL   rv   r   r:   )rR   r   r1   r~   s       r,   commits_to_pushr      sx    + AR A A6JJ6=&&t,,--11( + + +sz***+s   >A A)A$$A)c                   $    e Zd ZU eed<   eed<   dS )PbarTbar
past_bytesN)rG   rH   rI   r   __annotations__rP   rQ   r.   r,   r   r   6  s"         	IIIOOOOOr.   r   c               #   \  K   t                                           t          j        k    r	 dV  n# t          $ r Y nw xY wdS dt
          j        fd} t          j        	                    dd          }t                      5 }t          j                            |d          t          j        d<   t                               dt          j        d                     t          j                    }t          j        | |fd	          }|                                 	 dV  |                                 |                                 |t          j        d<   n<# |                                 |                                 |t          j        d<   w xY w	 ddd           dS # 1 swxY w Y   dS )
zv
    This is a context manager that will log the Git LFS progress of cleaning,
    smudging, pulling and pushing.
    Nstopping_eventc           
          i fddt           t                   f fd}t          j                            t          j        d                   sc                                 r              dS t          j        d           t          j                            t          j        d                   c |t          j        d                   D ] }	 |	                                \  }}}}n%# t          $ r}t          d|           |d}~ww xY w|                                 d| }|	                    d	          \  }	}
t          |	          }t          |
          }                    ||f          }|,t          |||d
ddd          t          |	          d||f<   |d                             ||d         z
             ||d<   dS )zl
        To be launched as a separate thread with an event meaning it should stop
        the tail.
        c                                                       D ]e} | d                             | d         j        | d         z
             | d                                          | d                                          fd S )Nr   r   )r{   updatetotalrefreshclose)pbarpbarss    r,   close_pbarsz?_lfs_log_progress.<locals>.output_progress.<locals>.close_pbarsR  s|     $ $U""4;#4tL7I#IJJJU##%%%U!!####$ $r.   r/   c              3     K   t          | d          5 }d}	                                 r              nq|                                }|Ft          |                                          dk    s!||z  }|                    d          r|V  d}nt          j        d           	 ddd           dS # 1 swxY w Y   dS )z
            Creates a generator to be iterated through, which will return each
            line one by one. Will stop tailing the file if the stopping_event is
            set.
            rr$   TNr   rq   r   )r   is_setreadlinerx   ru   endswithtimesleep)rl   filecurrent_lineline_bitr   r   s       r,   	tail_filez=_lfs_log_progress.<locals>.output_progress.<locals>.tail_fileX  s      h$$ &!&%,,.. ##}}H+C8H8H4I4IQ4N4N$0'0066 ."....+-L
1& & & & & & & & & & & & & & & & & & &s   BB66B:=B:GIT_LFS_PROGRESSN   z!Cannot unpack LFS progress line:
z file /BTi   zhuggingface_hub.lfs_upload)descinitialr   unit
unit_scaleunit_divisorrt   )r   r   r   r   )r   rK   rU   rV   rW   environr   r   r   rZ   
ValueError
capitalizerP   getr   r   )r   r   linestatefile_progressbyte_progressrl   errordescriptioncurrent_bytestotal_bytescurrent_bytes_inttotal_bytes_intr   r   r   s   `             @@r,   output_progressz*_lfs_log_progress.<locals>.output_progressJ  s<    /1	$ 	$ 	$ 	$ 	$	&8C= 	& 	& 	& 	& 	& 	& 	&0 '..,>!?@@ 	$$&& JqMMM '..,>!?@@ 	 Ibj);<== 	7 	7DY@D

=}mXX Y Y Y !Ld!L!LMMSXXY #--//AAxAAK)6)<)<S)A)A&M; #M 2 2!+..O99eX.//D|  ( 1- #'%)9   #&m"4"4, ,uh'(( U""#4tL7I#IJJJ%6\""=	7 	7s   C//
D9DDr   r$   lfs_progresszFollowing progress in T)targetargsdaemon)loggergetEffectiveLevelr   ERROR	Exception	threadingEventrU   r   r   r   rV   rX   debugThreadstartr   )r   current_lfs_progress_valuetmpdir
exit_eventxs        r,   _lfs_log_progressr   <  s      !!W]22	EEEE 	 	 	D	K7	 K7 K7 K7 K7Z "$0BB!G!G		!	! HV)+fn)M)M
%&Nbj9K.LNNOOO_&&
O:-PTUUU					HEEENNFFHHH-GBJ)** NNFFHHH-GBJ)*GGGG*H H H H H H H H H H H H H H H H H Hs7   0 
== BF!E8F!9FF!!F%(F%c                   Z   e Zd ZU dZee         ed<   e edd          	 	 	 	 	 	 	 	 dHd	e	e
ef         d
ee
         dee
         de	ee
f         dee
         dee
         dee
         dedee         fd                        Zede
fd            Zd ZedIde
de	ee
df         fd            ZdJdee
         dee
         fdZd Zde
fdZde
fdZde
fdZdee
         fdZdKde	e
ee
         f         defd Zde	e
ee
         f         fd!Zd" ZdLd$e
dee
         fd%ZdLd$e
dee
         fd&ZdKd'ZdMd(ed)efd*Z dNd$e
d+efd,Z!dOd.e
fd/Z"	 	 	 dPd0ee
         d1ed2ede	e
e#e
ef         f         fd3Z$dKde
d4efd5Z%dId6e
d7ee
         defd8Z&dId6e
d7ee
         defd9Z'dJd6e
d:ee
         d7ee
         fd;Z(defd<Z)	 	 	 	 dQd.e
d1ed=ed2ede	de
e#e
ef         f         f
d>Z*e+	 	 	 	 dRd.e
d?ee
         d@ed1ed2ef
dA            Z,dee-         fdBZ.dCe-ddfdDZ/edE             Z0edF             Z1dG Z2dS )S
RepositoryaR  
    Helper class to wrap the git and git-lfs commands.

    The aim is to facilitate interacting with huggingface.co hosted model or
    dataset repos, though not a lot here (if any) is actually specific to
    huggingface.co.

    <Tip warning={true}>

    [`Repository`] is deprecated in favor of the http-based alternatives implemented in
    [`HfApi`]. Given its large adoption in legacy code, the complete removal of
    [`Repository`] will only happen in release `v1.0`. For more details, please read
    https://huggingface.co/docs/huggingface_hub/concepts/git_vs_http.

    </Tip>
    command_queuez1.0zPlease prefer the http-based alternatives instead. Given its large adoption in legacy code, the complete removal is only planned on next major release.
For more details, please read https://huggingface.co/docs/huggingface_hub/concepts/git_vs_http.)versionmessageNTF	local_dir
clone_from	repo_typetokengit_user	git_emailrevisionskip_lfs_filesclientc
                 $   t          |t                    rt          |          }t          j        |d           t          j                            t          j                    |          | _        || _	        g | _
        || _        |	|	nt                      | _        |                                  t          |t                    r|| _        n|du rd| _        nt!                      | _        ||                     |           n>t%          | j                  rt&                              d           nt+          d          | j        Q||M| j                            | j                  }
||
                    d          }||
                    d	          }|||                     ||           |                                  |                                  ||                     |d
           t9          j        | j                   dS )a	  
        Instantiate a local clone of a git repo.

        If `clone_from` is set, the repo will be cloned from an existing remote repository.
        If the remote repo does not exist, a `EnvironmentError` exception will be thrown.
        Please create the remote repo first using [`create_repo`].

        `Repository` uses the local git credentials by default. If explicitly set, the `token`
        or the `git_user`/`git_email` pair will be used instead.

        Args:
            local_dir (`str` or `Path`):
                path (e.g. `'my_trained_model/'`) to the local directory, where
                the `Repository` will be initialized.
            clone_from (`str`, *optional*):
                Either a repository url or `repo_id`.
                Example:
                - `"https://huggingface.co/philschmid/playground-tests"`
                - `"philschmid/playground-tests"`
            repo_type (`str`, *optional*):
                To set when cloning a repo from a repo_id. Default is model.
            token (`bool` or `str`, *optional*):
                A valid authentication token (see https://huggingface.co/settings/token).
                If `None` or `True` and machine is logged in (through `huggingface-cli login`
                or [`~huggingface_hub.login`]), token will be retrieved from the cache.
                If `False`, token is not sent in the request header.
            git_user (`str`, *optional*):
                will override the `git config user.name` for committing and
                pushing files to the hub.
            git_email (`str`, *optional*):
                will override the `git config user.email` for committing and
                pushing files to the hub.
            revision (`str`, *optional*):
                Revision to checkout after initializing the repository. If the
                revision doesn't exist, a branch will be created with that
                revision name from the default branch's current HEAD.
            skip_lfs_files (`bool`, *optional*, defaults to `False`):
                whether to skip git-LFS files or not.
            client (`HfApi`, *optional*):
                Instance of [`HfApi`] to use when calling the HF Hub API. A new
                instance will be created if this is left to `None`.

        Raises:
            [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
                If the remote repository set in `clone_from` does not exist.
        T)exist_okNF)repo_urlz [Repository] is a valid git repozNIf not specifying `clone_from`, you need to pass Repository a valid git clone.emailfullnamecreate_branch_ok)
isinstancer   rK   rU   makedirsrV   rX   getcwdr   
_repo_typer   r   r   r   check_git_versionshuggingface_tokenr   r   r_   r   r   r   whoamir   git_config_username_and_emaillfs_enable_largefilesgit_credential_helper_storegit_checkoutatexitregisterwait_for_commands)r+   r   r   r   r   r   r   r   r   r   users              r,   r-   zRepository.__init__  s   F i&& 	'II
I----bikk9==#, & 2ff!!!eS!! 	149D""e^^%)D"" &/[[D"!OOZO00004>** s?@@@@ !qrrr!-93DHX;%%d&<==D  HHW--	88J//9#8..xCCC""$$$((***h>>> 	./////r.   r/   c                     	 t          d| j                  j                                        }n+# t          j        $ r}t          |j                  d}~ww xY w|S )zz
        Returns the current checked out branch.

        Returns:
            `str`: Current checked out branch.
        zgit rev-parse --abbrev-ref HEADNr   r   r>   ru   rL   rv   r   r:   )r+   r1   r~   s      r,   current_branchzRepository.current_branch3  sc    	/#$Et~VV]cceeFF, 	/ 	/ 	/"3:...	/    ,/ AAAc                 r   	 t          d| j                  j                                        }n# t          $ r t          d          w xY w	 t          d| j                  j                                        }n# t          $ r t          d          w xY wt                              |dz   |z              dS )z
        Checks that `git` and `git-lfs` can be run.

        Raises:
            [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
                If `git` or `git-lfs` are not installed.
        zgit --versionz9Looks like you do not have git installed, please install.zgit-lfs --versionzLooks like you do not have git-lfs installed, please install. You can install from https://git-lfs.github.com/. Then run `git lfs install` (you only have to do this once).rq   N)r   r   r>   ru   FileNotFoundErrorr   r   info)r+   git_versionlfs_versions      r,   r  zRepository.check_git_versionsB  s    	`($.IIPVVXXKK  	` 	` 	`"#^___	`	()<dnMMTZZ\\KK  	 	 	"O  	 	K$&455555s   ,/ A	,A: :Br   c                 $   t          |t                    r|n|du rdn| j        }|$|                    d          rt	          d          | j        j        }||v s*d|vrt          |                    d                    dk    rt          ||          \  }}}|| d| n|}||| _
        |dz   }| j
        t          j        v r|t          j        | j
                 z  }|3t          |          j        }|                    | d	| d
| d          }||z  }t!          j        dd|          }		 t%          d| j                   t          t)          j        | j                            dk    rt,                              d|	 d           t1                      5  t(          j                                        }
| j        r|
                    ddi           t%          | j        rdnd d| d| j        |
           ddd           n# 1 swxY w Y   dS dS t;          | j                  s t=          d| j         d| j         d          t?          | j        |          r't,                              | j         d|	 d           dS t%          d| j        d          }d |	 d!|	 d"}|j         dk    r#t!          j        d#d$|j!                  }|d%| z  }t=          |          # tD          j#        $ r}t=          |j$                  d}~ww xY w)&a  
        Clone from a remote. If the folder already exists, will try to clone the
        repository within it.

        If this folder is a git repository with linked history, will try to
        update the repository.

        Args:
            repo_url (`str`):
                The URL from which to clone the repository
            token (`Union[str, bool]`, *optional*):
                Whether to use the authentication token. It can be:
                 - a string which is the token itself
                 - `False`, which would not use the authentication token
                 - `True`, which would fetch the authentication token from the
                   local folder and use it (you should be logged in for this to
                   work).
                - `None`, which would retrieve the value of
                  `self.huggingface_token`.

        <Tip>

        Raises the following error:

            - [`ValueError`](https://docs.python.org/3/library/exceptions.html#ValueError)
              if an organization token (starts with "api_org") is passed. Use must use
              your own personal access token (see https://hf.co/settings/tokens).

            - [`EnvironmentError`](https://docs.python.org/3/library/exceptions.html#EnvironmentError)
              if you are trying to clone the repository in a non-empty folder, or if the
              `git` operations raise errors.

        </Tip>
        FNapi_orgzgYou must use your personal access token, not an Organization token (see https://hf.co/settings/tokens).httpr   r   )hub_urlz://z://user:@z(https?)://.*@z\1://zgit lfs installr   zCloning z into local empty directory.GIT_LFS_SKIP_SMUDGE1z	git clonezgit lfs clone z .)envzPTried to clone a repository in a non-empty folder that isn't a git repository ('z7'). If you really want to do this, do it manually:
 cd z && git init && git remote add origin && git pull origin main
 or clone repo to a new folder and move your existing files there afterwards.z is already a clone of z?. Make sure you pull the latest changes with `repo.git_pull()`.zgit remote get-url originr   zTried to clone zn in an unrelated git repository.
If you believe this is an error, please add a remote with the following URL: r   rb   rc   z'
Local path has its origin defined as: )%r  rK   r	  
startswithr   r   endpointrx   rZ   r   r  r   REPO_TYPES_URL_PREFIXESr   schemereplacere   rf   r   r   rU   listdirr   warningr   r   copyr   r   r_   r   rk   r\   r>   rL   rv   r:   )r+   r   r   r  r   	namespace	repo_namerepo_idr(  clean_repo_urlr$  output	error_msgclean_local_remote_urlr~   s                  r,   r   zRepository.clone_fromY  s)   L %%%EE E>> + 	 !1!1)!<!<8  
 +&h6#9#9c(..QTBUBU>V>VZ[>[>[.I(\c.d.d.d+Iy)4=4I00Y000yG$"+}H)"CCCI=doNN !(++2#++vNNNv<W<Wu<W<W<WXXH  18XFF5	/,dn=== 2:dn--..!33V.VVVWWW&((  *//++C* A

$93#?@@@" +/*=R;;?aaU]aaa                       #4>22 *'/3~' ':>.' ' '   "$.(;; 6NN> . .. . . .     ,,G_deeeFO. O O=KO O O 
 (A--13
TZTa1b1b.!%hPf%h%hh	*9555, 	/ 	/ 	/"3:...	/sL   1A+K' A#H?K' HK' HK' A.K' 
AK' 'L6L

Lc                    	 |+t          d                                |gz   | j                   |,t          d|                                 | j                   dS dS # t          j        $ r}t          |j                  d}~ww xY w)a  
        Sets git username and email (only in the current repo).

        Args:
            git_user (`str`, *optional*):
                The username to register through `git`.
            git_email (`str`, *optional*):
                The email to register through `git`.
        Nzgit config user.namezgit config user.email )r   rZ   r   rL   rv   r   r:   )r+   r   r   r~   s       r,   r  z(Repository.git_config_username_and_email  s    	/#5;;==
JDN[[[$C	CCIIKKT^\\\\\ %$, 	/ 	/ 	/"3:...	/s   AA B.BBc                     	 t          d| j                   dS # t          j        $ r}t	          |j                  d}~ww xY w)z;
        Sets the git credential helper to `store`
        z"git config credential.helper storeN)r   r   rL   rv   r   r:   )r+   r~   s     r,   r  z&Repository.git_credential_helper_store  sR    	/?PPPPP, 	/ 	/ 	/"3:...	/s    A<Ac                     	 t          d| j                  }|j                                        S # t          j        $ r}t          |j                  d}~ww xY w)zy
        Get commit sha on top of HEAD.

        Returns:
            `str`: The current checked out commit SHA.
        zgit rev-parse HEADNr  )r+   r|   r~   s      r,   git_head_hashzRepository.git_head_hash  s]    	/3T^DDA8>>###, 	/ 	/ 	/"3:...	/s   -0 AAAc                     	 t          d| j                  }|j                                        }t	          j        dd|          S # t          j        $ r}t          |j	                  d}~ww xY w)zp
        Get URL to origin remote.

        Returns:
            `str`: The URL of the `origin` remote.
        z"git config --get remote.origin.urlrb   rc   N)
r   r   r>   ru   re   rf   rL   rv   r   r:   )r+   r|   urlr~   s       r,   git_remote_urlzRepository.git_remote_url  sp    	/CT^TTA(..""C6.*c:::, 	/ 	/ 	/"3:...	/s   AA A.A))A.c                     |                                  }|                                 }|                    d          r
|dd         }| d| S )z
        Get URL to last commit on HEAD. We assume it's been pushed, and the url
        scheme is the same one as for GitHub or HuggingFace.

        Returns:
            `str`: The URL to the current checked-out commit.
        r   Nr@   z/commit/)r7  r:  r   )r+   shar9  s      r,   git_head_commit_urlzRepository.git_head_commit_url  s[       ""!!##<< 	crc(C$$s$$$r.   c                 P   	 t          d| j                  j                                        }n+# t          j        $ r}t          |j                  d}~ww xY wt          |          dk    rg S d |	                    d          D             }d |D             }d |D             }|S )z
        Returns a list of the files that are deleted in the working directory or
        index.

        Returns:
            `List[str]`: A list of files that have been deleted in the working
            directory or index.
        zgit status -sNr   c                 6    g | ]}|                                 S rQ   )ru   rg   r5   s     r,   ri   z1Repository.list_deleted_files.<locals>.<listcomp>8  s     "W"W"Wf6<<>>"W"W"Wr.   rq   c                 J    g | ] }d |                                 d         v |!S )Dr   )rZ   r@  s     r,   ri   z1Repository.list_deleted_files.<locals>.<listcomp>;  s6    !k!k!kVRUY_YeYeYgYghiYjRjRj&RjRjRjr.   c                 f    g | ].}|                                 d                                          /S )r@   )rZ   ru   r@  s     r,   ri   z1Repository.list_deleted_files.<locals>.<listcomp>>  s1    YYY+1133YYYr.   
r   r   r>   ru   rL   rv   r   r:   rx   rZ   )r+   
git_statusr~   modified_files_statusesdeleted_files_statusesdeleted_filess         r,   list_deleted_fileszRepository.list_deleted_files  s    	/'HHOUUWWJJ, 	/ 	/ 	/"3:...	/ z??aI #X"W
@P@PQU@V@V"W"W"W "l!k7N!k!k!k ZYBXYYYr  patternsrl   c                     t          |t                    r|g}	 |D ]!}t          d|rdnd d| | j                   "dS # t          j        $ r}t          |j                  d}~ww xY w)a9  
        Tell git-lfs to track files according to a pattern.

        Setting the `filename` argument to `True` will treat the arguments as
        literal filenames, not as patterns. Any special glob characters in the
        filename will be escaped when writing to the `.gitattributes` file.

        Args:
            patterns (`Union[str, List[str]]`):
                The pattern, or list of patterns, to track with git-lfs.
            filename (`bool`, *optional*, defaults to `False`):
                Whether to use the patterns as literal filenames.
        zgit lfs track z
--filenamer$   r#  N)r  rK   r   r   rL   rv   r   r:   )r+   rJ  rl   r   r~   s        r,   	lfs_trackzRepository.lfs_trackB  s     h$$ 	" zH	/#  QX%E\\2QQQQN    
 , 	/ 	/ 	/"3:...	/s   $A   A(A##A(c                     t          |t                    r|g}	 |D ]-}t          d                                |gz   | j                   .dS # t
          j        $ r}t          |j                  d}~ww xY w)z
        Tell git-lfs to untrack those files.

        Args:
            patterns (`Union[str, List[str]]`):
                The pattern, or list of patterns, to untrack with git-lfs.
        zgit lfs untrackN)	r  rK   r   rZ   r   rL   rv   r   r:   )r+   rJ  r   r~   s       r,   lfs_untrackzRepository.lfs_untrack[  s     h$$ 	" zH	/# V V06688G9DdnUUUUV V, 	/ 	/ 	/"3:...	/s   0A A4A//A4c                     	 d}t          | d| j                   t          | dt           | j                   dS # t          j        $ r}t          |j                  d}~ww xY w)zI
        HF-specific. This enables upload support of files >5GB.
        z'git config lfs.customtransfer.multipartz.path huggingface-cliz.args N)r   r   r   rL   rv   r   r:   )r+   
lfs_configr~   s      r,   r  z Repository.lfs_enable_largefilesk  s    	/BJj???PPPCC%ACC     , 	/ 	/ 	/"3:...	/s   9= A%A  A%r   r   c                 <   g }|                                  }t          || j                  D ]}||v rt          j                            t          j                    | j        |          }t          |          st          |          s}t          j        	                    |          dz  }|dk    rt                              d           t          |          }|r*|                     |           |                    |           |                     |           |S )aH  
        Automatically track binary files with git-lfs.

        Args:
            pattern (`str`, *optional*, defaults to "."):
                The pattern with which to track files that are binary.

        Returns:
            `List[str]`: List of filenames that are now tracked due to being
            binary files
        rR      r   zParsing a large file to check if binary or not. Tracking large files using `repository.auto_track_large_files` is recommended so as to not load the full file in memory.)rI  r   r   rU   rV   rX   r  r   r   getsizer   r+  r   rL  appendrN  )r+   r   files_to_be_tracked_with_lfsrH  rl   path_to_file
size_in_mb	is_binarys           r,   auto_track_binary_filesz"Repository.auto_track_binary_filesy  s#    (*$//11*74>JJJ 	B 	BH=((7<<	T^XNNL'55 B9U9U BW__\::kJ
##NNR   +<88	 BNN8,,,077AAA 	'''++r.   c                    g }|                                  }t          || j                  D ]}||v rt          j                            t          j                    | j        |          }t          j                            |          dz  }|dk    rHt          |          s9t          |          s*| 
                    |           |                    |           |                     |           |S )ap  
        Automatically track large files (files that weigh more than 10MBs) with
        git-lfs.

        Args:
            pattern (`str`, *optional*, defaults to "."):
                The pattern with which to track files that are above 10MBs.

        Returns:
            `List[str]`: List of filenames that are now tracked due to their
            size.
        rR  rS  r   )rI  r   r   rU   rV   rX   r  rT  r   r   rL  rU  rN  )r+   r   rV  rH  rl   rW  rX  s          r,   auto_track_large_filesz!Repository.auto_track_large_files  s     (*$//11*74>JJJ 		> 		>H=((7<<	T^XNNL66+FJR(;L(I(IR`amRnRnx(((,33H=== 	'''++r.   c                 "   	 t                      5  t          d|rdnd | j                  }t                              |j                   ddd           dS # 1 swxY w Y   dS # t          j        $ r}t          |j	                  d}~ww xY w)a  
        git lfs prune

        Args:
            recent (`bool`, *optional*, defaults to `False`):
                Whether to prune files even if they were referenced by recent
                commits. See the following
                [link](https://github.com/git-lfs/git-lfs/blob/f3d43f0428a84fc4f1e5405b76b5a73ec2437e65/docs/man/git-lfs-prune.1.ronn#recent-files)
                for more information.
        zgit lfs prune z--recentr$   N
r   r   r   r   r  r>   rL   rv   r   r:   )r+   recentr1   r~   s       r,   	lfs_prunezRepository.lfs_prune  s    	/"$$ + +'(Wv9USU(W(WY]YghhFM***+ + + + + + + + + + + + + + + + + + , 	/ 	/ 	/"3:...	/s:   A& <AA& AA&  A!A& &B5B		Brebaserr   c                 .   |sdnd}|r|dz  }	 t                      5  t          || j                  }t                              |j                   ddd           dS # 1 swxY w Y   dS # t          j        $ r}t          |j	                  d}~ww xY w)a7  
        git pull

        Args:
            rebase (`bool`, *optional*, defaults to `False`):
                Whether to rebase the current branch on top of the upstream
                branch after fetching.
            lfs (`bool`, *optional*, defaults to `False`):
                Whether to fetch the LFS files too. This option only changes the
                behavior when a repository was cloned without fetching the LFS
                files; calling `repo.git_pull(lfs=True)` will then fetch the LFS
                file from the remote repository.
        zgit pullzgit lfs pullz	 --rebaseNr^  )r+   ra  rr   commandr1   r~   s         r,   git_pullzRepository.git_pull  s     %(;**^ 	#{"G	/"$$ + +'@@FM***+ + + + + + + + + + + + + + + + + + , 	/ 	/ 	/"3:...	/s:   A, 5AA, A##A, &A#'A, ,B;BBauto_lfs_trackc                    |r]|                      |          }|                    |                     |                     |rt                              d| d           	 t          d                                |gz   | j                  }t                              d|j	         d           dS # t          j        $ r}t          |j                  d}~ww xY w)a7  
        git add

        Setting the `auto_lfs_track` parameter to `True` will automatically
        track files that are larger than 10MB with `git-lfs`.

        Args:
            pattern (`str`, *optional*, defaults to "."):
                The pattern with which to add files to staging.
            auto_lfs_track (`bool`, *optional*, defaults to `False`):
                Whether to automatically track large and binary files with
                git-lfs. Any file over 10MB in size, or in binary format, will
                be automatically tracked.
        z!Adding files tracked by Git LFS: z5. This may take a bit of time if the files are large.z
git add -vzAdding to index:
rq   N)r\  extendrZ  r   r+  r   rZ   r   r  r>   rL   rv   r   r:   )r+   r   re  tracked_filesr1   r~   s         r,   git_addzRepository.git_add  s      	 77@@M   !=!=g!F!FGGG ; ; ; ;  
	/#L$6$6$8$8G9$DdnUUFKK>V]>>>?????, 	/ 	/ 	/"3:...	/s   !AB1 1C CCcommit files to HF hubcommit_messagec                 R   	 t          d                                |gz   | j                  }t                              d|j         d           dS # t          j        $ rE}t          |j	                  dk    rt          |j	                  t          |j                  d}~ww xY w)z
        git commit

        Args:
            commit_message (`str`, *optional*, defaults to "commit files to HF hub"):
                The message attributed to the commit.
        zgit commit -v -mzCommitted:
rq   r   N)r   rZ   r   r   r  r>   rL   rv   rx   r:   r   )r+   rk  r1   r~   s       r,   
git_commitzRepository.git_commit  s    	3#$6$<$<$>$>.AQ$QSWSabbFKK8v}88899999, 	3 	3 	33:""&sz222&sz222		3s   AA B&!A B!!B&r   blockingauto_lfs_prunec                    d}|r|d| z  }t          | j        |          }|dk    r:t                              d| d           |rt                              d           	 t	                      5  t          j        |                                t
          j        t
          j        d| j                  |r	                                \  }}
                                }                                 t          |          rt                              |           |rt          j        |j        ||	          d
d
d
           n# 1 swxY w Y   n+# t
          j        $ r}	t          |	j                  d
}	~	ww xY w|sUfd}
t#          dfd|
|r| j        nd
          }| j                            |           |                                 |fS |r|                                  |                                 S )a%  
        git push

        If used without setting `blocking`, will return url to commit on remote
        repo. If used with `blocking=True`, will return a tuple containing the
        url to commit and the command object to follow for information about the
        process.

        Args:
            upstream (`str`, *optional*):
                Upstream to which this should push. If not specified, will push
                to the lastly defined upstream or to the default one (`origin
                main`).
            blocking (`bool`, *optional*, defaults to `True`):
                Whether the function should return only when the push has
                finished. Setting this to `False` will return an
                `CommandInProgress` object which has an `is_done` property. This
                property will be set to `True` when the push is finished.
            auto_lfs_prune (`bool`, *optional*, defaults to `False`):
                Whether to automatically prune files once they have been pushed
                to the remote.
        zgit pushz --set-upstream r   zSeveral commits (z) will be pushed upstream.z$The progress bars may be unreliable.zutf-8)r:   r>   encodingrT   )r1  r:   Nc                  8                                     } | dS | S )Nr@   poll)r5   r!   s    r,   r    z*Repository.git_push.<locals>.status_methodd  s     >2!Mr.   pushc                  0                                      d uS rF   rs  )r!   s   r,   <lambda>z%Repository.git_push.<locals>.<lambda>m  s    w||~~T'A r.   )r   r    r!   r"   )r   r   r   r+  r   rL   rM   rZ   r[   communicatert  killrx   rv   r   r   r:   r   r`  r   rU  r=  )r+   r   rn  ro  rc  number_of_commitsr>   r:   return_coder~   r    command_in_progressr!   s               @r,   git_pushzRepository.git_push"  s   8  	54(444G+DNHEEq  NN\/@\\\]]] GEFFF	/"$$ u u$*MMOO%?%?$    	u%,%8%8%:%:NFF"),,..KLLNNN6{{ /v..." u(;K^dmstttt%u u u u u u u u u u u u u u u( , 	/ 	/ 	/"3:...	/  	C" " " " " #4AAAA+.<FDNN$# # # %%&9:::++--/BBB 	NN'')))s=   $E 2CE E EE EE F 'E;;F r  c                 2   	 t          d| | j                  }t                              d| d| j         d           t                              |j                   d	S # t          j        $ r}|st          |j	                  	 t          d| | j                  }t                              d| d| d           t                              |j                   n+# t          j        $ r}t          |j	                  d	}~ww xY wY d	}~d	S d	}~ww xY w)
a  
        git checkout a given revision

        Specifying `create_branch_ok` to `True` will create the branch to the
        given revision if that revision doesn't exist.

        Args:
            revision (`str`):
                The revision to checkout.
            create_branch_ok (`str`, *optional*, defaults to `False`):
                Whether creating a branch named with the `revision` passed at
                the current checked-out reference if `revision` isn't an
                existing revision is allowed.
        zgit checkout zChecked out z from r   zgit checkout -b z
Revision `z2` does not exist. Created and checked out branch `z`.N)
r   r   r   r+  r  r>   rL   rv   r   r:   )r+   r   r  r1   r~   s        r,   r  zRepository.git_checkout|  sI   	7#$>H$>$>OOFNNP(PP$:MPPPQQQNN6=))))), 	7 	7 	7# 
7&sz2227+,Ix,I,I4>ZZFNNmXmmaimmm   NN6=1111!4 7 7 7*3:6667 211111	7s=   AA! !D0DAC D D/DDDDtag_namerh   c                    |ro	 t          d| | j                  j                                        }n+# t          j        $ r}t          |j                  d}~ww xY wt          |          dk    S 	 t          d| j                  j                                        }n+# t          j        $ r}t          |j                  d}~ww xY w|	                    d          }||v S )aw  
        Check if a tag exists or not.

        Args:
            tag_name (`str`):
                The name of the tag to check.
            remote (`str`, *optional*):
                Whether to check if the tag exists on a remote. This parameter
                should be the identifier of the remote.

        Returns:
            `bool`: Whether the tag exists.
        zgit ls-remote origin refs/tags/Nr   zgit tagrq   rD  )r+   r  rh   r1   r~   git_tagss         r,   
tag_existszRepository.tag_exists  s      	(3'(T((T(TVZVdeelrrtt0 3 3 3&sz2223 v;;!##3))T^DDKQQSS0 3 3 3&sz2223  ~~d++Hx''s-   /4 AAA3,B   C/CCc                    d}d}|                      |          sd}|                      ||          sd}|r]	 t          ddd|g| j                  j                                         n+# t
          j        $ r}t          |j                  d}~ww xY w|ra|r_	 t          d| d	| | j                  j                                         n+# t
          j        $ r}t          |j                  d}~ww xY wdS )
a  
        Delete a tag, both local and remote, if it exists

        Args:
            tag_name (`str`):
                The tag name to delete.
            remote (`str`, *optional*):
                The remote on which to delete the tag.

        Returns:
             `bool`: `True` if deleted, `False` if the tag didn't exist.
                If remote is not passed, will just be updated locally
        TF)rh   gitr   z-dN	git push z
 --delete )	r  r   r   r>   ru   rL   rv   r   r:   )r+   r  rh   delete_locallydelete_remotelyr~   s         r,   
delete_tagzRepository.delete_tag  s4    x(( 	#"Nx77 	$#O 	33udH=t~NNU[[]]]]0 3 3 3&sz2223  	3o 	33G6GGXGGXX_eegggg0 3 3 3&sz2223 ts/   0A) )B8BB2C C4C//C4r   c                    |r	ddd|d|g}ndd|g}	 t          || j                  j                                         n+# t          j        $ r}t          |j                  d}~ww xY w|r`	 t          d| d| | j                  j                                         dS # t          j        $ r}t          |j                  d}~ww xY wdS )a[  
        Add a tag at the current head and push it

        If remote is None, will just be updated locally

        If no message is provided, the tag will be lightweight. if a message is
        provided, the tag will be annotated.

        Args:
            tag_name (`str`):
                The name of the tag to be added.
            message (`str`, *optional*):
                The message that accompanies the tag. The tag will turn into an
                annotated tag if a message is passed.
            remote (`str`, *optional*):
                The remote on which to add the tag.
        r  r   z-az-mNr  r#  r  )r+   r  r   rh   tag_argsr~   s         r,   add_tagzRepository.add_tag  s
   $  	0udHdGDHHuh/H	/8T^44;AACCCC, 	/ 	/ 	/"3:...	/  	33>6>>H>>OOV\\^^^^^0 3 3 3&sz2223	3 	3s-   ,? A'A""A'-2B! !C	0CC	c                     	 t          d| j                  j                                        }n+# t          j        $ r}t          |j                  d}~ww xY wt          |          dk    S )z
        Return whether or not the git status is clean or not

        Returns:
            `bool`: `True` if the git status is clean, `False` otherwise.
        zgit status --porcelainNr   )	r   r   r>   ru   rL   rv   r   r:   rx   )r+   rE  r~   s      r,   is_repo_cleanzRepository.is_repo_clean  so    	/'(@$.QQX^^``JJ, 	/ 	/ 	/"3:...	/ :!##r  clean_okc                     |r0|                                  rt                              d           dS |                     d           |                     |           |                     d| j         ||          S )aF  
        Helper to add, commit, and push files to remote repository on the
        HuggingFace Hub. Will automatically track large files (>10MB).

        Args:
            commit_message (`str`):
                Message to use for the commit.
            blocking (`bool`, *optional*, defaults to `True`):
                Whether the function should return only when the `git push` has
                finished.
            clean_ok (`bool`, *optional*, defaults to `True`):
                If True, this function will return None if the repo is
                untouched. Default behavior is to fail because the git command
                fails.
            auto_lfs_prune (`bool`, *optional*, defaults to `False`):
                Whether to automatically prune files once they have been pushed
                to the remote.
        z*Repo currently clean. Ignoring push_to_hubNTre  origin r   rn  ro  )r  r   r  ri  rm  r}  r  )r+   rk  rn  r  ro  s        r,   push_to_hubzRepository.push_to_hub  s    2  	**,, 	KKDEEE4D)))'''}}4t244)  
 
 	
r.   branchtrack_large_filesc              #     K   t          d| j                  }t          |          rbt          |          dk    r"t          |dd                   dd         dz   nt          |          }t                              d| d           ||                     |d	
           t          | j                  r1t                              d           | 	                    d	           n#t                              d| j
         d           t          j                    }t          j        t          j                            || j                             	 | V  |                     |           	 |                     |           n*# t$          $ r}	dt          |	          vr|	Y d}	~	nd}	~	ww xY w	 |                     d| j
         ||           n5# t$          $ r(}	dt          |	          v rt%          d          |	|	d}	~	ww xY wt          j        |           dS # |                     |           	 |                     |           n*# t$          $ r}	dt          |	          vr|	Y d}	~	nd}	~	ww xY w	 |                     d| j
         ||           n5# t$          $ r(}	dt          |	          v rt%          d          |	|	d}	~	ww xY wt          j        |           w xY w)a  
        Context manager utility to handle committing to a repository. This
        automatically tracks large files (>10Mb) with git-lfs. Set the
        `track_large_files` argument to `False` if you wish to ignore that
        behavior.

        Args:
            commit_message (`str`):
                Message to use for the commit.
            branch (`str`, *optional*):
                The branch on which the commit will appear. This branch will be
                checked-out before any operation.
            track_large_files (`bool`, *optional*, defaults to `True`):
                Whether to automatically track large files or not. Will do so by
                default.
            blocking (`bool`, *optional*, defaults to `True`):
                Whether the function should return only when the `git push` has
                finished.
            auto_lfs_prune (`bool`, defaults to `True`):
                Whether to automatically prune files once they have been pushed
                to the remote.

        Examples:

        ```python
        >>> with Repository(
        ...     "text-files",
        ...     clone_from="<user>/text-files",
        ...     token=True,
        >>> ).commit("My first file :)"):
        ...     with open("file.txt", "w+") as f:
        ...         f.write(json.dumps({"hey": 8}))

        >>> import torch

        >>> model = torch.nn.Transformer()
        >>> with Repository(
        ...     "torch-model",
        ...     clone_from="<user>/torch-model",
        ...     token=True,
        >>> ).commit("My cool model :)"):
        ...     torch.save(model.state_dict(), "model.pt")
        ```

        r   rR     Nr@   z, ...]zPThere exists some updated files in the local repository that are not committed: z|. This may lead to errors if checking out a branch. These files and their modifications will be added to the current commit.Tr  zPulling changes ...)ra  z@The current branch has no upstream branch. Will push to 'origin 'r  znothing to commitr  r  zcould not read UsernamezCCouldn't authenticate user for push. Did you set `token` to `True`?)r   r   rx   rK   r   r   r  r   r+  rd  r  rU   r  chdirrV   rX   ri  rm  rw   r}  )
r+   rk  r  r  rn  ro  files_to_stagefiles_in_msgcurrent_working_directoryes
             r,   commitzRepository.commit3  s     n ,CGGG~ 	FI.FYFY\]F]F]3~bqb1223B37(BBcfgucvcvLLL#+# # #   ft<<<t~.. 	vNN0111MMM&&&&NNt^b^qtttuuu$&IKK!
7HHIII	0JJJLL(9L:::////   &c!ff44G 54444
<t':<<%#1     
    ,A66!"ghhnooG H./////- LL(9L:::////   &c!ff44G 54444
<t':<<%#1     
    ,A66!"ghhnooG H.////s   H 1F 
F.F))F.2 G 
H#H  HK"6IK"
I3I.)K".I33K"7 JK"
K
"#KK

K"c                     t           j                            | j        t          j                  }t           j                            |          rt          |          S d S rF   )rU   rV   rX   r   r   REPOCARD_NAMEisfiler   )r+   filepaths     r,   repocard_metadata_loadz!Repository.repocard_metadata_load  sE    7<<	0GHH7>>(## 	+ ***tr.   datac                 |    t          t          j                            | j        t
          j                  |          S rF   )r   rU   rV   rX   r   r   r  )r+   r  s     r,   repocard_metadata_savez!Repository.repocard_metadata_save  s(    RW\\$.):QRRTXYYYr.   c                 $    d | j         D             S )z@
        Returns the asynchronous commands that failed.
        c                 (    g | ]}|j         d k    |S )r   r7   rg   cs     r,   ri   z.Repository.commands_failed.<locals>.<listcomp>  s    >>>aAr.   r   r4   s    r,   commands_failedzRepository.commands_failed  s    
 ?>4->>>>r.   c                 $    d | j         D             S )zS
        Returns the asynchronous commands that are currently in progress.
        c                      g | ]}|j         	|S rQ   )r2   r  s     r,   ri   z3Repository.commands_in_progress.<locals>.<listcomp>  s    ???aQY????r.   r  r4   s    r,   commands_in_progresszRepository.commands_in_progress  s    
 @?4-????r.   c                 f   d}| j         D ]Q}t                              d|j         d|j        j         d           t                              |j                   R| j        rN|dz  dk    r#t                              d| j         d           |dz  }t          j
        d           | j        Ld	S d	S )
zr
        Blocking method: blocks all subsequent execution until all commands have
        been processed.
        r   zThe z command with PID z failed.r   zCWaiting for the following commands to finish before shutting down: r   r   N)r  r   r   r   r'   rD   r:   r  r+  r   r   )r+   indexcommand_faileds      r,   r  zRepository.wait_for_commands  s    
 "2 	0 	0NLLm 4mmH_HcmmmnnnLL.////' 	rzQvZ^Zsvvv   QJEJqMMM ' 	 	 	 	 	r.   )NNTNNNFNrF   )NN)F)r   )FF)r   F)rj  )NTF)rj  TTF)NTTF)3rG   rH   rI   rJ   r   r   r   r   r   r   rK   r   r	   rO   r   r-   rN   r  r  r   r  r  r7  r:  r=  rI  rL  rN  r  rZ  r\  r`  rd  ri  rm  r
   r}  r  r  r  r  r  r  r   r  r   r  r  r  r  r  rQ   r.   r,   r   r     s]         " )****Q   %)#'"&"&#'"&$"&j0 j0d#j0 SMj0 C=	j0
 T3Yj0 3-j0 C=j0 3-j0 j0 j0 j0 j0  j0X     X6 6 6. }/ }/3 }/uT3_/E }/ }/ }/ }/~/ /hsm /W_`cWd / / / /&/ / //s / / / // / / / /%S % % % %!DI ! ! ! !F/ /%T#Y"7 /4 / / / /2/E#tCy.$9 / / / / / / /), ),s ),T#Y ), ), ), ),V, ,c ,DI , , , ,B/ / / /$/ /t /$ / / / /0 /  /s  /$  /  /  /  /D3 3 3 3 3 3& #'$	X* X*3-X* X* 	X*
 
sE#0011	2X* X* X* X*t7 7S 7D 7 7 7 7@( (3 ( ( ( ( ( (<# #3 # # # # # #J 3  3  3hsm  3HUXM  3  3  3  3D$t $ $ $ $  7$"
 "
"
 "
 	"

 "
 
tS%%6 677	8"
 "
 "
 "
H  !%"&$f0 f0f0 f0  	f0
 f0 f0 f0 f0 ^f0P    Z4 ZD Z Z Z Z ? ? X? @ @ X@    r.   r   )r   NrF   ):r  rU   re   rL   r   r   
contextlibr   pathlibr   typingr   r   r   r   r	   r
   r   r   urllib.parser   huggingface_hubr   huggingface_hub.repocardr   r   hf_apir   r   rr   r   utilsr   r   r   r   r   r   utils._deprecationr   
get_loggerrG   r   r   rK   rO   r_   rk   r   r   r   r   r   rP   r   r   r   r   rQ   r.   r,   <module>r     s    				 				          % % % % % %       T T T T T T T T T T T T T T T T T T T T ! ! ! ! ! ! % % % % % % A A A A A A A A 6 6 6 6 6 6 6 6 - - - - - -                2 1 1 1 1 1 
	H	%	%P
 P
 P
 P
 P
 P
 P
 P
f8c4i( 8T 8 8 8 8"!5d+ ! ! ! ! ! !2"'%T	"2 "'t "' "' "' "'JU39- $    2U39- $    .  5dD3I UYZ]U^    2c4i 0 T    ,+ +E#t), + +QT + + + +,    I    jH jH jHZ[ [ [ [ [ [ [ [ [ [r.   