
    64%e7                        U d dl mZmZ d dlmZ d dl mZ ddlmZ ddl	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mZmZmZmZmZmZmZmZmZ d dlm Z m!Z! erd dl"m#Z# d dl$m%Z% ee&e'e(f         Z)eeed         eed         f                  Z*d Z+ee(e(ge'f         e,d<   dZ-de)de)de'fdZ.dee)         dee)e)ge'f         ddfdZ/ G d de0          Z1 G d de
ej2        ej3        ej4                  Z5e5e5j6        e5j7        <   dS )    )IterableList	join_pathN)
to_bin_sha   )util)IndexObjectIndexObjUnion)Blob)	Submodule)tree_entries_from_datatree_to_stream)AnyCallableDictIterableIteratorListTupleTypeUnioncastTYPE_CHECKING)PathLikeLiteral)Repo)BytesIO)TreeN)r   r   c                     | |k    | |k     z
  S N )abs     0lib/python3.11/site-packages/git/objects/tree.py<lambda>r$   4   s    q1uQ.?     cmp)TreeModifierr   t1t2returnc                     | d         |d         }}t          |          t          |          }}t          ||          }t          |d |         |d |                   }|r|S ||z
  S )N   )lenminr&   )r(   r)   r!   r"   len_alen_bmin_lenmin_cmps           r#   git_cmpr3   9   sm    a5"Q%qAq663q665E%G!HWH+q'{++G 5=r%   r!   c                    t          |           dk     rd S t          |           dz  }| d |         }| |d          }t          ||           t          ||           d}d}d}|t          |          k     r{|t          |          k     rh |||         ||                   dk    r||         | |<   |dz   }n||         | |<   |dz   }|dz   }|t          |          k     r|t          |          k     h|t          |          k     r(||         | |<   |dz   }|dz   }|t          |          k     (|t          |          k     r*||         | |<   |dz   }|dz   }|t          |          k     (d S d S )Nr,   r   r   )r-   
merge_sort)r!   r&   midlefthalf	righthalfijks           r#   r5   r5   F   s   
1vvzzt
a&&A+C#wH#$$Ixy#	A	A	A
c(mm

C	NN 2 23x{IaL))Q..A;AaDAAAQ<AaDAAE c(mm

C	NN 2 2 c(mm

{!EE c(mm


 c)nn

|!EE c)nn





r%   c                       e Zd ZdZdZdee         ddfdZdede	fdZ
dd	Zddede	dededd f
dZdede	deddfdZdeddfdZdS )r'   zA utility class providing methods to alter the underlying cache in a list-like fashion.

    Once all adjustments are complete, the _cache, which really is a reference to
    the cache of a tree, will be sorted. Assuring it will be in a serializable state_cachecacher*   Nc                     || _         d S r   )r=   )selfr>   s     r#   __init__zTreeModifier.__init__r   s    r%   namec                 Z    t          | j                  D ]\  }}|d         |k    r|c S dS )z7:return: index of an item with name, or -1 if not foundr,   )	enumerater=   )r@   rB   r9   ts       r#   _index_by_namezTreeModifier._index_by_nameu   sA    dk** 	 	DAqtt||  rr%   c                 :    t          | j        t                     | S )zCall this method once you are done modifying the tree information.
        It may be called several times, but be aware that each call will cause
        a sort operation

        :return self:)r5   r=   r3   r@   s    r#   set_donezTreeModifier.set_done   s     	4;(((r%   Fshamodeforcec                    d|v rt          d          |dz	  t          j        vrt          d|z            t          |          }|                     |          }|||f}|dk    r| j                            |           nD|r|| j        |<   n7| j        |         }|d         |k    s|d         |k    rt          d|z            | S )	aA  Add the given item to the tree. If an item with the given name already
        exists, nothing will be done, but a ValueError will be raised if the
        sha and mode of the existing item do not match the one you add, unless
        force is True

        :param sha: The 20 or 40 byte sha of the item to add
        :param mode: int representing the stat compatible mode of the item
        :param force: If True, an item with your name and information will overwrite
            any existing item with the same name, no matter which information it has
        :return: self/z$Name must not contain '/' characters   z(Invalid object type according to mode %orD   r   r   z)Item %r existed with different properties)
