o ﯪg @sUddlZgdZejdkredddlmZddlZddlmZddl Z ddl Z ddl Z ddl m ZddlZddlZddlZddlZddlZddlZddlZddlmZmZddlZddlmZmZmZmZmZmZm 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.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5e1rdd l6m7Z7dd l8m9Z9m:Z:dd l;mZ>ddl?m@Z@mAZAmBZBmCZCmDZDmEZEmFZFmGZGmHZHe2de3dddZIe JeKZLdeMdeNdeNfddZOdeMdeNdeNfddZPePddZQePddZRe2dZSde'deSfde'deSffdd ZTejUd!eDde)eDddffd"d#ZVejUdeMd$eMde)d%fd&d'ZWd(eDddfd)d*ZXd(eDddfd+d,ZYdd.e&d/e&d0eZdeZfd1d2Z[d3eDd4eDdeDfd5d6Z\ejdkrwd(eDdeDfd7dZ]d(eDdeMfd8d9Z^e]Z_n d(eDdeMfd:d9Z^e^Z_d3eDd4eDdeDfd;d<Z`dd(eDd>eNdeNfd?d@Zade/eMfdAdBZbddCeMd(e-eDde,eMfdDdEZcdFe-eMd(eMdeMfdGdHZdeedIdJdKd=feedLedd=feedMedd=feedNejfdOdKdfeedPdQdKd=ffZge0e0e.eMe'eNfdfehdR<d(eMdeMfdSdTZieedUZjd(eDdeMfdVdWZkiZle(eMe-eNfehdX<dYeMdeNfdZd[Zme5dYddeCd=fd\d]Zne5dYeDdeNfd^d]ZndYe3deDfdeNfd_d]ZndeMfd`daZodbe3ejpdcfdde$ddfdedfZqe5dd4ddgeNddfdhdiZre5dd4eDdgeNdeMfdjdiZrdd4e3deDfdgeNde-eDfdkdiZrdle/eMde,eMfdmdnZsGdodpdpZtGdqdrdretZuGdsdtdtZvGdudvdvZwGdwdxdxZxGdydzdzZyGd{d|d|eyZzGd}d~d~e,eIZ{eHGdddeEZ|Gddde}Z~Gddde~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 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)rFrGvalueadjusted_valuerYD/var/www/html/chatdoc2/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[)rFrGrYrYrZ_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.)InvalidGitRepositoryErrorselfr8argskwargsrHcs,|jjr dj|g|Ri|S)Nz/Method '%s' cannot operate on bare repositories)repobare__name__rdrerfrcrarYrZwrapperszunbare_repo..wrapper)excrcrr#r`)rarlrYrkrZrs "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)rPgetcwdchdir)rnold_dirrYrYrZcwds  rrrW)NNNc cs`t|}|tj|<zdVW|durtj|=dS|tj|<dS|dur*tj|=w|tj|<w)z=Context manager to temporarily patch an environment variable.N)rPgetenvrQ)rFrW old_valuerYrYrZ patch_envs   rupathcCs`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. functionrv_excinforHNc 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)rPchmodstatS_IWUSRPermissionErrorrunittestry)rwrvrxexryrYrYrZhandlers zrmtree..handlerr) )onexc)onerror)r&r>r#r\r]shutilr version_info)rvrrYrYrZrs   rcCs2t|rtjdkrt|dt|dSdS)zWEnsure file deleted also on *Windows* where read-only files need special treatment.riN)ospisfiler\r]rPrzremovervrYrYrZrmfiles   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)rrrbrchunkrYrYrZrs    rapcGsht|}|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./rbNrI)str startswithendswith)rrrvbrYrYrZrs  rcCt|}|ddS)Nr\rreplacerrYrYrZr$ cCr)NrrrrrYrYrZr(rrcCst|SN)rrrYrYrZr/scGstt|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)rrrYrYrZr5srFis_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)rdirnameisdirrPmakedirs)rvrrYrYrZr>s   rcCs>tjdd}|rtdd|tjDStjdkrdSdS)NPATHEXTcss|]}|VqdSr)upper).0rrYrYrZ Tsz&_get_exe_extensions..r)z.BATz.COMz.EXErY)rPrQgettuplesplitpathsepr\r])rrYrYrZ_get_exe_extensionsQs  rprogramcstdtdtffdd }g}|stjd}t|tjD]'}|d}|rFt ||gfddDD] }||rE| |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. fpathrHcs>tottjotjdkp ptfddDS)Nrc3s|] }|VqdSr)rr)rextrrYrZrpsz,py_where..is_exec..)rrrPaccessX_OKr\r]anyr) winprog_extsrrZis_execks  $zpy_where..is_execPATH"csg|]}d|fqS)z%s%srY)re)exe_pathrYrZ {szpy_where..) rrboolrPrQrrrUrjoinappend)rrvrprogsfolderfrY)rrrZpy_where[s     rdrivecCstt|r |s |}n&|ottt|}t|r&|r!|}nt|}n |r0d||f}t|}|ddS)Nz/proc/cygdrive/%s/%srr) risabsnormpath expandvars expandusercygpathrVrr)rrvrp_strrYrYrZ _cygexpaths   rz*\\\\\?\\UNC\\([^\\]+)\\([^\\]+)(?:\\(.*))?cCsd|||ddfS)Nz //%s/%s/%srr)r)servershare rest_pathrYrYrZsrz\\\\\?\\(\w):[/\\](.*)z(\w):[/\\](.*)z file:(.*)cC|SrrY)rrYrYrZrz (\w{2,}:.*)cCrrrY)urlrYrYrZrr_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)rrrmatchgroupsrr)rvregexparserrecurserrYrYrZrs    rz(?:/proc)?/cygdrive/(\w)(/.*)?cCsBt|}t|}|r|\}}d||pdf}|ddS)Nz%s:%srIrr)r_decygpath_regexrrrr)rvmrrrYrYrZ decygpaths    r_is_cygwin_cachegit_executablec Cst|}|durZd}z2t|}|s"t|}|r t|dnd}t|d}tj|gtjdd}| \}}d|v}Wnt yU}z t d|WYd}~nd}~ww|t|<|S) NFrrIunameT)stdoutuniversal_newlinesCYGWINz/Failed checking if running in CYGWIN due to: %r) rrrrrr subprocessPopenPIPE communicate ExceptionrSdebug) r is_cygwingit_dirres uname_cmdprocess uname_out_rrYrYrZ_is_cygwin_gits$     rcCdSrrYrrYrYrZ is_cygwin_gitrcCrrrYrrYrYrZrrcCs&tjdkrdS|dur dStt|S)NrF)r\r]rrrrYrYrZrs  cCsdttfS)zM:return: String identifying the currently active system user as ``name@node``z%s@%s)getpassgetuserr]noderYrYrYrZr sr proczGit.AutoInterruptrfcKs|jdi|dS)zXWait for the process (clone, fetch, pull or push) and handle its errors accordingly.NrY)wait)rrfrYrYrZfinalize_processsr expand_varscCrrrYrrrYrYrZ expand_pathrrcCrrrYrrYrYrZrscCsTt|tjr |Szt|}|rt|}tt|WSt y)YdSwr) isinstancepathlibPathresolverrrrabspathrrrYrYrZrs    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_parserrYrYrZremove_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)rbrY)rxrYrYrZrCszRemoteProgress.zdone.z, ) _cur_line _seen_ops error_lines other_linesz%(remote: )?([\w\s]+):\s+()(\d+)()(.*)z2(remote: )?([\w\s]+):\s+(\d+)% \((\d+)/(\d+)\)(.*)rHNcCsg|_d|_g|_g|_dSr)rrrrrdrYrYrZ__init__Ss 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 filesrI)rbytesdecoderrrrre_op_relativerre_op_absolute line_droppedrrCOUNTING COMPRESSINGWRITING RECEIVING RESOLVINGFINDING_SOURCES CHECKING_OUTrBEGINrUr DONE_TOKENENDrTOKEN_SEPARATORupdatefloat) rdrline_str cur_count max_countrop_code_remoteop_name_percentmessagerYrYrZ_parse_progress_lineYsb                      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. rrHNcs|Sr)r3rstrip)rrrYrZrsz3RemoteProgress.new_message_handler..handler)r$)rdrrYrrZnew_message_handlersz"RemoteProgress.new_message_handlercCdS)zICalled whenever a line could not be understood and was therefore dropped.NrY)rdrrYrYrZrszRemoteProgress.line_droppedrIr.r,r-r2cCr6)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>`. NrY)rdr.r,r-r2rYrYrZr)s$zRemoteProgress.updaterHNNrI)$ri __module__ __qualname____doc__rint__annotations__ranger%r'rrr r!r"r#r$ STAGE_MASKOP_MASKr&r( __slots__recompilerrrr$r3r&rr5rr2r*r)rYrYrYrZr3sL      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`.  _callablefnrHNcs||_tdSr)rEsuperr)rdrF __class__rYrZrzCallableRemoteProgress.__init__rerfcOs|j|i|dSrrDrjrYrYrZr)szCallableRemoteProgress.update) rir9r:r;rAr&rr#r) __classcell__rYrYrHrZrs  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_EMAILrFemailrFrPrHNcC||_||_dSrrQ)rdrFrPrYrYrZr zActor.__init__othercCs|j|jko |j|jkSrrQrdrTrYrYrZ__eq__sz Actor.__eq__cCs ||k SrrYrUrYrYrZ__ne__ z Actor.__ne__cCst|j|jfSr)hashrFrPrrYrYrZ__hash__zActor.__hash__cCs|jr|jSdSr8)rFrrYrYrZ__str__"r[z Actor.__str__cCsd|j|jfS)Nz">rQrrYrYrZ__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` rbN)name_email_regexsearchrr name_only_regexgroup)clsr^rrFrPrYrYrZ _from_string(s     zActor._from_stringenv_name env_email config_reader)Nr6r7c 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) NrIrHcsstSr)r rY)user_idrYrZ default_emailKsz(Actor._main_actor..default_emailcsddS)N@r)rrY)rirYrZ default_nameQr[z'Actor._main_actor..default_namerFrPuser) r r conf_name conf_emailrPrQsetattrrRrrgetattr) rcrerfrgactorrkattrevarcvarrGvalrY)rirhrZ _main_actorAs.          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. )rvenv_committer_nameenv_committer_emailrcrgrYrYrZ committeris zActor.committercCrw)zSame as :meth:`committer`, but defines the main author. It may be specified in the environment, but defaults to the committer.)rvenv_author_nameenv_author_emailrzrYrYrZauthorxsz Actor.authorr) rir9r:r;rBrCrar_r|r}rxryrmrnrAr,rrr#rrVrWr<rZr\r] classmethodrdr2rvr{r~rYrYrYrZr 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 totalfilesrrrHNcCrRrr)rdrrrYrYrZrrSzStats.__init__rgr9textc 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 -rrrrrrb)rrr change_type) splitlinesrr<rUr) rcrgrhshrrraw_insertions raw_deletionsfilenamerr files_dictrYrYrZ_list_from_strings$  zStats._list_from_string) rir9r:r;rArAr'r>r:rrrrrYrYrYrZrs 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. )rsha1rrHNcCs||_td|_dS)N)rr r)rdrrYrYrZrrJzIndexFileSHA1Writer.__init__datacCs|j||j|Sr)rr)rr)rdrrYrYrZrs  zIndexFileSHA1Writer.writecCs|j}|j||Sr)rdigestrrrdsharYrYrZ write_shas  zIndexFileSHA1Writer.write_shacCs|}|j|Sr)rrcloserrYrYrZrs zIndexFileSHA1Writer.closecCs |jSr)rtellrrYrYrZrrXzIndexFileSHA1Writer.tell)rir9r:r;rAr)rr$r<rrrrrrYrYrYrZrs 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_pathrHNcCs||_d|_dS)NFr)rdrrYrYrZrrSzLockFile.__init__cCs |dSr) _release_lockrrYrYrZ__del__ zLockFile.__del__cCs d|jS)z:return: Path to lockfilez%s.lock)rrrYrYrZ_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. )rrrYrYrZ _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)rd lock_filerrYrYrZ_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. )rrrYrYrZ _obtain_lockszLockFile._obtain_lockcCs>|sdS|}zt|Wn tyYnwd|_dS)z Release our lock if we have one.NF)rrrrr)rdlfprYrYrZr!s   zLockFile._release_lockr7)rir9r:r;rAr>rrrrrrrrrrYrYrYrZr 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_srHNcst|||_||_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)rGrrr)rdrrrrHrYrZr;s  zBlockingLockFile.__init__c st}|t|j} ztWdSty\}zr*r<rrrKrYrYrHrZr 0sr 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_prefixrIid_attrprefixrHzIterableList[T_IterableObj]cs t|Sr)rG__new__)rcrrrHrYrZrrzIterableList.__new__NcCrRrr)rdrrrYrYrZrrSzIterableList.__init__rrc Csbz t||}|r |WSWn ttfyYnwz t|tt|WdSttfy0YdSw)NTF)list __contains__AttributeError TypeErrorrpr3r)rdrrrvalrYrYrZrs zIterableList.__contains__cCs8|j|}|D]}t||j|kr|Sqt||Sr)rrprr__getattribute__)rdrritemrYrYrZ __getattr__s  zIterableList.__getattr__r c Cszt|tttfs Jdt|trt||St|tr tdzt||WSty<}z t d|j ||d}~ww)N-Index of IterableList should be an int or strzIndex should be an int or strzNo item found with id %r) rr<rslicer __getitem__r rpr IndexErrorr)rdr rrYrYrZrs    zIterableList.__getitem__cCst|ttfs Jdtt|}t|ts;d}|j|}t|D]\}}t||j|kr0|}nq |dkr;td|t ||dS)NrzItem with name %s not found) rr<rr3rrrprrr __delitem__)rdr delindexrFirrYrYrZrs    zIterableList.__delitem__)rI)rir9r:r;rArrrobjectrrrCrr2r@r<rrrrKrYrYrHrZr rs&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 ` rY_id_attribute_rgr9rerfrHcOtd)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 SubclassNotImplementedErrorrcrgrerfrYrYrZ 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 rextendrrcrgrerfout_listrYrYrZ list_itemss zIterableObj.list_itemsN)rir9r:r;rArr=rrr#r*rCrr rrYrYrYrZrs  " $rc@s*eZdZdZdedededdfddZdS) IterableClassWatcherzbMetaclass that issues :exc:`DeprecationWarning` when :class:`git.util.Iterable` is subclassed.rFbasesclsdictrHNcCs2|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)rcrFrrbaserYrYrZr s  zIterableClassWatcher.__init__)rir9r:r;rr/r'rrYrYrYrZr 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. rYz5attribute that most suitably identifies your instancergr9rerfrHcOr)zDeprecated, use :class:`IterableObj` instead. Find (all) items of this type. See :meth:`IterableObj.iter_items` for details on usage. :return: Iterator yielding Items rrrrYrYrZr%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 rrrYrYrZr2s zIterable.list_itemsN) rir9r:r;rArrr#rrrYrYrYrZrs r) metaclass)r)Fr).)T)r\__all__r]rabcr contextlib functoolsrrloggingrPos.pathrvrrrBrr{rr urllib.parserrr gitdb.utilrrrrrrr r!r"typingr#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4git.cmdr5 git.configr6r7 git.remoter8 git.repo.baser9 git.typesr:r;r<r=r>r?r@rArBrC getLoggerrirSrrr[r^rr_r`rcontextmanagerrrrurrr<rrrrrrrrrrrCIrr=rrrrrrr rrrrrrr rrr r r rrrrrYrYrYrZs      ,P   ,   " !    &"   $ "9@#NBb4