o 3gC@sddlmZddlZddlZddlZddlZddlZddlZddlZddl m Z m Z ddl m Z ejejejejdZGdddeZejdd d ZGd d d ee ZGd d d ZdS)) annotationsN)ABCabstractmethod)reduce)fwrxc@seZdZdZdddZdS)FSUserzA special object that represents a file-system user. It derives from ``int``, so it behaves just like a number (``uid``/``gid``), but also have a ``.name`` attribute that holds the string-name of the user, if given (otherwise ``None``) NcCst||}||_|SN)int__new__name)clsvalrselfrI/home/garg/my-data/venv/lib/python3.10/site-packages/plumbum/path/base.pyr s zFSUser.__new__r )__name__ __module__ __qualname____doc__r rrrrr sr _PathImplPath)boundc@steZdZdZdZddZdd d Zd d ZddZddZ dddZ ddZ ddZ ddZ ddZddZd d!Zd"d#Zd$d%Zd&d'Zedd)d*Zdd,d-Zd.d/d0d/fd1d2Zeedd4d5Zed6d7Zeedd8d9Zeedd:d;Zeeddd?Zeedd@dAZeeddCdDZ eeddFdGZ!eeddHdIZ"edddMdNZ#eddOdPZ$eddQdRZ%eddTdUZ&eddWdXZ'eddYdZZ(d[d\Z)edd]d^Z*dd_d`Z+dadbZ,eddcddZ-eddedfZ.eddhdiZ/eddkdlZ0edddpdqZ1drdsZ2eddvdwZ3edxdyZ4edzd{Z5d|d}Z6edd~dZ7edddZ8eddJddddZ9eddddZ:eddddZ;eddZe?dddZ@eddddZAeddZBeddZCeddZDddZEeddZFddZGddZHe?ddZIdddZJeddZKeddZLdJS)rzAn abstraction over file system paths. This class is abstract, and the two implementations are :class:`LocalPath ` and :class:`RemotePath `. TcCsd|jjd|dS)N< >) __class__rrrrr__repr__'sz Path.__repr__rrother typing.AnyreturncC ||S)zJoins two pathsjoinrr!rrr __truediv__* zPath.__truediv__cCs*t|tks t|tr||St||Sr )typestr isinstancer)rkeyrrr __getitem__.s zPath.__getitem__cCr$)VReturns a (possibly empty) list of paths that matched the glob-pattern under this path)glob)rexprrrr __floordiv__3r)zPath.__floordiv__cCs t|S)z(Iterate over the files in this directory)iterlistrrrr__iter__7s z Path.__iter__objectboolcCsNt|tr ||kSt|tr%|jrt||kSt||kStSr )r,r _get_infor+CASE_SENSITIVElowerNotImplementedr'rrr__eq__;s   z Path.__eq__cC ||k Sr rr'rrr__ne__F z Path.__ne__cCt|t|kSr r+r'rrr__gt__Iz Path.__gt__cCt|t|kSr rAr'rrr__ge__LrCz Path.__ge__cCt|t|kSr rAr'rrr__lt__OrCz Path.__lt__cCt|t|kSr rAr'rrr__le__RrCz Path.__le__cCs"|jr tt|Stt|Sr )r9hashr+r:rrrr__hash__Us"z Path.__hash__cC tt|Sr r7r+rrrr__bool__X z Path.__bool__cCst|S)zAdded for Python 3.6 supportrArrrr __fspath__[szPath.__fspath__cCs0z||jWSty||YSw)zEPaths should support checking to see if an file or folder is in them.)rexistsAttributeError)ritemrrr __contains___s  zPath.__contains__partscGdSr rrrUrrr_formfz Path._formcCs|d|S)z1Go up in ``count`` directories (the default is 1)z../r%rcountrrrupjszPath.upcCdSNTr_rrrpz Path.cCr^r_rr`rrrrbqrcccsD|D]}||r|V|r||r|||EdHqdS)antraverse all (recursive) sub-elements under this directory, that match the given filter. By default, the filter accepts everything; you can provide a custom filter function that takes a path as an argument and returns a boolean :param filter: the filter (predicate function) for matching results. Only paths matching this predicate are returned. Defaults to everything. :param dir_filter: the filter (predicate function) for matching directories. Only directories matching this predicate are recursed into. Defaults to everything. N)r4is_dirwalk)rfilter dir_filterprrrrens z Path.walkr+cCr^)z#The basename component of this pathNrrrrrrrcz Path.namecCstjdtdd|jS)2Included for compatibility with older Plumbum codezUse .name instead stacklevel)warningswarn FutureWarningrrrrrbasenamesz Path.basenamecCr^)z@The name without an extension, or the last component of the pathNrrrrrstemrcz Path.stemcCr^)z"The dirname component of this pathNrrrrrdirnamercz Path.dirnamecCr^)z'The root of the file tree (`/` on Unix)Nrrrrrrootrcz Path.rootcCr^)zThe drive letter (on Windows)Nrrrrrdrivercz Path.drivecCr^)zThe suffix of this fileNrrrrrsuffixrcz Path.suffix list[str]cCr^)zThis is a list of all suffixesNrrrrrsuffixesrcz Path.suffixesr cCr^)zThe user that owns this path. The returned value is a :class:`FSUser ` object which behaves like an ``int`` (as expected from ``uid``), but it also has a ``.name`` attribute that holds the string-name of the userNrrrrruidrczPath.uidcCr^)zThe group that owns this path. The returned value is a :class:`FSUser ` object which behaves like an ``int`` (as expected from ``gid``), but it also has a ``.name`` attribute that holds the string-name of the groupNrrrrrgidrczPath.gidNscheme str | NonecCr^)zJReturns a universal resource identifier. Use ``scheme`` to force a scheme.Nr)rrzrrras_urircz Path.as_uricCrVr rrrrrr8rYzPath._get_infocGr^)z(Joins this path with any number of pathsNrrWrrrr&rcz Path.joinbuiltins.list[_PathImpl]cCr^)z#Returns the files in this directoryNrrrrrr4rcz Path.listtyping.Iterable[_PathImpl]cCr^)z[Returns an iterator over the directory. Might be slightly faster on Python 3.5 than .list()Nrrrrriterdirrcz Path.iterdircCr^)zAReturns ``True`` if this path is a directory, ``False`` otherwiseNrrrrrrdrcz Path.is_dircCtjdtdd|S)rizUse .is_dir() insteadrjrk)rmrnrordrrrrisdirz Path.isdircCr^)zDReturns ``True`` if this path is a regular file, ``False`` otherwiseNrrrrris_filercz Path.is_filecCr)rizUse .is_file() insteadrjrk)rmrnrorrrrrisfilerz Path.isfilecCr)rizUse is_symlink insteadrjrk)rmrnro is_symlinkrrrrislinkrz Path.islinkcCr^)zEReturns ``True`` if this path is a symbolic link, ``False`` otherwiseNrrrrrrrczPath.is_symlinkcCr^)z9Returns ``True`` if this path exists, ``False`` otherwiseNrrrrrrQrcz Path.existsos.stat_resultcCr^)zReturns the os.stats for a fileNrrrrrstatrcz Path.statrcCr^)z%Returns a path with the name replacedNr)rrrrr with_namerczPath.with_namerudepth int | NonecCr^)a#Returns a path with the suffix replaced. Up to last ``depth`` suffixes will be replaced. None will replace all suffixes. If there are less than ``depth`` suffixes, this will replace all suffixes. ``.tar.gz`` is an example where ``depth=2`` or ``depth=None`` is usefulNr)rrurrrr with_suffixrczPath.with_suffixcCst|jdkr |S||S)z|Adds a suffix if one does not currently exist (otherwise, no change). Useful for loading files with a default suffixr)lenrwr)rrurrrpreferred_suffixszPath.preferred_suffixpatternstr | typing.Iterable[str]cCr^)r/Nr)rrrrrr0rcz Path.globcCr^)z/Deletes this path (recursively, if a directory)Nrrrrrdeletercz Path.deletecCr^)z'Moves this path to a different locationNrrdstrrrmove rcz Path.movecCs|||S)zDRenames this path to the ``new name`` (only the basename is changed))rr])rnewnamerrrrenamesz Path.renamecCr^)zCopies this path (recursively, if a directory) to the destination path "dst". Raises TypeError if dst exists and override is False. Will overwrite if override is True. Will silently fail to copy if override is None (the default).Nr)rroverriderrrcopyrcz Path.copycCr^)aA Creates a directory at this path. :param mode: **Currently only implemented for local paths!** Numeric mode to use for directory creation, which may be ignored on some systems. The current implementation reproduces the behavior of ``os.mkdir`` (i.e., the current umask is first masked out), but this may change for remote paths. As with ``os.mkdir``, it is recommended to call :func:`chmod` explicitly if you need to be sure. :param parents: If this is true (the default), the directory's parents will also be created if necessary. :param exist_ok: If this is true (the default), no exception will be raised if the directory already exists (otherwise ``OSError``). Note that the defaults for ``parents`` and ``exist_ok`` are the opposite of what they are in Python's own ``pathlib`` - this is to maintain backwards-compatibility with Plumbum's behaviour from before they were implemented. Nr)rmodeparentsexist_okrrrmkdirrcz Path.mkdirr)encodingrr io.IOBasecCr^)zopens this path as a fileNr)rrrrrropen-rcz Path.opencCr^)zreturns the contents of this file as a ``str``. By default the data is read as text, but you can specify the encoding, e.g., ``'latin1'`` or ``'utf8'``Nr)rrrrrread1rcz Path.readdata typing.AnyStrNonecCr^)zwrites the given data to this file. By default the data is written as-is (either text or binary), but you can specify the encoding, e.g., ``'latin1'`` or ``'utf8'``Nr)rrrrrrwrite6rcz Path.writecCr^)z=Update the access time. Creates an empty file if none exists.Nrrrrrtouch<rcz Path.touchcCr^)aChange ownership of this path. :param owner: The owner to set (either ``uid`` or ``username``), optional :param group: The group to set (either ``gid`` or ``groupname``), optional :param recursive: whether to change ownership of all contained files and subdirectories. Only meaningful when ``self`` is a directory. If ``None``, the value will default to ``True`` if ``self`` is a directory, ``False`` otherwise. Nr)rownergroup recursiverrrchown@rcz Path.chowncCr^)zeChange the mode of path to the numeric mode. :param mode: file mode as for os.chmod NrrrrrrchmodKrcz Path.chmodcs:durtt|trttjfdd|DdS|S)Ncsg|]}|qSrr).0mflagsrr Xsz.Path._access_mode_to_flags..r)FLAGSr,r+roperatoror_r:)rrrrr_access_mode_to_flagsRs   zPath._access_mode_to_flagsr int | strcCr^)a Test file existence or permission bits :param mode: a bitwise-or of access bits, or a string-representation thereof: ``'f'``, ``'x'``, ``'r'``, ``'w'`` for ``os.F_OK``, ``os.X_OK``, ``os.R_OK``, ``os.W_OK`` Nrrrrraccess\rcz Path.accesscCr^)z_Creates a hard link from ``self`` to ``dst`` :param dst: the destination path Nrrrrrlinkercz Path.linkcCr^)zcCreates a symbolic link from ``self`` to ``dst`` :param dst: the destination path Nrrrrrsymlinklrcz Path.symlinkcCr^)zDeletes a symbolic linkNrrrrrunlinksrcz Path.unlinkcOs<g}|}||jkr||j|j}||jks |dddS)zSplits the path on directory separators, yielding a list of directories, e.g, ``"/var/log/messages"`` will yield ``['var', 'log', 'messages']``. N)rrappendr)r_args_kargsrUpathrrrsplitws   z Path.splitcCs|j|jg|RS)zNSplits the directory into parts, including the base directory, returns a tuple)rtrsrrrrrrUsz Path.partscCsdt|tr ||}|}|}tttddt||}t dgt||||dS)akComputes the "relative path" require to get from ``source`` to ``self``. They satisfy the invariant ``source_path + (target_path - source_path) == target_path``. For example:: /var/log/messages - /var/log/messages = [] /var/log/messages - /var = [log, messages] /var/log/messages - / = [var, log, messages] /var/log/messages - /var/tmp = [.., log, messages] /var/log/messages - /opt = [.., var, log, messages] /var/log/messages - /opt/lib = [.., .., var, log, messages] cSs|d|dkS)NrrZr)rhrrrrbsz"Path.relative_to..z..N) r,r+rXrrr4 itertools takewhilezip RelativePath)rsourcerU baseparts ancestorsrrr relative_tos "zPath.relative_tocCr$)z#Same as ``self.relative_to(other)``)rr'rrr__sub__r)z Path.__sub__cs,t|tr |Sfdd|D}t|S)zNApplies a glob string or list/tuple/iterable to the current path, using ``fn``csh|] }|D]}|qqSrr)rsingle_patternvaluefnrr szPath._glob..)r,r+sorted)rrresultsrrr_globs z Path._globFcCs|S)zAdded to allow pathlib like syntax. Does nothing since Plumbum paths are always absolute. Does not (currently) resolve symlinks.r)rstrictrrrresolvesz Path.resolvecs,fddttjdddD}t|S)z"Pathlib like sequence of ancestorsc3s4|]}tfddjd|jdVqdS)cs||Sr )rX)r yrrrrbsz(Path.parents...Nr)rrU)rirrr s " zPath.parents..rZrr)rangerrUtuple)ras_listrrrrs z Path.parentscCs |jdS)z Pathlib like parent of the path.r)rrrrrparents z Path.parent)rrr!r"r#r)r!r6r#r7)rrrUr"r#rrZ)r#r+)rrr#r)r#rv)r#r r )rzr{r#r+)r#r")rrr#r})rrr#r~)r#r7)r#r)rrrr"r#r)rrrur+rrr#r)rrrrr#r})rTT)r)rr+rr{r#r)rr{r#r+)rrrr{r#r)NNN)r)rrr#r7)F)Mrrrrr9r r(r.r2r5r<r>rBrErGrIrKrNrPrTrrXr]repropertyrrprqrrrsrtrurwrxryr|r8r&r4rrdrrrrrrQrrrrr0rrrrrrrrrrr staticmethodrrrrrrrUrrrrrrrrrrrs                                   c@seZdZdZddZddZddZdd Zd d Zd d Z ddZ ddZ ddZ ddZ ddZddZddZddZd$dd Zd!d"Zd#S)%ra Relative paths are the "delta" required to get from one path to another. Note that relative path do not point at anything, and thus are not paths. Therefore they are system agnostic (but closed under addition) Paths are always absolute and point at "something", whether existent or not. Relative paths are created by subtracting paths (``Path.relative_to``) cCs ||_dSr rUrWrrr__init__r?zRelativePath.__init__cCs d|jS)N/r&rUrrrr__str__rOzRelativePath.__str__cC t|jSr )r3rUrrrrr5r?zRelativePath.__iter__cCrr )rrUrrrr__len__r?zRelativePath.__len__cCs |j|Sr r)rindexrrrr.r?zRelativePath.__getitem__cCsd|jdS)Nz RelativePath()rrrrrr szRelativePath.__repr__cCst|t|kSr rAr'rrrr<rCzRelativePath.__eq__cCr=r rr'rrrr>r?zRelativePath.__ne__cCr@r rAr'rrrrBrCzRelativePath.__gt__cCrDr rAr'rrrrErCzRelativePath.__ge__cCrFr rAr'rrrrGrCzRelativePath.__lt__cCrHr rAr'rrrrIrCzRelativePath.__le__cCrLr )rJr+rrrrrKrOzRelativePath.__hash__cCrLr rMrrrrrNrOzRelativePath.__bool__rZcCst|jd| Sr )rrUr[rrrr]szRelativePath.upcCs |j|jSr r)rrrrr__radd__rOzRelativePath.__radd__Nr)rrrrrrr5rr.r r<r>rBrErGrIrKrNr]rrrrrrs$   r) __future__rbuiltinsiorrostypingrmabcrr functoolsrF_OKW_OKR_OKX_OKrr r TypeVarrr+rrrrrrs$   "