
    g%(                         d dgZ ddlmZ ddlmZ ddlmZ ddl	m
Z
mZmZmZ ddlmZ ddlmZmZmZ dd	lmZmZmZ er$dd
lmZ ddlmZ ddlmZ ddlmZ ddl m!Z! ddl"m#Z# ed   Z$ G d d e
      Z% G d de%      Z&y)ObjectIndexObject    N)WorkTreeRepositoryUnsupported)	LazyMixin
bin_to_hexjoin_path_nativestream_copy   )get_object_type_by_name)AnyTYPE_CHECKINGUnion)AnyGitObjectGitObjectTypeStringPathLike)OStream)	Reference)Repo)Blob)	Submodule)Tree)r   r   r   c                       e Zd ZU dZdZdZej                  ej                  ej                  ej                  fZdZdZeedf   ed<   	 ddd	ed
df fdZedddeedf   d
efd       Zeddded
efd       Zded
df fdZded
efdZded
efdZd
efdZd
efdZd
efdZ e!d
efd       Z"e!dd       Z#ddZ$ xZ%S )r   ar  Base class for classes representing git object types.

    The following four leaf classes represent specific kinds of git objects:

    * :class:`Blob <git.objects.blob.Blob>`
    * :class:`Tree <git.objects.tree.Tree>`
    * :class:`Commit <git.objects.commit.Commit>`
    * :class:`TagObject <git.objects.tag.TagObject>`

    See :manpage:`gitglossary(7)` on:

    * "object": https://git-scm.com/docs/gitglossary#def_object
    * "object type": https://git-scm.com/docs/gitglossary#def_object_type
    * "blob": https://git-scm.com/docs/gitglossary#def_blob_object
    * "tree object": https://git-scm.com/docs/gitglossary#def_tree_object
    * "commit object": https://git-scm.com/docs/gitglossary#def_commit_object
    * "tag object": https://git-scm.com/docs/gitglossary#def_tag_object

    :note:
        See the :class:`~git.types.AnyGitObject` union type of the four leaf subclasses
        that represent actual git object types.

    :note:
        :class:`~git.objects.submodule.base.Submodule` is defined under the hierarchy
        rooted at this :class:`Object` class, even though submodules are not really a
        type of git object. (This also applies to its
        :class:`~git.objects.submodule.root.RootModule` subclass.)

    :note:
        This :class:`Object` class should not be confused with :class:`object` (the root
        of the class hierarchy in Python).
    (0000000000000000000000000000000000000000s                       )repobinshasizeNtyper   r   r   returnc                     t         |           || _        || _        t	        |      dk(  sJ d|t	        |      fz         y)zInitialize an object by identifying it by its binary sha.

        All keyword arguments will be set on demand if ``None``.

        :param repo:
            Repository this object is located in.

        :param binsha:
            20 byte SHA1
           z,Require 20 byte binary sha, got %r, len = %iN)super__init__r   r   len)selfr   r   	__class__s      E/var/www/openai/venv/lib/python3.12/site-packages/git/objects/base.pyr"   zObject.__init__d   sO     		6{b  	
