Current File : //lib/python3/dist-packages/twisted/python/__pycache__/filepath.cpython-312.pyc
�
Ϫ�f�� � �& � d Z ddlmZ ddlZddlZddlZddlZddlmZmZm Z ddl
m Z m Z m
Z
mZmZmZmZmZmZ ddlmZmZmZmZmZmZmZm Z m Z m Z m Z m Z m!Z!m"Z" ddl#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3 ddl4m5Z5m6Z6m7Z7 dd l#m8Z8 dd
l9m:Z:m;Z; dd l<m=Z= dd l>m?Z? dd
l@mAZAmBZBmCZCmDZDmEZE ej� ej� z ej� z eEz ZI e0dd�� ZJej� ZLej� ZN G d� de6� ZO G d� deP� ZQ G d� deP� ZR G d� deS� ZTd'd�ZU e0deVeW� ZXe8d ZY G d � d e*e' � ZZ G d � d e?� Z[ G d � d!e?� Z\d(d)d"�Z]d*d+d#�Z^ d* d,d$�Z_e; e7eO� G d%� d&eZe' � � � Z`y)-z1
Object-oriented filesystem path representation.
� )� annotationsN)�listdir�stat�utime) �abspath�basename�dirname�exists�isabs�islink�join�normpath�splitext)�S_IMODE�S_IRGRP�S_IROTH�S_IRUSR�S_ISBLK�S_ISDIR�S_ISREG�S_ISSOCK�S_IWGRP�S_IWOTH�S_IWUSR�S_IXGRP�S_IXOTH�S_IXUSR)�IO�
TYPE_CHECKING�Any�AnyStr�Callable�Dict�Generic�Iterable�List�Optional�Sequence�Tuple�TypeVar�Union�cast�overload)� Attribute� Interface� implementer)�Literal)�cmp�
comparable)�platform)� FancyEqMixin)�ERROR_DIRECTORY�ERROR_FILE_NOT_FOUND�ERROR_INVALID_NAME�ERROR_PATH_NOT_FOUND�O_BINARY�_SelfzAbstractFilePath[Any]��boundc � � e Zd ZdZ ed� Zdd�Zddd�Zdd�Zdd�Z dd�Z
dd�Z dd �Z dd
�Z
dd �Zdd �Zdd
�Zdd�Zdd�Zdd�Zy) � IFilePatha�
File path object.
A file path represents a location for a file-like-object and can be
organized into a hierarchy; a file path can can children which are
themselves file paths.
A file path has a name which unique identifies it in the context of its
parent (if it has one); a file path can not have two children with the same
name. This name is referred to as the file path's "base name".
A series of such names can be used to locate nested children of a file
path; such a series is referred to as the child's "path", relative to the
parent. In this case, each name in the path is referred to as a "path
segment"; the child's base name is the segment in the path.
When representing a file path as a string, a "path separator" is used to
delimit the path segments within the string. For a file system path, that
would be C{os.sep}.
Note that the values of child names may be restricted. For example, a file
system path will not allow the use of the path separator in a name, and
certain names (e.g. C{"."} and C{".."}) may be reserved or have special
meanings.
@since: 12.1
z3The path separator to use in string representationsc � � y)a�
Obtain a direct child of this file path. The child may or may not
exist.
@param name: the name of a child of this path. C{name} must be a direct
child of this path and may not contain a path separator.
@return: the child of this path with the given C{name}.
@raise InsecurePath: if C{name} describes a file path that is not a
direct child of this file path.
N� ��names �9/usr/lib/python3/dist-packages/twisted/python/filepath.py�childzIFilePath.childy � � � c � � y)z�
Opens this file path with the given mode.
@return: a file-like object.
@raise Exception: if this file path cannot be opened.
NrA )�modes rD �openzIFilePath.open� rF rG c � � y)zT
Clear any cached information about the state of this path on disk.
NrA rA rG rD �changedzIFilePath.changed� rF rG c � � y)z�
Retrieve the size of this file in bytes.
@return: the size of the file at this file path in bytes.
@raise Exception: if the size cannot be obtained.
NrA rA rG rD �getsizezIFilePath.getsize� rF rG c � � y)��
Retrieve the time of last access from this file.
@return: a number of seconds from the epoch.
@rtype: L{float}
NrA rA rG rD �getModificationTimez IFilePath.getModificationTime� rF rG c � � y)��
Retrieve the time of the last status change for this file.
@return: a number of seconds from the epoch.
@rtype: L{float}
NrA rA rG rD �getStatusChangeTimez IFilePath.getStatusChangeTime� rF rG c � � y)��
Retrieve the time that this file was last accessed.
@return: a number of seconds from the epoch.
@rtype: L{float}
NrA rA rG rD �
getAccessTimezIFilePath.getAccessTime� rF rG c � � y)z�
Check if this file path exists.
@return: C{True} if the file at this file path exists, C{False}
otherwise.
@rtype: L{bool}
NrA rA rG rD r
zIFilePath.exists� rF rG c � � y)z�
Check if this file path refers to a directory.
@return: C{True} if the file at this file path is a directory, C{False}
otherwise.
NrA rA rG rD �isdirzIFilePath.isdir� rF rG c � � y)z�
Check if this file path refers to a regular file.
@return: C{True} if the file at this file path is a regular file,
C{False} otherwise.
NrA rA rG rD �isfilezIFilePath.isfile� rF rG c � � y)z�
List the children of this path object.
@return: a sequence of the children of the directory at this file path.
@raise Exception: if the file at this file path is not a directory.
NrA rA rG rD �childrenzIFilePath.children� rF rG c � � y)a�
Retrieve the final component of the file path's path (everything after
the final path separator).
@note: In implementors, the return type should be generic, i.e.
C{AbstractFilePath[str].basename()} is a C{str}. However,
L{Interface} objects cannot be generic as of this writing.
@return: the base name of this file path.
NrA rA rG rD r zIFilePath.basename� rF rG c � � y)zV
A file path for the directory containing the file at this file path.
NrA rA rG rD �parentzIFilePath.parent� rF rG c � � y)a$
A file path for the directory containing the file at this file path.
@param name: the name of a sibling of this path. C{name} must be a
direct sibling of this path and may not contain a path separator.
@return: a sibling file path of this one.
NrA rB s rD �siblingzIFilePath.sibling� rF rG N)rC r! �returnr? ��r�rI �FileModerd � IO[bytes]�rd �None�rd �int�rd �float�rd �bool)rd zIterable[IFilePath])rd �Union[str, bytes])rd r? )�__name__�
__module__� __qualname__�__doc__r. �seprE rJ rL rN rQ rT rW r
rZ r\ r^ r ra rc rA rG rD r? r? Z sZ � ��8 �I�
J�C�
� � �
� � � � � � � �
� �
rG r? c � � e Zd ZdZy)� InsecurePathzP
Error that is raised when the path provided to L{FilePath} is invalid.
N�rs rt ru rv rA rG rD ry ry � s � �rG ry c � � e Zd ZdZy)� LinkErrorz�
An error with symlinks - either that there are cyclical symlinks or that
symlink are not supported on this platform.
Nrz rA rG rD r| r| � s � �rG r| c � � e Zd ZdZdd�Zy)�UnlistableErrorai
An exception which is used to distinguish between errors which mean 'this
is not a directory you can list' and other, more catastrophic errors.
This error will try to look as much like the original error as possible,
while still being catchable as an independent type.
@ivar originalException: the actual original exception instance.
c �\ � | j j |j � || _ y)zq
Create an UnlistableError exception.
@param originalException: an instance of OSError.
N)�__dict__�update�originalException)�selfr� s rD �__init__zUnlistableError.__init__ s% � �
�
�
� � � .� 7� 7�8�!2�� rG N)r� �OSError)rs rt ru rv r� rA rG rD r~ r~ � s � ��3rG r~ c �H � t t d� � dd }t | |� S )a
Compute a string usable as a new, temporary filename.
@param path: The path that the new temporary filename should be able to be
concatenated with.
@return: A pseudorandom, 16 byte string for use in secure filenames.
@rtype: the type of C{path}
� N)�armor� randomBytes�_coerceToFilesystemEncoding)�path�secureishStrings rD �_secureEnoughStringr� s& � � �K��O�,�S�b�1�O� &�t�_� =�=rG � OtherAnyStr)rf �w�azr+zw+za+c �� � e Zd ZU dZ edd�� Zded< d d�Zd d�Zd d �Z d d d
�Z
d d �Z d d �Z d!d
�Z
d"d�Zd#d�Zd$d�Zd%d�Zd&d�Z d' d(d�Zd)d�Z d*d�Zd+d�Zd,d�Zd,d�Zd,d�Zd,d�Zy)-�AbstractFilePathaa
Abstract implementation of an L{IFilePath}; must be completed by a
subclass.
This class primarily exists to provide common implementations of certain
methods in L{IFilePath}. It is *not* a required parent class for
L{IFilePath} implementations, just a useful starting point.
@ivar path: Subclasses must set this variable.
�Selfish�AbstractFilePath[AnyStr]r< r! r� c � � t � �)zZ
Subclasses must implement this.
@see: L{FilePath.getAccessTime}
��NotImplementedError�r� s rD rW z AbstractFilePath.getAccessTime3 �
� � "�#�#rG c � � t � �)z`
Subclasses must implement this.
@see: L{FilePath.getModificationTime}
r� r� s rD rQ z$AbstractFilePath.getModificationTime; r� rG c � � t � �)z`
Subclasses must implement this.
@see: L{FilePath.getStatusChangeTime}
r� r� s rD rT z$AbstractFilePath.getStatusChangeTimeC r� rG c � � t � ��z1
Subclasses must implement this.
r� �r� rI s rD rJ zAbstractFilePath.openK �
� � "�#�#rG c � � t � �r� r� r� s rD rZ zAbstractFilePath.isdirQ r� rG c � � t � �r� r� r� s rD r zAbstractFilePath.basenameW r� rG c � � t � �r� r� r� s rD ra zAbstractFilePath.parent] r� rG c � � t � �r� r� r� s rD r zAbstractFilePath.listdirc r� rG c � � t � �r� r� �r� r� s rD rE zAbstractFilePath.childi r� rG c �n � | j � 5 }|j � cddd� S # 1 sw Y yxY w)z�
Retrieve the contents of the file at this path.
@return: the contents of the file
@rtype: L{bytes}
N)rJ �read)r� �fps rD �
getContentzAbstractFilePath.getContento s- � � �Y�Y�[� �B��7�7�9� � � �s �+�4c # �t K � | }|j � }||k7 r |�� |}|j � }||k7 r� yy�w)z�
Retrieve an iterator of all the ancestors of this path.
@return: an iterator of all the ancestors of this path, from the most
recent (its immediate parent) to the root of its filesystem.
N)ra )r� r� ra s rD �parentszAbstractFilePath.parentsy s= � �� � ����� ���f�n��L��D��]�]�_�F� �f�n�s �38�8c �l � | j � }g }|D ]$ }| j |� }|j |� �& |S # t $ rk}t |dd� t t t
t fv r t |� �|j t j t j fv r t |� �� d}~ww xY w)a�
List the children of this path object.
@raise OSError: If an error occurs while listing the directory. If the
error is 'serious', meaning that the operation failed due to an access
violation, exhaustion of some kind of resource (file descriptors or
memory), OSError or a platform-specific variant will be raised.
@raise UnlistableError: If the inability to list the directory is due
to this path not existing or not being a directory, the more specific
OSError subclass L{UnlistableError} is raised instead.
@return: an iterable of all currently-existing children of this object.
�winerrorN)
r r� �getattrr9 r7 r8 r6 r~ �errno�ENOENT�ENOTDIRrE �append)r� �subnames�ose�resultrC rE s rD r^ zAbstractFilePath.children� s� � � �%)�\�\�^�H�2 �� � !�D� �:�:�d�+�E� �M�M�%� � !� �
��? � � �s�J��-�$�$�"� � 2� � &�c�*�*��y�y�U�\�\�5�=�=� 9�9�%�c�*�*�
��/ �s �? � B3�A&B.�.B3Nc # � K � | �� | j � r�| j � D ]� }|� ||� r�|j |� D ]p }t j j | j � j
t j j |j � � r t d� �|�� �r ��|�� �� yy�w)a�
Yield myself, then each of my children, and each of those children's
children in turn.
The optional argument C{descend} is a predicate that takes a FilePath,
and determines whether or not that FilePath is traversed/descended
into. It will be called with each path for which C{isdir} returns
C{True}. If C{descend} is not specified, all directories will be
traversed (including symbolic links which refer to directories).
@param descend: A one-argument callable that will return True for
FilePaths that should be traversed, False otherwise.
@return: a generator yielding FilePath-like objects.
NzCycle in file graph.)rZ r^ �walk�osr� �realpath�
startswithr| )r� �descend�c�subcs rD r� zAbstractFilePath.walk� s� � �� �& �
� �:�:�<��]�]�_�
�� �?�g�a�j� !���w�� #�� �7�7�+�+�D�I�I�6�A�A� �G�G� ,� ,�T�Y�Y� 7� � #,�,B�"C� C� "�
� #� �G�
� �s �B?Cc �@ � | j � j |� S )a�
Return a L{FilePath} with the same directory as this instance but with
a basename of C{path}.
@note: for type-checking, subclasses should override this signature to
make it clear that it returns the subclass and not
L{AbstractFilePath}.
@param path: The basename of the L{FilePath} to return.
@type path: L{str}
@return: The sibling path.
@rtype: L{FilePath}
)ra rE r� s rD rc zAbstractFilePath.sibling� s � � �{�{�}�"�"�4�(�(rG c �: � | }|D ] }|j |� }� |S )a�
Retrieve a child or child's child of this path.
@note: for type-checking, subclasses should override this signature to
make it clear that it returns the subclass and not
L{AbstractFilePath}.
@param segments: A sequence of path segments as L{str} instances.
@return: A L{FilePath} constructed by looking up the C{segments[0]}
child of this path, the C{segments[1]} child of that path, and so
on.
@since: 10.2
)rE )r� �segmentsr� rC s rD �
descendantzAbstractFilePath.descendant� s+ � �$ /3�� � $�D��:�:�d�#�D� $�� rG c �� � | }|j � }g }||k7 r6||k7 r1|j � g|dd |}|j � }||k7 r||k7 r�1||k( r|r|S t |�d| ��� �)a
Return a list of segments between a child and its ancestor.
For example, in the case of a path X representing /a/b/c/d and a path Y
representing /a/b, C{Y.segmentsFrom(X)} will return C{['c',
'd']}.
@param ancestor: an instance of the same class as self, ostensibly an
ancestor of self.
@raise ValueError: If the C{ancestor} parameter is not actually an
ancestor, i.e. a path for /x/y/z is passed as an ancestor for /a/b/c/d.
@return: a list of strs
r z not parent of )ra r �
ValueError)r� �ancestor�f�pr� s rD � segmentsFromz AbstractFilePath.segmentsFrom s~ � �&
���8�8�:��!#���8�m��Q�� �Z�Z�\�N�H�Q�q�M��A����
�A� �8�m��Q��
��=�X��O��H�<��t�h�?�@�@rG c �D � t | j | j f� S )zZ
Hash the same as another L{AbstractFilePath} with the same path as mine.
)�hash� __class__r� r� s rD �__hash__zAbstractFilePath.__hash__# s � � �T�^�^�T�Y�Y�/�0�0rG c �4 � t | j � � S )z?
Deprecated. Use getModificationTime instead.
)rm rQ r� s rD �getmtimezAbstractFilePath.getmtime* � � � �4�+�+�-�.�.rG c �4 � t | j � � S )z9
Deprecated. Use getAccessTime instead.
)rm rW r� s rD �getatimezAbstractFilePath.getatime0 s � � �4�%�%�'�(�(rG c �4 � t | j � � S )z?
Deprecated. Use getStatusChangeTime instead.
)rm rT r� s rD �getctimezAbstractFilePath.getctime6 r� rG rn re rg rp �rd r! )rd r� �rd � List[AnyStr])r� r� rd � AbstractFilePath[OtherAnyStr])rd �bytes)rd z"Iterable[AbstractFilePath[AnyStr]])r� r; rd �Iterable[_Self]�N)r� r; r� z!Optional[Callable[[_Self], bool]]rd r� )r� r; r� r� rd r� )r� �Sequence[OtherAnyStr]rd r� )r� r; r� r; rd r� rl )rs rt ru rv r* r� �__annotations__rW rQ rT rJ rZ r ra r rE r� r� r^ r� rc r� r� r� r� r� r� rA rG rD r� r� # s� � � � �i�'A�B�G�
�L�$�$�$�$� $� $� $� $� $� �
%� 0�h 6:� �� �2� �
� �D)�"�-�� &��. A�>1�/� )� /rG r� c �, � e Zd ZdZdZdd�Zdd�Zdd�Zy) �RWXa�
A class representing read/write/execute permissions for a single user
category (i.e. user/owner, group, or other/world). Instantiate with
three boolean values: readable? writable? executable?.
@type read: C{bool}
@ivar read: Whether permission to read is given
@type write: C{bool}
@ivar write: Whether permission to write is given
@type execute: C{bool}
@ivar execute: Whether permission to execute is given
@since: 11.1
�r� �write�executec �. � || _ || _ || _ y r� r� )r� �readable�writable�
executables rD r� z RWX.__init__Q s � � �� � ��
�!�� rG c �d � dj | j | j | j � S )Nz"RWX(read={}, write={}, execute={}))�formatr� r� r� r� s rD �__repr__z RWX.__repr__V s* � �3�:�:� �I�I� �J�J� �L�L�
�
rG c � � g d�}d}| j | j | j fD ] }|sd||< |dz
}� dj |� S )z�
Returns a short string representing the permission bits. Looks like
part of what is printed by command line utilities such as 'ls -l'
(e.g. 'rwx')
@return: The shorthand string.
@rtype: L{str}
)rf r� �xr �-� � )r� r� r� r
)r� � returnval�i�vals rD � shorthandz
RWX.shorthand] sV � � $� �
���I�I�t�z�z�4�<�<�8� �C�� "� �!� �
��F�A� � �w�w�y�!�!rG N)r� rq r� rq r� rq rd rk �rd �str�rs rt ru rv �compareAttributesr� r� r� rA rG rD r� r� = s � ��" 5��"�
�"rG r� c �, � e Zd ZdZdZdd�Zdd�Zdd�Zy) � Permissionsae
A class representing read/write/execute permissions. Instantiate with any
portion of the file's mode that includes the permission bits.
@type user: L{RWX}
@ivar user: User/Owner permissions
@type group: L{RWX}
@ivar group: Group permissions
@type other: L{RWX}
@ivar other: Other/World permissions
@since: 11.1
)�user�group�otherc � �� �fd�t t t gt t t
gt t t gfD � \ | _ | _
| _ y )Nc 3 �@ �K � | ] }t �fd �|D � � �� � y�w)c 3 �. �K � | ] }�|z d kD �� � y�w)r NrA )�.0�bit� statModeInts �rD � <genexpr>z1Permissions.__init__.<locals>.<genexpr>.<genexpr>� s �� �� �<�C�+��#�a�'�<�s �N)r� )r� �bitGroupr� s �rD r z'Permissions.__init__.<locals>.<genexpr>� s$ �� �� � -
��
�<�8�<� =�-
�s � ) r r r r r r r r r r� r� r� )r� r� s `rD r� zPermissions.__init__� sA �� �-
� �'�7�+��'�7�+��'�7�+� �-
�)�� �4�:�t�zrG c � � dt | j � � dt | j � � dt | j � � d�S )N�[z | �])r� r� r� r� r� s rD r� zPermissions.__repr__� s8 � ��3�t�y�y�>�"�#�c�$�*�*�o�%6�c�#�d�j�j�/�9J�!�L�LrG c � � dj | j | j | j fD �cg c] }|j � �� c}� S c c}w )z�
Returns a short string representing the permission bits. Looks like
what is printed by command line utilities such as 'ls -l'
(e.g. 'rwx-wx--x')
@return: The shorthand string.
@rtype: L{str}
r� )r
r� r� r� r� )r� r� s rD r� zPermissions.shorthand� s: � � �w�w�� � �4�:�:�t�z�z�/R�S�!�� � �
�S�T�T��Ss �AN)r� rm rd rk r� r� rA rG rD r� r� o s � �� 3��
�M� UrG r� c �x � t | t � r| S |st j � }| j |d�� S )aR
Return C{path} as a string of L{bytes} suitable for use on this system's
filesystem.
@param path: The path to be made suitable.
@type path: L{bytes} or L{unicode}
@param encoding: The encoding to use if coercing to L{bytes}. If none is
given, L{sys.getfilesystemencoding} is used.
@return: L{bytes}
�surrogateescape��errors)�
isinstancer� �sys�getfilesystemencoding�encode�r� �encodings rD �_asFilesystemBytesr � s8 � � �$�� �� ���0�0�2�H��{�{�8�,=�{�>�>rG c �x � t | t � r| S |�t j � }| j |d�� S )aY
Return C{path} as a string of L{unicode} suitable for use on this system's
filesystem.
@param path: The path to be made suitable.
@type path: L{bytes} or L{unicode}
@param encoding: The encoding to use if coercing to L{unicode}. If none
is given, L{sys.getfilesystemencoding} is used.
@return: L{unicode}
r r )r
r� r r �decoder s rD �_asFilesystemTextr � s; � � �$�� �� � � ��0�0�2�H��{�{�8�,=�{�>�>rG c �V � t | t � r
t ||�� S t ||�� S )a
Return a C{newpath} that is suitable for joining to C{path}.
@param path: The path that it should be suitable for joining to.
@param newpath: The new portion of the path to be coerced if needed.
@param encoding: If coerced, the encoding that will be used.
�r )r
r� r r )r� �newpathr s rD r� r� � s( � � �$�� �!�'�H�=�=� ��8�<�<rG c � � e Zd ZU dZdZded< dHdId�Zer$dJd�ZdKd�Z dLd�Z
dMd �Z dMd
�Z dMd �Z
dMd �ZdMd
�ZdMd�Z dH dNd�ZdOd�ZedPd�� ZdQdRd�ZdQdSd�ZdQdTd�ZdQdUd�ZdVd�ZdWd�ZdWd�Z dXd�Z dYd�Z dZd�Z d[d �Z d\d �Z d]d^d �Z!d_d`d �Z"dad �Z#dbd!�Z$dcd"�Z%ddd#�Z&ddd$�Z'ddd%�Z(dcd&�Z)dcd'�Z*dcd(�Z+dcd)�Z,dcd*�Z-ded+�Z.dfd,�Z/dfd-�Z0dfd.�Z1dfd/�Z2dfd0�Z3dfd1�Z4dfd2�Z5dgd3�Z6dhd4�Z7did5�Z8dad6�Z9dad7�Z:dHdjd8�Z;dkd9�Z<dPd:�Z=dPd;�Z>dZd<�Z?dldmd=�Z@dnd>�ZAdad?�ZBd_dod@�ZCdpdA�ZDeEdZdB�� ZFeE dqdC�� ZF dQ dqdD�ZFdEZG d_ drdF�ZH d_ drdG�ZIy)s�FilePatha�
I am a path on the filesystem that only permits 'downwards' access.
Instantiate me with a pathname (for example,
FilePath('/home/myuser/public_html')) and I will attempt to only provide
access to files which reside inside that path. I may be a path to a file,
a directory, or a file which does not exist.
The correct way to use me is to instantiate me, and then do ALL filesystem
access through me. In other words, do not import the 'os' module; if you
need to open a file, call my 'open' method. If you need to list a
directory, call my 'path' method.
Even if you pass me a relative path, I will convert that to an absolute
path internally.
The type of C{path} when instantiating decides the mode of the L{FilePath}.
That is, C{FilePath(b"/")} will return a L{bytes} mode L{FilePath}, and
C{FilePath(u"/")} will return a L{unicode} mode L{FilePath}.
C{FilePath("/")} will return a L{bytes} mode L{FilePath} on Python 2, and a
L{unicode} mode L{FilePath} on Python 3.
Methods that return a new L{FilePath} use the type of the given subpath to
decide its mode. For example, C{FilePath(b"/").child(u"tmp")} will return a
L{unicode} mode L{FilePath}.
@type alwaysCreate: L{bool}
@ivar alwaysCreate: When opening this file, only succeed if the file does
not already exist.
@ivar path: The path from which 'downward' traversal is permitted.
Nr! r� c �2 � t |� | _ || _ y)z�
Convert a path string to an absolute path if necessary and initialize
the L{FilePath} with the result.
N)r r� � alwaysCreate�r� r� r s rD r� zFilePath.__init__� s � �
�D�M�� � (��rG c � � y r� rA r� s rD rc zFilePath.sibling � � � rG c � � y r� rA )r� r� s rD r� zFilePath.descendant r rG c � � y r� rA r� s rD r� zFilePath.parents r rG c � � y r� rA �r� r� s rD �__gt__zFilePath.__gt__ r rG c � � y r� rA r! s rD �__ge__zFilePath.__ge__ r rG c � � y r� rA r! s rD �__lt__zFilePath.__lt__ r rG c � � y r� rA r! s rD �__le__zFilePath.__le__ r rG c � � y r� rA r! s rD �__eq__zFilePath.__eq__ r rG c � � y r� rA r! s rD �__ne__zFilePath.__ne__ r rG c � � t |� S )ze
Make an object of the same type as this FilePath, but with path of
C{path}.
)r r s rD � clonePathzFilePath.clonePath! s � � ��~� rG c �H � | j j � }d|v r|d= |S )zv
Support serialization by discarding cached L{os.stat} results and
returning everything else.
� _statinfo)r� �copy)r� �ds rD � __getstate__zFilePath.__getstate__* s* � �
�M�M� � � �� �!� ��+���rG c �J � t | j t j � S )z�
Return a filesystem separator.
@return: The native filesystem separator.
@returntype: The same type as C{self.path}.
)r� r� r� rw r� s rD rw z FilePath.sep4 s � � +�4�9�9�b�f�f�=�=rG c �0 � t | j |�� S )z�
Return the path of this L{FilePath} as bytes.
@param encoding: The encoding to use if coercing to L{bytes}. If none is
given, L{sys.getfilesystemencoding} is used.
@return: L{bytes}
r )r r� �r� r s rD � _asBytesPathzFilePath._asBytesPath> s � � "�$�)�)�h�?�?rG c �0 � t | j |�� S )z�
Return the path of this L{FilePath} as text.
@param encoding: The encoding to use if coercing to L{unicode}. If none
is given, L{sys.getfilesystemencoding} is used.
@return: L{unicode}
r )r r� r6 s rD � _asTextPathzFilePath._asTextPathI s � � !����X�>�>rG c �| � t | j t � r!| j | j |�� � S | S )z�
Return this L{FilePath} in L{bytes}-mode.
@param encoding: The encoding to use if coercing to L{bytes}. If none is
given, L{sys.getfilesystemencoding} is used.
@return: L{bytes} mode L{FilePath}
r )r
r� r� r. r7 r6 s rD � asBytesModezFilePath.asBytesModeT s4 � � �d�i�i�� %��>�>�$�"3�"3�X�"3�"F�G� G�� rG c �| � t | j t � r!| j | j |�� � S | S )z�
Return this L{FilePath} in L{unicode}-mode.
@param encoding: The encoding to use if coercing to L{unicode}. If none
is given, L{sys.getfilesystemencoding} is used.
@return: L{unicode} mode L{FilePath}
r )r
r� r� r. r9 r6 s rD �
asTextModezFilePath.asTextModea s4 � � �d�i�i�� '��>�>�$�"2�"2�H�"2�"E�F� F�� rG c �b � t |t � r| j � S | j � S )a
If C{pattern} is C{bytes}, return L{FilePath.path} as L{bytes}.
Otherwise, return L{FilePath.path} as L{unicode}.
@param pattern: The new element of the path that L{FilePath.path} may
need to be coerced to match.
)r
r� r7 r9 )r� �patterns rD �_getPathAsSameTypeAsz FilePath._getPathAsSameTypeAsn s, � � �g�u� %��$�$�&� &��#�#�%� %rG c � � t |d� }t |t j � }| j |� }t j
� r |j
|� rt |�d�� �t |� }||v rt |�d�� �t t ||� � }|j |� st |�d|��� �| j |� S )a0
Create and return a new L{FilePath} representing a path contained by
C{self}.
@param path: The base name of the new L{FilePath}. If this contains
directory separators or parent references it will be rejected.
@type path: L{bytes} or L{unicode}
@raise InsecurePath: If the result of combining this path with C{path}
would result in a path which is not a direct child of this path.
@return: The child path.
@rtype: L{FilePath} with a mode equal to the type of C{path}.
�:z contains a colon.z* contains one or more directory separators� is not a child of )
r� r� rw r@ r4 � isWindows�country r r �joinpathr� r. )r� r� �colonrw �ourPath�normr s rD rE zFilePath.child{ s� � � ,�D�#�6��)�$����7���+�+�D�1�� � � � �D�J�J�u�$5� �$��);� <�=� =���~�� �$�;� �$��)S� T�U� U��(�7�D�1�2���!�!�'�*� �'��,?��{� K�L� L��~�~�g�&�&rG c �� � | j |� }t t |t |� � � }|j |� st |�d|��� �| j
|� S )a�
Use me if C{path} might have slashes in it, but you know they're safe.
@param path: A relative path (ie, a path not starting with C{"/"})
which will be interpreted as a child or descendant of this path.
@type path: L{bytes} or L{unicode}
@return: The child path.
@rtype: L{FilePath} with a mode equal to the type of C{path}.
rC )r@ r rF r r� ry r. )r� r� rH r s rD � preauthChildzFilePath.preauthChild� s] � � �+�+�D�1���(�7�H�T�N�;�<���!�!�'�*� �'��,?��{� K�L� L��~�~�g�&�&rG c � � |D ]= }| j |� }t ||� }t |� s�,| j |� c S y)a�
Return my first existing child with a name in C{paths}.
C{paths} is expected to be a list of *pre-secured* path fragments;
in most cases this will be specified by a system administrator and not
an arbitrary user.
If no appropriately-named children exist, this will return L{None}.
@return: L{None} or the child path.
@rtype: L{None} or L{FilePath}
N)r@ rF r
r. )r� �pathsrE r� �jps rD �childSearchPreauthzFilePath.childSearchPreauth� sJ � � � *�E��)�)�%�0�A��!�U�#�B��b�z��~�~�b�)�)� *�
rG c �� � |D ]� }|s2| j � r"| j | j |� � c S | j |� }t |d� }t |d� }||k( r`t |� |z }t t
|� � D ]; }|j |� s�| j t t
|� |� � c c S ||z }t |� s��| j |� c S y)a�
Attempt to return a path with my name, given multiple possible
extensions.
Each extension in C{exts} will be tested and the first path which
exists will be returned. If no path exists, L{None} will be returned.
If C{''} is in C{exts}, then if the file referred to by this path
exists, C{self} will be returned.
The extension '*' has a magic meaning, which means "any path that
begins with C{self.path + '.'} is acceptable".
�*�.N) r
r. r@ r� r r r r� rF ) r� �exts�extr� �star�dot�basedot�fn�p2s rD �siblingExtensionSearchz FilePath.siblingExtensionSearch� s� � � � *�C��4�;�;�=��~�~�d�&?�&?��&D�E�E��)�)�#�.�A�.�s�C�8�D�-�c�3�7�C��d�{�"�1�+��+��!�'�!�*�-� H�B��}�}�W�-� #�~�~�h�w�q�z�2�.F� G�G�H� �S��B��b�z��~�~�b�)�)� *� rG c �� � | j � rTt j j | j � }|| j k( r t d� �| j |� S | S )a�
Returns the absolute target as a L{FilePath} if self is a link, self
otherwise.
The absolute link is the ultimate file or directory the
link refers to (for instance, if the link refers to another link, and
another...). If the filesystem does not support symlinks, or
if the link is cyclical, raises a L{LinkError}.
Behaves like L{os.path.realpath} in that it does not resolve link
names in the middle (ex. /x/y/z, y is a link to w - realpath on z
will return /x/y/z, not /x/w/z).
@return: L{FilePath} of the target path.
@rtype: L{FilePath}
@raises LinkError: if links are not supported or links are cyclical.
z!Cyclical link - will loop forever)r r� r� r� r| r. )r� r� s rD r� zFilePath.realpath� sQ � �$ �;�;�=��W�W�%�%�d�i�i�0�F�����"� � C�D�D��>�>�&�)� )�� rG c �L � | j |� }| j ||z � S )a
Attempt to return a path with my name, given the extension at C{ext}.
@param ext: File-extension to search for.
@type ext: L{bytes} or L{unicode}
@return: The sibling path.
@rtype: L{FilePath} with the same mode as the type of C{ext}.
)r@ r. )r� rT rH s rD �siblingExtensionzFilePath.siblingExtension� s' � � �+�+�C�0���~�~�g��m�,�,rG c �X � t j | j |j � y)a�
Creates a symlink to self to at the path in the L{FilePath}
C{linkFilePath}.
Only works on posix systems due to its dependence on
L{os.symlink}. Propagates L{OSError}s up from L{os.symlink} if
C{linkFilePath.parent()} does not exist, or C{linkFilePath} already
exists.
@param linkFilePath: a FilePath representing the link to be created.
@type linkFilePath: L{FilePath}
N)r� �symlinkr� )r� � linkFilePaths rD �linkTozFilePath.linkTo
s � � �
�
�4�9�9�l� /� /�0rG c � � | j rd|vsJ d� �| j � S t | j |j dd� dz � S )a�
Open this file using C{mode} or for writing if C{alwaysCreate} is
C{True}.
In all cases the file is opened in binary mode, so it is not necessary
to include C{"b"} in C{mode}.
@param mode: The mode to open the file in. Default is C{"r"}.
@raises AssertionError: If C{"a"} is included in the mode and
C{alwaysCreate} is C{True}.
@return: An open file-like object.
r� z1Appending not supported when alwaysCreate == True�br� )r �createrJ r� �replacer� s rD rJ z
FilePath.open sR � � � � ��d�?�
�F�
�?� �;�;�=� ��D�I�I�t�|�|�C�� 4�s� :�;�;rG c �l � t | j � | _ y# t $ r
d| _ |r� Y yw xY w)a�
Re-calculate cached effects of 'stat'. To refresh information on this
path after you know the filesystem may have changed, call this method.
@param reraise: a boolean. If true, re-raise exceptions from
L{os.stat}; otherwise, mark this path as not existing, and remove
any cached stat information.
@raise Exception: If C{reraise} is C{True} and an exception occurs
while reloading metadata.
N)r r� r0 r� )r� �reraises rD �restatzFilePath.restat0 s7 � � � !�$�)�)�_�D�N��� � !�D�N��� � �s � �3�3c � � d| _ y)zl
Clear any cached information about the state of this path on disk.
@since: 10.1.0
N)r0 r� s rD rL zFilePath.changedC s � � ��rG c �D � t j | j |� y)z�
Changes the permissions on self, if possible. Propagates errors from
L{os.chmod} up.
@param mode: integer representing the new permissions desired (same as
the command line chmod)
@type mode: L{int}
N)r� �chmodr� r� s rD rk zFilePath.chmodK s � � ������D�!rG c �v � | j }|s | j � | j }|�J �|j S )z�
Retrieve the size of this file in bytes.
@return: The size of the file at this file path in bytes.
@raise Exception: if the size cannot be obtained.
@rtype: L{int}
)r0 rh �st_size�r� �sts rD rN zFilePath.getsizeV s6 � � �^�^��� �K�K�M�� � �B��~� �~��z�z�rG c � � | j }|s | j � | j }|�J �t |j � S )rP )r0 rh ro �st_mtimern s rD rQ z FilePath.getModificationTimee �; � � �^�^��� �K�K�M�� � �B��~� �~��R�[�[�!�!rG c � � | j }|s | j � | j }|�J �t |j � S )rS )r0 rh ro �st_ctimern s rD rT z FilePath.getStatusChangeTimes rr rG c � � | j }|s | j � | j }|�J �t |j � S )rV )r0 rh ro �st_atimern s rD rW zFilePath.getAccessTime� rr rG c � � t j � rt �| j }|s | j � | j }|�J �|j
S )a�
Retrieve the file serial number, also called inode number, which
distinguishes this file from all other files on the same device.
@raise NotImplementedError: if the platform is Windows, since the
inode number would be a dummy value for all files in Windows
@return: a number representing the file serial number
@rtype: L{int}
@since: 11.0
)r4 rD r� r0 rh �st_inorn s rD �getInodeNumberzFilePath.getInodeNumber� sH � � � � � �%� %�
�^�^��� �K�K�M�� � �B��~� �~��y�y�rG c � � t j � rt �| j }|s | j � | j }|�J �|j
S )a�
Retrieves the device containing the file. The inode number and device
number together uniquely identify the file, but the device number is
not necessarily consistent across reboots or system crashes.
@raise NotImplementedError: if the platform is Windows, since the
device number would be 0 for all partitions on a Windows platform
@return: a number representing the device
@rtype: L{int}
@since: 11.0
)r4 rD r� r0 rh �st_devrn s rD � getDevicezFilePath.getDevice� sH � � � � � �%� %�
�^�^��� �K�K�M�� � �B��~� �~��y�y�rG c � � t j � rt �| j }|s | j � | j }|�J �|j
S )a�
Retrieves the number of hard links to the file.
This count keeps track of how many directories have entries for this
file. If the count is ever decremented to zero then the file itself is
discarded as soon as no process still holds it open. Symbolic links
are not counted in the total.
@raise NotImplementedError: if the platform is Windows, since Windows
doesn't maintain a link count for directories, and L{os.stat} does
not set C{st_nlink} on Windows anyway.
@return: the number of hard links to the file
@rtype: L{int}
@since: 11.0
)r4 rD r� r0 rh �st_nlinkrn s rD �getNumberOfHardLinksz FilePath.getNumberOfHardLinks� sH � � � � � �%� %�
�^�^��� �K�K�M�� � �B��~� �~��{�{�rG c � � t j � rt �| j }|s | j � | j }|�J �|j
S )a
Returns the user ID of the file's owner.
@raise NotImplementedError: if the platform is Windows, since the UID
is always 0 on Windows
@return: the user ID of the file's owner
@rtype: L{int}
@since: 11.0
)r4 rD r� r0 rh �st_uidrn s rD � getUserIDzFilePath.getUserID� �H � � � � � �%� %�
�^�^��� �K�K�M�� � �B��~� �~��y�y�rG c � � t j � rt �| j }|s | j � | j }|�J �|j
S )z�
Returns the group ID of the file.
@raise NotImplementedError: if the platform is Windows, since the GID
is always 0 on windows
@return: the group ID of the file
@rtype: L{int}
@since: 11.0
)r4 rD r� r0 rh �st_gidrn s rD �
getGroupIDzFilePath.getGroupID� r� rG c � � | j }|s | j � | j }|�J �t t |j � � S )a
Returns the permissions of the file. Should also work on Windows,
however, those permissions may not be what is expected in Windows.
@return: the permissions for the file
@rtype: L{Permissions}
@since: 11.1
)r0 rh r� r �st_modern s rD �getPermissionszFilePath.getPermissions� s@ � � �^�^��� �K�K�M�� � �B��~� �~��7�2�:�:�.�/�/rG c �Z � | j ry| j d� | j ryy)z�
Check if this L{FilePath} exists.
@return: C{True} if the stats of C{path} can be retrieved successfully,
C{False} in the other cases.
@rtype: L{bool}
TF)r0 rh r� s rD r
zFilePath.exists s' � � �>�>�� �K�K�� ��~�~�� rG c � � | j }|s | j d� | j }|syt |j � S )z�
Check if this L{FilePath} refers to a directory.
@return: C{True} if this L{FilePath} refers to a directory, C{False}
otherwise.
@rtype: L{bool}
F)r0 rh r r� rn s rD rZ zFilePath.isdir �: � � �^�^��� �K�K�� �� � �B�� ��r�z�z�"�"rG c � � | j }|s | j d� | j }|syt |j � S )z�
Check if this file path refers to a regular file.
@return: C{True} if this L{FilePath} points to a regular file (not a
directory, socket, named pipe, etc), C{False} otherwise.
@rtype: L{bool}
F)r0 rh r r� rn s rD r\ zFilePath.isfile/ r� rG c � � | j }|s | j d� | j }|syt |j � S )z�
Returns whether the underlying path is a block device.
@return: C{True} if it is a block device, C{False} otherwise
@rtype: L{bool}
@since: 11.1
F)r0 rh r r� rn s rD �
isBlockDevicezFilePath.isBlockDevice? r� rG c � � | j }|s | j d� | j }|syt |j � S )z�
Returns whether the underlying path is a socket.
@return: C{True} if it is a socket, C{False} otherwise
@rtype: L{bool}
@since: 11.1
F)r0 rh r r� rn s rD �isSocketzFilePath.isSocketO s: � � �^�^��� �K�K�� �� � �B�� ���
�
�#�#rG c �, � t | j � S )z�
Check if this L{FilePath} points to a symbolic link.
@return: C{True} if this L{FilePath} points to a symbolic link,
C{False} otherwise.
@rtype: L{bool}
)r r� r� s rD r zFilePath.islink_ s � � �d�i�i� � rG c �, � t | j � S )z�
Check if this L{FilePath} refers to an absolute path.
This always returns C{True}.
@return: C{True}, always.
@rtype: L{bool}
)r r� r� s rD r zFilePath.isabsm s � � �T�Y�Y� � rG c �, � t | j � S )a�
List the base names of the direct children of this L{FilePath}.
@return: A L{list} of L{bytes}/L{unicode} giving the names of the
contents of the directory this L{FilePath} refers to. These names
are relative to this L{FilePath}.
@rtype: L{list}
@raise OSError: Any exception the platform L{os.listdir} implementation
may raise.
)r r� r� s rD r zFilePath.listdirx s � � �t�y�y�!�!rG c �, � t | j � S )a
Split the file path into a pair C{(root, ext)} such that
C{root + ext == path}.
@return: Tuple where the first item is the filename and second item is
the file extension. See Python docs for L{os.path.splitext}.
@rtype: L{tuple}
)r r� r� s rD r zFilePath.splitext� � � � �� � �"�"rG c �" � d| j �d�S )Nz FilePath(�))r� r� s rD r� zFilePath.__repr__� s � ��4�9�9�-�q�)�)rG c � � | j d� j � t | j d� y# t $ r Y �"w xY w)a$
Updates the access and last modification times of the file at this
file path to the current time. Also creates the file if it does not
already exist.
@raise Exception: if unable to create or modify the last modification
time of the file.
r� N)rJ �closer� r r� r� s rD �touchzFilePath.touch� s? � � � �I�I�c�N� � � "� �d�i�i�� �� � � � �s � 8 � A�Ac �, � | j � rU| j � sE| j � D ] }|j � � t j
| j � n t j | j � | j � y)z�
Removes the file or directory that is represented by self. If
C{self.path} is a directory, recursively remove all its children
before removing the directory. If it's a file or link, just delete it.
N)rZ r r^ �remover� �rmdirr� rL )r� rE s rD r� zFilePath.remove� s\ � � �:�:�<�� � �
� � � � �
��� � ��
� �H�H�T�Y�Y� � �I�I�d�i�i� � � � �rG c �� � t j | j � y# t $ r:}|j t j
k( r|r| j
� s� Y d}~yd}~ww xY w)a
Create all directories not yet existing in C{path} segments, using
L{os.makedirs}.
@param ignoreExistingDirectory: Don't raise L{OSError} if directory
already exists.
@type ignoreExistingDirectory: L{bool}
@return: L{None}
N)r� �makedirsr� r� r� �EEXISTrZ )r� �ignoreExistingDirectory�es rD r� zFilePath.makedirs� sL � � � �K�K�� � � "��� ����5�<�<�'�,C��
�
� �� IU�� �s � " � A%�0A � A%c � � t |t j � }| j |� }ddl}|d |k( xr ||z xs |j ||g� }|j |� D �cg c] }| j
|� �� c}S c c}w )a�
Assuming I am representing a directory, return a list of FilePaths
representing my children that match the given pattern.
@param pattern: A glob pattern to use to match child paths.
@type pattern: L{unicode} or L{bytes}
@return: A L{list} of matching children.
@rtype: L{list} of L{FilePath}, with the mode of C{pattern}'s type
r N���)r� r� rw r@ �globr
r. )r� r? rw rH r� r� r� s rD � globChildrenzFilePath.globChildren� sw � � *�'�2�6�6�:���+�+�G�4����r�{�c�!�7�g��&7�W�3�8�8�W�g�DV�;W��+/�9�9�T�?�;�a����q�!�;�;��;s �'Bc �, � t | j � S )a:
Retrieve the final component of the file path's path (everything
after the final path separator).
@return: The final component of the L{FilePath}'s path (Everything
after the final path separator).
@rtype: the same type as this L{FilePath}'s C{path} attribute
)r r� r� s rD r zFilePath.basename� r� rG c �, � t | j � S )ah
Retrieve all of the components of the L{FilePath}'s path except the
last one (everything up to the final path separator).
@return: All of the components of the L{FilePath}'s path except the
last one (everything up to the final path separator).
@rtype: the same type as this L{FilePath}'s C{path} attribute
)r r� r� s rD r zFilePath.dirname� s � � �t�y�y�!�!rG c �@ � | j | j � � S )z�
A file path for the directory containing the file at this file path.
@return: A L{FilePath} representing the path which directly contains
this L{FilePath}.
@rtype: L{FilePath}
)r. r r� s rD ra zFilePath.parent� s � � �~�~�d�l�l�n�-�-rG c � � | j |� }|j d� 5 }|j |� ddd� t j � r4t | j � r t j | j � t j |j | j � j � y# 1 sw Y ��xY w)a�
Replace the file at this path with a new file that contains the given
bytes, trying to avoid data-loss in the meanwhile.
On UNIX-like platforms, this method does its best to ensure that by the
time this method returns, either the old contents I{or} the new
contents of the file will be present at this path for subsequent
readers regardless of premature device removal, program crash, or power
loss, making the following assumptions:
- your filesystem is journaled (i.e. your filesystem will not
I{itself} lose data due to power loss)
- your filesystem's C{rename()} is atomic
- your filesystem will not discard new data while preserving new
metadata (see U{http://mjg59.livejournal.com/108257.html} for
more detail)
On most versions of Windows there is no atomic C{rename()} (see
U{http://bit.ly/win32-overwrite} for more information), so this method
is slightly less helpful. There is a small window where the file at
this path may be deleted before the new file is moved to replace it:
however, the new file will be fully written and flushed beforehand so
in the unlikely event that there is a crash at that point, it should be
possible for the user to manually recover the new version of their
data. In the future, Twisted will support atomic file moves on those
versions of Windows which I{do} support them: see U{Twisted ticket
3004<http://twistedmatrix.com/trac/ticket/3004>}.
This method should be safe for use by multiple concurrent processes,
but note that it is not easy to predict which process's contents will
ultimately end up on disk if they invoke this method at close to the
same time.
@param content: The desired contents of the file at this path.
@type content: L{bytes}
@param ext: An extension to append to the temporary filename used to
store the bytes while they are being written. This can be used to
make sure that temporary files can be identified by their suffix,
for cleanup in case of crashes.
@type ext: L{bytes}
r� N) �temporarySiblingrJ r� r4 rD r
r� r� �unlink�renamer; )r� �contentrT �sibr� s rD �
setContentzFilePath.setContent� s� � �Z �#�#�C�(��
�X�X�c�]� �a�
�G�G�G� � � � � � �F�4�9�9�$5� �I�I�d�i�i� �
� � �#�(�(�D� ,� ,� .� 3� 3�4� � �s �B>�>Cc �n � t |t � st S t | j |j � S r� )r
r �NotImplementedr2 r� r! s rD �__cmp__zFilePath.__cmp__+ s' � ��%��*�!� !��4�9�9�e�j�j�)�)rG c �B � t j | j � y)z�
Create the directory the L{FilePath} refers to.
@see: L{makedirs}
@raise OSError: If the directory cannot be created.
N)r� �mkdirr� r� s rD �createDirectoryzFilePath.createDirectory0 s � � ������rG c � � || _ y)z�
Sets the C{alwaysCreate} variable.
@param val: C{True} or C{False}, indicating whether opening this path
will be required to create the file or not.
@type val: L{bool}
@return: L{None}
N)r )r� r� s rD �
requireCreatezFilePath.requireCreate: s � � ��rG c � � t j | j t � }t t
t t j |d� � S )z�
Exclusively create a file, only if this file previously did not exist.
@return: A file-like object opened from this path.
zw+b)r� rJ r� �
_CREATE_FLAGSr, r r� �fdopen)r� �fdints rD rd zFilePath.createF s6 � � ���� � �=�1�� �B�u�I�r�y�y��� 6�7�7rG c � � y r� rA r� s rD r� zFilePath.temporarySiblingT s � � rG c � � y r� rA )r� � extensions rD r� zFilePath.temporarySiblingX s � � rG c �� � |�| j dd }n|}| j |� }| j t |� | j |� j � z |z � }|j
� |S )a�
Construct a path referring to a sibling of this path.
The resulting path will be unpredictable, so that other subprocesses
should neither accidentally attempt to refer to the same path before it
is created, nor they should other processes be able to guess its name
in advance.
@param extension: A suffix to append to the created filename. (Note
that if you want an extension with a '.' you must include the '.'
yourself.)
@type extension: L{bytes} or L{unicode}
@return: a path object with the given extension suffix, C{alwaysCreate}
set to True.
@rtype: L{FilePath} with a mode equal to the type of C{extension}
r )r� r@ rc r� r. r r� )r� r� rT rH r� s rD r� zFilePath.temporarySibling^ sv � �* � � �)�)�A�a�.�C��C��+�+�C�0���l�l� �� (�4�>�>�'�+B�+K�+K�+M� M�PS� S�
�� �����
rG i c �B � | j � r@|s>t j t j | j � |j � y| j � rg|j
� s|j � | j � D ]3 }|j |j � � }|j ||� �5 y| j � r||j d� 5 }| j � 5 } |j | j � }|j! |� t# |� | j k rn�F ddd� ddd� y| j
� st% t& j( d� �t+ d� �# 1 sw Y �GxY w# 1 sw Y yxY w)a�
Copies self to destination.
If self doesn't exist, an OSError is raised.
If self is a directory, this method copies its children (but not
itself) recursively to destination - if destination does not exist as a
directory, this method creates it. If destination is a file, an
IOError will be raised.
If self is a file, this method copies it to destination. If
destination is a file, this method overwrites it. If destination is a
directory, an IOError will be raised.
If self is a link (and followLinks is False), self will be copied
over as a new symlink with the same target as returned by os.readlink.
That means that if it is absolute, both the old and new symlink will
link to the same thing. If it's relative, then perhaps not (and
it's also possible that this relative link will be broken).
File/directory permissions and ownership will NOT be copied over.
If followLinks is True, symlinks are followed so that they're treated
as their targets. In other words, if self is a link, the link's target
will be copied. If destination is a link, self will be copied to the
destination's target (the actual destination will be destination's
target). Symlinks under self (if self is a directory) will be
followed and its target's children be copied recursively.
If followLinks is False, symlinks will be copied over as symlinks.
@param destination: the destination (a FilePath) to which self
should be copied
@param followLinks: whether symlinks in self should be treated as links
or as their targets
Nr� zNo such file or directoryz/Only copying of files and directories supported)r r� r_ �readlinkr� rZ r
r� r^ rE r �copyTor\ rJ r� �
_chunkSizer� �lenr� r� r� r� )r� � destination� followLinksrE � destChild� writefile�readfile�chunks rD r� zFilePath.copyTo� sP � �N �;�;�=�� �J�J�r�{�{�4�9�9�-�{�/?�/?� @� �
�:�:�<� �%�%�'��+�+�-� � � � �
5�� '� -� -�e�n�n�.>� ?� �� � �Y� �4�
5� �[�[�]� �!�!�#�&�
�)�T�Y�Y�[�
�H�� %�M�M�$�/�/� :�E� �O�O�E�*��5�z�D�O�O�3� � � �
�
�
� ��� ��%�,�,�(C�D� D� &�&W�X� X�%
�
��
�
�s% �)F�:AF �F� F �F�F c �� � t j | j |j � |j � | j � |j � y# t
$ r�}|j t j k( rg|j � }| j ||� |j ||� | j � }| j ||� |j � n� Y d}~yd}~ww xY w)a�
Move self to destination - basically renaming self to whatever
destination is named.
If destination is an already-existing directory,
moves all children to destination if destination is empty. If
destination is a non-empty directory, or destination is a file, an
OSError will be raised.
If moving between filesystems, self needs to be copied, and everything
that applies to copyTo applies to moveTo.
@param destination: the destination (a FilePath) to which self
should be copied
@param followLinks: whether symlinks in self should be treated as links
or as their targets (only applicable when moving between
filesystems)
N) r� r� r@ r� rL r� r� �EXDEVr� r� �moveTor� )r� r� r� r� �secsib�mysecsibs rD r� zFilePath.moveTo� s� � �* "� �I�I�d�/�/� �0@�0@�A�;�CS�CS� T�,
�L�L�N� � � � !��- � ��y�y�E�K�K�'� %�5�5�7��� � �F�K�0��
�
�k�;�7� �0�0�2��� � �H�k�2����!�� "��# �s �9A � C4�%BC/�/C4)F)r� r! r rq rd rk )r� r; r� r� rd �FilePath[OtherAnyStr])r� r� rd r� )rd zIterable[FilePath[AnyStr]])r� �objectrd rq )r� r� r rq rd r� )rd zDict[str, object]r� r� )r �
Optional[str]rd r� )r r� rd r� )r r� rd zFilePath[bytes])r r� rd z
FilePath[str])r? r� rd r� )r� r� rd r� )rM r� rd � Optional[FilePath[OtherAnyStr]])rS r� rd r� )rd �FilePath[AnyStr])rT r� rd r� )r` r� rd rk re rg )T)rg rq rd rk rj )rI rm rd rk rl rn )rd r� rp r� )rd zTuple[AnyStr, AnyStr]r� )r� rq rd rk )r? r� rd zList[FilePath[OtherAnyStr]])z.new)r� r� rT rr rd rk )r� r� rd rm )r� rq rd rk )rd ri )r� zOptional[OtherAnyStr]rd r� )r� r� r� rq rd rk )Jrs rt ru rv r0 r� r� r rc r� r� r" r$ r& r( r* r, r. r3 �propertyrw r7 r9 r; r= r@ rE rK rO rZ r� r] ra rJ rh rL rk rN rQ rT rW ry r| r r� r� r� r
rZ r\ r� r� r r r r r� r� r� r� r� r r ra r� r� r� r� rd r- r� r� r� r� rA rG rD r r � sE � � �B �I�
�L�)� � � � � � � � � � � 7<� � � �/3� � � �� �>� �>� @� ?� � � &� '�@'�$�!�� (��, � � � (� �B�2 -�
1� <�.�& � "�
� "� "� "� �*�0�4�(�(0� �"#� #� #� $� !� � "� #�*�
� � �&<�& #� "�.�25�h*�
�
� 8� � � � � � �.� � � � � � 26� �.� � � �D �J� GK�GY�0�GY�?C�GY�
�GY�T GK�-"�0�-"�?C�-"�
�-"rG r )r� r! rd r! )r� )r� �Union[bytes, str]r r� rd r� r� )r� r� r r� rd r� )r� r! r r� r r� rd r! )arv �
__future__r �base64r� r� r r r r �os.pathr r r r
r r r
rF r r r r r r r r r r r r r r r r �typingr r r r! r" r# r$ r% r& r' r( r) r* r+ r, r- �zope.interfacer. r/ r0 r1 �twisted.python.compatr2 r3 �twisted.python.runtimer4 �twisted.python.utilr5 �twisted.python.win32r6 r7 r8 r9 r: �O_EXCL�O_CREAT�O_RDWRr� r; �urandomr� �urlsafe_b64encoder� r? � Exceptionry r| r� r~ r� r� r� r� rh r� r� r� r r r� r rA rG rD �<module>r� s� ��
� #�
� � �
� #� #�
�
�
�� � � � � � � � �& =� <� � 1� +� ,�� � � � �B�J�J�&����2�X�=�
��� 6�7�� �j�j� �� � ��R � � R �j�9� � � � �3�g� 3�* >� �m�S�%�0� � �2� 3��W/�w�v�� W/�t/"�,� /"�d)U�,� )U�X?�(?�, IM�
=�
�
=�,�
=�8E�
=� �
=� � �Y��b"� ��'� b"� � �b"rG
Mini Shell