Your IP : 216.73.216.213
B
��\�& � @ s� d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl Z ddl
m Z ddl m
Z
mZmZmZmZmZmZ ddlmZ ddlmZmZ ddlmZ ddlm Z m Z m Z m Z m Z m!Z!m"Z"m#Z#m$Z$m%Z% d Z&d
Z'd Z(d Z)d
Z*dZ+dZ,dZ-e dd�Z.ddddddd�Z/ej0d dk �r4ejdk�r4de/d < ej0d k�rPd e/d < d e/d!< ej�1d"��rdd#Z2nd$Z2d%Z3dZ4e%�rzd&ne�5� a6e%�r�d&ne�7� a8d'd(� Z9d)d*� Z:d+d,� Z;G d-d.� d.e<�Z=d/d0� Z>G d1d2� d2e?�Z@G d3d4� d4e@�ZAe�Be@e@jCd5� e�Be@e@jDd6� e�Be@e@jEd7� G d8d9� d9e@�ZFG d:d;� d;e@�ZGe�BeGeGjHd<� e�BeGeGjId=� e�BeGeGjDd6� e�BeGeGjJd>� G d?d@� d@eG�ZKG dAdB� dBe?�ZLe�BeLeLjMdC� e�BeLeLjNdD� e�BeLeLjOdE� e�BeLeLjPdF� e�BeLeLj dG� e�BeLeLjQdH� e�BeLeLjRdI� e�BeLeLjSdJ� e�BeLeLjTdK� e�BeLeLjUdL� e�BeLeLjVdM� e�BeLeLjWdN� e�BeLeLjXdO� e�BeLeLjYdP� e�BeLeLjZdQ� e�BeLeLj[dR� e�BeLeLj\dS� e�BeLeLj]dT� e�BeLeLj^dU� e�BeLeLj_dV� e�BeLeLj`dW� e�BeLeLjadX� e�BeLeLjbdY� e�BeLeLjcdZ� e�BeLeLjdd[� e�BeLeLjed\� e�BeLeLjfd]� e�BeLeLjgd^� e�BeLeLjhd_� e�BeLeLjid`� e�BeLeLjjda� e�BeLeLjkdb� e�BeLeLjldc� e�BeLeLjmdd� e�BeLeLjnde� e�BeLeLjodf� e�BeLeLjpdg� e�BeLeLjqdh� e�BeLeLjrdi� e�BeLeLjsdj� e�BeLeLjtdk� e�BeLeLjudl� e�BeLeLjvdm� G dndo� doe?�ZwG dpdq� dqe?�ZxG drds� dse?�ZyG dtdu� due?�ZzG dvdw� dwe?�Z{G dxdy� dye?�Z|e�BezezjcdZ� e�Bezezj}dz� G d{d|� d|e?�Z~d}d~� Ze�dk�r�e� dS )�a� A fake filesystem implementation for unit testing.
:Includes:
* :py:class:`FakeFile`: Provides the appearance of a real file.
* :py:class:`FakeDirectory`: Provides the appearance of a real directory.
* :py:class:`FakeFilesystem`: Provides the appearance of a real directory
hierarchy.
* :py:class:`FakeOsModule`: Uses :py:class:`FakeFilesystem` to provide a
fake :py:mod:`os` module replacement.
* :py:class:`FakeIoModule`: Uses :py:class:`FakeFilesystem` to provide a
fake ``io`` module replacement.
* :py:class:`FakePathModule`: Faked ``os.path`` module replacement.
* :py:class:`FakeFileOpen`: Faked ``file()`` and ``open()`` function
replacements.
:Usage:
>>> from pyfakefs import fake_filesystem
>>> filesystem = fake_filesystem.FakeFilesystem()
>>> os_module = fake_filesystem.FakeOsModule(filesystem)
>>> pathname = '/a/new/dir/new-file'
Create a new file object, creating parent directory objects as needed:
>>> os_module.path.exists(pathname)
False
>>> new_file = filesystem.create_file(pathname)
File objects can't be overwritten:
>>> os_module.path.exists(pathname)
True
>>> try:
... filesystem.create_file(pathname)
... except IOError as e:
... assert e.errno == errno.EEXIST, 'unexpected errno: %d' % e.errno
... assert e.strerror == 'File exists in the fake filesystem'
Remove a file object:
>>> filesystem.remove_object(pathname)
>>> os_module.path.exists(pathname)
False
Create a new file object at the previous path:
>>> beatles_file = filesystem.create_file(pathname,
... contents='Dear Prudence\nWon\'t you come out to play?\n')
>>> os_module.path.exists(pathname)
True
Use the FakeFileOpen class to read fake file objects:
>>> file_module = fake_filesystem.FakeFileOpen(filesystem)
>>> for line in file_module(pathname):
... print(line.rstrip())
...
Dear Prudence
Won't you come out to play?
File objects cannot be treated like directory objects:
>>> try:
... os_module.listdir(pathname)
... except OSError as e:
... assert e.errno == errno.ENOTDIR, 'unexpected errno: %d' % e.errno
... assert e.strerror == 'Not a directory in the fake filesystem'
The FakeOsModule can list fake directory objects:
>>> os_module.listdir(os_module.path.dirname(pathname))
['new-file']
The FakeOsModule also supports stat operations:
>>> import stat
>>> stat.S_ISREG(os_module.stat(pathname).st_mode)
True
>>> stat.S_ISDIR(os_module.stat(os_module.path.dirname(pathname)).st_mode)
True
� N)�
namedtuple)�S_IFREG�S_IFDIR�S_ISLNK�S_IFMT�S_ISDIR�S_IFLNK�S_ISREG)�
Deprecator)�scandir�walk)� use_scandir)
�FakeStatResult� FileBufferIO�IS_PY2�NullFileBufferIO� is_int_type�is_byte_string�is_unicode_string�make_string_path� text_type�IS_WINzno-reimportselfz3.5.8� � �@ i� i� i� �
open_modesz<must_exist can_read can_write truncate append must_not_exist)TTFFFF)FFTTFF)FFTFTF)TTTFFF)FTTTFF)FTTFTF)�r�w�azr+zw+za+� �win32�rw)r r )FFTFFT�x)FTTFFTzx+�linux�( � z{Do not instantiate a FakePathModule directly; let FakeOsModule instantiate it. See the FakeOsModule docstring for details.� c C s | a dS )a% Set the global user id. This is used as st_uid for new files
and to differentiate between a normal user and the root user (uid 0).
For the root user, some permission restrictions are ignored.
Args:
uid: (int) the user ID of the user calling the file system functions.
N)�USER_ID)�uid� r) �I/opt/alt/python37/lib/python3.7/site-packages/pyfakefs/fake_filesystem.py�set_uid� s r+ c C s | a dS )z�Set the global group id. This is only used to set st_gid for new files,
no permision checks are performed.
Args:
gid: (int) the group ID of the user calling the file system functions.
N)�GROUP_ID)�gidr) r) r* �set_gid� s r. c C s t dkS )z1Return True if the current user is the root user.r )r' r) r) r) r* �is_root� s r/ c s e Zd ZdZ� fdd�Z� ZS )�FakeLargeFileIoExceptionz|Exception thrown on unsupported operations for fake large files.
Fake large files have a size with no real content.
c s t t| ��d| � d S )Nz?Read and write operations not supported for fake large file: %s)�superr0 �__init__)�self� file_path)� __class__r) r* r2 � s
z!FakeLargeFileIoException.__init__)�__name__�
__module__� __qualname__�__doc__r2 �
__classcell__r) r) )r5 r* r0 � s r0 c C s* t j�| jd�}t| j�}|t j| j< |S )z)Recompiles and creates new module object.N)�sys�modules�popr6 �
__import__)�old�saved�newr) r) r* � _copy_module� s
rB c s� e Zd ZdZdZeeB dddddfdd�Zedd� �Z edd � �Z
ed
d � �Z ed d
� �Z edd� �Z
e jdd � �Z e jdd
� �Z e
jdd� �Z
dd� Zdd� Zdd� Zdd� Zdd � Zd>d d �Zed d � �Zed!d"� �Zed#�d$d%� �Zed&�d'd(� �Zejd)d � �Zed&�d*d+� �Zed,�d-d.� �Zed/�d0d1� �Z ed2�d3d4� �Z � fd5d6�Z � fd7d8�Z d9d:� Z ed;�d<d=� �Z!� Z"S )?�FakeFilea� Provides the appearance of a real file.
Attributes currently faked out:
* `st_mode`: user-specified, otherwise S_IFREG
* `st_ctime`: the time.time() timestamp of the file change time (updated
each time a file's attributes is modified).
* `st_atime`: the time.time() timestamp when the file was last accessed.
* `st_mtime`: the time.time() timestamp when the file was last modified.
* `st_size`: the size of the file
* `st_nlink`: the number of hard links to the file
* `st_ino`: the inode number - a unique number identifying the file
* `st_dev`: a unique number identifying the (fake) file system device
the file belongs to
* `st_uid`: always set to USER_ID, which can be changed globally using
`set_uid`
* `st_gid`: always set to GROUP_ID, which can be changed globally using
`set_gid`
.. note:: The resolution for `st_ctime`, `st_mtime` and `st_atime` in the
real file system depends on the used file system (for example it is
only 1s for HFS+ and older Linux file systems, but much higher for
ext4 and NTFS). This is currently ignored by pyfakefs, which uses
the resolution of `time.time()`.
Under Windows, `st_atime` is not updated for performance reasons by
default. pyfakefs never updates `st_atime` under Windows, assuming
the default setting.
)
�st_mode�st_ino�st_dev�st_nlink�st_uid�st_gid�st_size�st_atime�st_mtime�st_ctime� st_atime_ns� st_mtime_ns� st_ctime_nsNc C s� |dkrt d��|| _|| _|| _t|jttt�� �| _ || j _
|| _ |pLd| _ | �
|�| _| jdk rpt| j�nd| j _d| _d| _i | _dS )aF
Args:
name: Name of the file/directory, without parent path information
st_mode: The stat.S_IF* constant representing the file type (i.e.
stat.S_IFREG, stat.S_IFDIR)
contents: The contents of the filesystem object; should be a string
or byte object for regular files, and a list of other
FakeFile or FakeDirectory objects for FakeDirectory objects
filesystem: The fake filesystem where the file is created.
encoding: If contents is a unicode string, the encoding used
for serialization.
errors: The error mode used for encoding/decoding errors.
side_effect: function handle that is executed when file is written,
must accept the file object as an argument.
Nz filesystem shall not be None�strictr )�
ValueError�
filesystem� _side_effect�namer �
is_windows_fsr' r, �time� stat_resultrD �encoding�errors�_encode_contents�_byte_contents�lenrJ �epoch�
parent_dir�xattr)r3 rU rD �contentsrS rY rZ � side_effectr) r) r* r2 � s
zFakeFile.__init__c C s | j S )z&Return the contents as raw byte array.)r\ )r3 r) r) r* �
byte_contents! s zFakeFile.byte_contentsc C s4 t s.t| jt�r.| jj| jp$t�d�| jd�S | jS )z9Return the contents as string with the original encoding.F)rZ ) r �
isinstancerc �bytes�decoderY �locale�getpreferredencodingrZ )r3 r) r) r* ra & s
zFakeFile.contentsc C s | j jS )z*Return the creation time of the fake file.)rX rM )r3 r) r) r* rM / s zFakeFile.st_ctimec C s | j jS )z(Return the access time of the fake file.)rX rK )r3 r) r) r* rK 4 s zFakeFile.st_atimec C s | j jS )z.Return the modification time of the fake file.)rX rL )r3 r) r) r* rL 9 s zFakeFile.st_mtimec C s || j _dS )z'Set the creation time of the fake file.N)rX rM )r3 �valr) r) r* rM > s c C s || j _dS )z%Set the access time of the fake file.N)rX rK )r3 ri r) r) r* rK C s c C s || j _dS )z+Set the modification time of the fake file.N)rX rL )r3 ri r) r) r* rL H s c C s@ | � |� | jrd| _| jr0| j�|| j| j� || _d| _dS )a Sets the self.st_size attribute and replaces self.content with None.
Provided specifically to simulate very large files without regards
to their content (which wouldn't fit in memory).
Note that read/write operations with such a file raise
:py:class:`FakeLargeFileIoException`.
Args:
st_size: (int) The desired file size
Raises:
IOError: if the st_size is not a non-negative integer,
or if st_size exceeds the available file system space
r N)�_check_positive_intrJ �sizerS �change_disk_usagerU rF r\ )r3 rJ r) r) r* �set_large_file_sizeM s
z FakeFile.set_large_file_sizec C s& t |�r|dk r"| j�tj| j� d S )Nr )r rS �raise_io_error�errno�ENOSPCrU )r3 rk r) r) r* rj d s z FakeFile._check_positive_intc C s
| j dkS )zNReturn `True` if this file was initialized with size but no contents.
N)r\ )r3 r) r) r* �
is_large_filei s zFakeFile.is_large_filec C sF t |�rBtr(|�| jp t�d�| j�}nt|| jp:t�d�| j�}|S )NF)r r �encoderY rg rh rZ re )r3 ra r) r) r* r[ n s
zFakeFile._encode_contentsc C sh | � |�}| j|k}t|�}| jr(d| _| jp0d}| j�|| | j| j� || _|| _| j d7 _ |S )a� Sets the file contents and size.
Called internally after initial file creation.
Args:
contents: string, new content of file.
Returns:
True if the contents have been changed.
Raises:
IOError: if the st_size is not a non-negative integer,
or if st_size exceeds the available file system space
r r& )
r[ r\ r] rk rJ rS rl rU rF r^ )r3 ra �changedrJ � current_sizer) r) r* �_set_initial_contents{ s
z FakeFile._set_initial_contentsc C s( || _ | �|�}| jdk r$| �| � |S )a+ Sets the file contents and size and increases the modification time.
Also executes the side_effects if available.
Args:
contents: (str, bytes, unicode) new content of file.
encoding: (str) the encoding to be used for writing the contents
if they are a unicode string.
If not given, the locale preferred encoding is used.
Raises:
IOError: if `st_size` is not a non-negative integer,
or if it exceeds the available file system space.
N)rY ru rT )r3 ra rY rs r) r) r* � set_contents� s
zFakeFile.set_contentsc C s | j S )z7Return the size in bytes of the file contents.
)rJ )r3 r) r) r* rk � s z
FakeFile.sizec C s� g }| }x |r$|� d|j� |j}q
W | j�| j�}|d |kr�|�d� |�|�}|ovt|d �dkov|d d dk}|s�|| }n
|�|�}| j�|�}|S )z+Return the full path of the current object.r � r& �:) �insertrU r_ rS �_path_separatorr= �joinr] � absnormpath)r3 �names�obj�sep�dir_path�is_driver) r) r* �path� s
$
z
FakeFile.pathz
property pathc C s | j S )N)r� )r3 r) r) r* �GetPath� s zFakeFile.GetPathz
property sizec C s | j S )N)rk )r3 r) r) r* �GetSize� s zFakeFile.GetSizec C s� | � |� | jpd}| j�|| | j| j� | jr�||k rL| jd|� | _n4trjd| jd|| f | _n| jd|| 7 _|| _| jd7 _dS )a: Resizes file content, padding with nulls if new size exceeds the
old size.
Args:
st_size: The desired size for the file.
Raises:
IOError: if the st_size arg is not a non-negative integer
or if st_size exceeds the available file system space
r Nz%s%s� � r& ) rj rJ rS rl rU rF r\ r r^ )r3 rJ rt r) r) r* rk � s
c C s
|| _ d S )N)rk )r3 �valuer) r) r* �SetSize� s zFakeFile.SetSizezproperty st_atimec C s
|| _ dS )zeSet the self.st_atime attribute.
Args:
st_atime: The desired access time.
N)rK )r3 rK r) r) r* �SetATime� s zFakeFile.SetATimezproperty st_mtimec C s
|| _ dS )zkSet the self.st_mtime attribute.
Args:
st_mtime: The desired modification time.
N)rL )r3 rL r) r) r* �SetMTime� s zFakeFile.SetMTimezproperty st_ctimec C s
|| _ dS )zgSet the self.st_ctime attribute.
Args:
st_ctime: The desired creation time.
N)rM )r3 rM r) r) r* �SetCTime s zFakeFile.SetCTimec s& || j krt| j|�S tt| ��|�S )z'Forward some properties to stat_result.)�
stat_types�getattrrX r1 rC � __getattr__)r3 �item)r5 r) r* r� s
zFakeFile.__getattr__c s* || j krt| j||�S tt| ��||�S )z'Forward some properties to stat_result.)r� �setattrrX r1 rC � __setattr__)r3 �keyr� )r5 r) r* r� s
zFakeFile.__setattr__c C s d| j | jf S )Nz%s(%o))rU rD )r3 r) r) r* �__str__ s zFakeFile.__str__rE c C s
|| _ dS )a
Set the self.st_ino attribute.
Note that a unique inode is assigned automatically to a new fake file.
This function does not guarantee uniqueness and should be used with
caution.
Args:
st_ino: (int) The desired inode.
N)rE )r3 rE r) r) r* �SetIno s
zFakeFile.SetIno)N)#r6 r7 r8 r9 r� r �
PERM_DEF_FILEr2 �propertyrc ra rM rK rL �setterrm rj rq r[ ru rv rk r� r
r� r� r� r� r� r� r� r� r� r� r: r) r) )r5 r* rC � s@ #
rC c s0 e Zd Z� fdd�Zedd� �Zdd� Z� ZS )� FakeNullFilec s( |j r
dnd}tt| �j||dd� d S )Nz/dev/nul� )rS ra )rV r1 r� r2 )r3 rS �devnull)r5 r) r* r2 ( s
zFakeNullFile.__init__c C s dS )Nr� r) )r3 r) r) r* rc - s zFakeNullFile.byte_contentsc C s d S )Nr) )r3 ra r) r) r* ru 1 s z"FakeNullFile._set_initial_contents)r6 r7 r8 r2 r� rc ru r: r) r) )r5 r* r� ' s r� �SetLargeFileSize� SetContents� IsLargeFilec sD e Zd ZdZd � fdd� Zedd� �Zd � fdd� Zd d
� Z� Z S )
�FakeFileFromRealFileztRepresents a fake file copied from the real file system.
The contents of the file are read on demand only.
Nc s( t t| �jtj�|�||d� d| _dS )a3
Args:
file_path: Path to the existing file.
filesystem: The fake filesystem where the file is created.
Raises:
OSError: if the file does not exist in the real file system.
OSError: if the file already exists in the fake file system.
)rU rS rb FN)r1 r� r2 �osr� �basename�
contents_read)r3 r4 rS rb )r5 r) r* r2 @ s
z FakeFileFromRealFile.__init__c C sF | j s0d| _ t�| jd��}|�� | _W d Q R X t�| j�j| _| jS )NT�rb) r� �io�openr4 �readr\ r� �statrK )r3 �fr) r) r* rc O s z"FakeFileFromRealFile.byte_contentsc s d| _ tt| ��||� d S )NT)r� r1 r� rv )r3 ra rY )r5 r) r* rv Y s z!FakeFileFromRealFile.set_contentsc C s dS )z The contents are never faked.Fr) )r3 r) r) r* rq ] s z"FakeFileFromRealFile.is_large_file)N)N)
r6 r7 r8 r9 r2 r� rc rv rq r: r) r) )r5 r* r� : s
r� c s� e Zd ZdZedfdd�Zd dd�Zedd� �Zed d
� �Z d d � Z
d
d� Z dd� Z d dd�Z
edd� �Zed�dd� �Zdd� Z� fdd �Z� ZS ) �
FakeDirectoryz,Provides the appearance of a real directory.Nc C s* t j| |t|B i |d� | jd7 _dS )a
Args:
name: name of the file/directory, without parent path information
perm_bits: permission bits. defaults to 0o777.
filesystem: if set, the fake filesystem where the directory
is created
)rS r& N)rC r2 r rG )r3 rU � perm_bitsrS r) r) r* r2 e s zFakeDirectory.__init__c C s0 | j jrts| j j}n| j j}|tj| j��d S )N)rS rV r �raise_os_errorrn ro �EISDIRr� )r3 ra rY � error_fctr) r) r* rv s s
zFakeDirectory.set_contentsc C s | j S )z/Return the list of contained directory entries.)rc )r3 r) r) r* ra z s zFakeDirectory.contentsc C s dd� t | j�� dd� d�D �S )z^Return the list of contained directory entry names ordered by
creation order.
c S s g | ] }|d �qS )r r) )�.0r� r) r) r* �
<listcomp>� s z.FakeDirectory.ordered_dirs.<locals>.<listcomp>c S s
| d j S )Nr& )rE )�entryr) r) r* �<lambda>� r� z,FakeDirectory.ordered_dirs.<locals>.<lambda>)r� )�sortedrc �items)r3 r) r) r* � ordered_dirs s zFakeDirectory.ordered_dirsc C s� t � s4| jt@ s4| jjs4tr tnt}|tj d| j
��|j | j krR| j�
tj| j
� || j |j < | |_| jd7 _| jd7 _| j|_|jdkr�| j�|j|j | j� dS )a5 Adds a child FakeFile to this directory.
Args:
path_object: FakeFile instance to add as a child of this directory.
Raises:
OSError: if the directory has no write permission (Posix only)
OSError: if the file or directory to be added already exists
zPermission Deniedr& N)r/ rD �
PERM_WRITErS rV r �IOError�OSErrorro �EACCESr� rU ra r� �EEXISTr_ rG rF rl rk )r3 � path_object� exceptionr) r) r* � add_entry� s
zFakeDirectory.add_entryc C s | � |�}| j| S )a) Retrieves the specified child file or directory entry.
Args:
pathname_name: The basename of the child object to retrieve.
Returns:
The fake file or directory object.
Raises:
KeyError: if no child exists by the specified name.
)�_normalized_entrynamera )r3 �
pathname_namer) r) r* � get_entry� s
zFakeDirectory.get_entryc s, | j js(� fdd�| jD �}|r(|d � � S )Nc s g | ]}|� � � � � kr|�qS r) )�lower)r� rU )r� r) r* r� � s z7FakeDirectory._normalized_entryname.<locals>.<listcomp>r )rS �is_case_sensitivera )r3 r� �matching_namesr) )r� r* r� � s
z#FakeDirectory._normalized_entrynameTc C s
| � |�}| �|�}| jjrX|jt@ dkr:| j�tj|� | j� |�r�| j�tj|� n,t
� s�| jtt B @ tt B kr�| j�tj|� |r�t |t
�r�x@|jr�|�t|j�d � q�W n |jdkr�| j�|j ||j� | jd8 _| jd8 _|jdks�t�| j|= dS )a& Removes the specified child file or directory.
Args:
pathname_name: Basename of the child object to remove.
recursive: If True (default), the entries in contained directories
are deleted first. Used to propagate removal errors
(e.g. permission problems) from contained entries.
Raises:
KeyError: if no child exists by the specified name.
OSError: if user lacks permission to delete the file,
or (Windows only) the file is open.
r r& N)r� r� rS rV rD r� r� ro r� �
has_open_filer/ �PERM_EXErd r� ra � remove_entry�listrG rl rk rF �AssertionError)r3 r� � recursiver� r) r) r* r� � s(
zFakeDirectory.remove_entryc C s t dd� | j�� D ��S )zMReturn the total size of all files contained in this directory tree.
c S s g | ]}|d j �qS )r& )rk )r� r� r) r) r* r� � s z&FakeDirectory.size.<locals>.<listcomp>)�sumra r� )r3 r) r) r* rk � s zFakeDirectory.sizez
property sizec C s | j S )N)rk )r3 r) r) r* r� � s zFakeDirectory.GetSizec C s$ | }x|r ||krdS |j }qW dS )zmReturn `True` if dir_object is a direct or indirect parent
directory, or if both are the same object.TF)r_ )r3 �
dir_objectr~ r) r) r* �has_parent_object� s
z FakeDirectory.has_parent_objectc s\ t t| ��� d }xD| jD ]:}| j| �� }x&|�d�D ]}|r8|d | d }q8W qW |S )Nz:
�
z )r1 r� r� ra �split)r3 � descriptionr� � item_desc�line)r5 r) r* r� � s zFakeDirectory.__str__)N)T)r6 r7 r8 r9 �PERM_DEFr2 rv r� ra r� r� r� r� r� rk r
r� r� r� r: r) r) )r5 r* r� b s
'
r� �AddEntry�GetEntry� RemoveEntryc s> e Zd ZdZd � fdd� Zedd� �Ze� fdd��Z� ZS )
� FakeDirectoryFromRealDirectoryz~Represents a fake directory copied from the real file system.
The contents of the directory are read on demand only.
Nc st |p|}t �|�}tt| �jt j�|�d |j|d� |j| _|j | _ |j
| _
|j | _ |j | _ || _
|| _d| _dS )ao
Args:
source_path: Full directory path.
filesystem: The fake filesystem where the directory is created.
read_only: If set, all files under the directory are treated
as read-only, e.g. a write access raises an exception;
otherwise, writing to the files changes the fake files
only as usually.
target_path: If given, the target path of the directory,
otherwise the target is the same as `source_path`.
Raises:
OSError: if the directory does not exist in the real file system
r& )rU r� rS FN)r� r� r1 r� r2 r� r� rD rM rK rL rI rH � source_path� read_onlyr� )r3 r� rS r� � target_path� real_stat)r5 r) r* r2
s
z'FakeDirectoryFromRealDirectory.__init__c C s� | j s|d| _ | j}xht�| j�D ]X}tj�| j|�}tj�||�}tj�|�rd| jj|| j |d� q | jj
|| j |d� q W | j S )z[Return the list of contained directory entries, loading them
if not already loaded.T)r� ) r� r� r� �listdirr� r{ �isdirrS �add_real_directoryr� �
add_real_filerc )r3 �baser� r� r� r) r) r* ra * s z'FakeDirectoryFromRealDirectory.contentsc s | j s
dS tt| �jS )Nr )r� r1 r� rk )r3 )r5 r) r* rk < s z#FakeDirectoryFromRealDirectory.size)N) r6 r7 r8 r9 r2 r� ra rk r: r) r) )r5 r* r� s r� c
@ sb e Zd ZdZejjddfdd�Zedd� �Z d�dd�Z
d d
� Z d d � Z d
d� Z
dd� Zd�dd�Zd�dd�Zedd� �Zdd� Zdd� Zdd � Zd�d d �Zd�d d!�Zd"d#� Zd$d%� Zd�d&d'�Zd�d(d)�Zd*d+� Z d�d-d.�Z d�d/d0�Z d�d1d2�Z d�d3d4�Z d5d6� Z!e"d7d8� �Z#d9d:� Z$d;d<� Z%d=d>� Z&d?d@� Z'dAdB� Z(dCdD� Z)dEdF� Z*dGdH� Z+dIdJ� Z,dKdL� Z-dMdN� Z.dOdP� Z/dQdR� Z0dSdT� Z1dUdV� Z2dWdX� Z3dYdZ� Z4d[d\� Z5d]d^� Z6d_d`� Z7d�dadb�Z8edcdd� �Z9d�dedf�Z:dgdh� Z;didj� Z<dkdl� Z=dmdn� Z>dodp� Z?dqdr� Z@d�dsdt�ZAdudv� ZBd�dwdx�ZCd�dydz�ZDd{d|� ZEd}d~� ZFdd�� ZGd�d�� ZHd�d�� ZId�d�� ZJd�d�� ZKeLfd�d��ZMeNeOB d�dd,d dddfd�d��ZPd�d�d��ZQd�d�d��ZRd�d�d��ZSeNeOB d�dd,d ddd d df
d�d��ZTd�d�d��ZUd�d�� ZVd�d�� ZWd�d�� ZXeLfd�d��ZYd�d�� ZZeLd fd�d��Z[d�d�d��Z\d�d�d��Z]d�d�d��Z^d�d�� Z_d�d�� Z`d�d�� Zad�d�d��Zbd�d�� Zcd�d�� Zdd�d�� ZedS )��FakeFilesystema Provides the appearance of a real directory tree for unit testing.
Attributes:
path_separator: The path separator, corresponds to `os.path.sep`.
alternative_path_separator: Corresponds to `os.path.altsep`.
is_windows_fs: `True` in a real or faked Windows file system.
is_macos: `True` under MacOS, or if we are faking it.
is_case_sensitive: `True` if a case-sensitive file system is assumed.
root: The root :py:class:`FakeDirectory` entry of the file system.
cwd: The current working directory path.
umask: The umask used for newly created files, see `os.umask`.
patcher: Holds the Patcher object if created from it. Allows access
to the patcher object if using the pytest fs fixture.
Nc C s� || _ tjj| _|| _|tjkr&d| _tjdk| _ tjdk| _
| j pH| j
| _ t | j | d�| _
| j
j| _t�d�| _t�| j� g | _g | _d| _d| _i | _| �| j
j|� | �� t| �| _dS )a^
Args:
path_separator: optional substitute for os.path.sep
total_size: if not None, the total size in bytes of the
root filesystem.
Example usage to emulate real file systems:
>>> filesystem = FakeFilesystem(
... alt_path_separator='/' if _is_windows else None)
Nr �darwin)rS � r )�path_separatorr� r� �altsep�alternative_path_separator�patcherr r; �platformrV �is_macosr� r� �rootrU �cwd�umask�
open_files�
_free_fd_heap� _last_ino� _last_dev� mount_points�add_mount_point�_add_standard_streamsr� �dev_null)r3 r� �
total_sizer� r) r) r* r2 T s(
zFakeFilesystem.__init__c C s | j o| j S )N)rV r� )r3 r) r) r* �is_linux� s zFakeFilesystem.is_linuxc C sT t | j| d�| _| jj| _g | _g | _d| _d| _i | _ | �
| jj|� | � � dS )z3Remove all file system contents and reset the root.)rS r N) r� r� r� rU r� r� r� r� r� r� r� r� )r3 r� r) r) r* �reset� s
zFakeFilesystem.resetc C s | j dkrtd��| j �� dS )a� Pause the patching of the file system modules until `resume` is
called. After that call, all file system calls are executed in the
real file system.
Calling pause() twice is silently ignored.
Only allowed if the file system object was created by a
Patcher object. This is also the case for the pytest `fs` fixture.
Raises:
RuntimeError: if the file system was not created by a Patcher.
NzUpause() can only be called from a fake file system object created by a Patcher object)r� � RuntimeError�pause)r3 r) r) r* r� � s
zFakeFilesystem.pausec C s | j dkrtd��| j �� dS )aG Resume the patching of the file system modules if `pause` has
been called before. After that call, all file system calls are
executed in the fake file system.
Does nothing if patching is not paused.
Raises:
RuntimeError: if the file system has not been created by `Patcher`.
NzVresume() can only be called from a fake file system object created by a Patcher object)r� r� �resume)r3 r) r) r* r� � s
zFakeFilesystem.resumec C s | j r
dS dS )Nz
r� )rV )r3 r) r) r* �line_separator� s z FakeFilesystem.line_separatorc C s t �|�d S )Nz in the fake filesystem)r� �strerror)r3 ro r) r) r* �_error_message� s z FakeFilesystem._error_messagec C sP | � |�}|dk r@tjdkr@| jr@tr2t|||��t||||��t|||��dS )a* Raises OSError.
The error message is constructed from the given error code and shall
start with the error string issued in the real system.
Note: this is not true under Windows if winerror is given - in this
case a localized message specific to winerror will be shown in the
real file system.
Args:
errno: A numeric error code from the C variable errno.
filename: The name of the affected file, if any.
winerror: Windows only - the specific Windows error code.
Nr )r� r; r� rV r � WindowsErrorr� )r3 ro �filename�winerror�messager) r) r* r� � s
z FakeFilesystem.raise_os_errorc C s t || �|�|��dS )a% Raises IOError.
The error message is constructed from the given error code and shall
start with the error in the real system.
Args:
errno: A numeric error code from the C variable errno.
filename: The name of the affected file, if any.
N)r� r� )r3 ro r� r) r) r* rn � s z FakeFilesystem.raise_io_errorc C sL |dkr |S t r$t| t�rHt|�S n$t| t�rHt|t�rH|�t�d��S |S )z{Return the string as byte or unicode depending
on the type of matched, assuming string is an ASCII string.
NF)r rd r re �strrr rg rh )�matched�stringr) r) r* �_matching_string� s
z FakeFilesystem._matching_stringc C s | � || j�S )z2Return the path separator as the same type as path)r r� )r3 r� r) r) r* rz � s z FakeFilesystem._path_separatorc C s | � || j�S )z>Return the alternative path separator as the same type as path)r r� )r3 r� r) r) r* �_alternative_path_separator� s z*FakeFilesystem._alternative_path_separatorc C s | j ptjdkS )N)r rw )rV r; � version_info)r3 r) r) r* �_is_link_supported� s z!FakeFilesystem._is_link_supportedc C sr | � |�}|| jkr"| �tj|� | jd7 _| j|dd�| j|< || jjkrV| jn| �|�}| j|_ | j| S )a� Add a new mount point for a filesystem device.
The mount point gets a new unique device number.
Args:
path: The root path for the new mount path.
total_size: The new total size of the added filesystem device
in bytes. Defaults to infinite size.
Returns:
The newly created mount point dict.
Raises:
OSError: if trying to mount an existing mount point again.
r& r )�idevr� � used_size)
r| r� r� ro r� r� r� rU �
create_dirrF )r3 r� r� �root_dirr) r) r* r� � s
z FakeFilesystem.add_mount_pointFc C s6 | j r2|s| �|�s2| �|�d }|r2| j|d�S d S )Nr )r� )rV �_mount_point_for_path�
splitdriver� )r3 r� �force�driver) r) r* �_auto_mount_drive_if_needed s
z*FakeFilesystem._auto_mount_drive_if_neededc C s� dd� }| � | �|��}|| jkr,| j| S | �|d�}| �|�d d� }xH| jD ]>}| �||�}|rr|�|�srqR|�|�rRt|�t|�krR|}qRW |r�| j||� S | j|dd�}|s�t�|S )Nc S s> | dkst | t�r| S tr*| �t�d��S | �t�d��S dS )zXConvert the str, unicode or byte object to a str
using the default encoding.NF)rd r� r rr rg rh rf )r r) r) r* �to_str s
z4FakeFilesystem._mount_point_for_path.<locals>.to_str� r& T)r ) r| �_original_pathr� r r �
startswithr] r r� )r3 r� r �
mount_pathr
� root_path� mount_pointr) r) r* r
s"
z$FakeFilesystem._mount_point_for_pathc C s( x"| j �� D ]}|d |kr |S q W d S )Nr )r� �values)r3 r r r) r) r* �_mount_point_for_device9 s z&FakeFilesystem._mount_point_for_devicec C sh t dd�}|dkr"| j| jj }n
| �|�}|r\|d dk r\||d |d |d |d �S |ddd�S )a� Return the total, used and free disk space in bytes as named tuple,
or placeholder values simulating unlimited space if not set.
.. note:: This matches the return value of shutil.disk_usage().
Args:
path: The disk space is returned for the file system device where
`path` resides.
Defaults to the root path (e.g. '/' on Unix systems).
�usageztotal, used, freeNr� r l r )r r� r� rU r
)r3 r� � DiskUsager r) r) r* �get_disk_usage> s
z FakeFilesystem.get_disk_usagec C sL |dkr| j j}| �|�}|d dk r@|d |kr@| �tj|� ||d< dS )a� Changes the total size of the file system, preserving the used space.
Example usage: set the size of an auto-mounted Windows drive.
Args:
total_size: The new total size of the filesystem in bytes.
path: The disk space is changed for the file system device where
`path` resides.
Defaults to the root path (e.g. '/' on Unix systems).
Raises:
IOError: if the new space is smaller than the used size.
Nr� r )r� rU r
rn ro rp )r3 r� r� r r) r) r* �set_disk_usageV s
z FakeFilesystem.set_disk_usagec C sP | � |�}|rL|d }|dk r<||d |k r<| �tj|� |d |7 < dS )a� Change the used disk space by the given amount.
Args:
usage_change: Number of bytes added to the used space.
If negative, the used space will be decreased.
file_path: The path of the object needing the disk space.
st_dev: The device ID for the respective file system.
Raises:
IOError: if usage_change exceeds the free file system space
r� Nr )r rn ro rp )r3 � usage_changer4 rF r r� r) r) r* rl l s
z FakeFilesystem.change_disk_usageTc
C sx y(| j ||dd�}| �|||� |j�� S tk
rr } z,t|d�rJ|jn|j}| j|j||d� W dd}~X Y nX dS )a� Return the os.stat-like tuple for the FakeFile object of entry_path.
Args:
entry_path: Path to filesystem object to retrieve.
follow_symlinks: If False and entry_path points to a symlink,
the link itself is inspected instead of the linked object.
Returns:
The FakeStatResult object corresponding to entry_path.
Raises:
OSError: if the filesystem object doesn't exist.
T)�allow_fdr� )r� N) �resolve�(raise_for_filepath_ending_with_separatorrX �copyr� �hasattrr� ro r� )r3 �
entry_path�follow_symlinks� file_object�io_errorr� r) r) r* r� � s
zFakeFilesystem.statc
C s� | � |�r�t|j�r�y| �|�}W nR ttfk
rt } z0| jrN|jtjkrNd S | j rb| �
tj |� � W d d }~X Y nX |r�| j s�| jr�|}| j r�t |j�}n$| jr�|r�t|j� }n t
|j� }|r�| j r�tj ntj}| �
||� d S )N)�ends_with_path_separatorr rD r r� r� r� ro �ENOENTrV r� �EINVALr r �ENOTDIR) r3 r" r$ r# �macos_handling� link_object�exc�is_error�error_nrr) r) r* r � s*
z7FakeFilesystem.raise_for_filepath_ending_with_separatorc
C s� y| j ||dd�}W n> tk
rR } z |jtjkr@| �tj|� � W dd}~X Y nX | jr~|t@ rp|jdB |_q�|jd@ |_n|jt @ |t@ B |_t � � |_
dS )a5 Change the permissions of a file as encoded in integer mode.
Args:
path: (str) Path to the file.
mode: (int) Permissions.
follow_symlinks: If `False` and `path` points to a symlink,
the link itself is affected instead of the linked object.
T)r N� im� ) r r� ro r' r� rV r� rD �PERM_ALLrW rM )r3 r� �moder# r$ r% r) r) r* �chmod� s
zFakeFilesystem.chmodc
C s� | � ||� y| j||dd�}W n> tk
r^ } z |jtjkrL| �tj|� � W dd}~X Y nX |dk r�x"|D ]}t|ttf�snt d��qnW |d |_
|d |_ nR|dk r�x |D ]}t|t�s�t d��q�W |d |_ |d |_
nt�� }||_
||_ dS )a# Change the access and modified times of a file.
Args:
path: (str) Path to the file.
times: 2-tuple of int or float numbers, of the form (atime, mtime)
which is used to set the access and modified times in seconds.
If None, both times are set to the current time.
ns: 2-tuple of int numbers, of the form (atime, mtime) which is
used to set the access and modified times in nanoseconds.
If `None`, both times are set to the current time.
New in Python 3.3.
follow_symlinks: If `False` and entry_path points to a symlink,
the link itself is queried instead of the linked object.
New in Python 3.3.
Raises:
TypeError: If anything other than the expected types is
specified in the passed `times` or `ns` tuple,
or if the tuple length is not equal to 2.
ValueError: If both times and ns are specified.
T)r Nz atime and mtime must be numbersr r& z atime and mtime must be ints)�_handle_utime_arg_errorsr r� ro r' r� rd �int�float� TypeErrorrK rL rN rO rW ) r3 r� �times�nsr# r$ r% � file_time� current_timer) r) r* �utime� s,
zFakeFilesystem.utimec C sT |d k r|d k rt d��|d k r4t|�dkr4td��|d k rPt|�dkrPtd��d S )Nz:utime: you may specify either 'times' or 'ns' but not bothrw z9utime: 'times' must be either a tuple of two ints or Nonez'utime: 'ns' must be a tuple of two ints)rR r] r6 )r3 r8 r7 r) r) r* r3 s z'FakeFilesystem._handle_utime_arg_errorsc C s || � |�_dS )a> Set the self.st_ino attribute of file at 'path'.
Note that a unique inode is assigned automatically to a new fake file.
Using this function does not guarantee uniqueness and should used
with caution.
Args:
path: Path to file.
st_ino: The desired inode.
N)�
get_objectrE )r3 r� rE r) r) r* r� s zFakeFilesystem.SetInoc C s> | j r"t�| j �}|g| j|< |S | j�|g� t| j�d S )aX Add file_obj to the list of open files on the filesystem.
Used internally to manage open files.
The position in the open_files array is the file descriptor number.
Args:
file_obj: File object to be added to open files list.
Returns:
File descriptor number for the file object.
r& )r� �heapq�heappopr� �appendr] )r3 �file_obj�open_fdr) r) r* �_add_open_file s z FakeFilesystem._add_open_filec C s d| j |< t�| j|� dS )z�Remove file object with given descriptor from the list
of open files.
Sets the entry in open_files to None.
Args:
file_des: Descriptor of file object to be removed from
open files list.
N)r� r= �heappushr� )r3 �file_desr) r) r* �_close_open_file- s
z FakeFilesystem._close_open_filec C sL t |�std��|t| j�ks,| j| dkr>| �tjt|�� | j| d S )a Return an open file.
Args:
file_des: File descriptor of the open file.
Raises:
OSError: an invalid file descriptor.
TypeError: filedes is not an integer.
Returns:
Open file object.
zan integer is requiredNr )r r6 r] r� r� ro �EBADFr� )r3 rD r) r) r* �
get_open_file: s
z FakeFilesystem.get_open_filec C s |dd� | j D �kS )z�Return True if the given file object is in the list of open files.
Args:
file_object: The FakeFile object to be checked.
Returns:
`True` if the file is open.
c S s g | ]}|r|d � � �qS )r )r< )r� �wrappersr) r) r* r� W s z0FakeFilesystem.has_open_file.<locals>.<listcomp>)r� )r3 r$ r) r) r* r� N s z FakeFilesystem.has_open_filec C s* | j d ks|s|S |�| �|�| �|��S )N)r� �replacer rz )r3 r� r) r) r* �_normalize_path_sepZ s z"FakeFilesystem._normalize_path_sepc C s t |�}| �|�S )a Replace all appearances of alternative path separator
with path separator.
Do nothing if no alternative separator is set.
Args:
path: The path to be normalized.
Returns:
The normalized path that will be used internally.
)r rJ )r3 r� r) r) r* �normcase` s zFakeFilesystem.normcasec C s� | � |�}| �|�\}}| �|�}|�|�}|�|�}g }| �|d�}| �|d�}xN|D ]F} | rX| |krjqX| |kr�|r�|d |kr�|�� qXn|r�qX|�| � qXW |�|�}
|r�||
}
||
p�|S )a� Mimic os.path.normpath using the specified path_separator.
Mimics os.path.normpath using the path_separator that was specified
for this FakeFilesystem. Normalizes the path, but unlike the method
absnormpath, does not make it absolute. Eliminates dot components
(. and ..) and combines repeated path separators (//). Initial ..
components are left in place for relative paths.
If the result is an empty path, '.' is returned instead.
This also replaces alternative path separator with path separator.
That is, it behaves like the real os.path.normpath on Windows if
initialized with '\' as path separator and '/' as alternative
separator.
Args:
path: (str) The path to normalize.
Returns:
(str) A copy of path with empty components and dot components
removed.
�.z..���) rK r rz r r� r r= r? r{ ) r3 r� r
r �is_absolute_path�path_components�collapsed_path_components�dot�dotdot� component�collapsed_pathr) r) r* �normpatho s.
zFakeFilesystem.normpathc s� � ���fdd�}�j s �s �S �����g � �j}xb�D ]Z}t|t�sN|� S ��||�\}}|dks�t|t�r�|jdkr�|jdkr�|� S � �|� q:W |� S )aD Return a normalized case version of the given path for
case-insensitive file systems. For case-sensitive file systems,
return path unchanged.
Args:
path: the file path to be transformed
Returns:
A version of path matching the case of existing path elements.
c sZ t ��t � �kr&� ��t � �d � � ����} | �� �}��| �rV|�| �sV| | }|S )N)r] �extendrz r{ r )r �normalized_path)�normalized_componentsr� rO r3 r) r* �components_to_path� s
z9FakeFilesystem._original_path.<locals>.components_to_pathNr ) r� �_path_componentsr� rd r� �_directory_contentr\ rJ r? )r3 r� rY � current_dirrS �dir_namer) )rX r� rO r3 r* r � s$
z FakeFilesystem._original_pathc C s� | � |�}| �|| j�}|s$| j}nF| �|�sj| �|| jj�}| �|d�}| �|��||kr`|pb||f�}|| �|d�kr~|}| � |�S )ar Absolutize and minimalize the given path.
Forces all relative paths to be absolute, and normalizes the path to
eliminate dot and empty components.
Args:
path: Path to normalize.
Returns:
The normalized path relative to the current working directory,
or the root directory if path is empty.
r rL )
rK r r� r� �_starts_with_root_pathr� rU rz r{ rU )r3 r� r� � root_name�emptyr) r) r* r| � s
zFakeFilesystem.absnormpathc C s | � |�}| �|�}|�|�}|s&dS | �|�}|�� }| �|d�}|sr|rj|�|�}|d | |d fS d|fS x�|D ]|}|rxx|d s�|�� q�W |r�|s�|�|�}|d | |d fS t|�dkr�|d �|�r�|d | |fS |�|�|fS qxW ||fS )a� Mimic os.path.splitpath using the specified path_separator.
Mimics os.path.splitpath using the path_separator that was specified
for this FakeFilesystem.
Args:
path: (str) The path to split.
Returns:
(str) A duple (pathname, basename) for which pathname does not
end with a slash, and basename does not contain a slash.
)r r rx r r& r rM ) rK rz r� �_starts_with_drive_letterr= r r] �endswithr{ ) r3 r� r rO �starts_with_driver� �colon�
componentsrS r) r) r* � splitpath� s4
zFakeFilesystem.splitpathc C s t |�}| j�r
t|�dk�r
| �|�}| �|�}tjdkr�|dd� |d kr�|dd� |kr�|�|d�}|dkr�|dd� |fS |�||d �}||d kr�|dd� |fS |dkr�t|�}|d|� ||d� fS |dd� | �|d�k�r
|dd� |dd� fS |dd� |fS ) a� Splits the path into the drive part and the rest of the path.
Taken from Windows specific implementation in Python 3.5
and slightly adapted.
Args:
path: the full path to be splitpath.
Returns:
A tuple of the drive part and the rest of the path, or of
an empty string and the full path if drive letters are
not supported or no drive is present.
rw )rw � � r r rM Nr& rx ) r rV r] rK rz r; r �findr )r3 r� r � sep_index�
sep_index2r) r) r* r s(
zFakeFilesystem.splitdrivec G s" |d }|dd� }| � |�}|| �|�g}| �|�\}}x�|D ]�}| �|�\} }
|
rz|
dd� |krz| sn|sr| }|
}q@n0| r�| |kr�| js�| �� |�� kr�| }|
}q@| }|r�|dd� |kr�|| }||
}q@W | �|d�} |�r|dd� |k�r|�r|dd� | k�r|| | S || S )zSTaken from Python 3.5 os.path.join() code in ntpath.py
and slightly adaptedr r& NrM rx )rz r r r� r� r ) r3 � all_paths� base_path� paths_to_addr �seps� result_drive� result_pathr� �
drive_part� path_partrd r) r) r* � _join_paths_with_drive_support6 s6
z-FakeFilesystem._join_paths_with_drive_supportc G s� t jdkrdd� |D �}t|�dkr,|d S | jr<| j|� S g }| �|d �}xH|D ]@}| �|�rj|g}qT|r�|d �|�s�|�|� |rT|�|� qTW | � |d d��
|�S )a Mimic os.path.join using the specified path_separator.
Args:
*paths: (str) Zero or more paths to join.
Returns:
(str) The paths joined by the path separator, starting with
the last absolute path in paths.
)r � c S s g | ]}t �|��qS r) )r� �fspath)r� r� r) r) r* r� e s z,FakeFilesystem.joinpaths.<locals>.<listcomp>r& r rM r ) r; r r] rV rt rz r^ rb r? r r{ )r3 �paths�joined_path_segmentsr � path_segmentr) r) r* � joinpathsZ s"
zFakeFilesystem.joinpathsc C s� |r|| � |�krg S | �|�\}}|�| � |��}|s@|s@t�|d snt|�dkrb|d sbg }n |dd� }|r~|�d|� |S )a7 Breaks the path into a list of component names.
Does not include the root directory as a component, as all paths
are considered relative to the root directory for the FakeFilesystem.
Callers should basically follow this pattern:
.. code:: python
file_path = self.absnormpath(file_path)
path_components = self._path_components(file_path)
current_dir = self.root
for component in path_components:
if component not in current_dir.contents:
raise IOError
_do_stuff_with_component(current_dir, component)
current_dir = current_dir.get_entry(component)
Args:
path: Path to tokenize.
Returns:
The list of names split from path.
r r& N)rz r r� r� r] ry )r3 r� r
rO r) r) r* rZ x s z FakeFilesystem._path_componentsc C s< | � |d�}| jo:t|�dko:|dd� jo:|dd� |kS )a Return True if file_path starts with a drive letter.
Args:
file_path: the full path to be examined.
Returns:
`True` if drive letter support is enabled in the filesystem and
the path starts with a drive letter.
rx rw Nr& )r rV r] �isalpha)r3 r4 rd r) r) r* ra � s
z(FakeFilesystem._starts_with_drive_letterc C sH | � || jj�}| �|�}|�|�pF| j r>|�� �|�� �pF| �|�S )N)r r� rU rJ r r� r� ra )r3 r4 r_ r) r) r* r^ � s
z%FakeFilesystem._starts_with_root_pathc C sV | � || jj�}||kpT| j r0|�� |�� kpTdt|� koFdkn oT| �|�S )Nrw r )r r� rU r� r� r] ra )r3 r4 r_ r) r) r* �
_is_root_path� s
z FakeFilesystem._is_root_pathc C sR t |�r dS t|�}|oP|| j| jfkoP|�| �|��pP| jdk oP|�| �|��S )z>Return True if ``file_path`` ends with a valid path separator.FN)r r r� r� rb rz r )r3 r4 r) r) r* r& � s
z'FakeFilesystem.ends_with_path_separatorc C s | � |�sdS | �| �|��S )NF)r& �isfile�!_path_without_trailing_separators)r3 r� r) r) r* �!is_filepath_ending_with_separator� s
z0FakeFilesystem.is_filepath_ending_with_separatorc sR t �t�sdS � �jkr&� �j� fS | jsN� �fdd��jD �}|rN|d S dS )N)NNc s* g | ]"}|� � � � � kr|�j| f�qS r) )r� ra )r� �subdir)rS � directoryr) r* r� � s z5FakeFilesystem._directory_content.<locals>.<listcomp>r )rd r� ra r� )r3 r� rS �matching_contentr) )rS r� r* r[ � s
z!FakeFilesystem._directory_contentc C s� |r| � |�rdS t|�}|dkr&t�|s.dS || jjkrB| j S y | �|�rRdS | �|�}W n tt fk
rv dS X || j
jkr�dS | � |�}| j
}x$|D ] }| � ||�d }|s�dS q�W dS )a Return true if a path points to an existing file system object.
Args:
file_path: The path to examine.
Returns:
(bool) True if the corresponding object exists.
Raises:
TypeError: if file_path is None.
TNFr& )
�islinkr r6 r� rU rV r � resolve_pathr� r� r� rZ r[ )r3 r4 �
check_linkrO r\ rS r) r) r* �exists� s0
zFakeFilesystem.existsc C s" t s t| t�r | �t�d��} | S )NF)r rd re rf rg rh )r� r) r) r* �
_to_string s zFakeFilesystem._to_stringc C s� |r(t jdkr(t|t�r(| �|��� jS t|�}|dkr@td��| � |�}|rX| �
|�sf| � t j
|� | �| �|��}| �|�r�|S || jjkr�|S | �|�}| �||�}| �|�S )a9 Follow a path, resolving symlinks.
ResolvePath traverses the filesystem along the specified file path,
resolving file names and symbolic links until all elements of the path
are exhausted, or we reach a file which does not exist.
If all the elements are not consumed, they just get appended to the
path resolved so far.
This gives us the path which is as resolved as it can be, even if the
file does not exist.
This behavior mimics Unix semantics, and is best shown by example.
Given a file system that looks like this:
/a/b/
/a/b/c -> /a/b2 c is a symlink to /a/b2
/a/b2/x
/a/c -> ../d
/a/x -> y
Then:
/a/b/x => /a/b/x
/a/c => /a/d
/a/x => /a/y
/a/b/c/d/e => /a/b2/d/e
Args:
file_path: The path to examine.
allow_fd: If `True`, `file_path` may be open file descriptor.
raw_io: `True` if called from low-level I/O functions.
Returns:
The resolved_path (string) or None.
Raises:
TypeError: if `file_path` is `None`.
IOError: if `file_path` is '' or a part of the path doesn't exist.
)r r Nz/Expected file system path string, received None)r; r rd r4 rG r< r� r r6 r� �_valid_relative_pathrn ro r' r| r r| r� rU rZ �_resolve_components�_components_to_path)r3 r4 r �raw_iorO �resolved_componentsr) r) r* r� s" '
zFakeFilesystem.resolve_pathc C s8 |r| � |d �n| j}|�|�}| �|�s4|| }|S )Nr )rz r� r{ r^ )r3 �component_foldersr r� r) r) r* r� D s
z"FakeFilesystem._components_to_pathc
C s� | j }d}g }x�|r�|�d�}|�|� | �||�d }|d krL|�|� P t|j�r|tkr�|rh| jn| j }|t
j | � |�� | �
||�}| �|�} | | }g }| j }|d7 }qW |S )Nr r& )r� r= r? r[ rV r rD �_MAX_LINK_DEPTHr� rn ro �ELOOPr� � _follow_linkrZ )
r3 rO r� r\ �
link_depthr� rS r� � link_path�target_componentsr) r) r* r� L s.
z"FakeFilesystem._resolve_componentsc C sX | j r
dS | �|| jd �}x6|rR||krR|d |�|�� }| �| �|��s dS q W dS )NTz..F)rV r r� �rfindr� r| )r3 r4 � slash_dotdotr) r) r* r� s s z#FakeFilesystem._valid_relative_pathc C sD |j }| �|�}| �|�s:|dd� }|�|� |�|�}| �|�S )a9 Follow a link w.r.t. a path resolved so far.
The component is either a real file, which is a no-op, or a
symlink. In the case of a symlink, we have to modify the path
as built up so far
/a/b => ../c should yield /a/../c (which will normalize to /a/c)
/a/b => x should yield /a/x
/a/b => /x/y/z should yield /x/y/z
The modified path may land us in a new spot which is itself a
link, so we may repeat the process.
Args:
link_path_components: The resolved path built up to the link
so far.
link: The link object itself.
Returns:
(string) The updated path resolved after following the link.
Raises:
IOError: if there are too many levels of symbolic link
NrM )ra rz r^ r? r{ rU )r3 �link_path_components�linkr� r re r) r) r* r� ~ s
zFakeFilesystem._follow_linkc C s� t |�}|| jjkr| jS || jjkr,| jS | �|�}| �|�}| j}y^xX|D ]P}t|j�rh| �|j �}t
|j�s�| j s�| � t
j|� | � t
j|� |�|�}qNW W n" tk
r� | � t
j|� Y nX |S )a� Search for the specified filesystem object within the fake
filesystem.
Args:
file_path: Specifies target FakeFile object to retrieve, with a
path that has already been normalized/resolved.
Returns:
The FakeFile object corresponding to file_path.
Raises:
IOError: if the object is not found.
)r r� rU r� r rZ r rD r ra r rV rn ro r) r' r� �KeyError)r3 r4 rO �
target_objectrS r) r) r* �get_object_from_normpath� s(
z'FakeFilesystem.get_object_from_normpathc C s" t |�}| �| �|��}| �|�S )aA Search for the specified filesystem object within the fake
filesystem.
Args:
file_path: Specifies the target FakeFile object to retrieve.
Returns:
The FakeFile object corresponding to `file_path`.
Raises:
IOError: if the object is not found.
)r r| r r� )r3 r4 r) r) r* r< � s
zFakeFilesystem.get_objectc C sT t |t�r.|r&tjdkr&| �|��� S td��|rJt|�}| �| � |��S | �
|�S )a� Search for the specified filesystem object, resolving all links.
Args:
file_path: Specifies the target FakeFile object to retrieve.
follow_symlinks: If `False`, the link itself is resolved,
otherwise the object linked to.
allow_fd: If `True`, `file_path` may be an open file descriptor
Returns:
The FakeFile object corresponding to `file_path`.
Raises:
IOError: if the object is not found.
)r r zCpath should be string, bytes or os.PathLike (if supported), not int) rd r4 r; r rG r< r6 r r� r� �lresolve)r3 r4 r# r r) r) r* r � s
zFakeFilesystem.resolvec C s� t |�}|| jjkr| jS | �|�}| �|�}| �|�\}}|sF| j}yR| �|�}|sZt�t |t
�s�| j s�t |t �r�| �
tj|� | �
tj|� |�|�S tk
r� | �
tj|� Y nX dS )a� Search for the specified object, resolving only parent links.
This is analogous to the stat/lstat difference. This resolves links
*to* the object but not of the final object itself.
Args:
path: Specifies target FakeFile object to retrieve.
Returns:
The FakeFile object corresponding to path.
Raises:
IOError: if the object is not found.
N)r r� rU r~ r rf r� r r� rd r� rV rC rn ro r) r' r� r� )r3 r� �parent_directory�
child_name�
parent_objr) r) r* r� � s$
zFakeFilesystem.lresolvec C sT |p| j }|s| j}n0| �|�}t|j�sF| jr6tjntj}|||� |� |� dS )a� Add a fake file or directory into the filesystem at file_path.
Args:
file_path: The path to the file to be added relative to self.
file_object: File or directory to add.
error_class: The error class to be thrown if file_path does
not correspond to a directory (used internally(
Raises:
IOError or OSError: if file_path does not correspond to a
directory.
N)
r� r� r r rD rV ro r' r) r� )r3 r4 r$ r� �target_directory�errorr) r) r* �
add_object s
zFakeFilesystem.add_objectc
C s� | � |�}| �|�}| �|�}| j|dd�s<| �tj|d� |rJ| �|� | �|�}| jsh| � |||� | j|dd�r�| �
|||||�}|s�dS | � |�\}}| � |�\}} | �|�s�| �tj|� | � |�}
| � |�} |
j
| j
kr�| �tj|� t| j��s| �| j�rtjntj|� | �|��r4| �tj|� |
�|�} |
j|dd� | | _| �| �} | | jk�rr| �| � | �| � dS )a� Renames a FakeFile object at old_file_path to new_file_path,
preserving all properties.
Args:
old_file_path: Path to filesystem object to rename.
new_file_path: Path to where the filesystem object will live
after this call.
force_replace: If set and destination is an existing file, it
will be replaced even under Windows if the user has
permissions, otherwise replacement happens under Unix only.
Raises:
OSError: if old_file_path does not exist.
OSError: if new_file_path is an existing directory
(Windows, or Posix if old_file_path points to a regular file)
OSError: if old_file_path is a directory and new_file_path a file
OSError: if new_file_path is an existing file and force_replace
not set (Windows only).
OSError: if new_file_path is an existing file and could not be
removed (Posix, or Windows with force_replace set).
OSError: if dirname(new_file_path) does not exist.
OSError: if the file would be moved to another filesystem
(e.g. mount point).
T)r� rw NF)r� )r& r| r� r� ro r' �%_handle_broken_link_with_trailing_sepr� rV � _handle_posix_dir_link_errors�_rename_to_existing_pathrf r rF �EXDEVr rD r� r) r� r( r� r� rU r� ra r� )
r3 �
old_file_path�
new_file_path�
force_replace�
ends_with_sep�
old_object�old_dir�old_name�new_dir�new_name�old_dir_object�new_dir_object�object_to_renamer) r) r* �rename3 sL
zFakeFilesystem.renamec C sB | � |�r>| �|�s>| jr tjn| jr,tjntj}| �||� d S )N) r� r� r� ro r' rV r( r) r� )r3 r� r� r) r) r* r� y s
z4FakeFilesystem._handle_broken_link_with_trailing_sepc C s� | j |dd�r&| �|�r&| �tj|� | j |dd�rh| �|�rh|rL| jrLd S |rVtjntj}| �||� |r�| �|�r�||kr�| js�| �tj|� d S )NF)r# )r� r� r� ro r) r� r� rV )r3 r� r� r� r� r) r) r* r� � s
z,FakeFilesystem._handle_posix_dir_link_errorsc
C s | � |�}||krBt|j�s>|r>| jr,tjntj}| �||� d S ||krX| �||�}n�t |j�slt|j�r�| �
|||||� n�t |j�r�| jr�tj ntj}| �||� n^| jr�|s�| �tj |� nDy| � |� W n4 t
k
�r } z| �|j|j� W d d }~X Y nX |S )N)r< r rD rV ro r( r) r� �_rename_same_objectr �$_handle_rename_error_for_dir_or_linkr� �
remove_objectr� r� ) r3 r� r� r� r� r� �
new_objectr� r, r) r) r* r� � s.
"z'FakeFilesystem._rename_to_existing_pathc C sv | j r(|r| �tj|� n| �tj|� t|j�sr|jrZt|j�rL|rL| jsZ| �tj |� t
|j�rr| �tj |� d S )N) rV r� ro r� r� r rD ra r� � ENOTEMPTYr r� )r3 r� r� r� r� r� r) r) r* r� � s
z3FakeFilesystem._handle_rename_error_for_dir_or_linkc
C s� |� � |� � k}|s�y�| �|�}| �|�}| �|�}||kr~||k|� � |� � kkr~| j|dd�}tj�|�|jkpz| j }n|� � |� � k}|r�| � |�\}} | �
| �|�| �}W n t t fk
r� Y nX |s�d }|S )NF)r# )
r� r� r r r� r� r� rU r� rf rz r� r� )
r3 r� r� � do_rename�
real_old_path�original_old_path�
real_new_path� real_object�parent� file_namer) r) r* r� � s2
z"FakeFilesystem._rename_same_objectc C s� | � | �|��}| �|�r(| �tj|� y&| �|�\}}| �|�}|�|� W nB t k
rp | �
tj |� Y n" t k
r� | �
tj
|� Y nX dS )an Remove an existing file or directory.
Args:
file_path: The path to the file relative to self.
Raises:
IOError: if file_path does not correspond to an existing file, or
if part of the path refers to something other than a directory.
OSError: if the directory is in use (eg, if it is '/').
N)r| r r| r� ro �EBUSYrf r r� r� rn r' �AttributeErrorr) )r3 r4 �dirnamer� r� r) r) r* r� � s
z FakeFilesystem.remove_objectc C s0 t |�}| �|tj�}| �|| j�}|�||�S )N)r r r� r r� rI )r3 r� �os_sep�fake_sepr) r) r* r � s z FakeFilesystem.make_string_pathc C s | � |�}| �|�}| �|� | j|dd�r:| �tj|� | �|�}| j}g }x~|D ]v}| � ||�d }|s�t
|| d�}|� |� |� |� |}qTt
|j�r�| �|j�}|}|jt@ tkrT| �tj|j� qTW x|D ]}t|B |_q�W | jd7 _| j|_|S )a� Create `directory_path`, and all the parent directories.
Helper method to set up your test faster.
Args:
directory_path: The full directory path to create.
perm_bits: The permission bits as set by `chmod`.
Returns:
The newly created FakeDirectory object.
Raises:
OSError: if the directory already exists.
T)r� r& )rS )r r| r r� r� ro r� rZ r� r[ r� r? r� r rD r ra r r) r� r� rE ) r3 �directory_pathr� rO r\ �new_dirsrS r� r� r) r) r* r � s2
zFakeFilesystem.create_dirr c
C s | j ||||||||| d� S )aG Create `file_path`, including all the parent directories along
the way.
This helper method can be used to set up tests more easily.
Args:
file_path: The path to the file to create.
st_mode: The stat constant representing the file type.
contents: the contents of the file. If not given and st_size is
None, an empty file is assumed.
st_size: file size; only valid if contents not given. If given,
the file is considered to be in "large file mode" and trying
to read from or write to the file will result in an exception.
create_missing_dirs: If `True`, auto create missing directories.
apply_umask: `True` if the current umask must be applied
on `st_mode`.
encoding: If `contents` is a unicode string, the encoding used
for serialization.
errors: The error mode used for encoding/decoding errors.
side_effect: function handle that is executed when file is written,
must accept the file object as an argument.
Returns:
The newly created FakeFile object.
Raises:
IOError: if the file already exists.
IOError: if the containing directory is required and missing.
)rb )�create_file_internally)
r3 r4 rD ra rJ �create_missing_dirs� apply_umaskrY rZ rb r) r) r* � create_file* s !
zFakeFilesystem.create_filec C sn |p|}t |�}| � |�}t�|�}| j|dd�}|j�|� |rP| jdM _||_| �|j |j
|j � |S )aD Create `file_path`, including all the parent directories along the
way, for an existing real file. The contents of the real file are read
only on demand.
Args:
source_path: Path to an existing file in the real file system
read_only: If `True` (the default), writing to the fake file
raises an exception. Otherwise, writing to the file changes
the fake file only.
target_path: If given, the path of the target direction,
otherwise it is equal to `source_path`.
Returns:
the newly created FakeFile object.
Raises:
OSError: if the file does not exist in the real file system.
IOError: if the file already exists in the fake file system.
.. note:: On most systems, accessing the fake file's contents may
update both the real and fake files' `atime` (access time).
In this particular case, `add_real_file()` violates the rule
that `pyfakefs` must not modify the real file system.
T)�read_from_real_fsi$� ) r r� r� r� rX �set_from_stat_resultrD r4 rl rk rU rF )r3 r� r� r� r� � fake_filer) r) r* r� O s
z FakeFilesystem.add_real_filec
C s | � |�}tj�|�s$| �tj|� |p*|}|r�tj�|�d }| �|�rV| �|�}n
| � |�}t
|| ||�}|� |� | j d7 _ | j |_
nn| � |�}xbt�|�D ]T\}} }
tj�|jtj�||��} x.|
D ]&} | �tj�|| �|tj�| | �� q�W q�W |S )a" Create a fake directory corresponding to the real directory at the
specified path. Add entries in the fake directory corresponding to
the entries in the real directory.
Args:
source_path: The path to the existing directory.
read_only: If set, all files under the directory are treated as
read-only, e.g. a write access raises an exception;
otherwise, writing to the files changes the fake files only
as usually.
lazy_read: If set (default), directory contents are only read when
accessed, and only until the needed subdirectory level.
.. note:: This means that the file system size is only updated
at the time the directory contents are read; set this to
`False` only if you are dependent on accurate file system
size in your test
target_path: If given, the target directory, otherwise,
the target directory is the same as `source_path`.
Returns:
the newly created FakeDirectory object.
Raises:
OSError: if the directory does not exist in the real file system.
IOError: if the directory already exists in the fake file system.
r r& )r~ r� r� r� rn ro r' r� r< r r� r� r� rE r r{ �relpathr� )
r3 r� r� � lazy_readr� � parent_pathr_ r� r� �_�files�new_base� fileEntryr) r) r* r� x s.
z!FakeFilesystem.add_real_directoryc C s: x4|D ],}t j�|�r&| �|||� q| �||� qW dS )a� This convenience method adds multiple files and/or directories from
the real file system to the fake file system. See `add_real_file()` and
`add_real_directory()`.
Args:
path_list: List of file and directory paths in the real file
system.
read_only: If set, all files and files under under the directories
are treated as read-only, e.g. a write access raises an
exception; otherwise, writing to the files changes the fake
files only as usually.
lazy_dir_read: Uses lazy reading of directory contents if set
(see `add_real_directory`)
Raises:
OSError: if any of the files and directories in the list
does not exist in the real file system.
OSError: if any of the files and directories in the list
already exists in the fake file system.
N)r� r� r� r� r� )r3 � path_listr� �
lazy_dir_readr� r) r) r* �add_real_paths� s
z FakeFilesystem.add_real_pathsc C s| |
r
| j n| j} | �|�}| �|�}t|�s4td��| j|dd�rP| � tj|� | � |�\}
}|
sh| j
}
| � |
� | �|
�s�|s�| tj |
� | �
|
� n
| �|
�}
|r�|| j M }| r�t|| | d�}nt||| ||| d�}| jd7 _| j|_| �|
|| � |dk�r|dk�rd}| �sx|dk �s0|dk �rxy$|dk �rH|�|� n
|�|� W n" tk
�rv | �|� � Y nX |S ) a Internal fake file creator that supports both normal fake files
and fake files based on real files.
Args:
file_path: path to the file to create.
st_mode: the stat.S_IF constant representing the file type.
contents: the contents of the file. If not given and st_size is
None, an empty file is assumed.
st_size: file size; only valid if contents not given. If given,
the file is considered to be in "large file mode" and trying
to read from or write to the file will result in an exception.
create_missing_dirs: if True, auto create missing directories.
apply_umask: whether or not the current umask must be applied
on st_mode.
encoding: if contents is a unicode string, the encoding used for
serialization.
errors: the error mode used for encoding/decoding errors
read_from_real_fs: if True, the contents are read from the real
file system on demand.
raw_io: `True` if called from low-level API (`os.open`)
side_effect: function handle that is executed when file is written,
must accept the file object as an argument.
z;st_mode must be of int type - did you mean to set contents?T)r� )rS rb )rS rY rZ rb r& Nr )r� rn r r| r r6 r� ro r� rf r� r r' r r r� r� rC r� rE r� rm ru r� r� )r3 r4 rD ra rJ r� r� rY rZ r� r� rb r� r� �new_filer$ r) r) r* r� � sP
z%FakeFilesystem.create_file_internallyc C s | � � std��| �|�}| �|�}| �|�}| �|�r�| �|�rP| �tj|� | �|�rp| j s�| �tj
|� nd| j r�| �tj |� | j| � |�dd�s�| �tj
|� | j
r�| j|dd�r�| �|� n| �tj|� | �|�s�| �|�}t|�}| j|ttB ||dd�S )a, Create the specified symlink, pointed at the specified link target.
Args:
file_path: path to the symlink to create
link_target: the target of the symlink
create_missing_dirs: If `True`, any missing parent directories of
file_path will be created
Returns:
The newly created FakeFile object.
Raises:
OSError: if the symlink could not be created
(see :py:meth:`create_file`).
OSError: if on Windows before Python 3.2.
z=Symbolic links are not supported on Windows before Python 3.2T)r� )rD ra r� r� )r r� r rK r& r� r� ro r� rV r' r( r~ r� r� r� r� r� r r� )r3 r4 � link_targetr� r) r) r* �create_symlink
s:
z FakeFilesystem.create_symlinkc C s | � � std��| �|�}| j|dd�r6| �tj|� | �|�\}}|sN| j}| �|�sf| �tj |� | �
|�r�| j r|tj ntj
}| �||� | j s�| �
|�r�| �tj |� y| �|�}W n" tk
r� | �tj |� Y nX |jt@ �r| �| j r�tjntj|� ||_| �||� |S )a
Create a hard link at new_path, pointing at old_path.
Args:
old_path: An existing link to the target file.
new_path: The destination path to create a new link at.
Returns:
The FakeFile object referred to by old_path.
Raises:
OSError: if something already exists at new_path.
OSError: if old_path is a directory.
OSError: if the parent directory doesn't exist.
OSError: if on Windows before Python 3.2.
z4Links are not supported on Windows before Python 3.2T)r� )r r� r| r� r� ro r� rf r� r' r& rV r( r) r r� rD r r� �EPERMrU r� )r3 �old_path�new_path�new_path_normalized�new_parent_directory� new_basenamer� �old_filer) r) r* r� Q
s6
zFakeFilesystem.linkc
C sD y| � |j� W n. ttfk
r> } z |jtjkS d }~X Y nX dS )NF)r� ra r� r� ro r� )r3 �link_objr, r) r) r* �_is_circular_link�
s
z FakeFilesystem._is_circular_linkc
C s� |dkr t �y| �|�}W n0 tk
rJ } z| �|j|� W dd}~X Y nX t|j�tkrh| �tj|� | � |�r�| j
s�| � |�r�| �tj|� | � |j �s�| j
r�tj}n$| �
|�r�| jr�|j S tj}ntj}| �||j � |jS )a� Read the target of a symlink.
Args:
path: symlink to read the target of.
Returns:
the string representing the path to which the symbolic link points.
Raises:
TypeError: if path is None
OSError: (with errno=ENOENT) if path is not a valid path, or
(with errno=EINVAL) if path is valid, but is not a symlink,
or if the path ends with a path separator (Posix only)
N)r6 r� r� r� ro r rD r r( r& rV r� r� r� r� r� r' ra )r3 r� r� r, r� r) r) r* �readlink�
s*
zFakeFilesystem.readlinkc C s8 t |�}| �|�}| �|�}|s.| �tjd� | jr>| �|�}| �|�\}}|r�| � |�}| �
|| j d �}|� |�r�| js�|�
|�\}}}| �|�s�| �tj|� | �|�}| j|dd��r| jr�|| j kr�tj} ntj} |r�| jr�| �|�s�| �|� n | �| |� | �|�\}
} | �|
t| || j @ | d�� dS )a� Create a leaf Fake directory.
Args:
dir_name: (str) Name of directory to create.
Relative paths are assumed to be relative to '/'.
mode: (int) Mode to create directory with. This argument defaults
to 0o777. The umask is applied to this mode.
Raises:
OSError: if the directory name is invalid or parent directory is
read only or as per :py:meth:`add_object`.
r z..T)r� )rS N)r r& r~ r� ro r' rV r| rf rU r r� rb � partitionr� r� r� r� r� r� r� r� ) r3 r] r1 r� r_ r� �base_dir�ellipsis� dummy_dotdotr. �head�tailr) r) r* �makedir�
s6
zFakeFilesystem.makedirc C s x| � |�r|d d� }qW |S )NrM )r& )r3 r� r) r) r* r~ �
s z0FakeFilesystem._path_without_trailing_separatorsc
C s | � |�}| �|�}|r@| jr@| j|dd�r@| �|�s@| �|� | �|�}| j}x0|D ](}||jkspt|jt �stP qV|j| }qVW y| �
||| j @ � W nd t t
fk
r� } zB|r�t| �|�t�s�| jr�|jtjkr�tj|_| �|j|j� W dd}~X Y nX dS )a� Create a leaf Fake directory and create any non-existent
parent dirs.
Args:
dir_name: (str) Name of directory to create.
mode: (int) Mode to create directory (and any necessary parent
directories) with. This argument defaults to 0o777.
The umask is applied to this mode.
exist_ok: (boolean) If exist_ok is False (the default), an OSError is
raised if the target directory already exists.
New in Python 3.2.
Raises:
OSError: if the directory already exists and exist_ok=False,
or as per :py:meth:`create_dir`.
T)r� N)r& r| r� r� r� rZ r� ra rd �dictr r� r� r� r r� rV ro r) r' r� r� ) r3 r] r1 �exist_okr� rO r\ rS �er) r) r* �makedirs�
s*
zFakeFilesystem.makedirsc C sf t |�}|dkrt�y4| �||�}|rF| j||| d� t|j�|kS W n ttfk
r` dS X dS )a� Helper function to implement isdir(), islink(), etc.
See the stat(2) man page for valid stat.S_I* flag values
Args:
path: Path to file to stat and test
st_flag: The stat.S_I* flag checked for the file's st_mode
Returns:
(boolean) `True` if the st_flag is set in path's st_mode.
Raises:
TypeError: if path is None
N)r* F)r r6 r r r rD r� r� )r3 r� �st_flagr# r~ r) r) r* � _is_of_type s zFakeFilesystem._is_of_typec C s | � |t|�S )a Determine if path identifies a directory.
Args:
path: Path to filesystem object.
Returns:
`True` if path points to a directory (following symlinks).
Raises:
TypeError: if path is None.
)r� r )r3 r� r# r) r) r* r� 3 s zFakeFilesystem.isdirc C s | � |t|�S )a Determine if path identifies a regular file.
Args:
path: Path to filesystem object.
Returns:
`True` if path points to a regular file (following symlinks).
Raises:
TypeError: if path is None.
)r� r )r3 r� r# r) r) r* r} A s zFakeFilesystem.isfilec C s | j |tdd�S )a Determine if path identifies a symbolic link.
Args:
path: Path to filesystem object.
Returns:
`True` if path points to a symlink (S_IFLNK set in st_mode)
Raises:
TypeError: if path is None.
F)r# )r� r )r3 r� r) r) r* r� O s zFakeFilesystem.islinkc
C st y| � |�}W n0 tk
r> } z| �|j|� W dd}~X Y nX |jt@ sp| jr\tr\tj}ntj }| �||d� |S )an Test that the target is actually a directory, raising OSError
if not.
Args:
target_directory: Path to the target directory within the fake
filesystem.
Returns:
The FakeDirectory object corresponding to target_directory.
Raises:
OSError: if the target is not a directory.
Ni )
r r� r� ro rD r rV r r( r) )r3 r� r� r, r. r) r) r* �
confirmdir] s
zFakeFilesystem.confirmdirc
C s | � |�}| �|�r | �|� | �|�r�| �|�}t|j�tkr�| �|�}t|j�t kr�| j
rft j }n| j
rtt j}nt j}| �||� t|�}|�| j�r�| j
r�t j }n| j
r�t j}nt j}| �||� n | �||� y| �|� W n4 tk
�r } z| �|j |j� W dd}~X Y nX dS )a Remove the FakeFile object at the specified file path.
Args:
path: Path to file to be removed.
Raises:
OSError: if path points to a directory.
OSError: if path does not exist.
OSError: if removal failed.
N)r| r& r� r� r r rD r r� r rV ro r� r� r� r� r� r rb r� r) r r� r� r� )r3 r� � norm_pathr~ r� r� r, r) r) r* �removew s6
zFakeFilesystem.removec
C s� |dkr&| j rtjntj}| �||� | �|�}| �|�}| �|�r�| j st| �|�rt|r\dS |rf| j st| �tj
|� | � |�}|j r�| �tj
|� y| �|� W n2 tk
r� } z| �|j|j� W dd}~X Y nX dS )a Remove a leaf Fake directory.
Args:
target_directory: (str) Name of directory to remove.
allow_symlink: (bool) if `target_directory` is a symlink,
the function just returns, otherwise it raises (Posix only)
Raises:
OSError: if target_directory does not exist.
OSError: if target_directory does not point to a directory.
OSError: if removal failed per FakeFilesystem.RemoveObject.
Cannot remove '.'.
)� .rL N)rV ro r� r( r� r& r| r� r� r� r) r ra r� r� r� r� )r3 r� �
allow_symlinkr. r� r� r, r) r) r* �rmdir� s$
zFakeFilesystem.rmdirc C s* | j |dd�}| �|�}|j}t|�� �S )af Return a list of file names in target_directory.
Args:
target_directory: Path to the target directory within the
fake filesystem.
Returns:
A list of file names within the target directory in arbitrary
order.
Raises:
OSError: if the target is not a directory.
T)r )r� r� ra r� �keys)r3 r� r� �directory_contentsr) r) r* r� � s
zFakeFilesystem.listdirc C s
t | j�S )N)r� r� )r3 r) r) r* r� � s zFakeFilesystem.__str__c C s4 | � ttj�� | � ttj�� | � ttj�� d S )N)rB �StandardStreamWrapperr; �stdin�stdout�stderr)r3 r) r) r* r� � s z$FakeFilesystem._add_standard_streams)N)NN)N)N)F)N)N)T)TF)T)NNT)F)FT)TF)N)F)TN)TTN)TT)T)T)T)T)F)fr6 r7 r8 r9 r� r� r r2 r� r� r� r� r� r� r� r� rn � staticmethodr rz r r r� r r
r r r rl r� r r2 r; r3 r
r� rB rE rG r� rJ rK rU r r| rf r rt rz rZ ra 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� 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) r) r) r* r� D s� 4
1
1(,'$ '
&
<' )$
&
F " / "
)
6
I
86( /-
,
"r� � GetDiskUsage� SetDiskUsage�ChangeDiskUsage�
AddMountPoint�GetStat�
ChangeMode�
UpdateTime� AddOpenFile�
CloseOpenFile� HasOpenFile� GetOpenFile�NormalizePathSeparator� CollapsePath�
NormalizeCase�
NormalizePath� SplitPath�
SplitDrive� JoinPaths�GetPathComponents�StartsWithDriveLetter�Exists� ResolvePath�GetObjectFromNormalizedPath� GetObject�
ResolveObject�LResolveObject� AddObject� RemoveObject� RenameObject�CreateDirectory�
CreateFile�
CreateLink�CreateHardLink�ReadLink�
MakeDirectory�MakeDirectories�IsDir�IsFile�IsLink�
ConfirmDir�
RemoveFile�RemoveDirectory�ListDirc @ s e Zd ZdZeej�Zedd� �Z d;dd�Z
dd� Z d d
� Z d d � Z
d
d� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd� Zdd � Zd d � Zd d � Zd!d"� Zd#d$� Zd%d&� Zd<d'd(�Zd)d*� Z e j d+ks�e j d,kr�d-d.� Z d/d0� Z!d1d2� Z"d3d4� Z#d5d6� Z$e%�rd7d8� Z&d9d:� Z'dS )=�FakePathModulez�Faked os.path module replacement.
FakePathModule should *only* be instantiated by FakeOsModule. See the
FakeOsModule docstring for details.
c C sX ddddddddd d
d d d
ddddddddg} t r<| �d� tjdksJt sT| �d� | S )zqReturn the list of patched function names. Used for patching
functions imported from the module.
�abspathr� r� �
expanduser�getatime�getctime�getmtime�getsize�isabsr� r} r� �ismountr{ �lexistsrK rU �realpathr� r� r r r �samefile)r r? r; r� )�dirr) r) r* r5 s
zFakePathModule.dirNc C sL || _ | j| _|dkr&tjttdd� | | j_| _| j j| _ | j j
| _ dS )z�Init.
Args:
filesystem: FakeFilesystem used to provide file system information
os_module: (deprecated) FakeOsModule to assign to self.os
Nrw )�
stacklevel) rS �
_OS_PATH_COPY�_os_path�warnings�warn� FAKE_PATH_MODULE_DEPRECATION�DeprecationWarningr� r� r r� r� )r3 rS � os_moduler) r) r* r2 - s
zFakePathModule.__init__c C s | j �|�S )z�Determine whether the file object exists within the fake filesystem.
Args:
path: The path to the file object.
Returns:
(bool) `True` if the file exists.
)rS r� )r3 r� r) r) r* r� = s zFakePathModule.existsc C s | j j|dd�S )z�Test whether a path exists. Returns True for broken symbolic links.
Args:
path: path to the symlink object.
Returns:
bool (if file exists).
T)r� )rS r� )r3 r� r) r) r* r2 H s zFakePathModule.lexistsc
C s� yN| j �|�}| j �|�rJt|j�tkrJ| j jr6tjntj }| j �
||� |j S t k
r� } zt
�|j|j��W dd}~X Y nX dS )z�Return the file object size in bytes.
Args:
path: path to the file object.
Returns:
file size in bytes.
N)rS r r& r rD r rV ro r( r) r� rJ r� r� r� r� )r3 r� r@ r. r, r) r) r* r/ S s zFakePathModule.getsizec C s~ | j jr| �|�d }t|�}| j �|�}| j �|�}| j jr^t|�dko\|dd� ||fkS |�|�px|dk ox|�|�S dS )z,Return True if path is an absolute pathname.r& r N)rS rV r r rz r r] r )r3 r� r r� r) r) r* r0 g s
zFakePathModule.isabsc C s | j �|�S )z)Determine if path identifies a directory.)rS r� )r3 r� r) r) r* r� t s zFakePathModule.isdirc C s | j �|�S )z,Determine if path identifies a regular file.)rS r} )r3 r� r) r) r* r} x s zFakePathModule.isfilec C s | j �|�S )z�Determine if path identifies a symbolic link.
Args:
path: Path to filesystem object.
Returns:
`True` if path points to a symbolic link.
Raises:
TypeError: if path is None.
)rS r� )r3 r� r) r) r* r� | s zFakePathModule.islinkc C s> y| j �|�}|jS tk
r8 | j jtjdd� Y nX dS )aC Returns the modification time of the fake file.
Args:
path: the path to fake file.
Returns:
(int, float) the modification time of the fake file
in number of seconds since the epoch.
Raises:
OSError: if the file does not exist.
r )r� N)rS r rL r� r� ro r' )r3 r� r@ r) r) r* r. � s
zFakePathModule.getmtimec C s: y| j �|�}W n" tk
r2 | j �tj� Y nX |jS )a� Returns the last access time of the fake file.
Note: Access time is not set automatically in fake filesystem
on access.
Args:
path: the path to fake file.
Returns:
(int, float) the access time of the fake file in number of seconds
since the epoch.
Raises:
OSError: if the file does not exist.
)rS r r� r� ro r' rK )r3 r� r@ r) r) r* r, � s
zFakePathModule.getatimec C s: y| j �|�}W n" tk
r2 | j �tj� Y nX |jS )a2 Returns the creation time of the fake file.
Args:
path: the path to fake file.
Returns:
(int, float) the creation time of the fake file in number of
seconds since the epoch.
Raises:
OSError: if the file does not exist.
)rS r r� r� ro r' rM )r3 r� r@ r) r) r* r- � s
zFakePathModule.getctimec s� � �fdd�}t � �� �j�� �}�j�� �}��� �sH��|� � �� nJ�jjrZ� �|�sl|dk r�� �|�r�|� }�j�|�r���|dd� � �� �� � �S )z&Return the absolute version of a path.c s> t rt� t�r�j�� S t s0t� t�r0�j�� S �j�� S dS )z%Return the current working directory.N)r rd r r� �getcwdure �getcwdb�getcwdr) )r� r3 r) r* r@ � s
z&FakePathModule.abspath.<locals>.getcwdNrw )
r rS rz r r0 r{ rV r ra rU )r3 r� r@ r r� r� r) )r� r3 r* r* � s
zFakePathModule.abspathc G s | j j|� S )z8Return the completed path with a separator of the parts.)rS rz )r3 �pr) r) r* r{ � s zFakePathModule.joinc C s | j �|�S )zHSplit the path into the directory and the filename of the path.
)rS rf )r3 r� r) r) r* r� � s zFakePathModule.splitc C s | j �|�S )zRSplit the path into the drive part and the rest of the path, if
supported.)rS r )r3 r� r) r) r* r � s zFakePathModule.splitdrivec C s | j �|�S )z0Normalize path, eliminating double slashes, etc.)rS rU )r3 r� r) r) r* rU � s zFakePathModule.normpathc C s | j �|�}| j jr |�� }|S )zPConvert to lower case under windows, replaces additional path
separator.)rS rK rV r� )r3 r� r) r) r* rK � s zFakePathModule.normcasec C s� |s t d��t|�}|dk r&t|�}n| jj}| jjdk rb|�| jj| jj�}|�| jj| jj�}|�| jj| jj�}|�| jj| jj�}| j� ||�}|�| jj| jj�S )zQWe mostly rely on the native implementation and adapt the
path separator.zno path specifiedN)
rR r rS r� r� rI r8 r r� r� )r3 r� �startr) r) r* r� � s
zFakePathModule.relpathc C s> | j jr| �|�S t|�}| �|dd� |i �\}}| �|�S )z}Return the canonical path of the specified filename, eliminating any
symbolic links encountered in the path.
Nr )rS rV r* r �
_joinrealpath)r3 r� r� �okr) r) r* r3
s
zFakePathModule.realpathr )r rw c C s0 | j �|�}| j �|�}|j|jko.|j|jkS )a� Return whether path1 and path2 point to the same file.
Windows support new in Python 3.2.
Args:
path1: first file path or path object (Python >=3.6)
path2: second file path or path object (Python >=3.6)
Raises:
OSError: if one of the paths does not point to an existing
file system object.
)rS r� rE rF )r3 �path1�path2�stat1�stat2r) r) r* r4
s zFakePathModule.samefilec C s> | j �|d�}| j �|d�}| j �|�}| �|�rB|dd� }|}x�|�r4|�|�\}}}|rD||krhqD||kr�|r�| j �|�\}}||kr�| j �|||�}qD|}qD| j �||�} | j �| �s�| }qD| |kr�|| }|dk r�qD| j �| |�dfS d|| < | �|| j � | �|�\}}
|
�s*| j �||�dfS ||| < qDW |dfS )z�Join two paths, normalizing and eliminating any symbolic links
encountered in the second path.
Taken from Python source and adapted.
rL z..r& NFT)
rS r rz r0 r� rf rz r� rC r� ) r3 r� �rest�seen�curdir�pardirr rU r� �newpathrD r) r) r* rC +
sB
z FakePathModule._joinrealpathc C s | � |�d S )z2Returns the first part of the result of `split()`.r )r� )r3 r� r) r) r* r� \
s zFakePathModule.dirnamec C s | j �|��| j j| j�S )ztReturn the argument with an initial component of ~ or ~user
replaced by that user's home directory.
)r8 r+ rI r )r3 r� r) r) r* r+ `
s zFakePathModule.expanduserc C s� t |�}|sdS | j�|�}| j�|�}| jjr�| jjdk rN|| j�|�f}n|f}| j�|�\}}|r�|dd� |kr�| p�||kS ||kr�dS x(| jjD ] }|� |�|� |�kr�dS q�W dS )aP Return true if the given path is a mount point.
Args:
path: Path to filesystem object to be checked
Returns:
`True` if path is a mount point added to the fake file system.
Under Windows also returns True for drive and UNC roots
(independent of their existence).
FNr& T)
r rS r| rz rV r� r r r� �rstrip)r3 r� � normed_pathr � path_sepsr
rI r r) r) r* r1 g
s$ zFakePathModule.ismountc C s� y| j �|�}W n tjk
r& dS X ||||� x�|D ]|}| j �||�}| j jrp| j �|�r�| �|||� q:y| j j|dd�}W n tjk
r� w:Y nX t |j
�r:| �|||� q:W dS )a~ Directory tree walk with callback function.
Args:
top: Root path to traverse. The root itself is not included
in the called elements.
func: Function to be called for each visited path node.
arg: First argument to be called with func (apart from
dirname and filenames).
NF)r# ) rS r� r� r� rz rV r� r r� r rD )r3 �top�func�argr} rU �str) r) r* r �
s
zFakePathModule.walkc C s t | j|�S )z1Forwards any non-faked calls to the real os.path.)r� r8 )r3 rU r) r) r* r� �
s zFakePathModule.__getattr__)N)N)(r6 r7 r8 r9 rB r� r� r7 r� r5 r2 r� r2 r/ r0 r� r} r� r. r, r- r* r{ r� r rU rK r� r3 r; r� r r4 rC r� r+ r1 r r r� r) r) r) r* r) s>
1! r) c @ s� e Zd ZdZdZedd� �Zdgdd�Zdd� Zdhd
d �Z d d
� Z
didd�Z dd� Z dd� Z
dd� Zedjdd��Zdd� Zdd� Zd d � Zd d � Zer�d d!� Znd"d#� Zd$d%� Zejd&k� r�d'Zd(Zdkd*d+�Z dld,d-�Z dmd.d/�Z dnd1d2�Z e � r�dod4d5�Z!dpd7d8�Z"dqd9d:�Z#drd;d<�Z$dsd=d>�Z%dtd?d@�Z&dudAdB�Z'dvdCdD�Z(ejd&k�rTdEdF� Z)dwdGdH�Z*dIdJ� Z+e,dfdKdL�Z-e,dfdMdN�Z.dOdP� Z/dxdQdR�Z0dydSdT�Z1dUdV� Z2dzdWdX�Z3d{dYdZ�Z4d|d[d\�Z5d}d]d^�Z6d~d_d`�Z7dadb� Z8dcdd� Z9dedf� Z:dS )� FakeOsModulea� Uses FakeFilesystem to provide a fake os module replacement.
Do not create os.path separately from os, as there is a necessary circular
dependency between os and os.path to replicate the behavior of the standard
Python modules. What you want to do is to just let FakeOsModule take care
of `os.path` setup itself.
# You always want to do this.
filesystem = fake_filesystem.FakeFilesystem()
my_os_module = fake_filesystem.FakeOsModule(filesystem)
Nc C s� ddddddddd d
d d d
ddddddddddddddd d g } t rN| d g7 } n*| d d g7 } tj�d!�rx| d"d#d$d%d&g7 } tr�| d'g7 } | S )(zqReturn the list of patched function names. Used for patching
functions imported from the module.
�access�chdirr2 �chown�close�fstat�fsyncr@ �lchmodr� r� �lstatr� �mkdir�mknodr� r� r� r� �
removedirsr� r� r� �symlinkr� �unlinkr; r �writer> r? rI r# � fdatasync�getxattr� listxattr� removexattr�setxattrr )r r; r� r r
)r5 r) r) r* r5 �
s
zFakeOsModule.dirc C s� || _ |j| _|j| _|�� | _t| _|dkr>t | j | �| _
nt j t
tdd� || _
trb| j| _n| j| _|jrtdnd| j_dS )z�Also exposes self.path (to fake os.path).
Args:
filesystem: FakeFilesystem used to provide file system information
os_path_module: (deprecated) Optional FakePathModule instance
Nrw )r6 z/dev/nul)rS r� r r� r� r� �linesepr� �
_os_moduler) r� r9 r: r; r< r � _fdopen_ver2�fdopen�_fdopenrV r5 r� )r3 rS �os_path_moduler) r) r* r2 �
s
zFakeOsModule.__init__c O s$ t |d �std��t| j�||�S )a" Redirector to open() builtin function.
Args:
*args: Pass through args.
**kwargs: Pass through kwargs.
Returns:
File object corresponding to file_des.
Raises:
TypeError: if file descriptor is not an integer.
r zan integer is required)r r6 � FakeFileOpenrS )r3 �args�kwargsr) r) r* rm �
s
zFakeOsModule._fdopenr c
C s^ t |�std��yt| j�j||d�S tk
rX } z| j�|j|j� W dd}~X Y nX dS )a� Returns an open file object connected to the file descriptor
file_des.
Args:
file_des: An integer file descriptor for the file object requested.
mode: Additional file flags. Currently checks to see if the mode
matches the mode of the requested file object.
bufsize: ignored. (Used for signature compliance with
__builtin__.fdopen)
Returns:
File object corresponding to file_des.
Raises:
OSError: if bad file descriptor or incompatible mode is given.
TypeError: if file descriptor is not an integer.
zan integer is required)r1 N) r r6 ro rS �callr� r� ro r� )r3 rD r1 �bufsizer, r) r) r* rk �
s zFakeOsModule._fdopen_ver2c C s6 | j jr dS tjdkrdS t�d�}t�|� |S dS )zReturn the current umask.r r rw N)rS rV r; r� r� r� )r3 �maskr) r) r* �_umask s
zFakeOsModule._umaskc C s^ | � || j|�}|dkr4| jjr&d}nd| �� @ }t|tj@ |tj@ |tj tjB @ |tj
@ |tj @ |tj @ d�}|j
r�|jr�td��| jjs�| j�|�r�| j�|�}t|t�r�|js�| jjr�|jr�| j�tj|� t||| j�}| j�|�}||_|S d} d}
t td��r |tj @ tj k}
t | j|
d d
�|| |d �} | j | jj k�rV| �!||� | �"� S ) a� Return the file descriptor for a FakeFile.
Args:
file_path: the path to the file
flags: low-level bits to indicate io operation
mode: bits to define default permissions
Note: only basic modes are supported, OS-specific modes are
ignored
dir_fd: If not `None`, the file descriptor of a directory,
with `file_path` being relative to this directory.
New in Python 3.3.
Returns:
A file descriptor.
Raises:
IOError: if the path cannot be found
ValueError: if invalid mode is given
NotImplementedError: if `os.O_EXCL` is used without `os.O_CREAT`
Ni� i� )�
must_exist�can_read� can_write�truncater? �must_not_existz,O_EXCL without O_CREAT mode is not supported�bF� O_TEMPORARYT)�delete_on_closer� )r )#�_path_with_dir_fdr� rS rV ru �
_OpenModesr� �O_CREAT�O_WRONLY�O_RDWR�O_TRUNC�O_APPEND�O_EXCLrz rv �NotImplementedErrorr� r rd r� r� rx r� ro r� �FakeDirWrapperrB �filedesr! r| ro r$ r� r2 �fileno) r3 r4 �flagsr1 �dir_fdr r~ � dir_wrapperrD � str_flagsr} r� r) r) r* r� ' sJ
zFakeOsModule.openc C s | j �|�}|�� dS )z�Close a file descriptor.
Args:
file_des: An integer file descriptor for the file object requested.
Raises:
OSError: bad file descriptor.
TypeError: if file descriptor is not an integer.
N)rS rG rY )r3 rD � file_handler) r) r* rY j s
zFakeOsModule.closec C s | j �|�}d|_|�|�S )a� Read number of bytes from a file descriptor, returns bytes read.
Args:
file_des: An integer file descriptor for the file object requested.
num_bytes: Number of bytes to read from file.
Returns:
Bytes read from file.
Raises:
OSError: bad file descriptor.
TypeError: if file descriptor is not an integer.
T)rS rG r� r� )r3 rD � num_bytesr� r) r) r* r� w s zFakeOsModule.readc C sX | j �|�}t|t�r(| j �tj|j� d|_|� � |�
� |� |� |� � t
|�S )a� Write string to file descriptor, returns number of bytes written.
Args:
file_des: An integer file descriptor for the file object requested.
contents: String of bytes to write to file.
Returns:
Number of bytes written.
Raises:
OSError: bad file descriptor.
TypeError: if file descriptor is not an integer.
T)rS rG rd r� r� ro rF r4 r� �_sync_io�update_flush_posrc �flushr] )r3 rD ra r� r) r) r* rc � s
zFakeOsModule.writec C s
t �| �S )au Determine whether a file's time stamps are reported as floats
or ints.
Calling without arguments returns the current value. The value is
shared by all instances of FakeOsModule.
Args:
newvalue: If `True`, mtime, ctime, atime are reported as floats.
Otherwise, they are returned as ints (rounding down).
)r �stat_float_times)�newvaluer) r) r* r� � s z FakeOsModule.stat_float_timesc C s | j �|��� }|j�� S )aI Return the os.stat-like tuple for the FakeFile object of file_des.
Args:
file_des: The file descriptor of filesystem object to retrieve.
Returns:
The FakeStatResult object corresponding to entry_path.
Raises:
OSError: if the filesystem object doesn't exist.
)rS rG r< rX r )r3 rD r$ r) r) r* rZ � s
zFakeOsModule.fstatc C s$ t |�std��| jj}|| j_|S )z�Change the current umask.
Args:
new_mask: (int) The new umask value.
Returns:
The old umask.
Raises:
TypeError: if new_mask is of an invalid type.
zan integer is required)r r6 rS r� )r3 �new_mask� old_umaskr) r) r* r� � s
zFakeOsModule.umaskc C sT | j j|dd�}| j �|� | j �|�}t� sH|jtB sH| j �tj |� || j _
dS )a* Change current working directory to target directory.
Args:
target_directory: The path to new current working directory.
Raises:
OSError: if user lacks permission to enter the argument directory
or if the target is not a directory.
T)r N) rS r� r� r r/ rD r� r� ro r� r� )r3 r� r� r) r) r* rW � s
zFakeOsModule.chdirc C s | j jS )z!Return current working directory.)rS r� )r3 r) r) r* r@ � s zFakeOsModule.getcwdc C s t | jj�S )z;Return current working directory as unicode. Python 2 only.)r rS r� )r3 r) r) r* r> � s zFakeOsModule.getcwduc C s t | jjt�d��S )z9Return current working directory as bytes. Python 3 only.F)re rS r� rg rh )r3 r) r) r* r? � s zFakeOsModule.getcwdbc C s | j �|�S )ai Return a list of file names in target_directory.
Args:
target_directory: Path to the target directory within the fake
filesystem.
Returns:
A list of file names within the target directory in arbitrary
order.
Raises:
OSError: if the target is not a directory.
)rS r� )r3 r� r) r) r* r� � s zFakeOsModule.listdir)r r r& rw Tc C sF | j jstd��t|t�r(|�t�� �}| j j||dd�}|j �
|�S )ao Return the value of the given extended filesystem attribute for
`path`.
Args:
path: File path, file descriptor or path-like object (for
Python >= 3.6).
attribute: (str or bytes) The attribute name.
follow_symlinks: (bool) If True (the default), symlinks in the
path are traversed.
Returns:
The contents of the extended attribute as bytes or None if
the attribute does not exist.
Raises:
OSError: if the path does not exist.
z'module 'os' has no attribute 'getxattr'T)r ) rS r� r� rd re rf r; �getfilesystemencodingr r` �get)r3 r� � attributer# r@ r) r) r* re s
zFakeOsModule.getxattrc C s@ | j jstd��|dkr | �� }| j j||dd�}t|j�� �S )a Return a list of the extended filesystem attributes on `path`.
Args:
path: File path, file descriptor or path-like object (for
Python >= 3.6). If None, the current directory is used.
follow_symlinks: (bool) If True (the default), symlinks in the
path are traversed.
Returns:
A list of all attribute names for the given path as str.
Raises:
OSError: if the path does not exist.
z(module 'os' has no attribute 'listxattr'NT)r )rS r� r� r@ r r� r` r� )r3 r� r# r@ r) r) r* rf $ s
zFakeOsModule.listxattrc C sP | j jstd��t|t�r(|�t�� �}| j j||dd�}||j krL|j |= dS )a� Removes the extended filesystem attribute attribute from `path`.
Args:
path: File path, file descriptor or path-like object (for
Python >= 3.6).
attribute: (str or bytes) The attribute name.
follow_symlinks: (bool) If True (the default), symlinks in the
path are traversed.
Raises:
OSError: if the path does not exist.
z*module 'os' has no attribute 'removexattr'T)r N)
rS r� r� rd re rf r; r� r r` )r3 r� r� r# r@ r) r) r* rg = s
zFakeOsModule.removexattrr c C s� | j jstd��t|t�r(|�t�� �}t|�s8t d��| j j
||dd�}||j k}|rt|| j krt| j �
tj|j� |s�|| jkr�| j �
tj|j� ||j |< dS )aW Sets the value of the given extended filesystem attribute for
`path`.
Args:
path: File path, file descriptor or path-like object (for
Python >= 3.6).
attribute: The attribute name (str or bytes).
value: (byte-like) The value to be set.
follow_symlinks: (bool) If True (the default), symlinks in the
path are traversed.
Raises:
OSError: if the path does not exist.
TypeError: if `value` is not a byte-like object.
z'module 'os' has no attribute 'setxattr'z a bytes-like object is requiredT)r N)rS r� r� rd re rf r; r� r r6 r r` � XATTR_CREATEr� ro �ENODATAr� �
XATTR_REPLACEr� )r3 r� r� r� r� r# r@ r� r) r) r* rh U s
zFakeOsModule.setxattrr c C s t | j|�S )a� Return an iterator of DirEntry objects corresponding to the
entries in the directory given by path.
Args:
path: Path to the target directory within the fake filesystem.
Returns:
An iterator to an unsorted list of os.DirEntry objects for
each entry in path.
Raises:
OSError: if the target is not a directory.
)r rS )r3 r� r) r) r* r x s zFakeOsModule.scandirFc C s t | j||||�S )a� Perform an os.walk operation over the fake filesystem.
Args:
top: The root directory from which to begin walk.
topdown: Determines whether to return the tuples with the root as
the first entry (`True`) or as the last, after all the child
directory tuples (`False`).
onerror: If not `None`, function which will be called to handle the
`os.error` instance provided when `os.listdir()` fails.
followlinks: If `True`, symbolic links are followed.
Yields:
(path, directories, nondirectories) for top and each of its
subdirectories. See the documentation for the builtin os module
for further details.
)r rS )r3 rQ �topdown�onerror� followlinksr) r) r* r � s zFakeOsModule.walkc C s | � || j|�}| j�|�S )aD Read the target of a symlink.
Args:
path: Symlink to read the target of.
dir_fd: If not `None`, the file descriptor of a directory,
with `path` being relative to this directory.
New in Python 3.3.
Returns:
the string representing the path to which the symbolic link points.
Raises:
TypeError: if `path` is None
OSError: (with errno=ENOENT) if path is not a valid path, or
(with errno=EINVAL) if path is valid, but is not a symlink
)r~ r� rS )r3 r� r� r) r) r* r� � s zFakeOsModule.readlinkc C s> |dkrd}nt jdk r td��| �|| j|�}| j�||�S )a� Return the os.stat-like tuple for the FakeFile object of entry_path.
Args:
entry_path: path to filesystem object to retrieve.
dir_fd: (int) If not `None`, the file descriptor of a directory,
with `entry_path` being relative to this directory.
New in Python 3.3.
follow_symlinks: (bool) If `False` and `entry_path` points to a
symlink, the link itself is changed instead of the linked
object.
New in Python 3.3.
Returns:
The FakeStatResult object corresponding to entry_path.
Raises:
OSError: if the filesystem object doesn't exist.
NT)r r z;stat() got an unexpected keyword argument 'follow_symlinks')r; r r6 r~ r� rS )r3 r" r� r# r) r) r* r� � s
zFakeOsModule.statc C s | � || j|�}| jj|dd�S )a� Return the os.stat-like tuple for entry_path, not following symlinks.
Args:
entry_path: path to filesystem object to retrieve.
dir_fd: If not `None`, the file descriptor of a directory, with
`entry_path` being relative to this directory.
New in Python 3.3.
Returns:
the FakeStatResult object corresponding to `entry_path`.
Raises:
OSError: if the filesystem object doesn't exist.
F)r# )r~ r] rS r� )r3 r" r� r) r) r* r] � s zFakeOsModule.lstatc C s | � || j|�}| j�|� dS )a� Remove the FakeFile object at the specified file path.
Args:
path: Path to file to be removed.
dir_fd: If not `None`, the file descriptor of a directory,
with `path` being relative to this directory.
New in Python 3.3.
Raises:
OSError: if path points to a directory.
OSError: if path does not exist.
OSError: if removal failed.
N)r~ r� rS )r3 r� r� r) r) r* r� � s zFakeOsModule.removec C s | � || j|�}| j�|� dS )a� Remove the FakeFile object at the specified file path.
Args:
path: Path to file to be removed.
dir_fd: If not `None`, the file descriptor of a directory,
with `path` being relative to this directory.
New in Python 3.3.
Raises:
OSError: if path points to a directory.
OSError: if path does not exist.
OSError: if removal failed.
N)r~ rb rS r� )r3 r� r� r) r) r* rb � s zFakeOsModule.unlinkc C s" | � || j|�}| j�||� dS )a Rename a FakeFile object at old_file_path to new_file_path,
preserving all properties.
Also replaces existing new_file_path object, if one existed
(Unix only).
Args:
old_file_path: Path to filesystem object to rename.
new_file_path: Path to where the filesystem object will live
after this call.
dir_fd: If not `None`, the file descriptor of a directory,
with `old_file_path` being relative to this directory.
New in Python 3.3.
Raises:
OSError: if old_file_path does not exist.
OSError: if new_file_path is an existing directory.
OSError: if new_file_path is an existing file (Windows only)
OSError: if new_file_path is an existing file and could not
be removed (Unix)
OSError: if `dirname(new_file)` does not exist
OSError: if the file would be moved to another filesystem
(e.g. mount point)
N)r~ r� rS )r3 r� r� r� r) r) r* r� � s zFakeOsModule.renamec C s | j j||dd� dS )a0 Renames a FakeFile object at old_file_path to new_file_path,
preserving all properties.
Also replaces existing new_file_path object, if one existed.
Args:
old_file_path: Path to filesystem object to rename.
new_file_path: Path to where the filesystem object will live
after this call.
Raises:
OSError: if old_file_path does not exist.
OSError: if new_file_path is an existing directory.
OSError: if new_file_path is an existing file and could
not be removed
OSError: if `dirname(new_file)` does not exist
OSError: if the file would be moved to another filesystem
(e.g. mount point)
T)r� N)rS r� )r3 r� r� r) r) r* rI s zFakeOsModule.replacec C s | � || j|�}| j�|� dS )a� Remove a leaf Fake directory.
Args:
target_directory: (str) Name of directory to remove.
dir_fd: If not `None`, the file descriptor of a directory,
with `target_directory` being relative to this directory.
New in Python 3.3.
Raises:
OSError: if target_directory does not exist or is not a directory,
or as per FakeFilesystem.remove_object. Cannot remove '.'.
N)r~ r� rS )r3 r� r� r) r) r* r� 2 s
zFakeOsModule.rmdirc C s� | j �|�}| j �|�}|jr8| j �tj| j�|�� n
| � |� | j�
|�\}}|sf| j�
|�\}}x@|r�|r�| j �|�}|jr�P | j j |dd� | j�
|�\}}qhW dS )a' Remove a leaf fake directory and all empty intermediate ones.
Args:
target_directory: the directory to be removed.
Raises:
OSError: if target_directory does not exist or is not a directory.
OSError: if target_directory is not empty.
T)r� N) rS r| r� ra r� ro r� r� r� r� r� )r3 r� r� r� r� �head_dirr) r) r* r` C s
zFakeOsModule.removedirsc
C sh | � || j|�}y| j�||� W n@ tk
rb } z"|jtjkrP| j�|j|� � W dd}~X Y nX dS )a� Create a leaf Fake directory.
Args:
dir_name: (str) Name of directory to create.
Relative paths are assumed to be relative to '/'.
mode: (int) Mode to create directory with. This argument defaults
to 0o777. The umask is applied to this mode.
dir_fd: If not `None`, the file descriptor of a directory,
with `dir_name` being relative to this directory.
New in Python 3.3.
Raises:
OSError: if the directory name is invalid or parent directory is
read only or as per FakeFilesystem.add_object.
N)r~ r^ rS r� r� ro r� r� )r3 r] r1 r� r� r) r) r* r^ _ s zFakeOsModule.mkdirc C s4 |dkrd}nt jdk r td��| j�|||� dS )a� Create a leaf Fake directory + create any non-existent parent dirs.
Args:
dir_name: (str) Name of directory to create.
mode: (int) Mode to create directory (and any necessary parent
directories) with. This argument defaults to 0o777.
The umask is applied to this mode.
exist_ok: (boolean) If exist_ok is False (the default), an OSError
is raised if the target directory already exists.
New in Python 3.2.
Raises:
OSError: if the directory already exists and exist_ok=False, or as
per :py:meth:`FakeFilesystem.create_dir`.
NF)r rw z7makedir() got an unexpected keyword argument 'exist_ok')r; r r6 rS r� )r3 r] r1 r� r) r) r* r� w s
zFakeOsModule.makedirsc C s� |dk r~t jdk r td|j ��tt|j�}|| jkr>td��t|t �rVt
d|j ��| j � |�s~| j �
| j�|��� j |�S |S )z@Return the path considering dir_fd. Raise on nmvalid parameters.N)r r z0%s() got an unexpected keyword argument 'dir_fd'z#dir_fd unavailable on this platformz.%s: Can't specify dir_fd without matching path)r; r r6 r6 r� r� �supports_dir_fdr� rd r4 rR r� r0 r{ rS rG r< )r3 r� �fctr� �real_fctr) r) r* r~ � s
z FakeOsModule._path_with_dir_fdc
C s� |dk rt jdk rtd��| �|| j|�}y| j||d�}W n4 tk
rp } z|jtjkr^dS � W dd}~X Y nX t � r�|t
j M }||j d? d@ @ |kS )a� Check if a file exists and has the specified permissions.
Args:
path: (str) Path to the file.
mode: (int) Permissions represented as a bitwise-OR combination of
os.F_OK, os.R_OK, os.W_OK, and os.X_OK.
dir_fd: If not `None`, the file descriptor of a directory, with
`path` being relative to this directory.
New in Python 3.3.
follow_symlinks: (bool) If `False` and `path` points to a symlink,
the link itself is queried instead of the linked object.
New in Python 3.3.
Returns:
bool, `True` if file is accessible, `False` otherwise.
N)r r z=access() got an unexpected keyword argument 'follow_symlinks')r# Fru rg )
r; r r6 r~ rV r� r� ro r' r/ r� �W_OKrD )r3 r� r1 r� r# rX �os_errorr) r) r* rV � s zFakeOsModule.accessc C sD |dkrd}nt jdk r td��| �|| j|�}| j�|||� dS )a Change the permissions of a file as encoded in integer mode.
Args:
path: (str) Path to the file.
mode: (int) Permissions.
dir_fd: If not `None`, the file descriptor of a directory, with
`path` being relative to this directory.
New in Python 3.3.
follow_symlinks: (bool) If `False` and `path` points to a symlink,
the link itself is queried instead of the linked object.
New in Python 3.3.
NT)r r z<chmod() got an unexpected keyword argument 'follow_symlinks')r; r r6 r~ r2 rS )r3 r� r1 r� r# r) r) r* r2 � s
zFakeOsModule.chmodc C s& | j jrtdf�| j j||dd� dS )z�Change the permissions of a file as encoded in integer mode.
If the file is a link, the permissions of the link are changed.
Args:
path: (str) Path to the file.
mode: (int) Permissions.
z name 'lchmod' is not definedF)r# N)rS rV � NameErrorr2 )r3 r� r1 r) r) r* r\ � s zFakeOsModule.lchmodc C s` |dkrd}nt jdk r td��| �|| j|�}|dk rJt jdk rJtd��| j�||||� dS )a� Change the access and modified times of a file.
Args:
path: (str) Path to the file.
times: 2-tuple of int or float numbers, of the form (atime, mtime)
which is used to set the access and modified times in seconds.
If None, both times are set to the current time.
ns: 2-tuple of int numbers, of the form (atime, mtime) which is
used to set the access and modified times in nanoseconds.
If None, both times are set to the current time.
New in Python 3.3.
dir_fd: If not `None`, the file descriptor of a directory,
with `path` being relative to this directory.
New in Python 3.3.
follow_symlinks: (bool) If `False` and `path` points to a symlink,
the link itself is queried instead of the linked object.
New in Python 3.3.
Raises:
TypeError: If anything other than the expected types is
specified in the passed `times` or `ns` tuple,
or if the tuple length is not equal to 2.
ValueError: If both times and ns are specified.
NT)r r z<utime() got an unexpected keyword argument 'follow_symlinks'z/utime() got an unexpected keyword argument 'ns')r; r r6 r~ r; rS )r3 r� r7 r8 r� r# r) r) r* r; � s
zFakeOsModule.utimec
C s� |dkrd}nt jdk r td��| �|| j|�}y| jj||dd�}W n@ tk
r� } z"|jtj krt| j�
tj |� � W dd}~X Y nX t |�s�|dkr�t |�s�|dks�td��|dkr�||_ |dkr�||_
dS )aI Set ownership of a faked file.
Args:
path: (str) Path to the file or directory.
uid: (int) Numeric uid to set the file or directory to.
gid: (int) Numeric gid to set the file or directory to.
dir_fd: (int) If not `None`, the file descriptor of a directory,
with `path` being relative to this directory.
New in Python 3.3.
follow_symlinks: (bool) If `False` and path points to a symlink,
the link itself is changed instead of the linked object.
New in Python 3.3.
Raises:
OSError: if path does not exist.
`None` is also allowed for `uid` and `gid`. This permits `os.rename`
to use `os.chown` even when the source file `uid` and `gid` are
`None` (unset).
NT)r r z<chown() got an unexpected keyword argument 'follow_symlinks')r zAn integer is requiredrM )r; r r6 r~ rX rS r r� ro r' r� r rH rI )r3 r� r( r- r� r# r$ r% r) r) r* rX s(
zFakeOsModule.chownc
C s. | j jrtdf�|dkr tdB }|s2|t@ s@t� s@| j �tj� | �|| j |�}| j
� |�\}}|s�| j j |dd�r�| j �tj
|� | j �tj|� |dkr�| j �tj|� | j j |dd�r�| j �tj
|� y(| j �|t||| j j @ | j d�� W n4 tk
�r( } z| j �|j|� W dd}~X Y nX dS )a9 Create a filesystem node named 'filename'.
Does not support device special files or named pipes as the real os
module does.
Args:
filename: (str) Name of the file to create
mode: (int) Permissions to use and type of file to be created.
Default permissions are 0o666. Only the stat.S_IFREG file type
is supported by the fake implementation. The umask is applied
to this mode.
device: not supported in fake implementation
dir_fd: If not `None`, the file descriptor of a directory,
with `filename` being relative to this directory.
New in Python 3.3.
Raises:
OSError: if called with unsupported options or the file can not be
created.
z%module 'os' has no attribute 'mknode'Ni� T)r� )r� rL s ..z..)rS )rS rV r� r r/ r� ro r� r~ r_ r� r� r� r� r' r� rC r� r� )r3 r� r1 �devicer� r� r� r� r) r) r* r_ 1 s,
zFakeOsModule.mknodc C s& | � || j|�}| jj||dd� dS )a� Creates the specified symlink, pointed at the specified link target.
Args:
link_target: The target of the symlink.
path: Path to the symlink to create.
dir_fd: If not `None`, the file descriptor of a directory,
with `link_target` being relative to this directory.
New in Python 3.3.
Raises:
OSError: if the file already exists.
F)r� N)r~ ra rS r� )r3 r� r� r� r) r) r* ra ` s
zFakeOsModule.symlinkc C s" | � || j|�}| j�||� dS )a� Create a hard link at new_path, pointing at old_path.
Args:
oldpath: An existing link to the target file.
newpath: The destination path to create a new link at.
dir_fd: If not `None`, the file descriptor of a directory,
with `oldpath` being relative to this directory.
New in Python 3.3.
Returns:
The FakeFile object referred to by `oldpath`.
Raises:
OSError: if something already exists at new_path.
OSError: if the parent directory doesn't exist.
OSError: if on Windows before Python 3.2.
N)r~ r� rS )r3 �oldpathrM r� r) r) r* r� q s zFakeOsModule.linkc C s` d| krt k r&n n| j�tj� | j�|�}| jjr\t|d�rJ|js\| j�tj |j
� dS )a Perform fsync for a fake file (in other words, do nothing).
Args:
file_des: The file descriptor of the open file.
Raises:
OSError: file_des is an invalid file descriptor.
TypeError: file_des is not an integer.
r � allow_updateN) �NR_STD_STREAMSrS r� ro r( rG rV r! r� rF r4 )r3 rD r$ r) r) r* r[ � s
zFakeOsModule.fsyncc C sN | j js| j jrtd��d| kr,tk r>n n| j �tj� | j �|� dS )a Perform fdatasync for a fake file (in other words, do nothing).
Args:
file_des: The file descriptor of the open file.
Raises:
OSError: file_des is an invalid file descriptor.
TypeError: file_des is not an integer.
z(module 'os' has no attribute 'fdatasync'r N) rS rV r� r� r� r� ro r( rG )r3 rD r) r) r* rd � s
zFakeOsModule.fdatasyncc C s t | j|�S )z5Forwards any unfaked calls to the standard os module.)r� rj )r3 rU r) r) r* r� � s zFakeOsModule.__getattr__)N)r N)NN)N)T)NT)T)r T)r )TNF)N)NN)N)N)N)N)N)NN)NN)NNNN)NN)NNN)N)N);r6 r7 r8 r9 r� r� r5 r2 rm rk ru r� rY r� rc r� rZ r� rW r@ r r> r? r� r; r r� r� re rf rg rh r
r r r� r� r] r� rb r� rI r� r` r� r^ r� r~ rV r2 r\ r; rX r_ ra r� r[ rd r� r) r) r) r* rU �
sr
C
!
$
*
/
rU c @ s6 e Zd ZdZedd� �Zdd� Zdd
d �Zd d
� ZdS )� FakeIoModulea( Uses FakeFilesystem to provide a fake io module replacement.
Currently only used to wrap `io.open()` which is an alias to `open()`.
You need a fake_filesystem to use this:
filesystem = fake_filesystem.FakeFilesystem()
my_io_module = fake_filesystem.FakeIoModule(filesystem)
c C s dS )zqReturn the list of patched function names. Used for patching
functions imported from the module.
)r� r) r) r) r) r* r5 � s zFakeIoModule.dirc C s || _ t| _dS )zg
Args:
filesystem: FakeFilesystem used to provide file system information.
N)rS r� �
_io_module)r3 rS r) r) r* r2 � s zFakeIoModule.__init__r rM NTc
C s> |dk rt jdk rtd��t| jdd�} | ||||||||�S )z\Redirect the call to FakeFileOpen.
See FakeFileOpen.call() for description.
N)r r z2open() got an unexpected keyword argument 'opener'T)�use_io)r; r r6 ro rS )
r3 �filer1 � bufferingrY rZ �newline�closefd�opener� fake_openr) r) r* r� � s zFakeIoModule.openc C s t | j|�S )z5Forwards any unfaked calls to the standard io module.)r� r� )r3 rU r) r) r* r� � s zFakeIoModule.__getattr__)r rM NNNTN) r6 r7 r8 r9 r� r5 r2 r� r� r) r) r) r* r� � s
r� c
@ s e Zd ZdZd@dd�Zdd� Zd d
� Zd d � Zd
d� Zdd� Z dd� Z
e dd� �Z dd� Z
dd� Zdd� ZdAd d �Zd d � Zd d!� Zd"d#� Zd$d%� Zd&d'� Zd(d)� Zd*d+� Zd,d-� Zd.d/� Zd0d1� Zd2d3� Zd4d5� Z d6d7� Z d8d9� Z d:d;� Z d<d=� Z d>d?� Z!dS )B�FakeFileWrapperz�Wrapper for a stream object for use by a FakeFile object.
If the wrapper has any data written to it, it will propagate to
the FakeFile object on close() or flush().
FNTc C s || _ || _|| _|| _|| _|
| _|j| _|
| _| | _ || _
d| _ |j }| pVt
�d�| _| p`d} ||jkrptnt}|||�� | | || d�| _d| _d| _d| _|r�t|�| _|r�|s�| j�d� n"| j�| j� |r�|r�| j�� | _|r�|s�td��|| _ || _ |j | _ d | _ d S )NFrQ )ri �binaryrY r� rZ r z(delete_on_close=True requires filesystem)!r$ r4 �_append�_readr� �_closefdr^ � _file_epochr� �_binary� is_stream�_changedrc rg rh � _encodingr� r r r� �_io� _read_whence�
_read_seek�
_flush_posr] �seek�tellr� � _filesystemr} � opened_asrU r� )r3 r$ r4 �updater� r? r} rS r� r� r� rY rZ r� r� r� ra � buffer_classr) r) r* r2 � sH
zFakeFileWrapper.__init__c C s | S )z=To support usage of this fake file with the 'with' statement.r) )r3 r) r) r* � __enter__ s zFakeFileWrapper.__enter__c C s | � � dS )z=To support usage of this fake file with the 'with' statement.N)rY )r3 �typer� � tracebackr) r) r* �__exit__ s zFakeFileWrapper.__exit__c C s2 | j r| j�tj| j� tr$t|��t� |��d S )N)
r� r� r� ro rF r4 r r� r� �UnsupportedOperation)r3 r� r) r) r* �_raise s
zFakeFileWrapper._raisec C s | j S )zLReturn the FakeFile object that is wrapped by the current instance.
)r$ )r3 r) r) r* r< s zFakeFileWrapper.get_objectc C s | j S )z.Return the file descriptor of the file object.)r� )r3 r) r) r* r� # s zFakeFileWrapper.filenoc C s� | � � s dS | jr:| js:| �� | jjr:| jr:t�� | j_ | j
rP| j� | j � n| jj
| j �| � | jr|| j�| �� j� dS )zClose the file.N)�_is_openr� r� r� r� rV r� rW r$ rL r� rE r� r� r� r} r� r< r� )r3 r) r) r* rY ' s zFakeFileWrapper.closec C s
| � � S )z(Simulate the `closed` attribute on file.)r� )r3 r) r) r* �closed9 s zFakeFileWrapper.closedc C s� | � � | jr�| js�| j�� }| jrj| �� t|�r<| jj n| jj
}||| j d� }| � |� | �
� n
| j�� | j�|| j�r�| jjr�d| _nt�� }|| j_|| j_| jj| _| js�| �� dS )z Flush file contents to 'disk'.NT)�_check_open_filer� r� r� �getvaluer� r� r r$ rc ra r� �_set_stream_contentsr� r� rv r� r� rV r� rW rM rL r^ r� �_flush_related_files)r3 ra � old_contentsr: r) r) r* r� > s(
zFakeFileWrapper.flushc C s | j �� | _d S )N)r� r� r� )r3 r) r) r* r� Y s z FakeFileWrapper.update_flush_posc C sV xP| j jdd � D ]<}|d k rx.|D ]&}|| k r$| j|jkr$|js$|�� q$W qW d S )Nr )r� r� r$ r� r� )r3 r� � open_filer) r) r* r� \ s
z$FakeFileWrapper._flush_related_filesr c C s< | � � | js | j�||� n || _|| _| js8| �� dS )z"Move read/write pointer in 'file'.N)r� r� r� r� r� r� r� r� )r3 �offset�whencer) r) r* r� e s zFakeFileWrapper.seekc C sn | � � | �� r| �� | js(| j�� S | jrh| j�� }| j�| j| j� | j�� | _d| _| j�|� | jS )zoReturn the file's current position.
Returns:
int, file's current position in bytes.
r ) r� �_flushes_after_tellr� r� r� r� r� r� r� )r3 �
write_seekr) r) r* r� p s
zFakeFileWrapper.tellc C s | j o| jj pt S )N)r� r� rV r )r3 r) r) r* �_flushes_after_read� s z#FakeFileWrapper._flushes_after_readc C s | j o| jjpt S )N)r� r� r� r )r3 r) r) r* r� � s z#FakeFileWrapper._flushes_after_tellc C sD | j | jjkrdS | jjr$| jj}n| jj}| �|� | jj| _ dS )z;Update the stream with changes to the file object contents.N)r� r$ r^ r� r� rc ra r� )r3 ra r) r) r* r� � s
zFakeFileWrapper._sync_ioc C s^ | j �� }| j �d� | j �� | j js<t|�r<|�| j�}| j �|� | j sZ| j �|� d S )Nr )
r� r� r� ry r� r rf r� �putvaluer� )r3 ra r� r) r) r* r� � s
z$FakeFileWrapper._set_stream_contentsc s t �j|�� � �fdd�}|S )a_ Wrap a stream attribute in a read wrapper.
Returns a read_wrapper which tracks our own read pointer since the
stream object has no concept of a different read and write pointer.
Args:
name: The name of the attribute to wrap. Should be a read call.
Returns:
The read_wrapper function.
c s@ �j ��j�j� � | |�}�j �� �_d�_�j �dd� |S )a� Wrap all read calls to the stream object.
We do this to track the read pointer separate from the write
pointer. Anything that wants to read from the stream object
while we're in append mode goes through this.
Args:
*args: pass through args
**kwargs: pass through kwargs
Returns:
Wrapped stream object method
r rw )r� r� r� r� r� )rp rq � ret_value)�io_attrr3 r) r* � read_wrapper� s
z4FakeFileWrapper._read_wrappers.<locals>.read_wrapper)r� r� )r3 rU r� r) )r� r3 r* �_read_wrappers� s z FakeFileWrapper._read_wrappersc s t �j|�� � ��fdd�}|S )z�Wrap a stream attribute in an other_wrapper.
Args:
name: the name of the stream attribute to wrap.
Returns:
other_wrapper which is described below.
c sD �j �� }� | |�}|�j �� kr4�j �� �_d�_�r<ts@|S dS )a� Wrap all other calls to the stream Object.
We do this to track changes to the write pointer. Anything that
moves the write pointer in a file open for appending should move
the read pointer as well.
Args:
*args: Pass through args.
**kwargs: Pass through kwargs.
Returns:
Wrapped stream object method.
r N)r� r� r� r� r )rp rq r� r� )r� r3 �writingr) r* �
other_wrapper� s
z5FakeFileWrapper._other_wrapper.<locals>.other_wrapper)r� r� )r3 rU r� r� r) )r� r3 r� r* �_other_wrapper� s z FakeFileWrapper._other_wrapperc C s\ xV| j jdd � D ]B}|d k rx4|D ],}|| k r$| j|jkr$|jr$| j|7 _q$W qW d S )Nr )r� r� r$ r� r� )r3 rk r� r� r) r) r* � _adapt_size_for_related_files� s
z-FakeFileWrapper._adapt_size_for_related_filesc s t �jd�� � �fdd�}|S )zwWrap truncate() to allow flush after truncate.
Returns:
Wrapper which is described below.
ry c s� �j r�j��j�j� � | |�}��� �js�|�j_t �j�
� �}||k r��j�|� �j� d|| � �j� �j�
� �j
� |�_�jjs�tjd dkr���|| � ��� ts�|S dS )z0Wrap truncate call to call flush after truncate.r� r rw N)r� r� r� r� r� r� r� r$ rk r] r� rc rv r� r� r� r� r; r r� r )rp rq rk � buffer_size)r� r3 r) r* �truncate_wrapper� s$
z;FakeFileWrapper._truncate_wrapper.<locals>.truncate_wrapper)r� r� )r3 r� r) )r� r3 r* �_truncate_wrapper� s z!FakeFileWrapper._truncate_wrapperc s t | j|�� � fdd�}|S )zyWrap write() to adapt return value for Python 2.
Returns:
Wrapper which is described below.
c s � | |�}t s|S dS )z*Wrap all write calls to the stream object.N)r )rp rq r� )r� r) r* �
write_wrapper s
z5FakeFileWrapper._write_wrapper.<locals>.write_wrapper)r� r� )r3 rU r� r) )r� r* �_write_wrapper s z FakeFileWrapper._write_wrapperc C s | j jS )z5Return the content size in bytes of the wrapped file.)r$ rJ )r3 r) r) r* rk # s zFakeFileWrapper.sizec C s� | j �� rt| j��|�d�p$|dk}|dk}|�d�p:|}|sD|rL| �� | js^|r^| �� S | jsp|rp| � � S |r�| �
� | � � r�| � � | j
js�t�� | j _|r�| �� S | jr�|r�| �|�S | �||�S |r�| �|�S t| j|�S )Nr� �nextry rc )r$ rq r0 r4 r r� r� � _read_errorr� � _write_errorr� r� r� r� rV rW rK r� r� r� r� r� r� r� )r3 rU �readingry r� r) r) r* r� ' s4
zFakeFileWrapper.__getattr__c s � fdd�}|S )Nc s: | r,| d dkr,� j jr,� jr,� jr(dS dS � �d� dS )z+Throw an error unless the argument is zero.r r� r z File is not open for reading.N)r� rV r� r� r� )rp rq )r3 r) r* �
read_errorI s z/FakeFileWrapper._read_error.<locals>.read_errorr) )r3 r� r) )r3 r* r� H s zFakeFileWrapper._read_errorc s � fdd�}|S )Nc s4 � j r&� jjr&| r&t| d �dkr&dS � �d� dS )zThrow an error.r z File is not open for writing.N)r� r� rV r] r� )rp rq )r3 r) r* � write_errorS s
z1FakeFileWrapper._write_error.<locals>.write_errorr) )r3 r� r) )r3 r* r� R s z FakeFileWrapper._write_errorc C s6 | j t| jj�k o4| jj| j d k o4| | jj| j kS )N)r� r] r� r� )r3 r) r) r* r� ] s zFakeFileWrapper._is_openc C s | j s| �� std��d S )Nz I/O operation on closed file)r� r� rR )r3 r) r) r* r� b s z FakeFileWrapper._check_open_filec C s | j s| �d� | j�� S )Nz File is not open for reading)r� r� r� �__iter__)r3 r) r) r* r� f s
zFakeFileWrapper.__iter__)
FFFFNNTTNNFFT)r )"r6 r7 r8 r9 r2 r� r� r� r< r� rY r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� r� rk r� r� r� r� r� r� r) r) r) r* r� � sB
+
$# !
r� c @ s8 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
d � Zd S )
r� zHWrapper for a system standard stream to be used in open files list.
c C s || _ d | _d S )N)�_stream_objectr� )r3 �
stream_objectr) r) r* r2 p s z StandardStreamWrapper.__init__c C s | j S )N)r� )r3 r) r) r* r< t s z StandardStreamWrapper.get_objectc C s | j S )z:Return the file descriptor of the wrapped standard stream.)r� )r3 r) r) r* r� w s z StandardStreamWrapper.filenoc C s dS )z+We do not support closing standard streams.Nr) )r3 r) r) r* rY { s zStandardStreamWrapper.closec C s dS )NTr) )r3 r) r) r* r� s z StandardStreamWrapper.is_streamN) r6 r7 r8 r9 r2 r< r� rY r� r) r) r) r* r� l s r� c @ s0 e Zd ZdZdd� Zdd� Zdd� Zdd � Zd
S ) r� zFWrapper for a FakeDirectory object to be used in open files list.
c C s || _ || _|| _d | _d S )N)r$ r4 r� r� )r3 r$ r4 rS r) r) r* r2 � s zFakeDirWrapper.__init__c C s | j S )zLReturn the FakeFile object that is wrapped by the current instance.
)r$ )r3 r) r) r* r< � s zFakeDirWrapper.get_objectc C s | j S )z.Return the file descriptor of the file object.)r� )r3 r) r) r* r� � s zFakeDirWrapper.filenoc C s | j �| j� dS )zClose the directory.N)r� rE r� )r3 r) r) r* rY � s zFakeDirWrapper.closeN)r6 r7 r8 r9 r2 r< r� rY r) r) r) r* r� � s
r� �Sizec @ sJ e Zd ZdZd Z ddd�Zdd� Zdd
d �Zdd
d�Zdd� Zdd� Z d S )ro z�Faked `file()` and `open()` function replacements.
Returns FakeFile objects in a FakeFilesystem in place of the `file()`
or `open()` function.
Fc C sB || _ || _to| | _|p4t p4t�� dkp4| j j| _|| _dS )a5
Args:
filesystem: FakeFilesystem used to provide file system information
delete_on_close: optional boolean, deletes file on close()
use_io: if True, the io.open() version is used (ignored for Python 3,
where io.open() is an alias to open() )
�PyPyN) rS �_delete_on_closer �
_py2_newlinesr� �python_implementationr� �_use_ior� )r3 rS r} r� r� r) r) r* r2 � s
zFakeFileOpen.__init__c O s" | j r| j||�S | j||�S dS )z:Redirects calls to file() or open() to appropriate method.N)r� rr �
_call_ver2)r3 rp rq r) r) r* �__call__� s zFakeFileOpen.__call__r rM Nc C s |p|}| j ||||d�S )z8Limits args of open() or file() for Python 2.x versions.)r )rr )r3 r4 r1 r� r� r r) r) r* r� � s zFakeFileOpen._call_ver2Tc
C s d|k}
| � ||| �\}} | �|�\} } }
}|
s4d}| jrB| jjn| jj}| jrt| sh| j�| �rt| jjst|t j
| � | r�t � s�| j r�| j
t@ r�| jr�| j
t@ s�|t j| � | jr�| jr�| �d� n�| jr�|t j| � | j�| �r�| jj| dd�}|j}n| }| j�|��r:| jj�rt jn| jj�r*t jnt j}||| � | jj |dd| jd�} t | j
��r�| jj�rt|t j| � n |t j| � | | _ | j�r�t � � }|| _ | jj�s�|| _!t"| | | j| j | j#| j$| j||
|||| j| j%d�}|
dk �r|
|_&| jj'|
�#|� n| j�(|�|_&|S ) ad Return a file-like object with the contents of the target
file object.
Args:
file_: Path to target file or a file descriptor.
mode: Additional file modes (all modes in `open()` are supported).
buffering: ignored. (Used for signature compliance with
__builtin__.open)
encoding: The encoding used to encode unicode strings / decode
bytes.
errors: (str) Defines how encoding errors are handled.
newline: Controls universal newlines, passed to stream object.
closefd: If a file descriptor rather than file name is passed,
and this is set to `False`, then the file descriptor is kept
open when file is closed.
opener: not supported.
open_modes: Modes for opening files if called from low-level API.
Returns:
A file-like object containing the contents of the target file.
Raises:
IOError, OSError depending on Python version / call mode:
- if the target object is a directory
- on an invalid path
- if the file does not exist when it should
- if the file exists but should not
- if permission is denied
ValueError: for an invalid mode or mode combination
r{ Tr F)r# )r� r� r� ) r� r� r? r} rS r� r� r� rY rZ r� r� N))�_handle_file_mode�_handle_file_argr� rS r� rn rz r� rV ro r� r/ rw rD � PERM_READrx r� r� ry rv rv r' r ra r& r( r� r� r� r r� rW rL rM r� r? r� r� r� r� rB )r3 �file_r1 r� rY rZ r� r� r� r r� r$ r4 r� � real_pathr� r+ r� r� r: �fakefiler) r) r* rr � s� !
zFakeFileOpen.callc C s� d }t |t�rB|}| j�|�}|j| _| j�|��� }|j}|}nNd }|}|| jjjkrf| jj}|}n*| jj || j
d�}| j� |�r�| j� |�}||||fS )N)r� )
rd r4 rS rG r} r� r< rU r� r� r� r� r� )r3 r� r$ r� �wrapperr4 r� r) r) r* r� 6 s&
z FakeFileOpen._handle_file_argc C s� |}d|kr,d|kr,t r | jjr,td| ��|�dd��dd�}| jrRd|krRd}|�dd��dd�}| js�|tkr�td | ��tt| � }||fS )
Nr{ �tzInvalid mode: r �U�-�rUr zInvalid mode: %r) r rS rV rR rI r� r� �_OPEN_MODE_MAPr )r3 r1 r� r �
orig_modesr) r) r* r� O s z FakeFileOpen._handle_file_mode)FFF)r rM NN)r rM NNNTNN)
r6 r7 r8 r9 r2 r� r� rr r� r� r) r) r) r* ro � s
nro c C s dd l } ddlm} | �|�S )Nr )�fake_filesystem)�doctest�pyfakefsr �testmod)r r r) r) r* � _run_doctesta s r �__main__)�r9 ro r= r� rg r� r� r; rW r9 � collectionsr r� r r r r r r r �pyfakefs.deprecatorr
�pyfakefs.fake_scandirr r �pyfakefs.extra_packagesr
�pyfakefs.helpersr r r r r r r r r r �
__pychecker__� __version__r� r� r� r� r� r0 r r r r r� r; r� �getuidr' �getgidr, r+ r. r/ � Exceptionr0 rB �objectrC r� �addrm rv rq r� r� r� r� r� r� r� r r rl r� r2 r; rB rE r� rG rK rU r r| rf r rz rZ ra r� r� r� r< r r� r� r� r� r r� r� r� r� r� r� r� r} r� r� r� r� r� r) rU r� r� r� r� rk ro r r6 r) r) r) r* �<module>_ s< $ 0 P( @ .
* C