g ` d Z ddlZddlZddlZddlZddlZddlZddlZddlZddl m
Z
m Z ddl m
Z
ddlmZ ddlmZmZmZmZmZmZmZ ddlmZmZmZm Z m Z m Z m Z m Z m!Z!m"Z"m#Z# ddl$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z* dd l+m,Z,m-Z- dd
l.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7 ej8 9 d rd Z:nd
Z: G d de Z;e%j< Z Z>e%j? Z?e%j@ Z@e%jA ZAe%jB ZBe%jC ZCe%jD ZDe&jE ZEe(jF ZFe*jG ZGe'jH ZHej8 dk re'jI ZIe'jJ ZJe)jK ZKe)jL ZLe)jM ZMe)jN ZNe)jO ZOe)jP ZPe)jQ ZQe)jR ZRe)jS ZSe)jT ZTe)jU ZUe)jV ZV G d d ZWde
fdZXd ZYeZdk r eX dS dS )a" A fake filesystem implementation for unit testing.
:Usage:
>>> from pyfakefs import fake_filesystem, fake_os
>>> filesystem = fake_filesystem.FakeFilesystem()
>>> os_module = fake_os.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 OSError 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 OrderedDict) TestResults)Enum)S_IFREGS_IFDIRS_ISLNKS_IFMTS_ISDIRS_IFLNKS_ISREG) ListCallableUnionAnyDictTuplecastAnyStroverloadNoReturnOptional) fake_file fake_pathfake_iofake_oshelpers fake_open)AnyFileWrapperAnyFile) is_int_typemake_string_path to_stringmatching_stringAnyPath AnyStringWINDOWS_PROPERTIESPOSIX_PROPERTIESFSTypelinux( c e Zd ZdZdZdZdZdS )OSTypez?Defines the real or simulated OS of the underlying file system.r* macoswindowsN)__name__
__module__ __qualname____doc__LINUXMACOSWINDOWS j/builddir/build/BUILD/cloudlinux-venv-1.0.10/venv/lib/python3.11/site-packages/pyfakefs/fake_filesystem.pyr. r. s# II E EGGGr9 r. win32c e Zd ZdZej j dddfdedee de
de ddf
d Z e
de fd
Ze
de fd Zej d e ddfd
Ze
de fd Zej d e ddfd Ze
defd Zej d eddfd Ze
dee fd Zej d ee ddfd Ze
defd Ze
defd Ze
defd Ze
defd Zej d eddfd Ze
defd Ze
defd Ze
defd Zej d eddfd Zddee d e fd Z e j d e fd! Z d" Z!dd#Z"dd$Z#dd%Z$ dd&e d'ee% d(ee de&fd)Z'd*e(de(fd+Z)d*e(dee( fd,Z*d*e(de fd-Z+ dd*e(dee d.e de,fd/Z-d0e.defd1Z/d*e(dee, fd2Z0d*e(de,fd3Z1defd4Z2d5e dee, fd6Z3dd*ee( de4e e e f fd7Z5dde d*ee( ddfd8Z6d9e d:e(d;e ddfd<Z7dd=e(d>e fd?Z8 dd=e(d@e9d>e dAe ddf
dBZ: dd*e;e(e f dCe d>e dDe ddf
dEZ< ddd dFd*e(dGee4e;e e=f e;e e=f f dHee4e e f d>e ddf
dIZ>e?dHee4e e f dGee4e;e e=f e;e e=f f fdJ Z@ddLeAdMe de fdNZBdOe ddfdPZCdOe deAfdQZDdOe deEeA fdRZFd@e9de fdSZGd*e(de(fdTZHd*e(de(fdUZId*e(de(fdVZJd*e(de(fdWZKd*e(de(fdXZLd*e(de4e(e(f fdYZMd*e(de4e(e(f fdZZNd*e(fd[ZOd\e(de(fd]ZPd^e(de(fd_ZQeRd*edeEe fd` ZSeRd*eTdeEeT fda ZSd*e(deEe( fdbZSd:e(de fdcZUd:e(de fddZVd*e(de(fdeZWd:e(de fdfZXd:e(de fdgZYd*e;e e.f de fdhZZd*e(de fdiZ[djedkede4ee ee\ f fdlZ]dd:e.dme de fdnZ^dd:e(doe de(fdpZ_dq Z`dreEe( deEe fdsZad:e(de fdtZbdueEe dve\defdwZc dd:e.dxe dye dze de\f
d{Zde?d| Ze dd:e.dxe dye de9fd}Zfd:e.de9fd~Zg dd:e;e(e f d>e doe dxe dye dze de9fdZhd*e.de9fdZid:e(d@e\ddfdZj dde.de.de ddfdZkd Zld*e(ddfdZmde(de(de ddfdZnde de(de(de9de dee( f dZode de(de9de9de ddf dZpde(de(dee( fdZqd:e(ddfdZrd*e.de(fdZsetju d fd0e.de de defdZvewetjx z ddd d dddfd:e.de de%dee de de dee dee deey de9fdZz dde.de dee. de9fdZ{ dde.dee. de9fdZ| dde.de de dee. def
dZ}d Z~d Z ddeEe( de de ddfdZdeddfdZewetjx z ddd d ddddf d:e.de de%dee de de dee dee de deey de9fdZ dd:e.de.de de9fdZ dde.de.d>e de de9f
dZ dde.de.d>e de9fdZde9de fdZd*e.defdZetju fde.dCe ddfdZd*e(de(fdZetju dfde(dCe de ddfdZ dd*e.de d>e de fdZdd*e.d>e de fdZdd*e.d>e de fdZd*e.de fdZej dk rd*e.de fdZ dde(dxe dye dze def
dĄZd*e(ddfdńZdde(de ddfdDŽZde(deEe( fdȄZdefdɄZej dk rM eh dˣd̄ dD z d΄ dD z Z edτ edЦ D h dѣz Zd҄ ZddӄZdԄ ZdՄ ZdS )FakeFilesystemaB Provides the appearance of a real directory tree for unit testing.
Attributes:
is_case_sensitive: `True` if a case-sensitive file system is assumed.
root: The root :py:class:`FakeDirectory` entry
of the file system.
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.
patch_open_code: Defines how
`io.open_code `__
will be patched; patching can be on, off, or in automatic mode.
shuffle_listdir_results: If `True`, `os.listdir` will not sort the
results to match the real file system behavior.
NFpath_separator
total_sizepatchercreate_temp_dirreturnc || _ || _ t j dk | _ t j dk | _ | j p| j | _ t j | _ | j rt nt }t j
| t t g| _ || _ | d| _ t# j d | _ t# j | j g | _ g | _ d| _ d| _ t/ | _ d| _ | |d t6 j | _ d| _ dS ) ap
Args:
path_separator: optional substitute for os.path.sep
total_size: if not `None`, the total size in bytes of the
root filesystem.
patcher: the Patcher instance if created from the Patcher
create_temp_dir: If `True`, a temp directory is created on initialization.
Under Posix, if the temp directory is not `/tmp`, a link to the temp
path is additionally created at `/tmp`.
Example usage to use the same path separator under all systems:
>>> filesystem = FakeFilesystem(path_separator='/')
r; darwin r NF)r? init_pathlib) r@ rA sysplatform_is_windows_fs _is_macosis_case_sensitiver) DEFAULTfs_typer' r( dataclassesreplace
fs_propertiesr> _cwdosumask
open_files
_free_fd_heaplast_inolast_devr mount_pointsdev_nullreset PatchModeOFFpatch_open_codeshuffle_listdir_results)selfr> r? r@ rA base_propertiess r: __init__zFakeFilesystem.__init__ s+ , . "lg 5 1 -1,?,Q4>'R ~ "&"5 K ;K
0 0
- (4..
AC(*
3>== !
ju
=== )} ',$$$r9 c " | j o| j S )z4Returns `True` in a real or faked Linux file system.)
is_windows_fsis_macosr` s r: is_linuxzFakeFilesystem.is_linux s %%;dm*;;r9 c d | j t j k p| j t j k o| j S )z6Returns `True` in a real or faked Windows file system.)rN r) r7 rM rJ rf s r: rd z FakeFilesystem.is_windows_fs s. |v~-
LFN * Bt/B
r9 valuec | j |k r@|| _ |rd| _ | t | d S d S NF)rJ rK r[ FakePathModuler` ri s r: rd z FakeFilesystem.is_windows_fs sV % ' '"'D
'!& JJLLL & & & & & ( 'r9 c | j S )z4Returns `True` in a real or faked macOS file system.)rK rf s r: re zFakeFilesystem.is_macos' s ~ r9 c | j |k r@|| _ |rd| _ | t | d S d S rk )rK rJ r[ rl rm s r: re zFakeFilesystem.is_macos, sU >U " " "DN
,&+# JJLLL & & & & & # "r9 c : | j | j j j S )z9Returns the path separator, corresponds to `os.path.sep`.)rQ rN ri seprf s r: r> z FakeFilesystem.path_separator5 s !$,"4599r9 c \ || j d _ |t j k r d | _ d S d S Nr )rQ rq rS alternative_path_separatorrm s r: r> z FakeFilesystem.path_separator: s2 $)1 ! BF??.2D + + + ?r9 c : | j | j j j S )zHReturns the alternative path separator, corresponds to `os.path.altsep`.)rQ rN ri altseprf s r: rt z)FakeFilesystem.alternative_path_separator@ s !$,"45< rR _auto_mount_drive_if_needed)r` ri rR s r: r zFakeFilesystem.cwdZ s`
&&LL D"& ) )?4AT+U+U
((/////r9 c F | j r| S | j S )ziReturn the root directory, which represents "/" under POSIX,
and the current drive under Windows.)rd _mount_point_dir_for_cwdrootrf s r: root_dirzFakeFilesystem.root_dire s) 30022 2yr9 c t | j j }| | j s
|| j z S |S )zwReturn the root directory name, which is "/" under POSIX,
and the root path of the current drive under Windows.)r# r nameendswithr> )r` r s r:
root_dir_namez FakeFilesystem.root_dir_namem sB T] /00 !455 2d 11 1r9 c f | j r t j n | j r t j n t j S )z6Return the real or simulated type of operating system.)rd r. r7 re r6 r5 rf s r: rS zFakeFilesystem.osv s1
!
FNN }
r9 c @ |t j k | _ |t j k | _ |t j k | _ t j | _ | j rt nt }|| j d< |
t
| dS )zSSet the simulated type of operating system underlying the fake
file system.r N)r. r7 rJ r6 rK r5 rL r) rM rN r' r( rQ r[ rl )r` ri ra s r: rS zFakeFilesystem.os s $v~ 5 &,.!&&,!6 ~ "&"5 K ;K !01
T"""""r9 TrG c t | j | | _ t | | _ | j | j d| _ d| _ | j
| | | | j
r| |r ddlm} | | dS dS )z3Remove all file system contents and reset the root.
filesystemr ) fake_pathlibN)
FakeDirectoryr> r FakeNullFilerZ rU clearrV rW rX rY _add_root_mount_point_add_standard_streamsrA _create_temp_dirpyfakefsr init_module)r` r? rG r s r: r[ zFakeFilesystem.reset s !$"5$GGG $T**
"""
!!! "":... ""$$$ $ ! ! # # # + - - - - - - $ $T * * * * * + +r9 rN c # V K | j } || _ d V || _ d S # || _ w xY wry )rN )r` rN old_fs_types r: use_fs_typezFakeFilesystem.use_fs_type s@ l '"DL EEE&DLLL;DL & & & &s (c | j rdn| j }|| _ | j | j s| xj | j z
c_ | || d S )NzC:)rd r> rR r r add_mount_point)r` r? mount_points r: r z$FakeFilesystem._add_root_mount_point sg " 0Iddd6I x !455 - II, ,II [*55555r9 c d | j t d | j dS )a Pause the patching of the file system modules until :py:meth:`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@ RuntimeErrorpauserf s r: r zFakeFilesystem.pause s? < <
r9 c d | j t d | j dS )aP Resume the patching of the file system modules if :py:meth:`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 resumerf s r: r zFakeFilesystem.resume s? < <
r9 c J | j r| j dS dS )z'Clear the cache of non-patched modules.N)r@ clear_cacherf s r: r zFakeFilesystem.clear_cache s0 < ' L $ $ & & & & & ' 'r9 err_nofilenamewinerrorc t j | }|)t j dk r| j rt |||| t ||| )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:
err_no: 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; )rS strerrorrH rI rd OSError)r` r r r messages r: raise_os_errorz FakeFilesystem.raise_os_error sS $ +f%% CLG$;$;@R$;&'8X>> >fgx000r9 pathc , t || j S )z2Return the path separator as the same type as path)r$ r> r` r s r: get_path_separatorz!FakeFilesystem.get_path_separator s tT%8999r9 c , t || j S )z>Return the alternative path separator as the same type as path)r$ rt r s r: _alternative_path_separatorz*FakeFilesystem._alternative_path_separator s tT%DEEEr9 c | | }| | }| | p|duo| | S )z3Return `True` if path starts with a path separator.N)r r
startswith)r` r rq rv s r: starts_with_sepz FakeFilesystem.starts_with_sep sU %%d++11$77s##UvT'9'Udoof>U>UUr9 can_existc | | | }| j D ]}| j r|t || k s?| j si| t || k r1|r| j | c S | t j | | xj dz
c_ | j |dd| j |< |t || j
j k r$| j
}| xj dz
c_ | j |_
n| | }| j |_ | j | S )ah 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.
can_exist: If `True`, no error is raised if the mount point
already exists.
Returns:
The newly created mount point dict.
Raises:
OSError: if trying to mount an existing mount point again,
and ``can_exist`` is `False`.
r )idevr? used_size)normpathnormcaserY rL r$ lowerr errnoEEXISTrX r r rW st_ino_create_mount_point_dirst_dev)r` r r? r r r s r: r z FakeFilesystem.add_mount_point sR 2 }}T]]4 0 011 , 8 8K&
8OD+ > >>>- ?JJLLOD+:K:K:M:M$N$NNN : ,[9999##EL$777
M$#
#
$
?4 88 8 8yH MMQ MM "mHOO33D99H - &&r9 directory_pathc | | }| | }| j }g }d |D D ]}| |t | d }|s>t || }| | | | |}kt t
| }|D ]}t t j z |_ |S )zA version of `create_dir` for the mount point directory creation,
which avoids circular calls and unneeded checks.
c , g | ]}t | S r8 r# .0ps r:
z:FakeFilesystem._create_mount_point_dir..< @@@1)A,,@@@r9 r r )
r" _path_componentsr _directory_contentr# r append add_entryr r r PERM_DEFst_mode) r` r dir_pathpath_components current_dirnew_dirs component directorynew_dirs r: r z&FakeFilesystem._create_mount_point_dir3 s (( 88 //99i @@@@@ = =I // Yy=Q=QRRSTUI
=' dCCC(((%%g... % "=) < < 9 9G %(8 8GOOr9 c | | j r4| | d }|r| |d S dS )zWindows only: if `path` is located on an unmounted drive or UNC
mount point, the drive/mount point is added to the mount points.r T)r r N)rd
splitdriver )r` r drives r: r z*FakeFilesystem._auto_mount_drive_if_neededK sM HOOD))!,E
H++$+GGGtr9 c B | | | }| j D ]%}|t || k r| j | c S &t |d }| | d }| j D ]a}t || }|r| | s*| | r"t
| t
| k r|}b|r| j t | S | | }|sJ |S )NrE r ) absnormpath_original_pathrY r$ r r lenr# r )r` r
mount_pathr root_pathr s r: _mount_point_for_pathz$FakeFilesystem._mount_point_for_pathT s; 3 3D 9 9:: + 5 5JtZ8888(4444 9$T2..
%%a( * ' 'I'i88I
Y 1 1% 8 8
y))
'c)nns:.N.N &
<$Yz%:%:; ;66t<< {r9 c dt f fd }t j } j D ]"}|t | k r
|| c S #d}t | d } j D ]`}t | }|r| | s)| | r"t
| t
| k r|}a || S )zjReturn the fake directory object of the mount point where the
current working directory points to.rB c | }j }|D ]*}t t | | }+|S ry )r r r r get_entry) file_pathr targetr r` s r: object_from_pathzAFakeFilesystem._mount_point_dir_for_cwd..object_from_pathk sR " 3 3I > >OYF ,
J
J mV-=-=i-H-HIIMr9 rE r )r r# r rY r r r )r` r r r r r
str_root_paths ` r: r z'FakeFilesystem._mount_point_dir_for_cwdg s = "" + 4 4Jy,,,,''
33333 -
$//$//233 * ' 'I %i 0 0M
] 5 5e < <
}--
'#m2D2Ds:2V2V &
+++r9 r c ^ | j D ]}|d |k r|c S d S )Nr )rY values)r` r r s r: _mount_point_for_devicez&FakeFilesystem._mount_point_for_device sF ,3355 # #K6"d**"""" +tr9 c T t dd }|4t t | j }n$t | }| | }|r0|d ( ||d |d |d |d z
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).
DiskUsageztotal, used, freeNr? r l r )r nextiterrY r r" r )r` r r r r s r: get_disk_usagez FakeFilesystem.get_disk_usage s {,?@@ < tD$5$<$<$>$> ? ?@@KK(..I 44Y??K ;|4@ 9L)K(L)K ,DD
y2A7PQQQr9 c ||n| j }| | }|d ,|d |k r | t j | ||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:
OSError: if the new space is smaller than the used size.
Nr? r )r r r r ENOSPC)r` r? r r r s r: set_disk_usagez FakeFilesystem.set_disk_usage sp $DD$*< 00;; % 1K(:55 d 3 3 3$. L!!!r9 usage_changer r c | | }|rK|d }|/||d z
|k r | t j | |dxx |z
cc< dS 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:
OSError: if `usage_change` exceeds the free file system space
r? Nr )r r r r )r` r r r r r? s r: change_disk_usagez FakeFilesystem.change_disk_usage s 226:: 5$\2J% K 88<GG'' i@@@ $ $ $ 4 $ $ $ $ $ 5 5r9
entry_pathfollow_symlinksc J | ||ddd }n%# t $ r | | }Y nw xY wt s%|j }|r | |j d | ||| |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.
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.
TF)allow_fdcheck_read_permcheck_exe_permr ) resolve TypeErroris_root
parent_dir _get_objectr (raise_for_filepath_ending_with_separator stat_resultcopy)r` r r file_objectr s r: statzFakeFilesystem.stat s 3 ,, % $ ' KK 3 3 3 ,,z22KKK 3yy I$/J
I % HHH 55 _
&++---s ??r
macos_handlingc P | | r
t |j r | | }n\# t $ rO}| j r|j t j k rY d }~d S | j r | t j
| d }~ww xY w|r| j s| j r|}| j rt |j }n4| j r|rt |j }nt |j }|r$| t j
| d S d S d S ry )
ends_with_path_separatorr r r r re r ENOENTrd r ENOTDIRr
r )r` r r
r r link_objectexcis_errors r: r z7FakeFilesystem.raise_for_filepath_ending_with_separator sb ( ( 4 4 ?{*++
."&,,z":":KK } el)B)B ) G ++EM:FFF ' .$*< .
."-K!
<";#677
<>
< &{': ; ;; &{': ; ;;
?##EM:>>>>>' ? ?$
?
?s A
B B.(BBmodeforce_unix_modec \ | j pt j dk }| |||d }| j r1|s/|t j z r|j dz |_ n:|j dz |_ n*|j t j z |t j z z |_ t j |_ dS )a Change the permissions of a file as encoded in integer mode.
Args:
path: (str | int) Path to the file or file descriptor.
mode: (int) Permissions.
follow_symlinks: If `False` and `path` points to a symlink,
the link itself is affected instead of the linked object.
force_unix_mode: if `True` and run under Windows, the mode is not
adapted for Windows to allow making dirs unreadable
T)r check_owner im N)
rd rH version_infor r
PERM_WRITEr PERM_ALLnowst_ctime)r` r r r r r r
s r: chmodzFakeFilesystem.chmod s " ))HS-=-Hll /H$ #
o g((
E&1&9E&A ##&1&9H&D ###.#6':J9J#Jw''#K '{}} r9 )nsr timesr" c | || | ||d }|L|D ]-}t |t t f st d .|d |_ |d |_ dS |E|D ]&}t |t st d '|d |_ |d |_ dS t 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.
follow_symlinks: If `False` and ``path`` points to a symlink,
the link itself is queried instead of the linked object.
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.
Tr Nz atime and mtime must be numbersr r z atime and mtime must be ints) _handle_utime_arg_errorsr
isinstanceintfloatr st_atimest_mtime st_atime_ns st_mtime_nsr r )r` r r# r" r r
file_time current_times r: utimezFakeFilesystem.utime2 s 6
%%b%000ll4 4lHH "
G
G !)c5\:: G#$EFFFG $)8K #(8K
^
D
D !)S11 D#$BCCCD ')eK #&(eK # # #";==L#/K #/K r9 c || t d |"t | dk rt d | "t | dk rt d d S d S )Nz:utime: you may specify either 'times' or 'ns' but not both z9utime: 'times' must be either a tuple of two ints or Nonez'utime: 'ns' must be a tuple of two ints)
ValueErrorr r )r" r# s r: r& z'FakeFilesystem._handle_utime_arg_errorsc su
L
Uq WXX X
>c"ggll EFF F >llr9 file_objnew_fdc |dk rt | j }||k rh| j | }|r*|D ]'} | # t $ r Y $w xY w|| j v r| j | |g| j |< nbt
|| D ]6}| j g t j | j | 7| j |g |S | j r&t j
| j }|g| j |< |S | j |g t | j dz
S )a 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.
new_fd: The optional new file descriptor.
Returns:
File descriptor number for the file object.
r r ) r rU closer rV removeranger heapqheappushheappop)r` r5 r6 sizerU ffdopen_fds r:
add_open_filez FakeFilesystem.add_open_fileq ss Q;;t''D}} !_V 4
! ' ! !! GGIIII & ! ! ! D!T ///&--f555+3*'' f-- ; ;BO**2...N4#5r::::&&z222M mD$677G(0zDOG $N z***4?##a''s A
AAfile_desc N d| j |< t j | j | dS )zRemove 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)rU r; r< rV r` rC s r: close_open_filez FakeFilesystem.close_open_file s+ %)!
t)844444r9 c | | d S # t $ r1 | t j t | Y dS w xY w)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.
r N)get_open_files
IndexErrorr r EBADFstrrE s r:
get_open_filez FakeFilesystem.get_open_file sb <&&x003 3 < < < S]] ; ; ; ; ; ; . s=
)1
QK " " $ $
r9 )rU )r` r
s r:
has_open_filez FakeFilesystem.has_open_file s/
59_
r9 c | | }|)| || | S |S ry )r rP r )r` r alt_seps r: _normalize_path_sepz"FakeFilesystem._normalize_path_sep sB 22488 <<)@)@)F)FGG G r9 c J 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" rV )r` r r s r: r zFakeFilesystem.normcase s% %T** '' 222r9 c | | }| | \ }}| | }| | }| | }g }t |d }t |d } |D ]L}
|
r|
|k r |
| k r&|r!|d | k r| 4|r7| |
M| | } |r|| z } || z 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.
...r4 ) r r r r splitr$ popr join) r` r path_strr rq is_absolute_pathr collapsed_path_componentsdotdotdotr collapsed_paths r: r zFakeFilesystem.normpath sG , ==&& //(33x%%h//#..s33(0 )
)
" h,, 400( 8 8I
9#3#3F"", -b1V;; .11333 % % , ,Y 7 7 7 7 ";<< 2 > 1N~%,,r9 c fd} j ssS g j }D ]}t |t
s | c S |t | \ }}|'t |t
r |j |j dk r | c S t t
| } | | 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 t t k r4 d t d D j } | } r | s| |z }t | dk r | r|| z
}|S )Nc 3 4 K | ]}t | V d S ry r r s r: zLFakeFilesystem._original_path..components_to_path..3 s9 - -%&IaLL- - - - - -r9 r2 )r extendr> r] r starts_with_drive_letter)rq normalized_pathnormalized_componentsr r r` s r: components_to_pathz9FakeFilesystem._original_path..components_to_path1 s ?##c*?&@&@@@%,, - -*9#>S:T:T:V:V*W- - - %C !hh'< = =O##D))
8$2F2F2W2W
8"%"7?##q((T-J-J . .( 3&" "r9 Nr ) rL replace_windows_rootr r r' r r r# _byte_contentsst_sizer r ) r` r rl r r dir_namer rk r s `` @@r: r z FakeFilesystem._original_path% sR
#
#
#
#
#
#
#
# ! K((.. //55 " i (
3
3I k=99
,))+++++"&"9"9Yy 1 1# # Hi 9m44 ! ,4 %**))+++++ }i88K ! ( ( 2 2 2 2!!###r9 c | | }t || j }|s| | }|t |d k r|}n| | s]t || j j }t |d }| | ||k r|p||f }n| | }| | 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.
rY rE )
r r$ r r _starts_with_root_pathr r r] rm r )r` r r root_nameemptys r: r zFakeFilesystem.absnormpathV s }}T"" dDH-- 1**400D ?4-- - -DD,,T22 3'din==I#D"--E**40055 !)c2UD9 DD ,,T22D}}T"""r9 c ~ t | }| | }| | }||n||z }| | \ }}t | }|r!||dz
|vr|dz }|r
||dz
|v|d| ||d }}| | p|}||z |fS )a Mimic os.path.split using the specified path_separator.
Mimics os.path.split 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.
Nr )r" r r r r rstrip) r` r rq rU sepsr iheadtails r: splitpathzFakeFilesystem.splitpatht s %%%%d++22488 oss3=ood++ t II DQKt++
FA DQKt++"1"XtABBxd{{4 (Dt|T!!r9 c ^ t | }| j r t | dk r| | }| | }|dd |dz k r|dd |k r| |d }|dk r |dd |fS | ||dz }||dz k r |dd |fS |dk rt | }|d| ||d fS |dd t
|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.
r2 r r r4 Nr :)r" rd r r r findr$ )r` r r^ norm_strrq sep_index
sep_index2s r: r zFakeFilesystem.splitdrive sb $D)) 68}}!! ==22--h77 QqSMS1W,,8AaC=C3G3G !)
c1 5 5I B '|X 55!) sIM!B!BJ!Y]22 '|X 55!R''%(]]
#KZK0(:;;2GGGAaC=OHc$B$BBB#BQB<!"" 55|X%%r9 c t j | }t |t r?| j }d}| j }|| }d}d}d}n| j }| j }d}d}d}| j r*|r| || n|} | dd |k r| dd |k r| dd
|k rd
nd }
|
||
} | d k r|||fS |
|| dz } | d k r|||fS |d| || | dz || dz d fS ||dd |dd fS | dd |k r@| d d |k r |dd |d d |d d fS |dd ||d d fS |||fS |dd |k r|||fS |dd |k s|d d |k r
|||dd fS ||dd |d d fS )
zlSplit a pathname into drive, root and tail.
Implementation taken from ntpath and posixpath.
N :s \\?\UNC\r9 r} z\\?\UNC\rE r r2 r4 r ) rS fspathr' bytesr> encodert rd rP upperr~ )
r` r r rq rv rt colon
unc_prefixrt normpstartindexindex2s
r: splitrootzFakeFilesystem.splitroot s
IdOO a %,,..CF)-)H &)53::<<E(JEE%C4FE'JE # +.4;AIIfc***!ERaRyC 1:$$ "'rr !2!2j!@!@AAaE !JJsE 2 2E {{ %. "ZZUQY 7 7F || %. WfW:q&1*)<'=q! NN !!BQB%122..qsu$$1:$$ RaR5!AaC&!ABB%// RaR5%122.. eQ&!u|| eQ&1Q33 !AaC&C-- c1QRR5(( aeQqrrU**r9 all_pathsc < |d }|dd }| | }|| | g}| | \ }}|D ]}| | \ } }
|
r|
dd |v r | s|s| }|
}1| r>| |k r8| j s*| | k r| }|
}o| }|r|dd |vr||z }||
z }t |d } |r$|dd |vr|r|dd | k r||z |z S ||z S )zSTaken from Python 3.5 os.path.join() code in ntpath.py
and slightly adaptedr r Nr4 r} )r r r rL r r$ ) r` r base_path paths_to_addrq rw result_drive result_pathr
drive_part path_partr s r: _join_paths_with_drive_supportz-FakeFilesystem._join_paths_with_drive_support s aL } %%i00T55i@@A$(OOI$>$>! k 2 2D$(OOD$9$9 !J
*Yrr]d 2 2 .\ .#-L '
*
l : :) Z-=-=-?-?. s 888$bioo888r9 r r N)r rd r r r r )r` r
file_pathsr rq path_segments r: joinpathszFakeFilesystem.joinpaths s 98%888
z??a 8O D646
C C!}%%jm44 &qrrN + +L&&s++
+4
+# s##
+ $l** r9 c d S ry r8 r s r: r z FakeFilesystem._path_components- s 8;r9 c d S ry r8 r s r: r z FakeFilesystem._path_components0 s .t s@ $) !&
1B1B B r9 F) r$ r isalphard rS r anyr entriesget_object_from_normpathr )r` r r s ` r: ri z'FakeFilesystem.starts_with_drive_letter^ s 3// y>>Q 9QqS>#9#9#;#; !A#RW@W@W!
tw$ !9~~** " -1]-B 11)<<< 4 ! ! ! 55!us )7B8 !B8 8
CCc 6 t || j j }| | }| | pU| j o8| | p| | S ry )r$ r r rV r rL r ri r` r rs s r: rr z%FakeFilesystem._starts_with_root_path s #Ity~>> ,,Y77 + +
8)) @!!,,Y__->->??
8 ,,Y77
r9 c X |r| j r| j r| | }|dd |k rvt | dk s|dd |k rU| j D ]+}t || }| | r|c S ,t || j }||dd z }|S )zIn windows, if a path starts with a single separator,
it points to the root dir of the current mount point, usually a
drive - replace it with that mount point path to get the real path.
r r r2 N)rd r r r rY r$ r r )r` r rq r r s r: rm z#FakeFilesystem.replace_windows_root s
.D& .4= .))$//CAaCyC SYY!^^tAaCyC7G7G!%!2 $ $I /i @ @Iy11 $ # $ .dD4F G G "T!""X- r9 c l t || j j }||k p| | S ry )r$ r r is_mount_pointr s r:
_is_root_pathz FakeFilesystem._is_root_path s3 #Ity~>> I%G)<)->-@-@@@ttur9 c t |t rdS t | }|sdS | | }| | }|||fvo-| | p|duo| | S )z@Return `True` if ``file_path`` ends with a valid path separator.FN)r' r( r" r r r )r` r r rq rv s r: r z'FakeFilesystem.ends_with_path_separator s dC 5$T** 5%%i0011)<<f
-
s # # XvT'9'Xi>P>PQW>X>X
r9 c | | sdS | | | S rk )r isfile!_path_without_trailing_separatorsr s r: !is_filepath_ending_with_separatorz0FakeFilesystem.is_filepath_ending_with_separator s= ,,T22 5{{4AA$GGHHHr9 r r c t t sdS j v rj fS | j s fdj D }|r|d S dS )NNNc g | ];}| k ,|j | f. sM <<>>Y__%6%666 *623666r9 r )r' r r rL )r` r r matching_contents `` r: r z!FakeFilesystem._directory_content s )]33 : ) ) ) i / :: :% + ' /
+'**zr9
check_linkc P |r| | rdS t | | }|t |sdS || j k r| j pt j dk S | | rdS | | }n# t $ r Y dS w xY w| | rdS | | }| j
}|D ]E}| |t | d }| dS t t | }FdS )aN Return true if a path points to an existing file system object.
Args:
file_path: The path to examine.
check_link: If `True`, links are not followed
Returns:
(bool) `True` if the corresponding object exists.
Raises:
TypeError: if file_path is `None`.
TNFr r r )islinkr# r" r rz rd rH r r resolve_pathr r r r r r r )r` r r r r r r r s r: existszFakeFilesystem.exists s] $++i00 4..y99:: <O 5 4< ))GS-=-G G 55d;;
u$$T**DD 55 d # # 4%)%:%:4%@%@i ( 9 9I // Yy=Q=QRRSTUI uu }i88KKts -B B
B('B(r c |rAt |t r,| | j S t | }|t
d t j dk rV| j t j k rA| t |t j t || j }|r| | s | t$ j | | | | }| | }| | r|S |t || j k r|S | | }| | }| | }| | S )a 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.
Returns:
The resolved_path (str or byte).
Raises:
TypeError: if `file_path` is `None`.
OSError: if `file_path` is '' or a part of the path doesn't exist.
Nz/Expected file system path string, received Noner; ) r' r( rL rQ r r" r rH rI rS r. r7 rP r$ rq r> _valid_relative_pathr r r r r rm r rz r _resolve_components_components_to_path)r` r r r r resolved_componentss r: r zFakeFilesystem.resolve_path s L C
9c22 C%%i00;;==B B ** < MNN N <7 " "tw&.'@'@<< bf-- d&9:: D 4444T:: 4
d 3 3 3 3 3D 9 9::((.. d # # K ?4 66 6 6K //55 " 6 6 G G''(;<<((...r9 c |r| |d n| j }| | }| | s||z }|S rs )r r> r] rr )r` component_foldersrq r s r: r z"FakeFilesystem._components_to_pathA sh !
%D # #$5a$8 9 9 9$
xx)****400 :D r9
componentsc H | j }d}d |D }g }|r| d }| | | || d }|| | nt |j r}|t k r3| t j
| | | || }|
| } | |z }g }| j }|dz
}nt t | }||S )Nr c , g | ]}t | S r8 r )r comps r: r z6FakeFilesystem._resolve_components..O s BBBt9T??BBBr9 r )r r\ r r rh r r _MAX_LINK_DEPTHr r ELOOPr _follow_linkr r r )
r` r r
link_depthr r r r link_pathtarget_componentss
r: r z"FakeFilesystem._resolve_componentsL sQ i
BBzBBB)+ ! ='++A..I & &y 1 1 1 // YGGJI $**?;;;*++
= //'' 001DEE ! - -.A9 M M %)$9$9)$D$D!"3o"E&(# "i a
"=) < < C ! =D #"r9 c | j rdS t || j dz }|rQ||v rM|d | | }| | | sdS |r||v MdS )NTrZ F)rd r$ r> rfindr r )r` r slash_dotdots r: r z#FakeFilesystem._valid_relative_pathu s 4&y$2E2LMM LI 5 5!"AIOOL$A$A"ABI;;t / / : :;;
u LI 5 5 tr9 link_path_componentslinkc d |j }|| j r | d r
|dd }| | }| | s4|dd }| | | | }| | S t d )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:
OSError: if there are too many levels of symbolic link
Nz\\?\ r4 z Invalid link) contentsrd r r rr r r] r r3 )r` r r r rq r s r: r zFakeFilesystem._follow_link s . M !
*i&:&:9&E&E
* %abbM )))44C ..y99
1 2#2# 6
!!),,, HHZ 0 0 ==++ + (((r9 r r r c t | }|t || j j k r| j S |t || j k r| j S | | }| | }| j } |D ] }t |j r4|j
r-t t |
|j
}t |j sG| j s | t" j | | t" j | | | }t+ sC|s|r?|r=| |||| s%| t" j |j n0# t2 $ r# | t" j | Y nw xY w|S )aU 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.
check_read_perm: If `True`, raises `OSError` if a parent directory
does not have read permission
check_exe_perm: If `True`, raises `OSError` if a parent directory
does not have execute (e.g. search) permission
check_owner: If `True`, and ``check_read_perm`` is also `True`,
only checks read permission if the current user id is
different from the file object user id
Returns:
The FakeFile object corresponding to file_path.
Raises:
OSError: if the object is not found.
)r" r$ r r rz rZ r r r r r r r r r rd r r r r r r _can_readEACCESr KeyError) r` r r r r r r r r s r: r z'FakeFilesystem.get_object_from_normpath s 6 ** ?4 88 8 89 ?4 66 6 6= ""4(( //55 4 ,
C
C 6>** T T!%mT\\&/5R5R!S!S v~.. < - A ++EM4@@@'' d;;; )))44 C(C,:C C !NN C '' fkBBB#
C$ 4 4 4 d 3 3 3 3 3 4
s DF *GGc |r | j t j k rdS |r t j nd}t | j r|r|t j z }|sdS | | S )NTr )st_uidr get_uid PERM_READr r PERM_EXEhas_permission)r r r owner_can_read
permissions r: r zFakeFilesystem._can_read s| fmw/@/@ @ @4*9@W&&q
6> " " +~ + '* *J 4$$Z000r9 c t | }| | | }| ||| S )a Search for the specified filesystem object within the fake
filesystem. By default, consider read and execute permissions.
Args:
file_path: Specifies the target
:py:class:`FakeFile` object to retrieve.
check_read_perm: If `True`, raises `OSError` if a parent directory
does not have read permission
check_exe_perm: If `True`, raises `OSError` if a parent directory
does not have execute (e.g. search) permission
Returns:
The :py:class:`FakeFile` object corresponding
to `file_path`.
Raises:
OSError: if the object is not found.
)r" r r r )r` r r r r s r: r zFakeFilesystem._get_object sJ 0 ** 3 3D 9 9::,,T?NSSSr9 c 2 | |dd S )a Search for the specified filesystem object within the fake
filesystem and return it. Ignore any read permissions.
Args:
file_path: Specifies the target
:py:class:`FakeFile` object to retrieve.
Returns:
The :py:class:`FakeFile` object corresponding
to `file_path`.
Raises:
OSError: if the object is not found.
Fr r )r )r` r s r: rQ zFakeFilesystem.get_object s 5QV WWWr9 c T t |t rQ|r@| | }t |t sJ |S t d |r,| | || ||| 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
check_read_perm: If `True`, raises `OSError` if a parent directory
does not have read permission
check_read_perm: If `True`, raises `OSError` if a parent directory
does not have execute permission
check_owner: If `True`, and ``check_read_perm`` is also `True`,
only checks read permission if the current user id is
different from the file object user id
Returns:
The FakeFile object corresponding to ``file_path``.
Raises:
OSError: if the object is not found.
z4path should be string, bytes or os.PathLike, not int) r' r( rL rQ FakeFiler r r lresolve)r` r r r r r r open_files r: r zFakeFilesystem.resolve s < i % % T
! . .y 9 9 D D F F !)X66666 RSS S 00!!)X66
}}Y'''r9 c t | }|s | t j | |t || j j k r| j S | | }|t |d k rt || j }| | }|
| \ }}|st || j } | | }|sJ t |t s\| j s5t |t r | t j | | t j | | t$ j s | t j | |r"| t- | n|S # t. $ r Y nw xY w| t j | 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:
OSError: if the object is not found.
rY N)r" r r r r$ r r r r r r{ r r' r rd r r r r r r r r# r )r` r r^ parent_directory
child_name
parent_objs r: r zFakeFilesystem.lresolveN s $D)) 8 h 7 7 7 x @@ @ @9 99(CC x55 5 5&x::H&&x00'+~~h'?'?$* C .x B B &677J : j-88
<) AjX.N.N A''
x@@@##EL(;;; ,,W->??
D##EL2BCCC
$$Yz%:%:;;;
D EL(33333s C.G
GGc , |s| j }ntt t | |dd }t |j s5| j r t j n t j }|
|| | | 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.
Raises:
OSError: if file_path does not correspond to a
directory.
FTr N) r r r r r r rd r r r r r )r` r r
target_directoryerrors r:
add_objectzFakeFilesystem.add_object s 6 #} # Yd SS +344
6(,(:M
##E9555"";/////r9
old_file_path
new_file_path
force_replacec t | }t | }| | }| | }| | }| |d s!| t
j |d |r| | | | }| j s|
||| | |d r | ||||| }|dS |}| | \ } }
| | \ } } | | s | t
j | |
| }
|
| }|
j |j k r | t
j | t! |j s3| | j r t
j n t
j | | | r | t
j | | |
|
|| 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).
Tr r2 N)r" r r r r r r %_handle_broken_link_with_trailing_sepr rd _handle_posix_dir_link_errors_rename_to_existing_pathr{ r r EXDEVr r EINVALr has_parent_object
_do_rename)r` r r r old_pathnew_path
ends_with_sep
old_object renamed_pathold_dirold_namer new_nameold_dir_objectnew_dir_objects r: renamezFakeFilesystem.rename sV < $M22#M22 55h??
##H--##H--{{8{55 ; h : : : A 6 6x @ @ @]]8,,
! R . .x= Q Q Q ;;xD; 1 1 ( 88 x:} L #' NN8 4 4 NN8 4 4{{7## 7 g 6 6 6 g.. g.. N$9 9 9 X 6 6 6~-.. $ 2E
x
+ +J 7 7 8 h 7 7 7 .(KKKKKr9 c | | }| |d ||_ | | }||j v r| | nd } |r| | | | d S # t $ r> |r ||j vr| | ||_ | | w xY w)NF) recursive)r remove_entryr _normalized_entrynamer r r )r` r r r r
object_to_rename old_entrys r: r zFakeFilesystem._do_rename s )33H==##H#>>> ( !77AA >111
$ $X . . .
6 ++H555 $ $%5 6 6 6 6 6
4X^-C C C ((333$, ! $ $%5 6 6 6
s
*,B AC c | | rL| | s9| j r t j n t j }| || d S d S d S ry )r r re r r r r )r` r r s r: r z4FakeFilesystem._handle_broken_link_with_trailing_sep sn ;;t 1;;t$$
1(,
H 5=##E400000 1 1
1
1r9 r c | |d r5| | r | t j | | |d rP| | r;|r | j rd S |r t j n t j }| || |rD| | r1||k r-| j s(| t j | d S d S d S d S d S NFr )isdirr r r r re EISDIRrd )r` r r r r s r: r z,FakeFilesystem._handle_posix_dir_link_errors s8 ::mU: ; ; > A
A
>
} = = = ::mU: ; ; 6 A
A
6
%2DEMM E } 5 5 5 > M** > ..& /
} = = = = =
> > > > /...r9 r c | | }||k rMt |j s7|r5| j r t j n t j }| || d S ||k r| || S t |j st |j r| ||||| nt |j r6| j r t j
n t j }| || n?| j r#|s!| t j
| n| | |S ry ) r r r rd r r r _rename_same_objectr $_handle_rename_error_for_dir_or_linkr
remove_object)r` r r r r r
new_objectr s r: r z'FakeFilesystem._rename_to_existing_path sh %%m44
M ) ):-..
:=
:)-);N
##E=9994 # #++M=II I :% & & .'*2D*E*E . 5 5
Z'
(
( .$($6IELLEME } 5 5 5 5
.
. m < < < < } - - - r9 r c | j rC|r!| t j | n | t j | t |j sz|j r=t |j r |r| j s | t j | t |j r$| t j | d S d S d S ry ) rd r r r r r r r re ENOTEMPTYr
r )r` r r r r r s r: r z3FakeFilesystem._handle_rename_error_for_dir_or_link3 s A
A##EL-@@@@##EL-@@@z)** A!
H
233H(H =H
'' GGGz)**
A##EL-@@@@@ A A
A
Ar9 c | | k }|s> | | }| | }| | }||k rz||k | | k k rH| |d }t j | |j k p| j }n*| | k }|rA| | \ }} |
| | | }n# t $ r Y nw xY w|sd S |S r ) r r r r rS r basenamer re r{ r r )
r` r r do_rename
real_old_pathoriginal_old_path
real_new_path real_objectparent file_names
r: r z"FakeFilesystem._rename_same_objectK s "''))]-@-@-B-BB
$ 1 1- @ @
$($7$7
$F$F! $ 1 1- @ @
$555!]2#))++}/B/B/D/DD;F ;F #',,}e,"T"TK(( 77;;KK - #}, I
!. 3 3 5 5 9L9L9N9N NI )-}(E(E%FI$(NN ++F33Y% %M
4 s D,E
E)(E)c | | | }| | r | t j | | | \ }}| |d }| | dS # t $ r$ | t j
| Y dS t $ r$ | t j | Y dS w xY w)an Remove an existing file or directory.
Args:
file_path: The path to the file relative to self.
Raises:
OSError: 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 '/').
Fr N)
r r r r r EBUSYr{ r r r r AttributeErrorr )r` r dirnamer" r s r: r z FakeFilesystem.remove_objecto s
$$T%8%8%C%CDD i ( ( 8 Y 7 7 7 : $y 9 9 GX #||GU| K K ) )( 3 3 3 3 3 9 9 9 i 8 8 8 8 8 8 : : :
y 9 9 9 9 9 9 :s AB% %*C?)C?>C?c t | }t |t j }| | }| || S ry )r" r$ rS rq r rP )r` r r^ os_sepfake_seps r: r" z FakeFilesystem.make_string_path sI #D)) 2622**844 111r9 perm_bits apply_umaskc | | }| | }| | | |d r)|| j vr | t j | | | }| j }g }d |D D ]}|
|t | d } | sWt || }
|
|
| j r|| j k r| j }| |
|
}t# | j r'| j sJ | | j } | sJ t+ t | }| j t, z t, k r%| t j |j |D ] }
|r || j z }t, |z |
_ |S )a Create `directory_path` and all the parent directories, and return
the created :py:class:`FakeDirectory` object.
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``.
apply_umask: If `True` (default), the current umask is applied
to `perm_bits`.
Returns:
The newly created
:py:class:`FakeDirectory` object.
Raises:
OSError: if the directory already exists.
Tr c , g | ]}t | S r8 r r s r: r z-FakeFilesystem.create_dir.. r r9 r r )r" r r r rY r r r r r r r# r r rd r r r r r r r r r r rT ) r` r r1 r2 r r r r r r r s r:
create_dirzFakeFilesystem.create_dir s 0 (( 88##H-- ((222 ;;xD; 1 1 8hdFW6W6W h 7 7 7 //99i @@@@@ I II // Yy=Q=QRRSTUI
I' dCCC(((% 0+*B*B"&-K%%g... % 9,-- %$---- $ Y-? @ @I$$$9 "=) < < $w.'99''
{7GHHH 2 2G
)dj[( % 1GOOr9 rE r r ro create_missing_dirsencodingerrors side_effectc
> | ||||||||| S )a Create `file_path`, including all the parent directories along
the way, and return the created
:py:class:`FakeFile` object.
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: If `True` (default), the current umask is applied
to `st_mode`.
encoding: If ``contents`` is of type `str`, the encoding used
for serialization.
errors: The error mode used for encoding/decoding errors.
side_effect: function handle that is executed when the file is written,
must accept the file object as an argument.
Returns:
The newly created :py:class:`FakeFile` object.
Raises:
OSError: if the file already exists.
OSError: if the containing directory is required and missing.
)r9 )create_file_internally)
r` r r r ro r6 r2 r7 r8 r9 s
r: create_filezFakeFilesystem.create_file s= T ** # +
r9 source_path read_only target_pathc 4 |p|}t | }t j | }| |d }|j | |r|xj dz c_ ||_ | |j |j
|j |S )a Create `file_path`, including all the parent directories along the
way, for an existing real file, and return the created
:py:class:`FakeFile` object.
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 :py:class:`FakeFile` object.
Raises:
OSError: if the file does not exist in the real file system.
OSError: 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" rS r r; r set_from_stat_resultr r r r> r r )r` r= r> r? source_path_str real_statr s r:
add_real_filez FakeFilesystem.add_real_file s > "0[ *;77GO,, // t/TT 229=== * ) - y~y~y?OPPPr9 c t | }| | }t j | s?t j | s | t j | t j | }|r|
|| S |
|| S )a Create a symlink at `source_path` (or `target_path`, if given) and return
the created :py:class:`FakeFile` object.
It will point to the same path as the symlink on the real filesystem.
Relative symlinks will point relative to their new location. Absolute symlinks
will point to the same, absolute path as on the real filesystem.
Args:
source_path: The path to the existing symlink.
target_path: If given, the name of the symlink in the fake
filesystem, otherwise, the same as `source_path`.
Returns:
the newly created :py:class:`FakeFile` object.
Raises:
OSError: if the directory does not exist in the real file system.
OSError: if the symlink could not be created
(see :py:meth:`create_file`).
OSError: if the directory already exists in the fake file system.
) r" r rS r r r r r r readlinkcreate_symlink)r` r= r? rC r s r: add_real_symlinkz FakeFilesystem.add_real_symlink* s . +;77 @@ QQw~~o.. ?rw~~o7V7V ? o > > >_-- @&&{F;; ;&&?? ?r9 lazy_readc t | }| | }t j | s | t j | t |p| }t j t j | }t j
| j k r%| t j
| j }|
| |r| ||| n| ||| t! t" | | S )a Create a fake directory corresponding to the real directory at the
specified path, and return the created
:py:class:`FakeDirectory` object.
Add entries in the fake directory corresponding to
the entries in the real directory. Symlinks are supported.
If the target directory already exists in the fake filesystem, the directory
contents are merged. Overwriting existing files is not allowed.
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
:py:class:`FakeDirectory` object.
Raises:
OSError: if the directory does not exist in the real filesystem.
OSError: if a file or link exists in the fake filesystem where a real
file or directory shall be mapped.
)r" r rS r r r r r rv r rq r> rP r !_create_fake_from_real_dir_lazily_create_fake_from_real_dirr r r )r` r= r> rJ r? rC target_path_strs r: add_real_directoryz!FakeFilesystem.add_real_directoryM s' P +;77 @@ QQw~~o.. ? o > > >*;+I/JJ 9 g . . ? ?O
6T( ( ( - 5 5bfd>Q R RO (( 999 Y 2 2 )
+ +O_i X X XM4#3#3O#D#DEEEr9 c
| | s| | t j | D ]H\ }}}t j |t j || }t j | D ]u}t j || } t j | r4| | t j || v|D ]v}t j || }
t j |
s5|
|
|t j || wJd S ry ) r r5 rS walkr r] relpathlistdirr rI rE ) r` rC rN r> base_filesnew_base
file_entryr r s r: rM z)FakeFilesystem._create_fake_from_real_dir s[ {{?++ - OOO , , , go 6 6 ND!Uw|| o66 H !j . .
Y
Y
GLLz : : 7>>),, Y)))RW\\(J5W5WXXX #
w||D*55w~~d++ && i h
)K)K
r9 c | | r?| | st t j d t j | D ]}t
j || }t
j || }t
j | r| ||d| zt
j
| r| || t
j | r|
||| | | S t
j | d }| | r| | }n| | }t# || || } | | | S )Nz!Mapping target is not a directoryTr )r r r r r rS rS r r] rO r rI r rE r r[ r5 FakeDirectoryFromRealDirectoryr )
r` rC rN r> r src_entry_pathtarget_entry_path parent_pathr r s
r: rL z0FakeFilesystem._create_fake_from_real_dir_lazily s ;; ' ' 5::o..
R em-PQQQO44
U
U!# ou!E!E$&GLL %$H$H!7== 00 U++& 49J W^^N33 U)).:KLLLLW^^N33 U&&~yBSTTT##O44 4gmmO44Q7 ;;{ # # 6 ))+66JJ 55J0 T9o
W%%%r9 path_list
lazy_dir_readc |D ]O}t j | r| ||| 9| || PdS )a This convenience method adds multiple files and/or directories from
the real file system to the fake file system. See :py:meth:`add_real_file` and
:py:meth:`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 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 :py:meth:`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 a file or link exists in the fake filesystem where a real
file or directory shall be mapped.
N)rS r r rO rE )r` r^ r> r_ r s r: add_real_pathsz FakeFilesystem.add_real_paths sg 4 4 4Dw}}T""
4''i GGGG""43333 4 4r9 package_namec t j dk rt d ddlm}m} | j r| || j }| || |D ])}| |
* | j r| dS dS # | j r| w w xY w)a
Convenience function to add all metadata distribution files of the package
with the given name to the fake filesystem. These are the files that are
usually located under `-.dist-info` beside the actual
package. The files are accessed by the functions in `importlib.metadata`.
Args:
package_name: Name of the package whose metadata shall be copied
Raises:
PackageNotFoundError: if the package with the given name is not found
r zNot available in Python 3.7r ) distributionPackageNotFoundErrorN) rH r NotImplementedErrorimportlib.metadatard re r@ r rV rE locater )r` rb rd re
dist_files
metadata_files r: add_package_metadataz#FakeFilesystem.add_package_metadata s f $ $%&CDD DIIIIIIII < JJLLL % l339J!**<888!+
;
;
""=#7#7#9#9::::
; |
t|
s
A B- - C rA c | | } | | } t | st d | | d r | t j | | | \ } }
| st | | j
} | | | | sK|s | t j | t | |
| j } n| | } |r || j z }| r t# t% | | |
}nt' |
|| |||
}| | | ||d}| sW||S || | n| | n$# t. $ r | | w xY w|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 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.
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?Tr )r r9 )r r7 r8 r9 NrE )r" r r! r r r r r r{ r$ r r r r5 r r rT FakeFileFromRealFiler# r r set_large_file_sizeset_initial_contentsr r )r` r r r ro r6 r2 r7 r8 rA r9 r r new_filer
s r: r; z%FakeFilesystem.create_file_internally sR F $$Y// %%7## M
;;t; - - 4 d 3 3 3%)^^D%9%9"( ? .tTX > > (()9:::{{+,, E&
D##EL2BCCC . 0116
$ 2 23C D D #
{ "G .$Dk KK # ! '
K
(+666 ?x /H h&:g>Q
& 33G<<<< 44X>>>
""4(((
s -G !G/ link_targetc | | }| | }| | }| | r7| | r | t
j | | | r(| j s | t
j | n| j r | t
j | | |
| d s | t
j | | j r-| |d r| | n | t
j | |
| s| | }| j r t j n t j }| |t& |z ||| j S )a Create the specified symlink, pointed at the specified link target,
and return the created :py:class:`FakeFile` object
representing the link.
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 :py:class:`FakeFile` object.
Raises:
OSError: if the symlink could not be created
(see :py:meth:`create_file`).
Tr )r r r6 r2 )r" r r r r r r rd r r r re r r r r
PERM_DEF_FILEr r; r )r` r rq r6 r link_target_pathr s r: rH z FakeFilesystem.create_symlinkT
s . )))44 00==MM),, ( ( 3 3 H{{9%%
=##EL)<<<{{+,,
H) A'' i@@@% I''
7GHHH{{::9EE # # H '' 6FGGG= H {{9{>> 6 **9555'' 6FGGG {{9%% 5 )))44I.2.@VW**gFV
** j(% 3
+
r9 r r c t | }t | }| | }| |d r | t j | | | \ }} |st || j }| | s8|r| | n | t j
| | | r | t j | | j
s5| | r | t j
| | || }
n0# t $ r# | t j
| Y nw xY w|
j t" z r3| | j
r t j n t j | | |
_ | ||
|
S )a Create a hard link at `new_path`, pointing at `old_path`,
and return the created :py:class:`FakeFile` object
representing the link.
Args:
old_path: An existing link to the target file.
new_path: The destination path to create a new link at.
follow_symlinks: If `False` and `old_path` is a symlink, link the
symlink instead of the object it points to.
create_missing_dirs: If `True`, any missing parent directories of
`file_path` will be created
Returns:
The :py:class:`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.
Tr r )r" r r r r r r{ r$ r r5 r r r rd r r r r r EPERMr r ) r` r r r r6 old_path_str new_path_strnew_path_normalizednew_parent_directory new_basenameold_files r: create_linkzFakeFilesystem.create_link
s 8 (11 '11 " . .| < < ;;*t; < < < l ; ; ;-1^^ r partitionr r r r r re r r r# r rT )r` r r rp r r restbase_direllipsis dummy_dotdotrU error_nrry rz s r: makedirzFakeFilesystem.makedir sa $H-- 55h??
99(CC 2 b 1 1 1 2''11H >>(33
D
<}}Z00H&z43F3MNNH""8,,
KT5G
K,6,@,@,J,J),!
=$
=t{{87L7L
= 00<<<;;x((
<##EL(;;;##H-- ;;xD; 1 1 8!
(h$2D&D&D < <
8
8t{{87L7L
8""8,,,,##Hh777^^H--
d dOO )D//44:++=$ O O O
r9 c n | | r |d d }| | |S )Nr4 )r r s r: r z0FakeFilesystem._path_without_trailing_separatorsR sB ++D11 9D ++D11 r9 rp exist_okc |s | t j d | | }| | }|rH| j rA| |d r*| | s| | t | }| | }| j
}|D ]=}t |d r ||j vr n!t t |j | }> | || dS # t $ r} | j t j k r |r(t% | | t sf| j r&| j t j k rt j | _ | t t, | j | j Y d} ~ dS Y d} ~ dS d} ~ ww xY w)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.
Raises:
OSError: if the directory already exists and exist_ok=False,
or as per :py:meth:`create_dir`.
rE Tr r N)r r r r r re r r r# r r hasattrr r r r5 r r r' r rd r r( r )
r` rp r r r dir_name_strr r r es
r: makedirszFakeFilesystem.makedirsW s $ 2 b 1 1 1 55h??
##H-- )
) H 66 ) KK)) )
x ( ( ( ** // == m ( R RIK33
R K$777 "=+2Ei2P Q Q
D OOHd + + + + + D D Dw%,&&
D:dll8.D.Dm#T#T
D% +!'U]*B*B #lAG##Dag$6$6
CCCCCCCCC
D
D
D
D
D
D Ds D
G%B GGst_flagc |t t | } | ||d }|r1| ||| t |j |k S n# t $ r Y dS w xY wdS )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
follow_symlinks: If `False` and path points to a symlink,
the link itself is checked instead of the linked object.
Returns:
(boolean) `True` if the st_flag is set in path's st_mode.
Raises:
TypeError: if path is `None`
NFr )r )r r" r r r
r r )r` r r r r objs r: _is_of_typezFakeFilesystem._is_of_type s , <O$T** ,,y/5,QQC
6== s3F > ck**g55
6
55 us A
A& &
A43A4c : | |t | S )a Determine if path identifies a directory.
Args:
path: Path to filesystem object.
follow_symlinks: If `False` and path points to a symlink,
the link itself is checked instead of the linked object.
Returns:
`True` if path points to a directory (following symlinks).
Raises:
TypeError: if path is `None`.
)r r r` r r s r: r zFakeFilesystem.isdir g???r9 c : | |t | S )a Determine if path identifies a regular file.
Args:
path: Path to filesystem object.
follow_symlinks: If `False` and path points to a symlink,
the link itself is checked instead of the linked object.
Returns:
`True` if path points to a regular file (following symlinks).
Raises:
TypeError: if path is `None`.
)r r r s r: r zFakeFilesystem.isfile r r9 c < | |t d 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`.
Fr )r r r s r: r zFakeFilesystem.islink s gu EEEr9 )r c dS )z+Returns `False`. Junctions are never faked.Fr8 r s r:
isjunctionzFakeFilesystem.isjunction s 5r9 r c t t | |||| }|j t z s!| t j |d |S )a Test that the target is actually a directory, raising OSError
if not.
Args:
target_directory: Path to the target directory within the fake
filesystem.
check_read_perm: If `True`, raises `OSError` if the directory
does not have read permission
check_exe_perm: If `True`, raises `OSError` if the directory
does not have execute (e.g. search) permission
check_owner: If `True`, only checks read permission if the current
user id is different from the file object user id
Returns:
The FakeDirectory object corresponding to target_directory.
Raises:
OSError: if the target is not a directory.
)r r r i )r r r r r r r r )r` r r r r r s r:
confirmdirzFakeFilesystem.confirmdir sl 4 LL / - '
7* F
/? E E Er9 c j t | }| | }| | r| | | | r9| |d }t
|j t k r| | }t
|j t k rJ| j r
t j
}n | j r
t j }n t j }| || | | | rJ| j r
t j
}n | j r
t j }n t j }| || n| || | | 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.
Fr N)r" r r r r r r
r r r r rd r r re rv r r r r r r r )r` r norm_pathr r r s r: r9 zFakeFilesystem.remove s %T** $$Y// ( ( . . B 6 6y A A A ;;y ! ! I,,y%,@@Cck""g-- ==33(*++w66) - % - % % ''y999==!8!8!>!>?? :) . % . % %
''y999==dCHHH 9%%%%%r9
allow_symlinkc V |t |d k r5| j r t j n t j }| || | | }| | }| |d r| j sB| | r-|rdS |r| j
s | t j | | |d }|j
r | t j | | | dS 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 '.'.
rY T)r N)r$ rd r r r r r r r r re r r r r r )r` r r r r
dir_objects r: rmdirzFakeFilesystem.rmdir8 sB /? E E E E'+'9Ku||u|H *: ; ; ; 556FGG
++,<== ??+? > >
1%
I$++6F*G*G
I F$ IDM I''
7GHHH &6D IIJ!
G##EO5EFFF / 0 0 0 0 0
1
1r9 c |g S | |d }| |d }t |j }| j rt
j | |S )a 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. If `shuffle_listdir_results` is set, the order is not the
same in subsequent calls to avoid tests relying on any ordering.
Raises:
OSError: if the target is not a directory.
NTr% F)r )r r listr keysr_ randomshuffle)r` r r directory_contentss r: rS zFakeFilesystem.listdirW s~ #I ,,-=,MMOO$4UOKK !)"3"8"8":": ; ; ' / N- . . .!!r9 c * t | j S ry )rK r rf s r: __str__zFakeFilesystem.__str__o s 4=!!!r9 r > CONIN$CONOUT$AUXCONNULPRNc h | ]}d | S )COMr8 r cs r: zFakeFilesystem.v :::QyQyy:::r9 u 123456789¹²³c h | ]}d | S )LPTr8 r s r: r zFakeFilesystem.w r r9 c , h | ]}t | S r8 )chr)r rx s r: r zFakeFilesystem.z s ' ' 'SVV ' ' 'r9 r, > *"/r} <>?r |c J j sdS fdt j | d } j | j j }t fdt | j D S )NFc 0 t j dk rddlm} || S | dd dv r| dvS j | rdS | d d d } | j v S )
Nr; r )_isreservednamer4 )rY )rY rZ TrY r )
rH rI os.pathr _WIN_RESERVED_CHARS intersectionr rv r _WIN_RESERVED_NAMES)r r r` s r: is_reserved_namez3FakeFilesystem.isreserved..is_reserved_name s <7**777777*?40009
** {22+88>> 4~~c**1-44S99??AAt 777r9 r2 c 3 . K | ]} | V d S ry r8 )r r r s r: rg z,FakeFilesystem.isreserved.. sB ! && r9 )
rd rS fsdecoder rt rP r> r reversedr[ )r` r r s ` @r:
isreservedzFakeFilesystem.isreserved} s %
u
8
8
8
8
8 ;t~~d 3 3A 677D.:||3T5H $TZZ0C%D%D E E
r9 c | t t j | t t j | t t j d S ry )rB StandardStreamWrapperrH stdinstdoutstderrrf s r: r z$FakeFilesystem._add_standard_streams se 0;;<<< 0<<=== 0<<=====r9 c dt _ dD ] }t j | }|r|c S t j dk r t j d S dS )zThis logic is extracted from tempdir._candidate_tempdir_list.
We cannot rely on tempdir.gettempdir() in an empty filesystem, as it tries
to write to the filesystem to ensure that the tempdir is valid.
N)TMPDIRTEMPTMPr z~\AppData\Local\Temp/tmp)tempfiletempdirrS getenvr r
expanduser)r` env_namerp s r:
_tempdir_namez FakeFilesystem._tempdir_name si / Hy**H
7d??7%%&=>> >vr9 c l | }| | s| | t j dk rc| d sP| d| dt
t | j d< d S d S d S )Nr; r r r )
r r r5 rH rI rH r r rY r )r` temp_dirs r: r z FakeFilesystem._create_temp_dir s %%''{{8$$ & OOH % % % <7 " "4;;v+>+> " 1 1 1 CDDd'..0011 2 2; ? ? ? # " " "r9 )NT)rB Nr rk ry )T)TF)r4 )F)TTF)TT)TFTTF)TN)TTN)r1 r2 r3 r4 rS r rq rK r r( r boolrb propertyrg rd setterre r> rt rz r} r r r r r r. r[
contextlibcontextmanagerr) 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) r0 staticmethodr& r rB rF rL r rH rS rV r r r r r{ r r r r r r r ri rr rm r r r r r r r r r r r r r r r rQ r r r r
r r r r r r r r" r r r5 r rs r r< rE rI rO rM rL ra rk r; rH r} r r rG r r r r r r r rH r r r r9 r rS r frozensetr r: r r r r r r8 r9 r: r= r= s $ !gk$( % G- G-G- SMG- G-
G-
G- G- G- G-R <$ < < < X<
t
X
'4 'D ' ' ' ' $ X _'d 't ' ' ' _' : : : : X: 3C 3D 3 3 3 3
=HSM = = = X= &-
-$ - - - '&- > > > > X> > > > > X> > > > > X> S X Z0 0 0 0 0 Z0 - X s X
F
X
Y # #4 # # # Y # + +
+D + + + +& '6 ' ' ' '6 6 6 $
' ' ' ' )-"& 1 11 9%1 3- 1
1 1 1 1.:v :& : : : :F F8F;K F F F FVF Vt V V V V %) 3' 3'3' SM3' 3'
3' 3' 3' 3'jg - 0 8D> & T &,- , , , ,2C HTN R R8F#3 RuS#s]?S R R R R2/ / /HV4D /PT / / / /45 5,25 " " " "4"&v "&%*? "& "& "& "&H7+f 7+ 7+ 7+ 7+r%* %*F %* %* %* %*N 6 6 ;S;T#Y;;; X;
?U?tE{??? X?) V ) V ) ) ) ) V & T B
4
F &Hv H$ H H H H 4 (
U3<-@
T
If I I I I I
&36 x}hw // 0 $& & &T &d & & & &P?/ ?/f ?/ ?/ ?/ ?/ ?/ ?/B '#d6l '#tCy '# '# '# '#Rf ,)c ,)' ,)c ,) ,) ,) ,)b !% # ! 9 99 9 9
9
9 9 9 9v 1 1 \1 !% # T TT T T
T T T T8XG X X X X X( !% $ # !,( ,(%,( ,( ,(
,(
,( ,(
,( ,( ,( ,(\/4W /4 /4 /4 /4 /4b0F 0 0T 0 0 0 06 $ EL EL EL EL EL
EL EL EL ELN .1& 1T 1 1 1 1> #>4:>KO>
> > > >,
& DAA A A
A
A
A A A A0" #" 4:" & " " " " H:v :$ : : : :.2W 2 2 2 2 2 !) : : : : :
: : : :~ !66 !%$( "& $*.4
4
4
4
4
# 4
"
4
4
3-4
4
h'4
4
4
4
4
r )- * * * * g& *
* * * *Z FJ!@ !@"!@19'1B!@ !@ !@ !@ !@L )- ;F ;F ;F ;F ;F
g& ;F
;F ;F ;F ;Fz & B " 4 4< 4 4 4
4 4 4 4@ D !66 !%$( "& $"'*.X XX X X
# X "
X X 3-X
X X h'X
X X X X| %) ;
;
;
;
" ;
;
;
;
;
B !%$( B BB B B
" B
B B B BP !%
4( t %!W %! %! %! %! %!N 6=5E 2
2
2
s 2
$ 2
2
2
2
hf -4," "4< " " " "0" " " " " 7"" 'i = = =::"9:::
;::"9:::
;
(i ' 'UU2YY ' ' '*X*X*X X
8> > > >
" D D D D Dr9 r= rB c F dd l } dd l}| |j S rs )doctestr testmodfake_filesystem)r r s r: _run_doctestr s) NNNOOO ??83 4 44r9 c p | dk r t j S | dk r t j S t d| d )NUSER_IDGROUP_IDz
No attribute rY )r r r r, )r s r: __getattr__r sC y z
2222
3
33r9 __main__)[r4 r rO r r; rS r rH r collectionsr r r r enumr r r r r r
r r r
typingr r r r r r r r r r r r r r r r r r pyfakefs.fake_filer r pyfakefs.helpersr! r" r# r$ r% r& r' r( r) rI r r r. r r rm r rZ FakeFileWrapperr FakeDirWrapperFakePipeWrapperrl FakeOsModule FakeFileOpen FakeIoModuleFakeFcntlModuler\ r r set_uidget_gidset_gid reset_idsr r r r rs r r= r r r1 r8 r9 r: r s C CJ
/ / / / / / / / P O O O O O O O O O O O O O O O 6 6 6 6 6 6 6 6
<7## OO O T % 5 '
!*!I +!7 )+)# % # <7 -O
/
/
/
/
/
%
B0D B0D B0D B0D B0D B0D B0D B0DJ`5k 5 5 5 54 4 4 zLNNNNN r9