o Ďi @sUddlZgdZejdkredddlmZddlZddlmZddl Z ddl Z ddl Z ddl m ZddlmZddlZddlZddlZddlZddlZddlZddlmZmZddlZdd lmZmZmZmZmZm Z m!Z!m"Z"m#Z#dd l$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6e2rdd l7m8Z8dd l9m:Z:m;Z;dd lm?Z?ddl@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHmIZIe3de4dddZJe KeLZMdeNdeOdeOfddZPdeNdeOdeOfddZQeQddZReQddZSe3dZTde(deTfde(deTffd d!ZUejVd"eEde*eEddffd#d$ZWejVdeNd%eNde*d&fd'd(ZXd)eEddfd*d+ZYd)eEddfd,d-ZZdd/e'd0e'd1e[de[fd2d3Z\d4eEd5eEdeEfd6d7Z]ejdkryd)eEdeEfd8dZ^d)eEdeNfd9d:Z_e^Z`n d)eEdeNfd;d:Z_e_Z`d4eEd5eEdeEfdfefdMeed>fefdNeed>fefdOejgdPdLdfefdQdRdLd>ffZhe1e1e/eNe(eOfdfeidS<d)eNdeNfdTdUZjefdVZkd)eEdeNfdWdXZliZme)eNe.eOfeidY<dZeNdeOfd[d\Zne6dZddeDd>fd]d^Zoe6dZeEdeOfd_d^ZodZe4deEfdeOfd`d^ZodeNfdadbZpdce4ejqddfdee%ddfdfdgZre6dd5ddheOddfdidjZse6dd5eEdheOdeNfdkdjZsdd5e4deEfdheOde.eEfdldjZsdme0eNde-eNfdndoZtGdpdqdqZuGdrdsdseuZvGdtduduZwGdvdwdwZxGdxdydyZyGdzd{d{ZzGd|d}d}ezZ{Gd~dde-eJZ|eIGdddeFZ}Gddde~ZGdddedZdS)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)Path)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 covariantnamedefaultreturncCsjztj|}Wn ty|YSwtd||}|dvr%dS|dvr+dStd||||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.>0nofalseF>1yestrueTz-%s has unrecognized value %r, treating as %r.)osenvironKeyError_loggerwarningstriplower)rGrHvalueadjusted_valuerZD/home/jeff/fluffinator/venv/lib/python3.10/site-packages/git/util.py_read_env_flagss   r\cCstjdko t||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)sysplatformr\)rGrHrZrZr[_read_win_env_flags r_rHIDE_WINDOWS_FREEZE_ERRORSTfunc.c s8ddlmtdddtdtdtffdd }|S) ztMethods with this decorator raise :exc:`~git.exc.InvalidGitRepositoryError` if they encounter a bare repository.)InvalidGitRepositoryErrorselfr9argskwargsrIcs,|jjr dj|g|Ri|S)Nz/Method '%s' cannot operate on bare repositories)repobare__name__rerfrgrdrbrZr[wrapperszunbare_repo..wrapper)excrdrr$ra)rbrmrZrlr[rs "rnew_dirc cs8t}t|z |VWt|dSt|w)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)rQgetcwdchdir)roold_dirrZrZr[cwds  rsrX)NNNc cs`t|}|tj|<zdVW|durtj|=dS|tj|<dS|dur*tj|=w|tj|<w)z=Context manager to temporarily patch an environment variable.N)rQgetenvrR)rGrX old_valuerZrZr[ patch_envs   rvpathcCs`dtdtdtddfdd}tjdkrt|dStjd kr'tj||d dStj||d dS) 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. functionrw_excinforINc SsXt|tjz||WdSty+}ztr&ddlm}|d||d}~ww)zuCallback for :func:`shutil.rmtree`. This works as either a ``onexc`` or ``onerror`` style callback. r)SkipTestz%FIXME: fails with: PermissionError N)rQchmodstatS_IWUSRPermissionErrorrunittestrz)rxrwryexrzrZrZr[handlers zrmtree..handlerr) )onexc)onerror)r'r?r$r]r^shutilr version_info)rwrrZrZr[rs   rcCs2t|rtjdkrt|dt|dSdS)zWEnsure file deleted also on *Windows* where read-only files need special treatment.riN)ospisfiler]r^rQr{removerwrZrZr[rmfiles   rsource destination chunk_sizecCs:d} ||}|||t|7}t||kr |Sq)zCopy all data from the `source` stream into the `destination` stream in chunks of size `chunk_size`. :return: Number of bytes written r)readwritelen)rrrbrchunkrZrZr[rs    rapcGslt|}|D],}t|}|sq|dr||dd7}q|dks(|dr-||7}q|d|7}q|S)zmJoin path tokens together similar to osp.join, but always use ``/`` instead of possibly ``\`` on Windows./rcNrJ)rQfspath startswithendswith)rrrwbrZrZr[rs    rcCt|}|ddS)Nr\rQrreplacerrZrZr[r$  cCr)NrrrrrZrZr[r(rrcCs t|SN)rQrrrZrZr[r/ cGstt|g|RS)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)rrrZrZr[r5srFis_filecCs.|rt|}t|stj|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)rdirnameisdirrQmakedirs)rwrrZrZr[r>s   rcCs>tjdd}|rtdd|tjDStjdkrdSdS)NPATHEXTcss|]}|VqdSr)upper).0rrZrZr[ Tsz&_get_exe_extensions..r)z.BATz.COMz.EXErZ)rQrRgettuplesplitpathsepr]r^)rrZrZr[_get_exe_extensionsQs  rprogramcstdtdtffdd }g}|stjd}t|tjD]'}|d}|rGt ||gfddDD] }||rF| |q;q |S) a6Perform a path search to assist :func:`is_cygwin_git`. This is not robust for general use. It is an implementation detail of :func:`is_cygwin_git`. When a search following all shell rules is needed, :func:`shutil.which` can be used instead. :note: Neither this function nor :func:`shutil.which` will predict the effect of an executable search on a native Windows system due to a :class:`subprocess.Popen` call without ``shell=True``, because shell and non-shell executable search on Windows differ considerably. fpathrIcs>tottjotjdkp ptfddDS)Nrc3s|] }|VqdSr)rr)rextrrZr[rpsz,py_where..is_exec..)rrrQaccessX_OKr]r^anyr) winprog_extsrr[is_execks  $zpy_where..is_execPATH"csg|]}d|fqS)z%s%srZ)re)exe_pathrZr[ {szpy_where..) rstrboolrQrRrrrrVrjoinappend)rrwrprogsfolderfrZ)rrr[py_where[s     rdrivecCsvt|r |s |}n&|ottt|}t|r&|r!|}nt|}n |r0d||f}t|}| ddS)Nz/proc/cygdrive/%s/%srr) risabsnormpath expandvars expandusercygpathrWrQrr)rrwrp_strrZrZr[ _cygexpaths    rz*\\\\\?\\UNC\\([^\\]+)\\([^\\]+)(?:\\(.*))?cCsd|||ddfS)Nz //%s/%s/%srr)r)servershare rest_pathrZrZr[srz\\\\\?\\(\w):[/\\](.*)z(\w):[/\\](.*)z file:(.*)cC|SrrZ)rrZrZr[rz (\w{2,}:.*)cCrrrZ)urlrZrZr[rr_cygpath_parserscCs^t|}|ds-tD]\}}}||}|r'||}|r$t|}|Sq td|}|S)zJUse :meth:`git.cmd.Git.polish_url` instead, that works on any environment.)z /cygdrivez//z/proc/cygdriveN)rQrrrmatchgroupsrr)rwregexparserrecurserrZrZr[rs     rz(?:/proc)?/cygdrive/(\w)(/.*)?cCsDt|}t|}|r|\}}d||pdf}|ddS)Nz%s:%srJrr)rQr_decygpath_regexrrrr)rwmrrrZrZr[ decygpaths    r_is_cygwin_cachegit_executablec Cst|}|durwd}zOt|}|s"t|}|r t|dnd}t|d}t|r5t |tj sEt d|d|t|<|WSt j|gt jdd}|\}}d |v}Wntyr}z t d |WYd}~nd}~ww|t|<|S) NFrrJunamez&Failed checking if running in CYGWIN: z is not an executableT)stdoutuniversal_newlinesCYGWINz/Failed checking if running in CYGWIN due to: %r)rrrrrrrrrQrrrTdebug subprocessPopenPIPE communicate Exception) r is_cygwingit_dirres uname_cmdprocess uname_out_rrZrZr[_is_cygwin_gits,     rcCdSrrZrrZrZr[ is_cygwin_gitrcCrrrZrrZrZr[rrcCs>tdtjd|tjdkrdS|durdStt|S)Nz sys.platform=z, git_executable=cygwinF)rTrr]r^rrrrZrZr[rs   cCsdttfS)zM:return: String identifying the currently active system user as ``name@node``z%s@%s)getpassgetuserr^noderZrZrZr[r sr proczGit.AutoInterruptrgcKs|jdi|dS)zXWait for the process (clone, fetch, pull or push) and handle its errors accordingly.NrZ)wait)rrgrZrZr[finalize_processsr expand_varscCrrrZrrrZrZr[ expand_pathrrcCrrrZrrZrZr[rscCsRt|tr |Szt|}|rt|}tt|WSty(YdSwr) isinstancerresolverrrrabspathrrrZrZr[r s    cmdlinec Csg}t|D]L\}}||z:t|}|jdur |jdur Wq|jdur1|j|j|jdd}|jdurB|j|j|jdd}t|||<Wqt yRYqw|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)r new_cmdlineindexto_parserrZrZr[remove_password_if_presents      rc @seZdZUdZdZeed<ddeeD\ ZZ Z Z Z Z ZZZee BZeZdZdZdZed Zed Zdd dZded d fddZd eegd ffddZded d fddZ ddede!ee"fde!ee"d fded d f ddZ#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)rcrZ)rxrZrZr[rKszRemoteProgress.zdone.z, ) _cur_line _seen_ops error_lines other_linesz%(remote: )?([\w\s]+):\s+()(\d+)()(.*)z2(remote: )?([\w\s]+):\s+(\d+)% \((\d+)/(\d+)\)(.*)rINcCsg|_d|_g|_g|_dSr)rrrrrerZrZr[__init__[s zRemoteProgress.__init__linec Cst|tr |d}n|}||_|jdr|j|jdSd\}}|j|}|dur3|j |}|sB| ||j |dSd}| \}}} }}} |dkrX||j O}nC|dkrb||jO}n9|dkrl||jO}n/|d krv||jO}n%|d kr||jO}n|d kr||jO}n|d kr||jO}n| |dS||jvr|j|||jO}| durd } | } | |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 filesrJ)rbytesdecoderrrrre_op_relativerre_op_absolute line_droppedrrCOUNTING COMPRESSINGWRITING RECEIVING RESOLVINGFINDING_SOURCES CHECKING_OUTrBEGINrVr DONE_TOKENENDrTOKEN_SEPARATORupdatefloat) rerline_str cur_count max_countrop_code_remoteop_name_percentmessagerZrZr[_parse_progress_lineasb                      z#RemoteProgress._parse_progress_linecsdtddffdd }|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. rrINcs|Sr)r5rstrip)rrrZr[rsz3RemoteProgress.new_message_handler..handler)r%)rerrZrr[new_message_handlersz"RemoteProgress.new_message_handlercCdS)zICalled whenever a line could not be understood and was therefore dropped.NrZ)rerrZrZr[rszRemoteProgress.line_droppedrJr0r.r/r4cCr8)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>`. NrZ)rer0r.r/r4rZrZr[r+s$zRemoteProgress.updaterINNrJ)$rj __module__ __qualname____doc__rint__annotations__ranger'r)r r!r"r#r$r%r& STAGE_MASKOP_MASKr(r* __slots__recompilerrrr%r5r'rr7rr3r,r+rZrZrZr[r;sL      Y  rcsDeZdZdZdZdeddffdd Zded eddfd d 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`.  _callablefnrINcs||_tdSr)rGsuperr)rerH __class__rZr[rzCallableRemoteProgress.__init__rfrgcOs|j|i|dSrrFrkrZrZr[r+szCallableRemoteProgress.update) rjr;r<r=rCr'rr$r+ __classcell__rZrZrJr[rs  rc @s eZdZdZedZedZdZdZ dZ dZ dZ d Z d Zdeed eed d fd dZded efddZded efddZd efddZd efddZd efddZeded dfddZe d'dededed d dfd!d"Zed'ded d dfd#d$Zed'ded d dfd%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 (.*) <(.*?)>GIT_AUTHOR_NAMEGIT_AUTHOR_EMAILGIT_COMMITTER_NAMEGIT_COMMITTER_EMAILrGemailrGrRrINcC||_||_dSrrS)rerGrRrZrZr[r zActor.__init__othercCs|j|jko |j|jkSrrSrerVrZrZr[__eq__!sz Actor.__eq__cCs ||k SrrZrWrZrZr[__ne__$rz Actor.__ne__cCst|j|jfSr)hashrGrRrrZrZr[__hash__'zActor.__hash__cCs|jr|jSdSr:)rGrrZrZr[__str__*r\z Actor.__str__cCsd|j|jfS)Nz">rSrrZrZr[__repr__-r\zActor.__repr__stringcCsP|j|}|r|\}}t||S|j|}|r#t|ddSt|dS)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` rcN)name_email_regexsearchrr name_only_regexgroup)clsr_rrGrRrZrZr[ _from_string0s     zActor._from_stringenv_name env_email config_reader)Nr7r8c stdd}ddtffdd dtffdd }d||j|fd||jffD]G\}}}} z tj|} t||| Wq'tyn|dur`z|d |} Wn t yY| } Ynwt||| t ||slt||| Yq'w|S) NrJrIcsstSr)r rZ)user_idrZr[ default_emailSsz(Actor._main_actor..default_emailcsddS)N@r)rrZ)rjrZr[ default_nameYr\z'Actor._main_actor..default_namerGrRuser) r r conf_name conf_emailrQrRsetattrrSrrgetattr) rdrfrgrhactorrlattrevarcvarrHvalrZ)rjrir[ _main_actorIs.          zActor._main_actorcC||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. )rwenv_committer_nameenv_committer_emailrdrhrZrZr[ committerqs zActor.committercCrx)zSame as :meth:`committer`, but defines the main author. It may be specified in the environment, but defaults to the committer.)rwenv_author_nameenv_author_emailr{rZrZr[authorsz Actor.authorr) rjr;r<r=rDrErbr`r}r~ryrzrnrorCr-rrr$rrXrYr>r[r]r^ classmethodrer3rwr|rrZrZrZr[r sD   'r c@sLeZdZdZdZdedeeefddfddZ e d d d e ddfd 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 change_type = type of change as str, A|C|D|M|R|T|U|X|B ``full-stat-dict`` In addition to the items in the stat-dict, it features additional information:: files = number of changed files as int totalfilesrrrINcCrTrr)rerrrZrZr[rrUzStats.__init__rhr:textc Csdddddid}|D]Z}|d\}}}}|dkr!t|p"d} |dkr+t|p,d} |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 deletionslinesrr -rrrrrrc)rrr change_type) splitlinesrr>rVr) rdrhrhshrrraw_insertions raw_deletionsfilenamerr files_dictrZrZr[_list_from_strings$  zStats._list_from_string) rjr;r<r=rCrBr(r?r;rrrrrZrZrZr[rs rc@sbeZdZdZdZdeddfddZdedefd d Z de fd d Z de fd dZ defddZ 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. )rsha1rrINcCs||_td|_dS)N)rr!r)rerrZrZr[rrLzIndexFileSHA1Writer.__init__datacCs|j||j|Sr)rr+rr)rerrZrZr[rs  zIndexFileSHA1Writer.writecCs|j}|j||Sr)rdigestrrresharZrZr[ write_shas  zIndexFileSHA1Writer.write_shacCs|}|j|Sr)rrcloserrZrZr[rs zIndexFileSHA1Writer.closecCs |jSr)rtellrrZrZr[rrzIndexFileSHA1Writer.tell)rjr;r<r=rCr*rr%r>rrrrrrZrZrZr[rs rc@sjeZdZdZdZdeddfddZddd Zdefd d Z de fd d Z dddZ dddZ dddZdS)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_lock file_pathrINcCs||_d|_dS)NFr)rerrZrZr[rrUzLockFile.__init__cCs |dSr) _release_lockrrZrZr[__del__ zLockFile.__del__cCs d|jS)z:return: Path to lockfilez%s.lock)rrrZrZr[_lock_file_paths zLockFile._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. )rrrZrZr[ _has_lockszLockFile._has_lockc Cs|rdS|}t|rtd|j|fzt|ddWdn1s*wYWntyC}ztt||d}~wwd|_ 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) rrrrIOErrorropenOSErrorrr)re lock_filerrZrZr[_obtain_lock_or_raise s&  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. )rrrZrZr[ _obtain_lock"szLockFile._obtain_lockcCs>|sdS|}zt|Wn tyYnwd|_dS)z Release our lock if we have one.NF)rrrrr)relfprZrZr[r)s   zLockFile._release_lockr9)rjr;r<r=rCr?rrrrrrrrrrZrZrZr[r s  r c sLeZdZdZdZdejfdedede ddffd d Z d fd 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?rcheck_interval_smax_block_time_srINcst|||_||_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)rIrrr)rerrrrJrZr[rCs  zBlockingLockFile.__init__c st}|t|j} ztWdSty\}zrrrMrZrZrJr[r 8sr cseZdZdZdZddededdffdd Zddededd fd d Zd ede fddZ d ede fddZ de eeeefde fddZde eeeefdd fddZZS)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_prefixrJid_attrprefixrIzIterableList[T_IterableObj]cs t|Sr)rI__new__)rdrrrJrZr[rrzIterableList.__new__NcCrTrr)rerrrZrZr[rrUzIterableList.__init__rsc Csbz t||}|r |WSWn ttfyYnwz t|tt|WdSttfy0YdSw)NTF)list __contains__AttributeError TypeErrorrqr4r)rersrvalrZrZr[rs zIterableList.__contains__cCs8|j|}|D]}t||j|kr|Sqt||Sr)rrqrr__getattribute__)rersitemrZrZr[ __getattr__s  zIterableList.__getattr__rc Csjt|tr t||St|trtdz t|tt|WSt y4}z t d|j ||d}~ww)NzIndex should be an int or strzNo item found with id ) rr>r __getitem__slicer rqr4rr IndexErrorr)rerrrZrZr[rs   zIterableList.__getitem__cCsptt|}t|tr0d}|j|}t|D]\}}t||j|kr%|}nq|dkr0td|t ||dS)NzItem with name %s not found) r4r>rrrrrqrrr __delitem__)rerdelindexrGirrZrZr[rs    zIterableList.__delitem__)rJ)rjr;r<r=rCrrrobjectrrrDrr3rAr>rrrrMrZrZrJr[r zs& r c @sfeZdZUdZdZeed<eeddde de de e fd d Z eddde de de e fd d 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 ` rZ_id_attribute_rhr:rfrgrIcOtd)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 SubclassNotImplementedErrorrdrhrfrgrZrZr[ iter_itemss zIterableObj.iter_itemscO,t|j}||j|g|Ri||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 rextendrrdrhrfrgout_listrZrZr[ list_itemss zIterableObj.list_itemsN)rjr;r<r=rCrr?rrr$r+rDrr rrZrZrZr[rs  " $rc@s*eZdZdZdedededdfddZdS) IterableClassWatcherzbMetaclass that issues :exc:`DeprecationWarning` when :class:`git.util.Iterable` is subclassed.rGbasesclsdictrINcCs2|D]}t|turtjd|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)rdrGrrbaserZrZr[rs  zIterableClassWatcher.__init__)rjr;r<r=rr0r(rrZrZrZr[r src @sTeZdZdZdZdZedddededefd d Zedddededefd d 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. rZz5attribute that most suitably identifies your instancerhr:rfrgrIcOr)zDeprecated, use :class:`IterableObj` instead. Find (all) items of this type. See :meth:`IterableObj.iter_items` for details on usage. :return: Iterator yielding Items rrrrZrZr[r)s zIterable.iter_itemscOr)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 rrrZrZr[r6s zIterable.list_itemsN) rjr;r<r=rCrrr$rrrZrZrZr[rs r) metaclass)r)Fr).)T)r]__all__r^rabcr contextlib functoolsrrloggingrQos.pathrwrpathlibrrDrr|rr urllib.parserrr gitdb.utilrrrrrr r!r"r#typingr$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5git.cmdr6 git.configr7r8 git.remoter9 git.repo.baser: git.typesr;r<r=r>r?r@rArBrCrD getLoggerrjrTrrr\r_rr`rarcontextmanagerrsrvrrr>rrrrrrrrrrrEIrr?rrrrrrr rrrrrrr rrr r r rrrrrZrZrZr[s       ,P   ,   " !    &"   $ "9@#NB^4