File manager - Edit - /opt/saltstack/salt/lib/python3.10/site-packages/git/objects/submodule/__pycache__/base.cpython-310.pyc
Back
o ;j�� � @ s� d dgZ ddlZddlmZ ddlZddlZddlmZ ddl Z ddl Z ddl Z ddl Z ddl Z ddlmZ ddlmZ ddlmZmZmZ ddlmZmZmZmZ dd lm Z m Z dd l m Z dd l m!Z!m"Z"m#Z#m$Z$m%Z%m&Z& d d l'm(Z(m)Z)m*Z*m+Z+m,Z, ddl-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6 e j7dkr�ddl-m8Z8 nddl9m8Z8 ddl:m;Z;m<Z<m=Z= e4r�ddl>m?Z? ddl@mAZA ddlBmCZCmDZD ddlEmFZF e�GeH�ZIG dd� de"�ZJeJjKZKeJjLZLeJjMZMeJjNZNeJjOZOG dd � d e e �ZPdS )� Submodule�UpdateProgress� N)�BytesIO)�Git)�defenc)�GitConfigParser�SectionConstraint�cp)�BadName�InvalidGitRepositoryError�NoSuchPathError�RepositoryDirtyError)� IndexObject�Object)�TraversableIterableObj)� IterableList�RemoteProgress�join_path_native�rmtree�to_native_path_linux� unbare_repo� )�SubmoduleConfigParser�find_first_remote_branch�mkhead�sm_name� sm_section) �Any�Callable�Dict�Iterator�Mapping�Sequence� TYPE_CHECKING�Union�cast)� � )�Literal)� Commit_ish�PathLike�TBD)� IndexFile)�Commit)�Head�RemoteReference)�Repoc @ sJ e Zd ZU dZdd� eejejd �D �\ZZZ ejd Ze e d< dZ dS )r z�Class providing detailed progress information to the caller who should derive from it and implement the :meth:`update(...) <git.util.RemoteProgress.update>` message.c C s g | ]}d |> �qS )r � )�.0�xr1 r1 �N/opt/saltstack/salt/lib/python3.10/site-packages/git/objects/submodule/base.py� <listcomp>R s zUpdateProgress.<listcomp>r& � _num_op_codesr1 N) �__name__� __module__� __qualname__�__doc__�ranger r6 �CLONE�FETCH� UPDWKTREE�int�__annotations__� __slots__r1 r1 r1 r4 r M s "c s� e Zd ZU dZdZdZdZdZej ej B Z dZ e d ed< dZd Z d�d d d edeed f deed f deed f ded deed f deed f dd f� fdd� Zdedd f� fdd� Zedd ded fdd ��Zed ede fd d ��Z d e de fd!d"�Z d e de fd#d$�Z!defd%d&�Z"defd'd(�Z#defd)d*�Z$ed d ded d+e de%fd,d-��Z&d�d.d/�Z'edd0de(fd1d2��Z)d+e de*fd3d4�Z+ed5d dededefd6d7��Z,e 8 8d�d d dededed9e d:e d;e dd fd<d=��Z-ed5d dedefd>d?��Z.ed@edAedd fdBdC��Z/e 8 8 8d�d d dededeed f deed f dDe dEeed f dFee0eef d f dGee1e2 d f d9e d:e dd fdHdI��Z3 8 J 8 8 8 8 8 8d�dKe dLe dMe dNedO dPe dQe dRe dFee0eef d f dGee1e2 d f d9e d:e dd fdSdT�Z4e5d�dUedVe dWe dd fdXdY��Z6e5 J 8 J 8d�dWe dQe dVe dPe dd f dZd[��Z7d�d\ee8ed f d]e dd fd^d_�Z9e5 Jd�d`eda dbe de*dc fddde��Z:e5dfedd fdgdh��Z;e5d�didj��Z<de fdkdl�Z=de fdmdn�Z>e?d�dpdq��Z@e?defdrds��ZAe?defdtdu��ZBe?defdvdw��ZCe?d�dxdy��ZDe?defdzd{��ZEde*e% fd|d}�ZFded fd~d�ZGe �d�d d dee8ef d�e d;e deHd f d�d���ZI� ZJS )�r a| Implements access to a git submodule. They are special in that their sha represents a commit in the submodule's repository which is to be checked out at the path of this instance. The submodule type does not have a string type associated with it, as it exists solely as a marker in the tree and index. All methods work in bare and non-bare repositories. �name� .gitmodules�branchZmaster� submodule�type)�_parent_commit�_url� _branch_path�_name� __weakref__��pathrH rI N�repor0 �binsha�moderM � parent_commit)r- N�url� branch_path�returnc sP t � �||||� d| _|| _|dur|| _|dur || _|dur&|| _dS dS )aJ Initialize this instance with its attributes. We only document the parameters that differ from :class:`~git.objects.base.IndexObject`. :param repo: Our parent repository. :param binsha: Binary sha referring to a commit in the remote repository. See the `url` parameter. :param parent_commit: The :class:`~git.objects.commit.Commit` whose tree is supposed to contain the ``.gitmodules`` blob, or ``None`` to always point to the most recent commit. See :meth:`set_parent_commit` for details. :param url: The URL to the remote repository which is the submodule. :param branch_path: Full repository-relative path to ref to checkout when cloning the remote repository. r N)�super�__init__�sizerG rH rI rJ ) �selfrN rO rP rM rB rQ rR rS �� __class__r1 r4 rV { s # �zSubmodule.__init__�attrc s� |dv rL| � � }z|�d�| _W n& tjy6 } z| jjd ur,tdt� | jjd� �|�W Y d }~nd }~ww |�d�| _ |� | j t j�| j��| _d S |dkrTtd��t� �|� d S )NrL rM z;This submodule instance does not exist anymore in '%s' filerC rR rJ zCCannot retrieve the name of a submodule if it was not set initially)� config_reader�getrM r �NoSectionErrorrN �working_tree_dir� ValueError�osp�joinrH � get_value� k_head_option�gitr. � to_full_path�k_head_defaultrI �AttributeErrorrU � _set_cache_)rX r[ �reader�erY r1 r4 ri � s* ��� ��� zSubmodule._set_cache_�itemc C s, z| � |�� �W S ty td� Y S w )z4:return: All the submodules of our module repository� )Z list_items�moduler r )�clsrl r1 r1 r4 �_get_intermediate_items� s �z!Submodule._get_intermediate_itemsre c C s |j d d� dkS )Nr& )r � � )� version_info)ro re r1 r1 r4 �_need_gitfile_submodules� s z"Submodule._need_gitfile_submodules�otherc C s | j |j kS )z Compare with another submodule.�rJ �rX ru r1 r1 r4 �__eq__� s zSubmodule.__eq__c C s | |k S )z.Compare with another submodule for inequality.r1 rw r1 r1 r4 �__ne__� � zSubmodule.__ne__c C s t | j�S )z5Hash this instance using its logical id, not the sha.)�hashrJ �rX r1 r1 r4 �__hash__� rz zSubmodule.__hash__c C � | j S )Nrv r| r1 r1 r4 �__str__� s zSubmodule.__str__c C s dt | �j| j| j| j| jf S )Nz0git.%s(name=%s, path=%s, url=%s, branch_path=%s))rF r7 rJ rM rR rS r| r1 r1 r4 �__repr__� s �zSubmodule.__repr__� read_onlyc C s� d}|durz|j j|k}W n ty Y nw |js)|r)|jr)t�|j| j�}n&|dus1J d��z| �|�}W n t yN } z t d| j|f �|�d}~ww |sZ|jsV|sZtd��t ||d�S )ag :return: Config parser constrained to our submodule in read or write mode :raise IOError: If the ``.gitmodules`` file cannot be found, either locally or in the repository at the given parent commit. Otherwise the exception would be delayed until the first access of the config parser. TNz-need valid parent_commit in bare repositoriesz6Could not find %s file in the tree of parent commit %sz;Cannot write blobs of 'historical' submodule configurations�r� ) �head�commitr` �barer_ ra rb �k_modules_file� _sio_modules�KeyError�IOErrorr )ro rN rQ r� Zparent_matches_headZ fp_modulerk r1 r1 r4 �_config_parser� s. � ���� zSubmodule._config_parserc C s0 | j D ]}zt| |� W q ty Y qw dS )z"Clear the possibly changed values.N)� _cache_attrs�delattrrh )rX rB r1 r1 r4 � _clear_cache s ��zSubmodule._clear_cacher- c C s" t |j| j j�� �}| j|_|S )z� :return: Configuration file as :class:`~io.BytesIO` - we only access it through the respective blob's data )r �treer� Z data_stream�readrB )ro rQ �sior1 r1 r4 r� s zSubmodule._sio_modulesc C sL z| j }W n ty d}Y nw | �| j||�}|�| � t|t| j��S )zI:return: Config parser constrained to our submodule in read or write modeN)rQ r` r� rN Z set_submoduler r rB )rX r� �pc�parserr1 r1 r4 �_config_parser_constrained% s � z$Submodule._config_parser_constrained� parent_repoc C s6 | � |j�rt�|jd|�S |jrt�|j|�S t� �)N�modules)rt re ra rb �git_dirr_ �NotADirectoryError)ro r� rM rB r1 r1 r4 �_module_abspath0 s zSubmodule._module_abspathF�allow_unsafe_options�allow_unsafe_protocols�kwargsc K s� | � |||�}|} | �|j�r)||d< t�|�} t�| �s"t�| � t�|j |�} |� d�rDt d|j � � �j} |�| �j} tj�| |�}tjj|| f||d�|��} | �|j�r^| �| |� | S )a� :return: :class:`~git.repo.base.Repo` instance of newly cloned repository. :param repo: Our parent repository. :param url: URL to clone from. :param path: Repository-relative path to the submodule checkout location. :param name: Canonical name of the submodule. :param allow_unsafe_protocols: Allow unsafe protocols to be used, like ``ext``. :param allow_unsafe_options: Allow unsafe options to be used, like ``--upload-pack``. :param kwargs: Additional arguments given to :manpage:`git-clone(1)`. Zseparate_git_dirz../r/ )r� r� )r� rt re ra �dirname�isdir�os�makedirsrb r_ � startswithr% Z active_branch�tracking_branch� remote_name�remoterR rM r0 Z clone_from�!_write_git_file_and_module_config)ro rN rR rM rB r� r� r� �module_abspath�module_checkout_pathZmodule_abspath_dirr� Zrepo_remote_url�cloner1 r1 r4 � _clone_repo8 s0 $ ��� zSubmodule._clone_repoc C s� t |�}|�d�r|dd� }t�|�r>|jr>t |j�}|�|�s)td||f ��|t|�d��d d� }|s>td| ��|S )z�:return: A path guaranteed to be relative to the given parent repository :raise ValueError: If path is not contained in the parent repository's working tree. �/N���zNSubmodule checkout path '%s' needs to be within the parents repository at '%s'r z?Absolute submodule path '%s' didn't yield a valid relative path) r �endswithra �isabsr_ r� r` �len�rstrip)ro r� rM Zworking_tree_linuxr1 r1 r4 �_to_relative_pathv s �� zSubmodule._to_relative_pathr_ r� c C s� t �|d�}t j||d�}tjdkr t �|�r t�|� t|d��}|� d| � t �� W d � n1 s6w Y t t �|d�ddd ��}|� d d tt j||d��� W d � dS 1 s`w Y dS ) a Write a ``.git`` file containing a (preferably) relative path to the actual git module repository. It is an error if the `module_abspath` cannot be made into a relative path, relative to the `working_tree_dir`. :note: This will overwrite existing files! :note: As we rewrite both the git file as well as the module configuration, we might fail on the configuration and will not roll back changes done to the git file. This should be a non-issue, but may easily be fixed if it becomes one. :param working_tree_dir: Directory to write the ``.git`` file into. :param module_abspath: Absolute path to the bare repository. �.git)�start�win32�wbz gitdir: %sN�configF)r� Zmerge_includes�coreZworktree)ra rb �relpath�sys�platform�isfiler� �remove�open�write�encoder r � set_valuer )ro r_ r� Zgit_fileZ rela_path�fp�writerr1 r1 r4 r� � s ��"�z+Submodule._write_git_file_and_module_config� no_checkout�depth�env�clone_multi_optionsc C s� |j rtd��| �||�}|durt|�}| || j| j||dd�} | �� rQz|jjj t � |� } || _ | W S t yP |j} | j| �|d� }|j| _| Y S w t�|tj�t|�p]| j��}| �� }|du }|r�|dur�|dd� | �� jD �vr�td|| jf ��d}|du r�|s�td | ��| �� }d d� |jD �}|s�td | j ��|d }n1d |i}|s�|j |d < |r�t |t �r�||d< ntd��| r�| |d< | j ||||f|| | d�|��}t �!|�}| j"�#� �}|�$t%|�d|� W d � n1 s�w Y | j"j} | j#| dd��&}|�$d|� |�$d|� || _&|�s)|�$| j'|j(� |j(| _)W d � n 1 �s4w Y |�rB|jjj| _| j*| gdd� | S )ax Add a new submodule to the given repository. This will alter the index as well as the ``.gitmodules`` file, but will not create a new commit. If the submodule already exists, no matter if the configuration differs from the one provided, the existing submodule will be returned. :param repo: Repository instance which should receive the submodule. :param name: The name/identifier for the submodule. :param path: Repository-relative or absolute path at which the submodule should be located. It will be created as required during the repository initialization. :param url: ``git clone ...``-compatible URL. See :manpage:`git-clone(1)` for more information. If ``None``, the repository is assumed to exist, and the URL of the first remote is taken instead. This is useful if you want to make an existing repository a submodule of another one. :param branch: Name of branch at which the submodule should (later) be checked out. The given branch must exist in the remote repository, and will be checked out locally as a tracking branch. It will only be written into the configuration if it not ``None``, which is when the checked out branch will be the one the remote HEAD pointed to. The result you get in these situation is somewhat fuzzy, and it is recommended to specify at least ``master`` here. Examples are ``master`` or ``feature/new``. :param no_checkout: If ``True``, and if the repository has to be cloned manually, no checkout will be performed. :param depth: Create a shallow clone with a history truncated to the specified number of commits. :param env: Optional dictionary containing the desired environment variables. Note: Provided variables will be used to update the execution environment for ``git``. If some variable is not specified in `env` and is defined in attr:`os.environ`, the value from attr:`os.environ` will be used. If you want to unset some variable, consider providing an empty string as its value. :param clone_multi_options: A list of clone options. Please see :meth:`Repo.clone <git.repo.base.Repo.clone>` for details. :param allow_unsafe_protocols: Allow unsafe protocols to be used, like ``ext``. :param allow_unsafe_options: Allow unsafe options to be used, like ``--upload-pack``. :return: The newly created :class:`Submodule` instance. :note: Works atomically, such that no change will be done if, for example, the repository update fails. z*Cannot add submodules to bare repositoriesNzinvalid-temporary�rR r c S � g | ]}|j �qS r1 r� �r2 �rr1 r1 r4 r5 1 � z!Submodule.add.<locals>.<listcomp>zJSpecified URL '%s' does not match any remote url of the repository at '%s'z8A URL was not given and a repository did not exist at %sc S r� r1 r� r� r1 r1 r4 r5 @ r� z.Didn't find any remote url in repository at %s�n�br� zdepth should be an integer� multi_options)r� r� r� rR F)�indexr� rM T�r� )+r� r r� r � NULL_BIN_SHA�k_default_mode�existsr� r� r� r� �fspathrJ r� r� �entries� entry_keyrO re r. rf �strrg � module_existsrn �remotesr` �abspathrB � isinstancer? r� r Z polish_urlrN � config_writerr� r rH rd rM rI �add)ro rN rB rM rR rD r� r� r� r� r� r� �smr� �entry�brZ has_moduleZbranch_is_default�mrepoZurlsr� r� r1 r1 r4 r� � s� Q � � � ��� � � � z Submodule.addT� recursive�init�to_latest_revision�progress)r N�dry_run�force� keep_goingc $ C s | j jr| S |du r t� }d} |rd} |rd} �z,zN| �� } | j}t|�}t|�D ]<\}}t}|dkr7|tO }|� |||| d|| j f � |sN|j |d� ||d krX|t O }|� |||| d| j � q)W n� t �yQ d} |sx| Y W S | j}|s�t�|�r�zt�|� W n ty� } ztd | �|�d}~ww |� ttB dd| d | j|| j f � |s�| j�d �r�tj�| j jjjd | j�}n| j}| j| j || j | j d || | | d� } |� t tB dd| d| � |�sOz.t d| �} t | j| j �}t | | j!�}|�"t#| | j$�� | j%j&|d| d� | j%j'�(|� W n t)t f�y- t*�+d| j!� Y nw | j �,� �}|�-t.| j �d| j� W d � n 1 �sJw Y Y nw | j/}| j0}| du�ra| j%j1}| du�r�|�r�d| j2 } |�s�| j%j'�3� } | du�r�| j4} | j/}| j0}nt*�5d| | j%j'� nt*�5d| � | du�rC| j%j4j/|k�rCd } | j%j4j/| j$k�r| �6| j%j4|�} t| �dk�s�| d du�r�| d j0|k�r�|�r�d}!|!d7 }!t*�7|!� nd}!|!|�r�d�p�d | j%| f; }!t*�8|!� d } | �r|�s| j9d d d d ��rt:| d ��|� tt;B dd| d | j | j |f � |�s4| �r4|�r+| j<j=||d!� n | j%j>|d d d"� |� t t;B dd| d#| j � W n t?�yb }" z|�sQ� t*�5t@|"�� W Y d}"~"nd}"~"ww |�r�| du�r�| �A| �� �D ]}#|#j |||||||d$� �qr| S )%a� Update the repository of this submodule to point to the checkout we point at with the binsha of this instance. :param recursive: If ``True``, we will operate recursively and update child modules as well. :param init: If ``True``, the module repository will be cloned into place if necessary. :param to_latest_revision: If ``True``, the submodule's sha will be ignored during checkout. Instead, the remote will be fetched, and the local tracking branch updated. This only works if we have a local tracking branch, which is the case if the remote repository had a master branch, or if the ``branch`` option was specified for this submodule and the branch existed remotely. :param progress: :class:`UpdateProgress` instance, or ``None`` if no progress should be shown. :param dry_run: If ``True``, the operation will only be simulated, but not performed. All performed operations are read-only. :param force: If ``True``, we may reset heads even if the repository in question is dirty. Additionally we will be allowed to set a tracking branch which is ahead of its remote branch back into the past or the location of the remote branch. This will essentially 'forget' commits. If ``False``, local tracking branches that are in the future of their respective remote branches will simply not be moved. :param keep_going: If ``True``, we will ignore but log all errors, and keep going recursively. Unless `dry_run` is set as well, `keep_going` could cause subsequent/inherited errors you wouldn't see otherwise. In conjunction with `dry_run`, it can be useful to anticipate all errors when updating submodules. :param env: Optional dictionary containing the desired environment variables. Note: Provided variables will be used to update the execution environment for ``git``. If some variable is not specified in `env` and is defined in attr:`os.environ`, value from attr:`os.environ` will be used. If you want to unset some variable, consider providing the empty string as its value. :param clone_multi_options: List of :manpage:`git-clone(1)` options. Please see :meth:`Repo.clone <git.repo.base.Repo.clone>` for details. They only take effect with the `init` option. :param allow_unsafe_protocols: Allow unsafe protocols to be used, like ``ext``. :param allow_unsafe_options: Allow unsafe options to be used, like ``--upload-pack``. :note: Does nothing in bare repositories. :note: This method is definitely not atomic if `recursive` is ``True``. :return: self Nrm z DRY-RUN: r z"Fetching remote %s of submodule %r)r� r z$Done fetching remote of submodule %rz:Module directory at %r does already exist and is non-emptyz(Cloning url '%s' to '%s' in submodule %r�.r� T)r� r� r� r� r� zDone cloning to %sr0 z submodule: attaching head to %s)Zlogmsgz%Failed to checkout tracking branch %srR z8Cannot update to latest revision in repository at %r as z6%s a tracking branch was not set for local branch '%s'z%%s there was no local tracking branchzNWill force checkout or reset on local branch that is possibly in the future ofzK the commit it will be checked out to, effectively 'forgetting' new commitszRSkipping %s on branch '%s' of submodule repo '%s' as it contains un-pushed commits�checkout�resetF�r� � working_treeZuntracked_filesz Cannot reset a dirty repositoryz;Updating working tree at %s for submodule %r to revision %s)r� )r� r� z+Done updating working tree for submodule %r)r� r� r� r� )BrN r� r rn r� r� � enumerater= �BEGIN�updaterB Zfetch�ENDr r� ra r� r� �rmdir�OSErrorr< rR r� �urllib�parse�urljoin�originr� rM r% r � branch_namer rS Z set_objectr r� r� Z set_referenceZ referenceZset_tracking_branch� IndexError�_logger�warningr� r� r rO �hexsha� is_detachedZ working_dirr� r� �errorZ merge_base�debug�info�is_dirtyr r> re r� r� � Exceptionr� � iter_items)$rX r� r� r� r� r� r� r� r� r� r� r� �prefixr� ZrmtsZlen_rmts�ir� �opZcheckout_module_abspathrk rR Z remote_branchZ local_branchr� rO r� r� Zmsg_base�rrefZrcommitZ may_resetZ base_commit�msg�errrE r1 r1 r4 r� � s\ T� �� ���� �� � � �� ���V � , � �� ���� � zSubmodule.update� module_path� configurationrn c C s, || dk r t d��| �| j|�}|| jkr| S tt| jj�|�}t�|�r,t d| ��| jj }|� |d�}|rA||j v rAt d��|ret� |�rdt t�|��rSt d��t�|�r^t�|� nt�|� n | j}d} |r�t� |�r�t�||� d} t�t�|d ��r�| �| j| j| j�} | �|| � | j} za|r�z)|� | jd�} |j | } |j | = t�| d d � |f | d d � �}||j |< W n ty� } zt d | j �|�d }~ww | j |d��}|� d|� || _W d � n1 s�w Y W n t �y | �rt�||� � w | | jk�r| � |� | S )a� Move the submodule to a another module path. This involves physically moving the repository at our current path, changing the configuration, as well as adjusting our index entry accordingly. :param module_path: The path to which to move our module in the parent repository's working tree, given as repository-relative or absolute path. Intermediate directories will be created accordingly. If the path already exists, it must be empty. Trailing (back)slashes are removed automatically. :param configuration: If ``True``, the configuration will be adjusted to let the submodule point to the given path. :param module: If ``True``, the repository managed by this submodule will be moved as well. If ``False``, we don't move the submodule's checkout, which may leave the parent repository in an inconsistent state. :return: self :raise ValueError: If the module path existed and was not empty, or was a file. :note: Currently the method is not atomic, and it could leave the repository in an inconsistent state if a sub-step fails for some reason. r zRYou must specify to move at least the module or the configuration of the submodulez&Cannot move repository onto a file: %sr z-Index entry for target path did already existz*Destination module directory was not emptyFTr� Nr& � z%Submodule's entry at %r did not exist)r� rM )!r` r� rN rM r r� r_ ra r� r� r� r� r� r� r� �listdir�islinkr� r� r� �renamesrb r� rB r� re Z IndexEntryr� r r� r� r �rename)rX r r rn r� �module_checkout_abspathr� ZtekeyZcur_pathZrenamed_moduler� Zprevious_sm_pathZekeyr� Znentryrk r� r1 r1 r4 �move� sl $�� �� � zSubmodule.movec C sf |s|st d��d}| �� D ]}|d7 }|�||||� ~q|r1|s1|dkr1| �� j�d| j � |r�| �� r�| �� }|j}|rj| j } d} t � | �rNt j} nt � | �rVt} n t �| �r_td��|si| seJ �| | � nW|jdddd�rytd |j ��|jD ]0} d} | j} | D ]}| t|j�|��dk7 } q�t| �r�| t| �kr�td |j ��t| �r�~~ ~ q||s�| �� |j}~t�� tt |�� |s�t � |�r�| �� t|� |s�| �� |�r1|�s1| j j}z |j |� | j d�= W n t!y� Y nw |�"� | j �#� �}|�$t%| j�� W d � n 1 �sw Y | �#� � }|�$� W d � | S 1 �s,w Y | S ) a Remove this submodule from the repository. This will remove our entry from the ``.gitmodules`` file and the entry in the ``.git/config`` file. :param module: If ``True``, the checked out module we point to will be deleted as well. If that module is currently on a commit outside any branch in the remote, or if it is ahead of its tracking branch, or if there are modified or untracked files in its working tree, then the removal will fail. In case the removal of the repository fails for these reasons, the submodule status will not have been altered. If this submodule has child modules of its own, these will be deleted prior to touching the direct submodule. :param force: Enforces the deletion of the module even though it contains modifications. This basically enforces a brute-force file system based deletion. :param configuration: If ``True``, the submodule is deleted from the configuration, otherwise it isn't. Although this should be enabled most of the time, this flag enables you to safely delete the repository of your submodule. :param dry_run: If ``True``, we will not actually do anything, but throw the errors we would usually throw. :return: self :note: Doesn't work in bare repositories. :note: Doesn't work atomically, as failure to remove any part of the submodule will leave an inconsistent state. :raise git.exc.InvalidGitRepositoryError: Thrown if the repository cannot be deleted. :raise OSError: If directories or files could not be removed. zCNeed to specify to delete at least the module, or the configurationr r z-Removed at least one of child-modules of '%s'NzKCannot forcibly delete repository as it was neither a link, nor a directoryTr� zLCannot delete module at %s with any modifications, unless force is specifiedz3Cannot delete module at %s as there are new commits)&r` �childrenr� rn r� r� rB r� r� r� ra r r� r� r r� �AssertionErrorr� r r_ r� Zrefsr� re Zcherryr� �gcZcollectr� rN r� r� rM r� r� r� Zremove_sectionr )rX rn r� r r� ZncZcsm�modr� �mp�methodr� Z num_branches_with_new_commitsZrrefsr ZwtdZ parent_indexZ gcp_writerZ sc_writerr1 r1 r4 r� I s� 3 ��� � � � ��zSubmodule.remover� �checkc C s� |du r d| _ | S | j�|�}|j}| j|vr td|| jf ��| j }|| _ |rF| j| j| j dd�}|�t| j ��sF|| _ td| j |f ��z |t | j � j | _ W n t y^ | j| _ Y nw | �� | S )a� Set this instance to use the given commit whose tree is supposed to contain the ``.gitmodules`` blob. :param commit: Commit-ish reference pointing at the root tree, or ``None`` to always point to the most recent commit. :param check: If ``True``, relatively expensive checks will be performed to verify validity of the submodule. :raise ValueError: If the commit's tree didn't contain the ``.gitmodules`` blob. :raise ValueError: If the parent commit didn't store this submodule under the current path. :return: self Nz-Tree of commit %s did not contain the %s fileTr� z6Submodule at path %r did not exist in parent commit %s)rG rN r� r� r� r` r� � has_sectionr rB rM r� rO r� r� r� )rX r� r ZpcommitZpctreeZprev_pcr� r1 r1 r4 �set_parent_commit� s* �zSubmodule.set_parent_commitr� )r, Nr� r c C s( | j dd�}|dur||j_||j_|S )a� :return: A config writer instance allowing you to read and write the data belonging to this submodule into the ``.gitmodules`` file. :param index: If not ``None``, an :class:`~git.index.base.IndexFile` instance which should be written. Defaults to the index of the :class:`Submodule`'s parent repository. :param write: If ``True``, the index will be written each time a configuration value changes. :note: The parameters allow for a more efficient writing of the index, as you can pass in a modified index on your own, prevent automatic writing, and write yourself once the whole operation is complete. :raise ValueError: If trying to get a writer on a parent_commit which does not match the current head commit. :raise IOError: If the ``.gitmodules`` file/blob could not be read. Fr� N)r� r� �_indexZ _auto_write)rX r� r� r� r1 r1 r4 r� + s zSubmodule.config_writer�new_namec C s2 | j |kr| S | j�� �}|�t| j ��r |�t| j �t|�� W d � n1 s*w Y | jdd�j�}|�t| j �t|�� W d � n1 sLw Y || _| �� }|� � r�| � | j| j |�}|j }t |��t |j ��r�| � | j| j t t�� ��}t�||� |}t�||� |jr�| �|j|� | S )a Rename this submodule. :note: This method takes care of renaming the submodule in various places, such as: * ``$parent_git_dir / config`` * ``$working_tree_dir / .gitmodules`` * (git >= v1.8.0: move submodule repository to new name) As ``.gitmodules`` will be changed, you would need to make a commit afterwards. The changed ``.gitmodules`` file will already be added to the index. :return: This :class:`Submodule` instance NTr� )rB rN r� r r Zrename_sectionr� rJ rn Zhas_separate_working_treer� rM r� r� r� �uuidZuuid4r� r r_ r� )rX r ZpwZcwr Zdestination_module_abspathZ source_dirZtmp_dirr1 r1 r4 r N s. � � � zSubmodule.renamec C s\ | j }zt�|�}|| jkr|W S W n ttfy' } ztd| �|�d}~ww td| ��)a2 :return: :class:`~git.repo.base.Repo` instance initialized from the repository at our submodule path :raise git.exc.InvalidGitRepositoryError: If a repository was not available. This could also mean that it was not yet initialized. zNo valid repository at %sNz(Repository at %r was not yet checked out)r� re r0 rN r r )rX r rN rk r1 r1 r4 rn � s ��� zSubmodule.modulec C s$ z| � � W dS ty Y dS w )z� :return: ``True`` if our module exists and is a valid git repository. See the :meth:`module` method. TF)rn r r| r1 r1 r4 r� � s �zSubmodule.module_existsc C s� t � }| jD ] }zt| |�rt| |�||< W q tjtfy" Y qw | �� z7z| j W W | jD ]}||v r?t | ||| � q1dS t y^ Y W | jD ]}||v r[t | ||| � qMdS w | jD ]}||v rpt | ||| � qbw )z� :return: ``True`` if the submodule exists, ``False`` otherwise. Please note that a submodule may exist (in the ``.gitmodules`` file) even though its module doesn't exist on disk. TF) �localsr� �hasattr�getattrr r^ r` r� rM �setattrr )rX �locr[ r1 r1 r4 r� � s@ �� �� � ��� ��zSubmodule.existsr. c C s t | �� | j�S )z� :return: The branch instance that we are to checkout :raise git.exc.InvalidGitRepositoryError: If our module is not yet checked out. )r rn rI r| r1 r1 r4 rD � s zSubmodule.branchc C r~ )z� :return: Full repository-relative path as string to the branch we would checkout from the remote and track )rI r| r1 r1 r4 rS � s zSubmodule.branch_pathc C s t �| j| j�jS )zi :return: The name of the branch, which is the shortest possible branch name )re r. rN rI rB r| r1 r1 r4 r� � s zSubmodule.branch_namec C r~ )zG:return: The url to the repository our submodule's repository refers to)rH r| r1 r1 r4 rR � s z Submodule.urlc C s | j du r | j�� S | j S )z� :return: :class:`~git.objects.commit.Commit` instance with the tree containing the ``.gitmodules`` file :note: Will always point to the current head's commit if it was not set explicitly. N)rG rN r� r| r1 r1 r4 rQ � s zSubmodule.parent_commitc C r~ )a� :return: The name of this submodule. It is used to identify it within the ``.gitmodules`` file. :note: By default, this is the name is the path at which to find the submodule, but in GitPython it should be a unique identifier similar to the identifiers used for remotes, which allows to change the path of the submodule easily. rv r| r1 r1 r4 rB s zSubmodule.namec C s | j dd�S )a :return: ConfigReader instance which allows you to query the configuration values of this submodule, as provided by the ``.gitmodules`` file. :note: The config reader will actually read the data directly from the repository and thus does not need nor care about your working tree. :note: Should be cached by the caller and only kept as long as needed. :raise IOError: If the ``.gitmodules`` file/blob could not be read. Tr� )r� r| r1 r1 r4 r\ s zSubmodule.config_readerc C s | � | �S )z� :return: IterableList(Submodule, ...) An iterable list of :class:`Submodule` instances which are children of this submodule or 0 if the submodule is not checked out. )rp r| r1 r1 r4 r s zSubmodule.children�HEAD�argsc o sF � z|� |�}| j||dd�}W n ttfy Y dS w |�� D ]}t|�}|�|d�} |�|d�} | j} |�|| j �rFt |�|| j ��} |j } z |j } | | }W n) t y{ z| j| �| d� }t||j|j|j�}W n t yx Y Y q!w Y nw t|�tjjjjur�q!||_||� � kr�||_tj� | �|_ | |_ |V q!dS )z� :return: Iterator yielding :class:`Submodule` instances available in the given repository Tr� NrM rR r ) r� r� r� r Zsectionsr r] rg Z has_optionrd r� r� r� r� r� r� r rO rP rM rF re ZobjectsrE �baserJ rG r. rf rI rH )ro rN rQ r# r� r� r� Zsmsr� �p�ur� r� Zrtr� r� r1 r1 r4 r - sH � � ��� �zSubmodule.iter_items)NNNNNN)rT N)FF)NNFNNNFF) FTFNFFFNNFF)TT)TFTF)T)NT)rT r0 )rT r. )rT r- )r" )Kr7 r8 r9 r: Z_id_attribute_r� rd rg �stat�S_IFDIR�S_IFLNKr� rF r( r@ rA r� �bytesr$ r? r* r� rV ri � classmethodr rp r �boolrt r rx �objectry r} r r� r r� r� r r� r r� r� r� r� r� r! r" r+ r� r� r r r� r) r r� r rn r� r� �propertyrD rS r� rR rQ rB r\ r r r � __classcell__r1 r1 rY r4 r b s� ��� � � �� � � �- ��� � ) �������� �=&���� � �� � � � � � � J�������� � � � � � S w����� � "-5��� �"7 % �� ����)Q�__all__r �ior �loggingr� Zos.pathrM ra r' r� r r� re Zgit.cmdr Z git.compatr Z git.configr r r Zgit.excr r r r Zgit.objects.baser r Zgit.objects.utilr Zgit.utilr r r r r r �utilr r r r r �typingr r r r r! r" r# r$ r% rs r( Ztyping_extensionsZ git.typesr) r* r+ Z git.indexr, Zgit.objects.commitr- Zgit.refsr. r/ Zgit.repor0 � getLoggerr7 r� r r� r� r< r= r> r r1 r1 r1 r4 �<module> sJ ,
| ver. 1.4 |
Github
|
.
| PHP 8.2.30 | Generation time: 0 |
proxy
|
phpinfo
|
Settings