ValueErrorr   _map_id_to_typer   rG   r=   append)r@   rK   rL   rB   rM   indexitemex_items           r#   addzTreeModifier.add   s     $;;CDDDBJt333G$NOOOoo##D))T4  B;;Kt$$$$ Y%)E""+e,1:$$
d(:(:$%PSW%WXXX r%   binshac                     t          |t                    r*t          |t                    rt          |t                    sJ |||f}| j                            |           dS )zAdd the given item to the tree, its correctness is assumed, which
        puts the caller into responsibility to assure the input is correct.
        For more information on the parameters, see ``add``

        :param binsha: 20 byte binary shaN)
isinstancebytesintstrr=   rS   )r@   rX   rL   rB   
tree_caches        r#   add_uncheckedzTreeModifier.add_unchecked   sb     &%((\Zc-B-B\zRVX[G\G\\\\dD)
:&&&&&r%   c                 P    |                      |          }|dk    r
| j        |= dS dS )z0Deletes an item with the given name if it existsrD   N)rG   r=   )r@   rB   rT   s      r#   __delitem__zTreeModifier.__delitem__   s5    ##D))2::E""" :r%   )r*   r'   )F)__name__
__module____qualname____doc__	__slots__r   TreeCacheTuprA   r]   r\   rG   rJ   r[   boolrW   r_   ra   r    r%   r#   r'   r'   i   s       X X
 Id<0 T    3 3       " "u "C "s "4 "N " " " "H	'E 	' 	'C 	'D 	' 	' 	' 	'# # # # # # # #r%   r'   c                   H    e Zd ZU dZdZed         ed<   dZdZdZ	dZ
dZeee	ee
eiZeeee         f         ed	<   ed
z  dfdddededeedf         f fdZededeed         ed         f         fd            Zdeddf fdZdee         dee         fdZdedefdZ dedefdZ!e"de#d          fd            Z$e"de#e         fd            Z%e"de&fd             Z'd! d" d#d$d%d&d%fd'e(eee)f         ege*f         d(e(eee)f         ege*f         d)ed*e*d+e*d,ed-e*deee         ee)         f         f fd.Z+d/e,d0e,de-e         f fd1Z.d2ed3ede#e         fd4Z/dee         fd5Z0defd6Z1d7eeee2f         defd8Z3d7eeef         de*fd9Z4dee         fd:Z5d?d=Z6d?d>Z7 xZ8S )@r   zTree objects represent an ordered list of Blobs and other Trees.

    ``Tree as a list``::

        Access a specific blob using the
        tree['filename'] notation.

        You may as well access by index
        blob = tree[0]
    treetyper=         
      rR   rP   Nrepor   rX   rL   pathc                 ^    t          t          |                               ||||           d S r   )superr   rA   )r@   rp   rX   rL   rq   	__class__s        r#   rA   zTree.__init__   s/     	dD""4t<<<<<r%   index_objectr*   )r   .r    c                 j    |j         dk    r't          |                    |j                            S dS )Nrj   r    )rk   tuple_iter_convert_to_objectr=   )clsru   s     r#   _get_intermediate_itemszTree._get_intermediate_items   s6    
 &&==l>QRRSSSrr%   attrc                     |dk    rL| j         j                            | j                  }t	          |                                          | _        d S t          t          |           	                    |           d S )Nr=   )
