U )3g@sUddlZdddddddd d d d d ddddddgZejdkrFedddlmZddlZddlmZddl Z ddl Z ddl Z ddl m ZddlZddlZddlZddlZddlZddlZddlZddlmZmZddlZddlmZmZmZmZmZmZm Z m!Z!m"Z"ddl#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5e1rddl6m7Z7ddl8m9Z9m:Z:ddl;mZ>ddl?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHe2d e3d!d"d#ZIe JeKZLeMeNeNd$d%d&ZOeMeNeNd$d'd(ZPePdd"ZQePd)d"ZRe2d*ZSe'd+eSfe'd+eSfd,d-dZTejUeDe)eDddfd.d/d0ZVejUeMeMe)d1d2d3d4ZWeDdd5d6dZXeDdd5d7d8ZYde&e&eZeZd:d;dZ[eDeDeDd<d=dZ\ejdkreDeDd5d>dZ]eDeMd5d?dZ^e]Z_neDeMd5d@dZ^e^Z_eDeDeDd<dAdZ`deDeNeNdCdDdZae/eMdEdFdGZbdeMe-eDe,eMdHdIdJZce-eMeMeMdKdLdMZdeedNdOdPdBfeedQeddBfeedReddBfeedSejfdTdPd"feedUdVdPdBffZge0e0e.eMe'eNfd+fehdW<eMeMd5dXdYZieedZZjeDeMd5d[d\ZkiZle(eMe-eNfehd]<eMeNd^d_d`Zme5deCdBd^dadbZne5eDeNd^dcdbZne3deDfeNd^dddbZneMdEded Zoe3ejpdffe$ddgdhdiZqe5ddeNddjdkdlZre5deDeNeMdjdmdlZrde3deDfeNe-eDdjdndlZre/eMe,eMdodpdqZsGdrddZtGdsddetZuGdtd d ZvGduddZwGdvddZxGdwd d ZyGdxd d eyZzGdyd d e,eIZ{eHGdzddeEZ|Gd{d|d|e}Z~Gd}d~d~e~dZdS)N stream_copy join_pathto_native_path_linuxjoin_path_nativeStatsIndexFileSHA1Writer IterableObj IterableListBlockingLockFileLockFileActor get_user_idassure_directory_existsRemoteProgressCallableRemoteProgressrmtree unbare_repoHIDE_WINDOWS_KNOWN_ERRORSwin32to_native_path_windows)abstractmethod)wraps)urlsplit urlunsplit) LazyMixinLockedFD bin_to_hexfile_contents_rofile_contents_ro_filepath hex_to_binmake_sha to_bin_sha to_hex_sha)AnyAnyStrBinaryIOCallableDict GeneratorIOIteratorListOptionalPatternSequenceTuple TYPE_CHECKINGTypeVarUnioncastoverload)Git)GitConfigParserSectionConstraint)Remote)Repo) Files_TDHas_id_attributeHSH_TDLiteralPathLikeProtocol SupportsIndexTotal_TDruntime_checkable T_IterableObj)rr;T)bound covariant)namedefaultreturncCslztj|}Wntk r&|YSXtd||}|dkrLdS|dkrXdStd||||S)zRead a boolean flag from an environment variable. :return: The flag, or the `default` value if absent or ambiguous. zlThe %s environment variable is deprecated. Its effect has never been documented and changes without warning.>falseno0F>1yestrueTz-%s has unrecognized value %r, treating as %r.)osenvironKeyError_loggerwarningstriplower)rFrGvalueZadjusted_valuerX,/tmp/pip-unpacked-wheel-3opeica4/git/util.py_read_env_flagss  rZcCstjdkot||S)aRead a boolean flag from an environment variable on Windows. :return: On Windows, the flag, or the `default` value if absent or ambiguous. On all other operating systems, ``False``. :note: This only accesses the environment on Windows. r)sysplatformrZ)rFrGrXrXrY_read_win_env_flags r]HIDE_WINDOWS_FREEZE_ERRORST.)funcrHcs2ddlmtdtttdfdd }|S)ztMethods with this decorator raise :exc:`~git.exc.InvalidGitRepositoryError` if they encounter a bare repository.)InvalidGitRepositoryErrorr8)selfargskwargsrHcs&|jjrdj|f||S)Nz/Method '%s' cannot operate on bare repositories)repoZbare__name__rcrdrerbr`rXrYwrapperszunbare_repo..wrapper)excrbrr#r_)r`rjrXrirYrs )new_dirrHc cs.t}t|z |VW5t|XdS)zContext manager to temporarily change directory. This is similar to :func:`contextlib.chdir` introduced in Python 3.11, but the context manager object returned by a single call to this function is not reentrant. N)rPgetcwdchdir)rlZold_dirrXrXrYcwds   ro)NNN)rFrWrHc csBt|}|tj|<z dVW5|dkr2tj|=n |tj|<XdS)z=Context manager to temporarily patch an environment variable.N)rPgetenvrQ)rFrW old_valuerXrXrY patch_envs    rr)pathrHcCsVtttdddd}tjdkr*t|n(tjdkrDtj||dntj||ddS) zRemove the given directory tree recursively. :note: We use :func:`shutil.rmtree` but adjust its behaviour to see whether files that couldn't be deleted are read-only. Windows will not remove them in that case. N)functionrs_excinforHc Ssdt|tjz ||WnDtk r^}z&trLddlm}|d||W5d}~XYnXdS)zuCallback for :func:`shutil.rmtree`. This works as either a ``onexc`` or ``onerror`` style callback. r)SkipTestz%FIXME: fails with: PermissionError N)rPchmodstatS_IWUSRPermissionErrorrZunittestrv)rtrsruexrvrXrXrYhandlers  zrmtree..handlerr) )Zonexc)onerror)r&r>r#r[r\shutilr version_info)rsr|rXrXrYrs    cCs.t|r*tjdkr t|dt|dS)zWEnsure file deleted also on *Windows* where read-only files need special treatment.riN)ospisfiler[r\rPrwremoversrXrXrYrmfiles   r)source destination chunk_sizerHcCs8d}||}|||t|7}t||krq4q|S)zCopy all data from the `source` stream into the `destination` stream in chunks of size `chunk_size`. :return: Number of bytes written r)readwritelen)rrrbrchunkrXrXrYrs    )aprHcGsht|}|D]V}t|}|sq |dr:||dd7}q |dksL|drV||7}q |d|7}q |S)zmJoin path tokens together similar to osp.join, but always use ``/`` instead of possibly ``\`` on Windows./raNrI)str startswithendswith)rrrsbrXrXrYrs  cCst|}|ddS)Nr\rreplacerrXrXrYr$scCst|}|ddS)NrrrrrXrXrYr(scCst|SN)rrrXrXrYr/scGstt|f|S)zLike :func:`join_path`, but makes sure an OS native path is returned. This is only needed to play it safe on Windows and to ensure nice paths that only use ``\``. )to_native_pathr)rrrXrXrYr5sF)rsis_filerHcCs.|rt|}t|s*tj|dddSdS)a$Make sure that the directory pointed to by path exists. :param is_file: If ``True``, `path` is assumed to be a file and handled correctly. Otherwise it must be a directory. :return: ``True`` if the directory was created, ``False`` if it already existed. T)exist_okF)rdirnameisdirrPmakedirs)rsrrXrXrYr>s   rHcCsBtjdd}|r,tdd|tjDStjdkr:dSdSdS)NPATHEXTcss|]}|VqdSr)upper).0rrXrXrY Tsz&_get_exe_extensions..r)z.BATZCOMz.EXErX)rPrQgettuplesplitpathsepr[r\)rrXrXrY_get_exe_extensionsQs  r)programrsrHcstttdfdd }g}|s,tjd}t|tjD]N}|d}|rto.is_exec..)rrrPaccessX_OKr[r\anyr) winprog_extsrrYis_execks   $zpy_where..is_execPATH"csg|]}d|fqS)z%s%srX)re)exe_pathrXrY {szpy_where..) rrboolrPrQrrrUrjoinappend)rrsrZprogsfolderfrX)rrrYpy_where[s    r)driversrHcCstt|r|s|}nL|o,ttt|}t|rL|rB|}q`t|}n|r`d||f}t|}|ddS)Nz/proc/cygdrive/%s/%srr) risabsnormpath expandvars expandusercygpathrVrr)rrsrZp_strrXrXrY _cygexpaths  rz*\\\\\?\\UNC\\([^\\]+)\\([^\\]+)(?:\\(.*))?cCsd|||ddfS)Nz //%s/%s/%srr)r)serverZshare rest_pathrXrXrYrz\\\\\?\\(\w):[/\\](.*)z(\w):[/\\](.*)z file:(.*)cCs|SrrX)rrXrXrYrrz (\w{2,}:.*)cCs|SrrX)urlrXrXrYrr_cygpath_parserscCsZt|}|dsVtD]4\}}}||}|r||}|rFt|}qVqtd|}|S)zJUse :meth:`git.cmd.Git.polish_url` instead, that works on any environment.)z /cygdrivez//z/proc/cygdriveN)rrrmatchgroupsrr)rsregexparserZrecurserrXrXrYrs    rz(?:/proc)?/cygdrive/(\w)(/.*)?cCsBt|}t|}|r6|\}}d||p0df}|ddS)Nz%s:%srIrr)r_decygpath_regexrrrr)rsmrrrXrXrY decygpaths   r_is_cygwin_cache)git_executablerHc Cst|}|dkrd}zdt|}|sDt|}|r@t|dnd}t|d}tj|gtjdd}| \}}d|k}Wn.t k r}zt d|W5d}~XYnX|t|<|S) NFrrIunameT)stdoutuniversal_newlinesZCYGWINz/Failed checking if running in CYGWIN due to: %r) rrrrrr subprocessPopenPIPE communicate ExceptionrSdebug) rZ is_cygwingit_dirresZ uname_cmdprocessZ uname_out_r{rXrXrY_is_cygwin_gits      rcCsdSrrXrrXrXrY is_cygwin_gitsrcCsdSrrXrrXrXrYrscCs*tjdkrdS|dkrdStt|SdS)NrF)r[r\rrrrXrXrYrs  cCsdttfS)zM:return: String identifying the currently active system user as ``name@node``z%s@%s)getpassgetuserr\noderXrXrXrYr szGit.AutoInterrupt)procrerHcKs|jf|dS)zXWait for the process (clone, fetch, pull or push) and handle its errors accordingly.N)wait)rrerXrXrYfinalize_processsr)r expand_varsrHcCsdSrrXrrrXrXrY expand_pathsrcCsdSrrXrrXrXrYrscCsZt|tjr|Sz*t|}|r.t|}tt|WSt k rTYdSXdSr) isinstancepathlibPathresolverrrrabspathrrrXrXrYrs   )cmdlinerHc Csg}t|D]\}}||ztt|}|jdkr@|jdkr@Wq |jdk rb|j|j|jdd}|jdk r|j|j|jdd}t|||<Wq t k rYq Yq Xq |S)a>Parse any command line argument and if one of the elements is an URL with a username and/or password, replace them by stars (in-place). If nothing is found, this just returns the command line as-is. This should be used for every log line that print a command line, as well as exception messages. Nz*****)netloc) enumeraterrpasswordusername_replacerrr ValueError)rZ new_cmdlineindexZto_parserrXrXrYremove_password_if_presents     rc @seZdZUdZdZeed<ddeeD\ ZZ Z Z Z Z ZZZee BZeZdZdZdZed Zed Zd d d dZed dddZeegd fd ddZed dddZ dee!ee"fe!ee"d fed dddZ#d S)rzHandler providing an interface to parse progress information emitted by :manpage:`git-push(1)` and :manpage:`git-fetch(1)` and to dispatch callbacks allowing subclasses to react to the progress. _num_op_codescCsg|] }d|>qS)rarX)rxrXrXrYrCszRemoteProgress.zdone.z, ) _cur_line _seen_ops error_lines other_linesz%(remote: )?([\w\s]+):\s+()(\d+)()(.*)z2(remote: )?([\w\s]+):\s+(\d+)% \((\d+)/(\d+)\)(.*)NrcCsg|_d|_g|_g|_dSr)rrrrrcrXrXrY__init__SszRemoteProgress.__init__linerHc Cst|tr|d}n|}||_|jdr>|j|jdSd\}}|j|}|dkrf|j |}|s| ||j |dSd}| \}}} }}} |dkr||j O}n|dkr||jO}nx|dkr||jO}nd|d kr||jO}nP|d kr||jO}n:|d kr||jO}n$|d kr.||jO}n| |dS||jkr^|j|||jO}| dkrld } | } | |jr||jO}| dt|j } | |j} |||ot||ot|| dS)a^Parse progress information from the given line as retrieved by :manpage:`git-push(1)` or :manpage:`git-fetch(1)`. - Lines that do not contain progress info are stored in :attr:`other_lines`. - Lines that seem to contain an error (i.e. start with ``error:`` or ``fatal:``) are stored in :attr:`error_lines`. zutf-8)zerror:zfatal:N)NNrzCounting objectszCompressing objectszWriting objectszReceiving objectszResolving deltaszFinding sourceszChecking out filesrI)rbytesdecoderrrrre_op_relativerre_op_absolute line_droppedrrCOUNTING COMPRESSINGWRITING RECEIVING RESOLVINGFINDING_SOURCES CHECKING_OUTrBEGINrUr DONE_TOKENENDrTOKEN_SEPARATORupdatefloat) rcrline_str cur_count max_countrop_codeZ_remoteZop_nameZ_percentmessagerXrXrY_parse_progress_lineYsb                          z#RemoteProgress._parse_progress_linecstddfdd }|S)z :return: A progress handler suitable for :func:`~git.cmd.handle_process_output`, passing lines on to this progress handler in a suitable format. Nrcs|Sr)rrstrip)rrrXrYr|sz3RemoteProgress.new_message_handler..handler)r$)rcr|rXrrYnew_message_handlersz"RemoteProgress.new_message_handlercCsdS)zICalled whenever a line could not be understood and was therefore dropped.NrX)rcrrXrXrYr szRemoteProgress.line_droppedrI)rrrrrHcCsdS)aCalled whenever the progress changes. :param op_code: Integer allowing to be compared against Operation IDs and stage IDs. Stage IDs are :const:`BEGIN` and :const:`END`. :const:`BEGIN` will only be set once for each Operation ID as well as :const:`END`. It may be that :const:`BEGIN` and :const:`END` are set at once in case only one progress message was emitted due to the speed of the operation. Between :const:`BEGIN` and :const:`END`, none of these flags will be set. Operation IDs are all held within the :const:`OP_MASK`. Only one Operation ID will be active per call. :param cur_count: Current absolute count of items. :param max_count: The maximum count of items we expect. It may be ``None`` in case there is no maximum number of items or if it is (yet) unknown. :param message: In case of the :const:`WRITING` operation, it contains the amount of bytes transferred. It may possibly be used for other purposes as well. :note: You may read the contents of the current line in :attr:`self._cur_line <_cur_line>`. NrX)rcrrrrrXrXrYrs$zRemoteProgress.update)NrI)$rg __module__ __qualname____doc__rint__annotations__rangerrr r rrrrrZ STAGE_MASKZOP_MASKrr __slots__recompiler r rr$rr&rr r r2rrrXrXrXrYr3sB    Y  cs>eZdZdZdZeddfdd Zeedddd ZZ S) raA :class:`RemoteProgress` implementation forwarding updates to any callable. :note: Like direct instances of :class:`RemoteProgress`, instances of this :class:`CallableRemoteProgress` class are not themselves directly callable. Rather, instances of this class wrap a callable and forward to it. This should therefore not be confused with :class:`git.types.CallableProgress`.  _callableN)fnrHcs||_tdSr)r+superr)rcr, __class__rXrYrszCallableRemoteProgress.__init__)rdrerHcOs|j||dSrr*rhrXrXrYrszCallableRemoteProgress.update) rgr!r"r#r'r&rr#r __classcell__rXrXr.rYrs c@s eZdZdZedZedZdZdZ dZ dZ dZ d Z d Zeeeed d d dZeedddZeedddZedddZedddZedddZeeddddZed'eeedddd d!Zed(eddd"d#d$Zed)eddd"d%d&Zd S)*r zActors hold information about a person acting on the repository. They can be committers and authors or anything with a name and an email as mentioned in the git log entries.z<(.*)>z (.*) <(.*?)>ZGIT_AUTHOR_NAMEZGIT_AUTHOR_EMAILZGIT_COMMITTER_NAMEZGIT_COMMITTER_EMAILrFemailrFr1N)rFr1rHcCs||_||_dSrr2)rcrFr1rXrXrYrszActor.__init__)otherrHcCs|j|jko|j|jkSrr2rcr3rXrXrY__eq__sz Actor.__eq__cCs ||k SrrXr4rXrXrY__ne__sz Actor.__ne__rcCst|j|jfSr)hashrFr1rrXrXrY__hash__szActor.__hash__cCs|jr |jSdS)NrI)rFrrXrXrY__str__"sz Actor.__str__cCsd|j|jfS)Nz">r2rrXrXrY__repr__%szActor.__repr__)stringrHcCsT|j|}|r&|\}}t||S|j|}|rFt|ddSt|dSdS)zCreate an :class:`Actor` from a string. :param string: The string, which is expected to be in regular git format:: John Doe :return: :class:`Actor` raN)name_email_regexsearchrr name_only_regexgroup)clsr;rrFr1rXrXrY _from_string(s    zActor._from_string)Nr6r7)env_name env_email config_readerrHc stdd}dtdfdd tdfdd }d||j|fd||jffD]\}}}} ztj|} t||| WqNtk r|dk rz|d |} Wnt k r| } YnXt||| t ||st||| YqNXqN|S) NrIrcss tSr)r rX)user_idrXrY default_emailKsz(Actor._main_actor..default_emailcsddS)N@r)rrX)rFrXrY default_nameQsz'Actor._main_actor..default_namerFr1user) r r conf_name conf_emailrPrQsetattrrRrrgetattr) r@rBrCrDZactorrHattrZevarZcvarrGvalrX)rFrErY _main_actorAs(       zActor._main_actor)rDrHcCs||j|j|S)a :return: :class:`Actor` instance corresponding to the configured committer. It behaves similar to the git implementation, such that the environment will override configuration values of `config_reader`. If no value is set at all, it will be generated. :param config_reader: ConfigReader to use to retrieve the values from in case they are not set in the environment. )rPenv_committer_nameenv_committer_emailr@rDrXrXrY committeris zActor.committercCs||j|j|S)zSame as :meth:`committer`, but defines the main author. It may be specified in the environment, but defaults to the committer.)rPenv_author_nameenv_author_emailrSrXrXrYauthorxsz Actor.author)N)N)N) rgr!r"r#r(r)r>r<rUrVrQrRrJrKr'r,rrr#rr5r6r$r8r9r: classmethodrAr2rPrTrWrXrXrXrYr s<  'c@sDeZdZdZdZeeeefddddZ e de ddd d Z dS) raRepresents stat information as presented by git at the end of a merge. It is created from the output of a diff operation. Example:: c = Commit( sha1 ) s = c.stats s.total # full-stat-dict s.files # dict( filepath : stat-dict ) ``stat-dict`` A dictionary with the following keys and values:: deletions = number of deleted lines as int insertions = number of inserted lines as int lines = total number of lines changed as int, or deletions + insertions ``full-stat-dict`` In addition to the items in the stat-dict, it features additional information:: files = number of changed files as int totalfilesN)rZr[rHcCs||_||_dSrrY)rcrZr[rXrXrYrszStats.__init__r9)rftextrHc Csdddddid}|D]}|d\}}}|dkr@t|pBd}|dkrTt|pVd} |dd|7<|dd| 7<|dd || 7<|dd d 7<|| || d } | |d |<qt|d|d S) zCreate a :class:`Stats` object from output retrieved by :manpage:`git-diff(1)`. :return: :class:`git.Stats` r) insertions deletionslinesr[rY -rZr]r^r_r[ra)r]r^r_) splitlinesrr$rUr) r@rfr\ZhshrZraw_insertionsZ raw_deletionsfilenamer]r^Z files_dictrXrXrY_list_from_strings"  zStats._list_from_string) rgr!r"r#r'rAr'r>r:rrXrrdrXrXrXrYrs c@s^eZdZdZdZeddddZeeddd Z e d d d Z e d d dZ ed ddZ dS)raWrapper around a file-like object that remembers the SHA1 of the data written to it. It will write a sha when the stream is closed or if asked for explicitly using :meth:`write_sha`. Only useful to the index file. :note: Based on the dulwich project. )rsha1N)rrHcCs||_td|_dS)Nr)rr re)rcrrXrXrYrszIndexFileSHA1Writer.__init__)datarHcCs|j||j|Sr)rerrr)rcrfrXrXrYrs zIndexFileSHA1Writer.writercCs|j}|j||Sr)redigestrrrcsharXrXrY write_shas  zIndexFileSHA1Writer.write_shacCs|}|j|Sr)rjrcloserhrXrXrYrks zIndexFileSHA1Writer.closecCs |jSr)rtellrrXrXrYrlszIndexFileSHA1Writer.tell)rgr!r"r#r'r)rr$r$rrrjrkrlrXrXrXrYrs c@sxeZdZdZdZeddddZdddd Zedd d Z e dd d Z ddddZ ddddZ ddddZdS)r aProvides methods to obtain, check for, and release a file based lock which should be used to handle concurrent access to the same file. As we are a utility class to be derived from, we only use protected methods. Locks will automatically be released on destruction.  _file_path _owns_lockN) file_pathrHcCs||_d|_dS)NFrm)rcrprXrXrYrszLockFile.__init__rcCs |dSr) _release_lockrrXrXrY__del__szLockFile.__del__cCs d|jS)z:return: Path to lockfilez%s.lock)rnrrXrXrY_lock_file_pathszLockFile._lock_file_pathcCs|jS)z :return: True if we have a lock and if the lockfile still exists :raise AssertionError: If our lock-file does not exist. )rorrXrXrY _has_lockszLockFile._has_lockc Cs|r dS|}t|r0td|j|fzt|ddW5QRXWn0tk r|}ztt||W5d}~XYnXd|_ dS)zCreate a lock file as flag for other instances, mark our instance as lock-holder. :raise IOError: If a lock was already present or a lock file could not be written. NzILock for file %r did already exist, delete %r in case the lock is illegalw)modeT) rtrsrrIOErrorrnopenOSErrorrro)rcZ lock_filerrXrXrY_obtain_lock_or_raises  zLockFile._obtain_lock_or_raisecCs|S)zThe default implementation will raise if a lock cannot be obtained. Subclasses may override this method to provide a different implementation. )rzrrXrXrY _obtain_lockszLockFile._obtain_lockcCs@|s dS|}z t|Wntk r4YnXd|_dS)z Release our lock if we have one.NF)rtrsrryro)rcZlfprXrXrYrqs zLockFile._release_lock)rgr!r"r#r'r>rrrrrsrrtrzr{rqrXrXrXrYr s csJeZdZdZdZdejfeee ddfdd Z ddfd d Z Z S) r aThe lock file will block until a lock could be obtained, or fail after a specified timeout. :note: If the directory containing the lock was removed, an exception will be raised during the blocking period, preventing hangs as the lock can never be obtained. )_check_interval_max_block_timeg333333?N)rpcheck_interval_smax_block_time_srHcst|||_||_dS)aConfigure the instance. :param check_interval_s: Period of time to sleep until the lock is checked the next time. By default, it waits a nearly unlimited time. :param max_block_time_s: Maximum amount of seconds we may lock. N)r-rr|r})rcrpr~rr.rXrYr9s zBlockingLockFile.__init__rc st}|t|j}ztWqtk r}zpt}tt| spd| ||f}t||||krd||| f}t||t |j W5d}~XYqXqqdS)zThis method blocks until it obtained the lock, or raises :exc:`IOError` if it ran out of time or if the parent directory was not available anymore. If this method returns, you are guaranteed to own the lock. zVDirectory containing the lockfile %r was not readable anymore after waiting %g secondsz Waited %g seconds for lock at %rN) timerr}r-r{rwrrrrssleepr|)rcZ starttimeZmaxtimerZcurtimemsgr.rXrYr{Ls(  zBlockingLockFile._obtain_lock) rgr!r"r#r'r[maxsizer>rr$rr{r0rXrXr.rYr .scseZdZdZdZdeeddfdd Zdeeddd d Zee d d d Z ee d ddZ e eeeefe dddZe eeeefddddZZS)r aList of iterable objects allowing to query an object by id or by named index:: heads = repo.heads heads.master heads['master'] heads[0] Iterable parent objects: * :class:`Commit ` * :class:`Submodule ` * :class:`Reference ` * :class:`FetchInfo ` * :class:`PushInfo ` Iterable via inheritance: * :class:`Head ` * :class:`TagReference ` * :class:`RemoteReference ` This requires an ``id_attribute`` name to be set which will be queried from its contained items to have a means for comparison. A prefix can be specified which is to be used in case the id returned by the items always contains a prefix that does not matter to the user, so it can be left out. _id_attr_prefixrIzIterableList[T_IterableObj])id_attrprefixrHcs t|Sr)r-__new__)r@rrr.rXrYrszIterableList.__new__NcCs||_||_dSrr)rcrrrXrXrYrszIterableList.__init__)rNrHc Csjzt||}|r|WSWnttfk r2YnXzt|tt|WdSttfk rdYdSXdS)NTF)list __contains__AttributeError TypeErrorrMr3r)rcrNrvalrXrXrYrs  zIterableList.__contains__cCs8|j|}|D]}t||j|kr|Sqt||Sr)rrMrr__getattribute__)rcrNitemrXrXrY __getattr__s   zIterableList.__getattr__)rrHc Cst|tttfstdt|tr.t||St|trBtdnDz t||WSt k r}zt d|j ||W5d}~XYnXdS)N-Index of IterableList should be an int or strzIndex should be an int or strzNo item found with id %r) rr$rsliceAssertionErrorr __getitem__rrMr IndexErrorr)rcrrrXrXrYrs     zIterableList.__getitem__cCst|ttfstdtt|}t|tsvd}|j|}t|D] \}}t||j|kr@|}qbq@|dkrvt d|t ||dS)NrzItem with name %s not found) rr$rrr3rrrMrrr __delitem__)rcrZdelindexrFirrXrXrYrs    zIterableList.__delitem__)rI)rI)rgr!r"r#r'rrrobjectrrrCrr2r@r$rrrr0rXrXr.rYr psc@sZeZdZUdZdZeed<eede e e e dddZ ede e e e ddd Zd S) raDefines an interface for iterable items, so there is a uniform way to retrieve and iterate items within the git repository. Subclasses: * :class:`Submodule ` * :class:`Commit ` * :class:`Reference ` * :class:`PushInfo ` * :class:`FetchInfo ` * :class:`Remote ` rX_id_attribute_r9rfrdrerHcOs tddS)aSFind (all) items of this type. Subclasses can specify `args` and `kwargs` differently, and may use them for filtering. However, when the method is called with no additional positional or keyword arguments, subclasses are obliged to to yield all items. :return: Iterator yielding Items To be implemented by SubclassNNotImplementedErrorr@rfrdrerXrXrY iter_itemss zIterableObj.iter_itemscOs&t|j}||j|f|||S)aFind (all) items of this type and collect them into a list. For more information about the arguments, see :meth:`iter_items`. :note: Favor the :meth:`iter_items` method as it will avoid eagerly collecting all items. When there are many items, that can slow performance and increase memory usage. :return: list(Item,...) list of item instances r rextendrr@rfrdreZout_listrXrXrY list_itemss zIterableObj.list_itemsN)rgr!r"r#r'rr%rXrr#r*rCrr rrXrXrXrYrs   c@s$eZdZdZeeeddddZdS)IterableClassWatcherzbMetaclass that issues :exc:`DeprecationWarning` when :class:`git.util.Iterable` is subclassed.N)rFbasesclsdictrHcCs2|D](}t|tkrtjd|dtddqdS)Nz!GitPython Iterable subclassed by zq. Iterable is deprecated due to naming clash since v3.1.18 and will be removed in 4.0.0. Use IterableObj instead.) stacklevel)typerwarningswarnDeprecationWarning)r@rFrrbaserXrXrYr s  zIterableClassWatcher.__init__)rgr!r"r#rr/r'rrXrXrXrYrsrc@sHeZdZdZdZdZedeeedddZedeeeddd Z d S) IterablezDeprecated, use :class:`IterableObj` instead. Defines an interface for iterable items, so there is a uniform way to retrieve and iterate items within the git repository. rXz5attribute that most suitably identifies your instancer9rcOs tddS)zDeprecated, use :class:`IterableObj` instead. Find (all) items of this type. See :meth:`IterableObj.iter_items` for details on usage. :return: Iterator yielding Items rNrrrXrXrYr#s zIterable.iter_itemscOs&t|j}||j|f|||S)aDeprecated, use :class:`IterableObj` instead. Find (all) items of this type and collect them into a list. See :meth:`IterableObj.list_items` for details on usage. :return: list(Item,...) list of item instances rrrXrXrYr0s zIterable.list_itemsN) rgr!r"r#r'rrXr#rrrXrXrXrYrs r) metaclass)r)F)N).).)T)r[__all__r\rabcr contextlib functoolsrrloggingrPos.pathrsrrr(rrxrr urllib.parserrrZ gitdb.utilrrrrrrr r!r"typingr#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4Zgit.cmdr5Z git.configr6r7Z git.remoter8Z git.repo.baser9Z git.typesr:r;r<r=r>r?r@rArBrC getLoggerrgrSrrrZr]rr^r_rcontextmanagerrorrrrr$rrrrrrrrrrr)Irr%rrrrrrr rrrrrrr rrr r r rrrrrXrXrXrYs     ,P   ,     !    &"    "9>#NBb4