| Server IP : 198.38.94.13 / Your IP : 216.73.217.33 Web Server : Apache System : Linux d4744.dxb1.stableserver.net 5.14.0-611.49.1.el9_7.x86_64 #1 SMP PREEMPT_DYNAMIC Tue Apr 21 16:39:08 EDT 2026 x86_64 User : revivere ( 1140) PHP Version : 8.2.33 Disable Function : NONE MySQL : OFF | cURL : ON | WGET : ON | Perl : ON | Python : OFF | Sudo : OFF | Pkexec : OFF Directory : /opt/saltstack/salt/lib/python3.10/site-packages/git/objects/__pycache__/ |
Upload File : |
o
;j&] � @ s� d Z g d�ZddlmZmZ ddlZddlmZ ddlmZm Z m
Z
ddl Z ddl m
Z
ddlZddlZddlmZmZmZ dd lmZmZmZmZmZmZmZm Z m Z m Z m Z m Z m!Z! dd
l"m#Z#m$Z$ er�dd l%m&Z&m'Z' dd l(m)Z) dd
l"m*Z*m+Z+ ddl,m-Z- ddl.m/Z/ ddl0m1Z1 ddl2m3Z3 ddl4m5Z5m6Z6 neZ*dd� Z+G dd� de�Z7e ddd�Z8e e e d d f d f Z9e d�Z:d e e;e<f d e=fd d!�Z>d"e;d e e d# e d$ e d% e d& f fd'd(�Z?d)e<d e=fd*d+�Z@d,eAd e<fd-d.�ZBd/e<d e<fd0d1�ZCG d2d3� d3e
�ZDeDdd4�ZEd5eAd6eAd efd7d8�ZFd9e e<ef d e e=e=f fd:d;�ZGe �Hd<�ZIe �Hd=�ZJd>e<d e ee=e=f fd?d@�ZKG dAdB� dB�ZLe+G dCd � d e*��ZMe+G dDdE� dEe*��ZNG dFd� deeM�ZOdS )Gz/Utility functions for working with git objects.) �get_object_type_by_name�
parse_date�parse_actor_and_date�ProcessStreamAdapter� Traversable�altz_to_utctz_str�
utctz_to_altz� verify_utctz�Actor�tzoffset�utc� )�ABC�abstractmethodN)�deque)�datetime� timedelta�tzinfo)�digits)r � IterableList� IterableObj)
�Any�Callable�Deque�Iterator�
NamedTuple�Sequence�
TYPE_CHECKING�Tuple�Type�TypeVar�Union�cast�overload)�Has_id_attribute�Literal)�BytesIO�StringIO)�Popen)�Protocol�runtime_checkable� )�Blob)�Commit)� Submodule)� TagObject)�TraversedTreeTup�Treec C s | S �N� )�fr2 r2 �D/opt/saltstack/salt/lib/python3.10/site-packages/git/objects/util.pyr) C � r) c @ s. e Zd ZU eed< ed ed< ed ed< dS )�
TraverseNT�depth�r r+ �item�r N�srcN)�__name__�
__module__� __qualname__�int�__annotations__r r2 r2 r2 r4 r6 G s
r6 �T_TIobj�TraversableIterableObj)�boundr: r r/ �modestr�returnc C sL d}t t| dd� ��D ]\}}ttttf |�}|t|�|d > 7 }q |S )a� Convert mode bits from an octal mode string to an integer mode for git.
:param modestr:
String like ``755`` or ``644`` or ``100644`` - only the last 6 chars will be
used.
:return:
String identifying a mode compatible to the mode methods ids of the :mod:`stat`
module regarding the rwx permissions for user, group and other, special flags
and file system flags, such as whether it is a symlink.
r ���N� )� enumerate�reversedr! r �strr? )rD �modeZ iteration�charr2 r2 r4 �mode_str_to_int[ s
rM �object_type_namer, r. r0 r+ c C sx | dkr
ddl m} |jS | dkrddl m} |jS | dkr'ddl m} |jS | dkr4dd l m} |jS t d
| �
� ��) a Retrieve the Python class GitPython uses to represent a kind of Git object.
:return:
A type suitable to handle the given as `object_type_name`.
This type can be called create new instances.
:param object_type_name:
Member of :attr:`Object.TYPES <git.objects.base.Object.TYPES>`.
:raise ValueError:
If `object_type_name` is unknown.
s commitr* )�commits tag)�tags blob)�blobs tree)�treez%Cannot handle unknown object type: %s) � rO r, rP r. rQ r+ rR r0 �
ValueError�decode)rN rO rP rQ rR r2 r2 r4 r o s r �utctzc C s: t | �}t|�d d t|�d d }|dk r|S | S )z�Convert a git timezone offset into a timezone offset west of UTC in seconds
(compatible with :attr:`time.altzone`).
:param utctz:
git utc timezone string, e.g. +0200
�d � �< r )r? �abs)rV Z int_utctz�secondsr2 r2 r4 r � s r �altzc C s: t | �d }t | �d d }| dkrdnd}d�|||�S )z�Convert a timezone offset west of UTC in seconds into a Git timezone offset
string.
:param altz:
Timezone offset in seconds west of UTC.
rX rY �-�+z {}{:02}{:02})rZ �format)r\ �hours�minutes�signr2 r2 r4 r � s r �offsetc C sd t d| �}t| �dkr|�| d dvr|�| d tvs.| d tvs.| d tvs.| d tvr0|�| S ) z]
:raise ValueError:
If `offset` is incorrect.
:return:
`offset`
z"Invalid timezone offset format: %s� r z+-r* � rG � )rT �lenr )rc Zfmt_excr2 r2 r4 r � s 0r c @ s� e Zd Zddededef ddfdd�Zdeed eeef f fdd�Z d ee
df de fd
d �Z d ee
df defd d
�Z
d ee
df de fdd�ZdS )r
N�secs_west_of_utc�namerE c C s t | d�| _|p
d| _d S )N)r[ �fixed)r �_offset�_name)�selfrh ri r2 r2 r4 �__init__� s ztzoffset.__init__c C s t | j�� | jffS r1 )r
rk �
total_secondsrl �rm r2 r2 r4 �
__reduce__� s ztzoffset.__reduce__�dtc C � | j S r1 )rk �rm rr r2 r2 r4 � utcoffset� � ztzoffset.utcoffsetc C rs r1 )rl rt r2 r2 r4 �tzname� rv ztzoffset.tznamec C s t S r1 )�ZEROrt r2 r2 r4 �dst� r5 z tzoffset.dstr1 )r< r= r> �floatr rJ rn r r rq r r ru rw ry r2 r2 r2 r4 r
� s " r
�UTC� timestamp� tz_offsetc C s8 t �| t�}z
|�t|��}|W S ty | Y S w )z[Convert a `timestamp` + `tz_offset` into an aware :class:`~datetime.datetime`
instance.)r �
fromtimestampr �
astimezoner
rT )r| r} Zutc_dtZlocal_dtr2 r2 r4 �from_timestamp� s �r� � string_datec C s" t | t�r(| jr!tt| �� �}t|�� � }t| �t ��
� �|fS t d| � ���z�| � d�dkrU| �
d�dkrU| �� \}}|�d�rH|dd� }t|�}|tt|��fW S d}| d d
v rkt| d d� �}| dd � } t|�}g }d}d | v r�|�d
� | �
d�}n"|�d� |�d� |�d� |�d� | �
d�}|dkr�| �
d�}|dks�J �| |d d� }| d|� } t�|d�}
|D ]2} z't�| | �} t�| j| j| j|
j|
j|
j | j | j |
j f �}
t|
�|fW W S t y� Y q�w t d�� t �y } z
t d| � dt!| �� ��|�d}~ww )a Parse the given date as one of the following:
* Aware datetime instance
* Git internal format: timestamp offset
* :rfc:`2822`: ``Thu, 07 Apr 2005 22:13:13 +0200``
* ISO 8601: ``2005-04-07T22:13:13`` - The ``T`` can be a space as well.
:return:
Tuple(int(timestamp_UTC), int(offset)), both in seconds since epoch
:raise ValueError:
If the format could not be understood.
:note:
Date can also be ``YYYY.MM.DD``, ``MM/DD/YYYY`` and ``DD.MM.YYYY``.
z,string_date datetime object without tzinfo, � r* �:����@Nz+0000���z-+rF �,z %a, %d %b %Yz%Y-%m-%dz%Y.%m.%dz%m/%d/%Yz%d.%m.%Y�Tz%H:%M:%Szno format matchedz!Unsupported date format or type: z, type=)"�
isinstancer r r! r ru r? ro r r r| rT �count�rfind�split�
startswithr r �append�time�strptime�calendar�timegm�tm_year�tm_mon�tm_mday�tm_hour�tm_min�tm_sec�tm_wday�tm_yday�tm_isdst� Exception�type)r� ru rc r| Z
offset_strZ
timestamp_intZ date_formatsZsplitterZ time_partZ date_partZtstruct�fmtZdtstructZutctime�er2 r2 r4 r � st
��
���r z ^.+? (.*) (\d+) ([+-]\d+).*$z
^.+? (.*)$�linec C s` d\}}}t �| �}|r|�� \}}}nt�| �}|r |�d�n| p#d}t�|�t|�t|�fS )z�Parse out the actor (author or committer) info from a line like::
author Tom Preston-Werner <tom@mojombo.com> 1191999972 -0700
:return:
[Actor, int_seconds_since_epoch, int_timezone_offset]
)rS �0r� r* rS ) �_re_actor_epoch�search�groups�_re_only_actor�groupr Z _from_stringr? r )r� ZactorZepochrc �mr2 r2 r4 r F s
r c @ s< e Zd ZdZdZdddeddfdd �Zd
edefd d �ZdS )
r a% Class wiring all calls to the contained Process instance.
Use this type to hide the underlying process to provide access only to a specified
stream. The process is usually wrapped into an :class:`~git.cmd.Git.AutoInterrupt`
class to kill it if the instance goes out of scope.
)�_proc�_stream�processr' � stream_namerE Nc C s || _ t||�| _d S r1 )r� �getattrr� )rm r� r� r2 r2 r4 rn h s z ProcessStreamAdapter.__init__�attrc C s t | j|�S r1 )r� r� )rm r� r2 r2 r4 � __getattr__l s z ProcessStreamAdapter.__getattr__) r< r= r> �__doc__� __slots__rJ rn r r� r2 r2 r2 r4 r ^ s
r c @ s e Zd ZdZdZeededed fdd���Z edededefd d
��Z
d#d e dedede e
d
fdd�Zedededefdd��Zdd� dd� ddddd fdee
d def ege f dee
d def ege f ded e d e d ed e de
ee
d ee f fd d!�Zd"S )$r au Simple interface to perform depth-first or breadth-first traversals in one
direction.
Subclasses only need to implement one function.
Instances of the subclass must be hashable.
Defined subclasses:
* :class:`Commit <git.objects.Commit>`
* :class:`Tree <git.objects.tree.Tree>`
* :class:`Submodule <git.objects.submodule.base.Submodule>`
r2 r9 rE c C � t d��)aA
:return:
Tuple of items connected to the given item.
Must be implemented in subclass.
class Commit:: (cls, Commit) -> Tuple[Commit, ...]
class Submodule:: (cls, Submodule) -> Iterablelist[Submodule]
class Tree:: (cls, Tree) -> Tuple[Tree, ...]
� To be implemented in subclass��NotImplementedError)�clsr9 r2 r2 r4 �_get_intermediate_items� � z#Traversable._get_intermediate_items�args�kwargsc O � t jdtdd� | j|i |��S )z�Traverse self and collect all items found.
Calling this directly on the abstract base class, including via a ``super()``
proxy, is deprecated. Only overridden implementations should be called.
z�list_traverse() method should only be called from subclasses. Calling from Traversable abstract class will raise NotImplementedError in 4.0.0. The concrete subclasses in GitPython itself are 'Commit', 'RootModule', 'Submodule', and 'Tree'.re ��
stacklevel)�warnings�warn�DeprecationWarning�_list_traverse�rm r� r� r2 r2 r4 �
list_traverse� � �zTraversable.list_traverseF�as_edge)r, r- r0 r+ c O sX t | t�r | j}nd}|s t|�}|�| j|d|i|��� |S t| j|i |���}|S )aj Traverse self and collect all items found.
:return:
:class:`~git.util.IterableList` with the results of the traversal as
produced by :meth:`traverse`::
Commit -> IterableList[Commit]
Submodule -> IterableList[Submodule]
Tree -> IterableList[Union[Submodule, Tree, Blob]]
rS r� )r� r# Z_id_attribute_r �extend�traverse)rm r� r� r� �id�outZout_listr2 r2 r4 r� � s
zTraversable._list_traversec O r� )z�Iterator yielding items found when traversing self.
Calling this directly on the abstract base class, including via a ``super()``
proxy, is deprecated. Only overridden implementations should be called.
z�traverse() method should only be called from subclasses. Calling from Traversable abstract class will raise NotImplementedError in 4.0.0. The concrete subclasses in GitPython itself are 'Commit', 'RootModule', 'Submodule', and 'Tree'.re r� )r� r� r� � _traverser� r2 r2 r4 r� � r� zTraversable.traversec C � dS �NTr2 ��i�dr2 r2 r4 �<lambda>� � zTraversable.<lambda>c C r� �NFr2 r� r2 r2 r4 r� � r� r� Tr* � predicater+ �pruner7 � branch_first�
visit_once� ignore_selfr8 c
# s� � t � }t� } | �td�d�� dtt dddtdtddf
� �fd d
� }
| rr| �� \} � } |r4� |v r4q$|r;|�� � |rB| � f}
n� }
||
| �rJq$|oO� �u }|sZ||
| �rZ|
V | d }|d krg||krgq$|
| � ||� | s&dS dS )
a� Iterator yielding items found when traversing `self`.
:param predicate:
A function ``f(i,d)`` that returns ``False`` if item i at depth ``d`` should
not be included in the result.
:param prune:
A function ``f(i,d)`` that returns ``True`` if the search should stop at
item ``i`` at depth ``d``. Item ``i`` will not be returned.
:param depth:
Defines at which level the iteration should not go deeper if -1. There is no
limit if 0, you would effectively only get `self`, the root of the
iteration. If 1, you would only get the first level of
predecessors/successors.
:param branch_first:
If ``True``, items will be returned branch first, otherwise depth first.
:param visit_once:
If ``True``, items will only be returned once, although they might be
encountered several times. Loops are prevented that way.
:param ignore_self:
If ``True``, `self` will be ignored and automatically pruned from the
result. Otherwise it will be the first item to be returned. If `as_edge` is
``True``, the source of the first edge is ``None``.
:param as_edge:
If ``True``, return a pair of items, first being the source, second the
destination, i.e. tuple(src, dest) with the edge spanning from source to
destination.
:return:
Iterator yielding items found when traversing `self`::
Commit -> Iterator[Union[Commit, Tuple[Commit, Commit]] Submodule ->
Iterator[Submodule, Tuple[Submodule, Submodule]] Tree ->
Iterator[Union[Blob, Tree, Submodule,
Tuple[Union[Submodule, Tree], Union[Blob, Tree,
Submodule]]]
ignore_self=True is_edge=True -> Iterator[item] ignore_self=True
is_edge=False --> Iterator[item] ignore_self=False is_edge=True ->
Iterator[item] | Iterator[Tuple[src, item]] ignore_self=False
is_edge=False -> Iterator[Tuple[src, item]]
r N�stack�src_itemr r� r7 rE c sh �� ����s d S |r| �� �fdd��D �� d S � ��fdd�tt��d dd�D �}| �|� d S )Nc 3 s � | ] }t � |��V qd S r1 �r6 ��.0r� )r7 r� r2 r4 � <genexpr> s � z<Traversable._traverse.<locals>.addToStack.<locals>.<genexpr>c 3 s � | ] }t � �| ��V qd S r1 r� r� �r7 �lstr� r2 r4 r� s � r* r� )r� �
extendleft�rangerg r� )r� r� r� r7 Zreviter�r9 rm r� r4 �
addToStack s
&z)Traversable._traverse.<locals>.addToStackr* r� ) �setr r� r6 r �boolr? �pop�add)rm r� r� r7 r� r� r� r� Zvisitedr� r� r� r; ZrvalZ
skipStartItemZnext_dr2 r� r4 r� � sD �:�����
�zTraversable._traverseN)F)r< r= r> r� r� � classmethodr r r r� r� r� r r r� r� r � TraversedTupr? r r� r2 r2 r2 r4 r p sX ����
�#�������� �c @ s( e Zd ZdZdZd dd�Zd dd �Zd
S ) � SerializablezUDefines methods to serialize and deserialize objects from and into a data
stream.r2 �streamr% rE c C r� )a Serialize the data of this object into the given data stream.
:note:
A serialized object would :meth:`_deserialize` into the same object.
:param stream:
A file-like object.
:return:
self
r� r� �rm r� r2 r2 r4 �
_serializeK r� zSerializable._serializec C r� )z�Deserialize all information regarding this object from the stream.
:param stream:
A file-like object.
:return:
self
r� r� r� r2 r2 r4 � _deserializeZ s zSerializable._deserializeN)r� r% rE r� )r< r= r> r� r� r� r� r2 r2 r2 r4 r� C s
r� c s~ e Zd ZdZeeedf ef Zdededede e f� fdd� Z
e dede e fd d
��Z
e ded eeeeeedf ef f egef d eeeeeedf ef f egef d
edededed ded de e fdd
��Z
e ded eeeeeedf ef f egef d eeeeeedf ef f egef d
edededed ded de eeedf ef fdd
��Z
e ded eeeef egef d eeeef egef d
edededed ded de eeef fdd
��Z
dd� dd� dddddfded eeeef egef d eeeef egef d
edededededee e e eeef e e f f� fd d
�
Z
� ZS ) rB r2 Nrm r� r� rE c s t � j|i |��S r1 )�superr� r� �� __class__r2 r4 r� k s z$TraversableIterableObj.list_traversec C � d S r1 r2 rp r2 r2 r4 r� n r5 z TraversableIterableObj.traverser� r� r7 r� r� r� Tr� Fc C r� r1 r2 �rm r� r� r7 r� r� r� r� r2 r2 r4 r� q �
c C r� r1 r2 r� r2 r2 r4 r� } r� c C r� r1 r2 r� r2 r2 r4 r� � r� c C r� r� r2 r� r2 r2 r4 r� � r� z TraversableIterableObj.<lambda>c C r� r� r2 r� r2 r2 r4 r� � r� r� r* c s> t ttt tttdtf tf f t� �|||||||��S )z5For documentation, see :meth:`Traversable._traverse`.N)r! r r rA r r� r� r� r� r2 r4 r� � s "��)r< r= r> r� r r rA Z TIobj_tupler r r� r" r r� r r? r� r$ �
__classcell__r2 r2 r� r4 rB f s� "�&�&������ � �&�&������ � �������� �
��������� �)Pr� �__all__�abcr
r r� � collectionsr r r r �re�stringr r� r� Zgit.utilr r r �typingr r r r r r r r r r r r! r" Z git.typesr# r$ �ior% r& �
subprocessr' r( r) rQ r+ rO r, Zsubmodule.baser- rP r. rR r/ r0 r6 rA r� rx �bytesrJ r? rM r r rz r r r
r r� r �compiler� r� r r r r� rB r2 r2 r2 r4 �<module> sn < ���
�#
"
d
S"