rp   odbstreamrX   r   readr=   rs   r   _set_cache_)r@   r{   ostreamrt   s      r#   r   zTree._set_cache_   sf    8im**4;77G.DW\\^^.T.TDKKK$))$/////r%   iterablec              #      K   |D ]f\  }}}t          | j        |          }	  | j        |dz	           | j        |||          V  @# t          $ r}t          d||fz            |d}~ww xY wdS )zwIterable yields tuples of (binsha, mode, name), which will be converted
        to the respective object representationrP   z0Unknown mode %o found in tree data for path '%s'N)r   rq   rR   rp   KeyError	TypeError)r@   r   rX   rL   rB   rq   es          r#   rx   zTree._iter_convert_to_object   s       #+ 	j 	jFD$TY--Dj6d*42:6ty&$PTUUUUUU j j j RVZ\`Ua abbhiij		j 	js   #A
A)A$$A)filec                    d}d|v r| }| }|                     d          }t          |          D ]F\  }}||         }|j        dk    r|}|t          |          dz
  k    rt	          ||z            |c S || k    rt	          ||z            |S | j        D ]\}|d         |k    rN | j        |d         dz	           | j        |d         |d         t          | j	        |d                             c S ]t	          ||z            )zFind the named object in this tree's contents

        :return: ``git.Blob`` or ``git.Tree`` or ``git.Submodule``
        :raise KeyError: if given file or tree does not exist in treezBlob or Tree named %r not foundrO   rj   r   r,   rP   r   )
splitrE   rk   r-   r   r=   rR   rp   r   rq   )	r@   r   msgrj   rU   tokensr9   tokeninfos	            r#   joinz	Tree.join  s?   
 0$;;DDZZ__F%f--    5E{9&&DD CKK!O++&sTz222KKK t||sTz***K  7d??>4/Q2>	47DGYty$q'5R5R     #
 3:&&&r%   c                 ,    |                      |          S )zFor PY3 only)r   )r@   r   s     r#   __truediv__zTree.__truediv__(  s    yyr%   c                     d | D             S )z?:return: list(Tree, ...) list of trees directly below this treec                 (    g | ]}|j         d k    |S )rj   rk   .0r9   s     r#   
<listcomp>zTree.trees.<locals>.<listcomp>/  $    444a16V#3#3#3#3#3r%   r    rI   s    r#   treesz
Tree.trees,       5444444r%   c                     d | D             S )z?:return: list(Blob, ...) list of blobs directly below this treec                 (    g | ]}|j         d k    |S )blobr   r   s     r#   r   zTree.blobs.<locals>.<listcomp>4  r   r%   r    rI   s    r#   blobsz
Tree.blobs1  r   r%   c                 *    t          | j                  S )aM  
        :return: An object allowing to modify the internal cache. This can be used
            to change the tree's contents. When done, make sure you call ``set_done``
            on the tree modifier, or serialization behaviour will be incorrect.
            See the ``TreeModifier`` for more information on how to alter the cache)r'   r=   rI   s    r#   r>   z
Tree.cache6  s     DK(((r%   c                     dS )NTr    r9   ds     r#   r$   zTree.<lambda>A  s    `d r%   c                     dS )NFr    r   s     r#   r$   zTree.<lambda>B  s    \a r%   rD   TFr   	predicateprunedepthbranch_first
visit_onceignore_selfas_edgec                     t          t          t          t                   t          t                   f         t          t          |                               ||||||                    S )zFor documentation, see util.Traversable._traverse()
        Trees are set to visit_once = False to gain more performance in the traversal)r   r   r   r	   TraversedTreeTuprs   r   	_traverse)	r@   r   r   r   r   r   r   r   rt   s	           r#   traversezTree.traverse?  s^    . (=)84D+EEF$'' 

 

 
	
r%   argskwargsc                 D     t          t          |           j        |i |S )z
        :return: IterableList with the results of the traversal as produced by
            traverse()
            Tree -> IterableList[Union['Submodule', 'Tree', 'Blob']]
        )rs   r   _list_traverse)r@   r   r   rt   s      r#   list_traversezTree.list_traverseb  s'     0uT4  /@@@@r%   r9   r:   c                 `    t          |                     | j        ||                             S r   )listrx   r=   )r@   r9   r:   s      r#   __getslice__zTree.__getslice__l  s)    D00QqS1ABBCCCr%   c                 6    |                      | j                  S r   )rx   r=   rI   s    r#   __iter__zTree.__iter__o  s    ++DK888r%   c                 *    t          | j                  S r   )r-   r=   rI   s    r#   __len__zTree.__len__r  s    4;r%   rU   c           
      V   t          |t                    rY| j        |         } | j        |d         dz	           | j        |d         |d         t          | j        |d                             S t          |t                    r|                     |          S t          d|z            )Nr   rP   r   r,   zInvalid index type: %r)