"PKT
 #
 	
     idr   c                 6    |j                  t        |            S )a"  
        :return:
            New :class:`Object` instance of a type appropriate to the object type behind
            `id`. The id of the newly created object will be a binsha even though the
            input id may have been a `~git.refs.reference.Reference` or rev-spec.

        :param id:
            :class:`~git.refs.reference.Reference`, rev-spec, or hexsha.

        :note:
            This cannot be a ``__new__`` method as it would always call :meth:`__init__`
            with the input id which is not necessarily a binsha.
        )	rev_parsestr)clsr   r(   s      r&   newz
Object.neww   s     ~~c"g&&r'   sha1c                     || j                   k(  r t        d      ||      S |j                  j                  |      } t        |j                        ||j
                        }|j                  |_        |S )z
        :return:
            New object instance of a type appropriate to represent the given binary sha1

        :param sha1:
            20 byte binary sha1.
        s   commit)NULL_BIN_SHAr   odbinfor   r   r   )r,   r   r.   oinfoinsts        r&   new_from_shazObject.new_from_sha   se     3###5*95dDAAd#2&uzz24FJJ	r'   attrc                     |dk(  rA| j                   j                  j                  | j                        }|j                  | _        yt
        |   |       y)zRetrieve object information.r   N)r   r1   r2   r   r   r!   _set_cache_)r$   r6   r3   r%   s      r&   r8   zObject._set_cache_   s>    6>IIMM&&t{{3E

DIG%r'   otherc                 N    t        |d      sy| j                  |j                  k(  S )z3:return: ``True`` if the objects have the same SHA1r   Fhasattrr   r$   r9   s     r&   __eq__zObject.__eq__   s"    uh'{{ell**r'   c                 N    t        |d      sy| j                  |j                  k7  S )z::return: ``True`` if the objects do not have the same SHA1r   Tr;   r=   s     r&   __ne__zObject.__ne__   s"    uh'{{ell**r'   c                 ,    t        | j                        S )zE:return: Hash of our id allowing objects to be used in dicts and sets)hashr   r$   s    r&   __hash__zObject.__hash__   s    DKK  r'   c                     | j                   S )z=:return: String of our SHA1 as understood by all git commands)hexsharC   s    r&   __str__zObject.__str__   s    {{r'   c                 P    d| j                   j                  d| j                  dS )z::return: String with pythonic representation of our objectz<git.z "z">)r%   __name__rF   rC   s    r&   __repr__zObject.__repr__   s    "&.."9"94;;GGr'   c                 J    t        | j                        j                  d      S )z6:return: 40 byte hex version of our 20 byte binary shaascii)r   r   decoderC   s    r&   rF   zObject.hexsha   s     $++&--g66r'   c                 `    | j                   j                  j                  | j                        S )z
        :return:
            File-object compatible stream to the uncompressed raw data of the object

        :note:
            Returned streams must be read in order.
        )r   r1   streamr   rC   s    r&   data_streamzObject.data_stream   s!     yy}}##DKK00r'   c                 |    | j                   j                  j                  | j                        }t	        ||       | S )zWrite our data directly to the given output stream.

        :param ostream:
            File-object compatible stream object.

        :return:
            self
        )r   r1   rO   r   r	   )r$   ostreamistreams      r&   stream_datazObject.stream_data   s/     ))--&&t{{3GW%r'   )r   r   )rR   r   r   r   )&rI   
__module____qualname____doc__NULL_HEX_SHAr0   dbtypstr_blob_typestr_tree_typestr_commit_typestr_tag_typeTYPES	__slots__r   r   r   __annotations__bytesr"   classmethodr+   r   r-   r5   r8   r   boolr>   r@   intrD   rG   rJ   propertyrF   rP   rT   __classcell__r%   s   @r&   r   r   &   sl   B LL 		E +I-1D%#T)
*1
V 
U 
t 
& 'v '5k)9#: '| ' '   e   "& & &+C +D ++C +D +!# ! H# H 7 7 7
 1 1r'   c                        e Zd ZdZdZdZ	 	 ddddededef   dede	f   d	df
 fd
Z
d	efdZded	df fdZed	efd       Zed	e	fd       Z xZS )r   a|  Base for all objects that can be part of the index file.

    The classes representing git object types that can be part of the index file are
    :class:`~git.objects.tree.Tree and :class:`~git.objects.blob.Blob`. In addition,
    :class:`~git.objects.submodule.base.Submodule`, which is not really a git object
    type but can be part of an index file, is also a subclass.
    )pathmoderi   Nr   r   r   rj   r   c                 L    t         |   ||       ||| _        ||| _        yy)a  Initialize a newly instanced :class:`IndexObject`.

        :param repo:
            The :class:`~git.repo.base.Repo` we are located in.

        :param binsha:
            20 byte sha1.

        :param mode:
            The stat-compatible file mode as :class:`int`.
            Use the :mod:`stat` module to evaluate the information.

        :param path:
            The path to the file in the file system, relative to the git repository
            root, like ``file.ext`` or ``folder/other.ext``.

        :note:
            Path may not be set if the index object has been created directly, as it
            cannot be retrieved without knowing the parent tree.
        N)r!   r"   rj   ri   )r$   r   r   rj   ri   r%   s        r&   r"   zIndexObject.__init__   s3    6 	v&DIDI r'   c                 ,    t        | j                        S )z
        :return:
            Hash of our path as index items are uniquely identifiable by path, not by
            their data!
        )rB   ri   rC   s    r&   rD   zIndexObject.__hash__  s     DIIr'   r6   c                     |t         j                  v r%t        d|dt        |       j                  d      t
        |   |       y )NzAttribute 'z<' unset: path and mode attributes must have been set during z object creation)r   r_   AttributeErrorr   rI   r!   r8   )r$   r6   r%   s     r&   r8   zIndexObject._set_cache_  sA    ;((( d,,. 
 G%r'   c                 @    t        j                  | j                        S )zA:return: Name portion of the path, effectively being the basename)ospbasenameri   rC   s    r&   namezIndexObject.name  s     ||DII&&r'   c                     | j                   j                  *t        | j                   j                  | j                        S t	        d      )a&  
        :return:
            Absolute path to this index object in the file system (as opposed to the
            :attr:`path` field which is a path relative to the git repository).

            The returned path will be native to the system and contains ``\`` on
            Windows.
        z"working_tree_dir was None or empty)r   working_tree_dirr   ri   r   rC   s    r&   abspathzIndexObject.abspath   s;     99%%1#DII$>$>		JJ/0TUUr'   )NN)rI   rU   rV   rW   r_   _id_attribute_ra   r   rd   r   r"   rD   r+   r8   re   rr   ru   rf   rg   s   @r&   r   r      s     !I N "&&*  D#I	
 D(N# 
B# & & & 'c ' ' V V Vr'   )'__all__os.pathri   rp   	gitdb.typtyprY   git.excr   git.utilr   r   r   r	   utilr   typingr   r   r   	git.typesr   r   r   
gitdb.baser   git.refs.referencer   git.repor   blobr   submodule.baser   treer   IndexObjUnionr   r    r'   r&   <module>r      sp    ]
#   1 I I ) - , A A",)12
pY pfTV& TVr'   