rZ   r\   r=   rR   rp   r   rq   r]   r   r   )r@   rU   r   s      r#   __getitem__zTree.__getitem__u  s    dC   	s;t$D64'Q26ty$q'4PQ7T]^b^gimnoipTqTqrrrdC   	#99T??" 047888r%   c                     t          |t                    r| j        D ]}|j        |d         k    r dS n.| j        }| j        D ]}|t          ||d                   k    r dS  dS )Nr   Tr,   F)rZ   r   r=   rX   rq   r   )r@   rU   r   rq   s       r#   __contains__zTree.__contains__  s    dK(( 	     ;$q'))44 *  9D    9T47333344 4 ur%   c                 P    t          |                     | j                            S r   )reversedrx   r=   rI   s    r#   __reversed__zTree.__reversed__  s     44T[AABBBr%   r~   r   c                 :    t          | j        |j                   | S )a
  Serialize this tree into the stream. Please note that we will assume
        our tree data to be in a sorted state. If this is not the case, serialization
        will not generate a correct tree representation as these are assumed to be sorted
        by algorithms)r   r=   writer@   r~   s     r#   
_serializezTree._serialize  s    
 	t{FL111r%   c                 R    t          |                                          | _        | S r   )r   r   r=   r   s     r#   _deserializezTree._deserialize  s    ,V[[]];;r%   )r~   r   r*   r   )9rb   rc   rd   re   rk   r   __annotations__rf   	commit_idblob_id
symlink_idtree_idr   r
   rR   r   r\   r   r	   r[   r   r   rA   classmethodr   rz   r]   r   r   rg   r   rx   r   r   propertyr   r   r   r'   r>   r   r   rh   r   r   r   r   r   r   r   slicer   r   r   r   r   __classcell__)rt   s   @r#   r   r      s        	 	 #D'&/"""I IGJG 	9D7OT#tM223    rM&*= == = 	=
 HdN#= = = = = = # 
u[!59,	-   [0 0 0 0 0 0 0 0j0F j8TaKb j j j j' ' ' ' ' 'D      5tF| 5 5 5 X5 5tDz 5 5 5 X5 )| ) ) ) X) TeSdOaOa! !
 !
U=2B#BCSI4OP!
 }.>>?EtKL!
 	!

 !
 !
 !
 !
 
x&1A(BB	C!
 !
 !
 !
 !
 !
FA3 A# A,}:U A A A A A ADc Dc Dd=.A D D D D9(=1 9 9 9 9         
9c3o 6 
9= 
9 
9 
9 
9}h'>!? D    &Ch}5 C C C C          r%   r   )8git.utilr   r   git.diffdiffgit_diffr    r   baser   r	   r   r
   submodule.baser   funr   r   typingr   r   r   r   r   r   r   r   r   r   r   	git.typesr   r   git.repor   ior   r[   r\   r]   rg   r   r&   r   __all__r3   r5   objectr'   DiffableTraversableSerializabler   rR   r   r    r%   r#   <module>r      s   - , , , , , , , ,                   , , , , , , , ,       % % % % % % 7 7 7 7 7 7 7 7
                          ( ' ' ' ' ' ' ' UC_%u\2M5IaCbbcd  "@!?XsCj#o ? ? ?
"
 
, 
3 
 
 
 
 $|$  8\<4PRU4U+V  [_        FU# U# U# U# U#6 U# U# U#t^ ^ ^ ^ ^;)4+;T=N ^ ^ ^H &* T\ " " "r%   