code string | signature string | docstring string | loss_without_docstring float64 | loss_with_docstring float64 | factor float64 |
|---|---|---|---|---|---|
if self._context is None:
self._context = {}
res = super(RoomReservationSummary, self).default_get(fields)
# Added default datetime as today and date to as today + 30.
from_dt = datetime.today()
dt_from = from_dt.strftime(dt)
to_dt = from_dt + relativ... | def default_get(self, fields) | To get default values for the object.
@param self: The object pointer.
@param fields: List of fields for which we want default values
@return: A dictionary which of fields with values. | 2.678645 | 2.754668 | 0.972402 |
'''
When you change checkout or checkin it will check whether
Checkout date should be greater than Checkin date
and update dummy field
-----------------------------------------------------------
@param self: object pointer
@return: raise warning depending on the v... | def on_change_check_out(self) | When you change checkout or checkin it will check whether
Checkout date should be greater than Checkin date
and update dummy field
-----------------------------------------------------------
@param self: object pointer
@return: raise warning depending on the validation | 9.361034 | 2.074994 | 4.511356 |
if self._context is None:
self._context = {}
res = super(QuickRoomReservation, self).default_get(fields)
if self._context:
keys = self._context.keys()
if 'date' in keys:
res.update({'check_in': self._context['date']})
if 'r... | def default_get(self, fields) | To get default values for the object.
@param self: The object pointer.
@param fields: List of fields for which we want default values
@return: A dictionary which of fields with values. | 3.026831 | 3.302015 | 0.916662 |
hotel_res_obj = self.env['hotel.reservation']
for res in self:
rec = (hotel_res_obj.create
({'partner_id': res.partner_id.id,
'partner_invoice_id': res.partner_invoice_id.id,
'partner_order_id': res.partner_order_id.id,
... | def room_reserve(self) | This method create a new record for hotel.reservation
-----------------------------------------------------
@param self: The object pointer
@return: new record set for hotel reservation. | 2.805351 | 2.740473 | 1.023674 |
dirs = []
files = []
for entry in filesystem.listdir(root):
if filesystem.isdir(filesystem.joinpaths(root, entry)):
dirs.append(entry)
else:
files.append(entry)
return root, dirs, files | def _classify_directory_contents(filesystem, root) | Classify contents of a directory as files/directories.
Args:
filesystem: The fake filesystem used for implementation
root: (str) Directory to examine.
Returns:
(tuple) A tuple consisting of three values: the directory examined,
a list containing all of the directory entries, an... | 2.454451 | 2.868496 | 0.855658 |
def do_walk(top_dir, top_most=False):
top_dir = filesystem.normpath(top_dir)
if not top_most and not followlinks and filesystem.islink(top_dir):
return
try:
top_contents = _classify_directory_contents(filesystem, top_dir)
except OSError as exc:
... | def walk(filesystem, top, topdown=True, onerror=None, followlinks=False) | Perform an os.walk operation over the fake filesystem.
Args:
filesystem: The fake filesystem used for implementation
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... | 2.986758 | 2.99848 | 0.996091 |
if self._inode is None:
self.stat(follow_symlinks=False)
return self._inode | def inode(self) | Return the inode number of the entry. | 4.470258 | 3.819265 | 1.17045 |
if follow_symlinks:
if self._statresult_symlink is None:
file_object = self._filesystem.resolve(self.path)
if self._filesystem.is_windows_fs:
file_object.st_nlink = 0
self._statresult_symlink = file_object.stat_result.copy(... | def stat(self, follow_symlinks=True) | Return a stat_result object for this entry.
Args:
follow_symlinks: If False and the entry is a symlink, return the
result for the symlink, otherwise for the object it points to. | 2.656302 | 2.705036 | 0.981984 |
return walk(self.filesystem, top, topdown, onerror, followlinks) | def walk(self, top, topdown=True, onerror=None, followlinks=False) | Perform a 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 (`Fa... | 5.082217 | 10.822596 | 0.469593 |
@Deprecator(func.__name__, deprecated_name)
def _old_function(*args, **kwargs):
return func(*args, **kwargs)
setattr(clss, deprecated_name, _old_function) | def add(clss, func, deprecated_name) | Add the deprecated version of a member function to the given class.
Gives a deprecation warning on usage.
Args:
clss: the class where the deprecated function is to be added
func: the actual function that is called by the deprecated version
deprecated_name: the deprec... | 3.655627 | 4.341335 | 0.842051 |
# pylint: disable=protected-access
FakePath.filesystem = filesystem
FakePathlibModule.PureWindowsPath._flavour = _FakeWindowsFlavour(
filesystem)
FakePathlibModule.PurePosixPath._flavour = _FakePosixFlavour(filesystem) | def init_module(filesystem) | Initializes the fake module with the fake file system. | 6.094135 | 5.886249 | 1.035317 |
if sep is None:
sep = self.filesystem.path_separator
if self.filesystem.is_windows_fs:
return self._splitroot_with_drive(path, sep)
return self._splitroot_posix(path, sep) | def splitroot(self, path, sep=None) | Split path into drive, root and rest. | 3.398806 | 3.391845 | 1.002052 |
if self.filesystem.is_windows_fs:
return [p.lower() for p in parts]
return parts | def casefold_parts(self, parts) | Return the lower-case version of parts for a Windows filesystem. | 5.835855 | 3.423949 | 1.704422 |
if self.filesystem.is_windows_fs:
return self._resolve_windows(path, strict)
return self._resolve_posix(path, strict) | def resolve(self, path, strict) | Make the path absolute, resolving any symlinks. | 3.893409 | 3.759514 | 1.035615 |
if sys.version_info >= (3, 6) or pathlib2:
if strict is None:
strict = False
else:
if strict is not None:
raise TypeError(
"resolve() got an unexpected keyword argument 'strict'")
strict = True
if se... | def resolve(self, strict=None) | Make the path absolute, resolving all symlinks on the way and also
normalizing it (for example turning slashes into backslashes
under Windows).
Args:
strict: If False (default) no exception is raised if the path
does not exist.
New in Python 3.6.
... | 4.015443 | 3.896875 | 1.030426 |
if self._closed:
self._raise_closed()
return FakeFileOpen(self.filesystem, use_io=True)(
self._path(), mode, buffering, encoding, errors, newline) | def open(self, mode='r', buffering=-1, encoding=None,
errors=None, newline=None) | Open the file pointed by this path and return a fake file object.
Raises:
IOError: if the target object is a directory, the path is invalid
or permission is denied. | 8.256112 | 7.874536 | 1.048457 |
if self._closed:
self._raise_closed()
if self.exists():
if exist_ok:
self.filesystem.utime(self._path(), None)
else:
self.filesystem.raise_os_error(errno.EEXIST, self._path())
else:
fake_file = self.open('w'... | def touch(self, mode=0o666, exist_ok=True) | Create a fake file for the path with the given access mode,
if it doesn't exist.
Args:
mode: the file mode for the file if it does not exist
exist_ok: if the file already exists and this is True, nothing
happens, otherwise FileExistError is raised
Raises... | 3.423176 | 3.464244 | 0.988145 |
saved = sys.modules.pop(old.__name__, None)
new = __import__(old.__name__)
sys.modules[old.__name__] = saved
return new | def _copy_module(old) | Recompiles and creates new module object. | 3.248013 | 3.148623 | 1.031566 |
if not IS_PY2 and isinstance(self.byte_contents, bytes):
return self.byte_contents.decode(
self.encoding or locale.getpreferredencoding(False),
errors=self.errors)
return self.byte_contents | def contents(self) | Return the contents as string with the original encoding. | 3.937292 | 3.440978 | 1.144236 |
self._check_positive_int(st_size)
if self.st_size:
self.size = 0
if self.filesystem:
self.filesystem.change_disk_usage(st_size, self.name, self.st_dev)
self.st_size = st_size
self._byte_contents = None | def set_large_file_size(self, st_size) | 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`.
... | 5.077024 | 5.347377 | 0.949442 |
contents = self._encode_contents(contents)
changed = self._byte_contents != contents
st_size = len(contents)
if self._byte_contents:
self.size = 0
current_size = self.st_size or 0
self.filesystem.change_disk_usage(
st_size - current_size,... | def _set_initial_contents(self, contents) | 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,
... | 4.791617 | 4.827044 | 0.992661 |
self.encoding = encoding
changed = self._set_initial_contents(contents)
if self._side_effect is not None:
self._side_effect(self)
return changed | def set_contents(self, contents, encoding=None) | 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 str... | 5.139163 | 5.482925 | 0.937303 |
names = []
obj = self
while obj:
names.insert(0, obj.name)
obj = obj.parent_dir
sep = self.filesystem._path_separator(self.name)
if names[0] == sep:
names.pop(0)
dir_path = sep.join(names)
# Windows paths with d... | def path(self) | Return the full path of the current object. | 3.96312 | 3.821557 | 1.037043 |
self._check_positive_int(st_size)
current_size = self.st_size or 0
self.filesystem.change_disk_usage(
st_size - current_size, self.name, self.st_dev)
if self._byte_contents:
if st_size < current_size:
self._byte_contents = self._byte_cont... | def size(self, st_size) | 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 | 3.221198 | 3.046973 | 1.05718 |
return [item[0] for item in sorted(
self.byte_contents.items(), key=lambda entry: entry[1].st_ino)] | def ordered_dirs(self) | Return the list of contained directory entry names ordered by
creation order. | 8.429183 | 6.329671 | 1.331694 |
if (not is_root() and not self.st_mode & PERM_WRITE and
not self.filesystem.is_windows_fs):
exception = IOError if IS_PY2 else OSError
raise exception(errno.EACCES, 'Permission Denied', self.path)
if path_object.name in self.contents:
self.fi... | def add_entry(self, path_object) | 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 | 3.286717 | 3.220625 | 1.020521 |
pathname_name = self._normalized_entryname(pathname_name)
return self.contents[pathname_name] | def get_entry(self, pathname_name) | 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. | 6.277727 | 12.94245 | 0.485049 |
pathname_name = self._normalized_entryname(pathname_name)
entry = self.get_entry(pathname_name)
if self.filesystem.is_windows_fs:
if entry.st_mode & PERM_WRITE == 0:
self.filesystem.raise_os_error(errno.EACCES, pathname_name)
if self.filesystem.ha... | def remove_entry(self, pathname_name, recursive=True) | 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) f... | 3.110166 | 3.165787 | 0.982431 |
obj = self
while obj:
if obj == dir_object:
return True
obj = obj.parent_dir
return False | def has_parent_object(self, dir_object) | Return `True` if dir_object is a direct or indirect parent
directory, or if both are the same object. | 3.035205 | 2.713013 | 1.118758 |
if not self.contents_read:
self.contents_read = True
base = self.path
for entry in os.listdir(self.source_path):
source_path = os.path.join(self.source_path, entry)
target_path = os.path.join(base, entry)
if os.path.isd... | def contents(self) | Return the list of contained directory entries, loading them
if not already loaded. | 2.568265 | 2.401602 | 1.069397 |
self.root = FakeDirectory(self.path_separator, filesystem=self)
self.cwd = self.root.name
self.open_files = []
self._free_fd_heap = []
self._last_ino = 0
self._last_dev = 0
self.mount_points = {}
self.add_mount_point(self.root.name, total_size)
... | def reset(self, total_size=None) | Remove all file system contents and reset the root. | 5.965101 | 5.339505 | 1.117164 |
message = self._error_message(errno)
if (winerror is not None and sys.platform == 'win32' and
self.is_windows_fs):
if IS_PY2:
raise WindowsError(winerror, message, filename)
raise OSError(errno, message, filename, winerror)
raise O... | def raise_os_error(self, errno, filename=None, winerror=None) | 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 ... | 3.89685 | 4.505946 | 0.864824 |
raise IOError(errno, self._error_message(errno), filename) | def raise_io_error(self, errno, filename=None) | 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. | 5.299739 | 8.415839 | 0.629734 |
if string is None:
return string
if IS_PY2:
# pylint: disable=undefined-variable
if isinstance(matched, text_type):
return text_type(string)
else:
if isinstance(matched, bytes) and isinstance(string, str):
r... | def _matching_string(matched, string) | Return the string as byte or unicode depending
on the type of matched, assuming string is an ASCII string. | 3.148082 | 2.952441 | 1.066264 |
path = self.absnormpath(path)
if path in self.mount_points:
self.raise_os_error(errno.EEXIST, path)
self._last_dev += 1
self.mount_points[path] = {
'idev': self._last_dev, 'total_size': total_size, 'used_size': 0
}
# special handling for r... | def add_mount_point(self, path, total_size=None) | 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:... | 4.399224 | 4.730593 | 0.929952 |
DiskUsage = namedtuple('usage', 'total, used, free')
if path is None:
mount_point = self.mount_points[self.root.name]
else:
mount_point = self._mount_point_for_path(path)
if mount_point and mount_point['total_size'] is not None:
return DiskUsa... | def get_disk_usage(self, path=None) | 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
`... | 2.185263 | 2.28569 | 0.956063 |
if path is None:
path = self.root.name
mount_point = self._mount_point_for_path(path)
if (mount_point['total_size'] is not None and
mount_point['used_size'] > total_size):
self.raise_io_error(errno.ENOSPC, path)
mount_point['total_size'] =... | def set_disk_usage(self, total_size, path=None) | 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
... | 3.384455 | 3.449833 | 0.981049 |
mount_point = self._mount_point_for_device(st_dev)
if mount_point:
total_size = mount_point['total_size']
if total_size is not None:
if total_size - mount_point['used_size'] < usage_change:
self.raise_io_error(errno.ENOSPC, file_path)
... | def change_disk_usage(self, usage_change, file_path, st_dev) | 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 fi... | 3.042359 | 3.429556 | 0.8871 |
# stat should return the tuple representing return value of os.stat
try:
file_object = self.resolve(
entry_path, follow_symlinks, allow_fd=True)
self.raise_for_filepath_ending_with_separator(
entry_path, file_object, follow_symlinks)
... | def stat(self, entry_path, follow_symlinks=True) | 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:
... | 4.598177 | 4.896217 | 0.939129 |
try:
file_object = self.resolve(path, follow_symlinks, allow_fd=True)
except IOError as io_error:
if io_error.errno == errno.ENOENT:
self.raise_os_error(errno.ENOENT, path)
raise
if self.is_windows_fs:
if mode & PERM_WRITE:... | def chmod(self, path, mode, follow_symlinks=True) | 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. | 2.582397 | 2.737522 | 0.943334 |
self._handle_utime_arg_errors(ns, times)
try:
file_object = self.resolve(path, follow_symlinks, allow_fd=True)
except IOError as io_error:
if io_error.errno == errno.ENOENT:
self.raise_os_error(errno.ENOENT, path)
raise
if tim... | def utime(self, path, times=None, ns=None, follow_symlinks=True) | 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 curren... | 2.129893 | 2.123772 | 1.002882 |
if self._free_fd_heap:
open_fd = heapq.heappop(self._free_fd_heap)
self.open_files[open_fd] = [file_obj]
return open_fd
self.open_files.append([file_obj])
return len(self.open_files) - 1 | def _add_open_file(self, file_obj) | 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 t... | 2.981802 | 3.010026 | 0.990623 |
self.open_files[file_des] = None
heapq.heappush(self._free_fd_heap, file_des) | def _close_open_file(self, file_des) | 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. | 4.601688 | 5.027507 | 0.915302 |
if not is_int_type(file_des):
raise TypeError('an integer is required')
if (file_des >= len(self.open_files) or
self.open_files[file_des] is None):
self.raise_os_error(errno.EBADF, str(file_des))
return self.open_files[file_des][0] | def get_open_file(self, file_des) | 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. | 3.389194 | 3.332501 | 1.017012 |
return (file_object in [wrappers[0].get_object()
for wrappers in self.open_files if wrappers]) | def has_open_file(self, file_object) | 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. | 13.541162 | 18.636913 | 0.726578 |
path = self.normcase(path)
drive, path = self.splitdrive(path)
sep = self._path_separator(path)
is_absolute_path = path.startswith(sep)
path_components = path.split(sep)
collapsed_path_components = []
dot = self._matching_string(path, '.')
dotdot ... | def normpath(self, path) | 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 r... | 3.100442 | 3.237347 | 0.957711 |
def components_to_path():
if len(path_components) > len(normalized_components):
normalized_components.extend(
path_components[len(normalized_components):])
sep = self._path_separator(path)
normalized_path = sep.join(normalized_com... | def _original_path(self, path) | 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. | 2.928386 | 2.954915 | 0.991022 |
path = self.normcase(path)
cwd = self._matching_string(path, self.cwd)
if not path:
path = self.path_separator
elif not self._starts_with_root_path(path):
# Prefix relative paths with cwd, if cwd is not root.
root_name = self._matching_string(... | def absnormpath(self, path) | 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,
... | 4.842148 | 5.200397 | 0.931111 |
path = self.normcase(path)
sep = self._path_separator(path)
path_components = path.split(sep)
if not path_components:
return ('', '')
starts_with_drive = self._starts_with_drive_letter(path)
basename = path_components.pop()
colon = self._matc... | def splitpath(self, path) | 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 n... | 3.286455 | 3.256694 | 1.009138 |
path = make_string_path(path)
if self.is_windows_fs:
if len(path) >= 2:
path = self.normcase(path)
sep = self._path_separator(path)
# UNC path handling is here since Python 2.7.8,
# back-ported from Python 3
... | def splitdrive(self, path) | 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
... | 3.579839 | 3.629419 | 0.986339 |
base_path = all_paths[0]
paths_to_add = all_paths[1:]
sep = self._path_separator(base_path)
seps = [sep, self._alternative_path_separator(base_path)]
result_drive, result_path = self.splitdrive(base_path)
for path in paths_to_add:
drive_part, path_par... | def _join_paths_with_drive_support(self, *all_paths) | Taken from Python 3.5 os.path.join() code in ntpath.py
and slightly adapted | 2.996002 | 2.913392 | 1.028355 |
if sys.version_info >= (3, 6):
paths = [os.fspath(path) for path in paths]
if len(paths) == 1:
return paths[0]
if self.is_windows_fs:
return self._join_paths_with_drive_support(*paths)
joined_path_segments = []
sep = self._path_separat... | def joinpaths(self, *paths) | 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. | 3.006624 | 3.037786 | 0.989742 |
if not path or path == self._path_separator(path):
return []
drive, path = self.splitdrive(path)
path_components = path.split(self._path_separator(path))
assert drive or path_components
if not path_components[0]:
if len(path_components) > 1 and no... | def _path_components(self, path) | 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.absnormpat... | 2.732765 | 2.818337 | 0.969638 |
colon = self._matching_string(file_path, ':')
return (self.is_windows_fs and len(file_path) >= 2 and
file_path[:1].isalpha and (file_path[1:2]) == colon) | def _starts_with_drive_letter(self, file_path) | 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. | 7.307717 | 8.570239 | 0.852685 |
if is_int_type(file_path):
return False
file_path = make_string_path(file_path)
return (file_path and
file_path not in (self.path_separator,
self.alternative_path_separator) and
(file_path.endswith(self._path_... | def ends_with_path_separator(self, file_path) | Return True if ``file_path`` ends with a valid path separator. | 3.411391 | 3.247788 | 1.050374 |
if check_link and self.islink(file_path):
return True
file_path = make_string_path(file_path)
if file_path is None:
raise TypeError
if not file_path:
return False
if file_path == self.dev_null.name:
return not self.is_windo... | def exists(self, file_path, check_link=False) | 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. | 3.009733 | 3.020421 | 0.996461 |
if (allow_fd and sys.version_info >= (3, 3) and
isinstance(file_path, int)):
return self.get_open_file(file_path).get_object().path
file_path = make_string_path(file_path)
if file_path is None:
# file.open(None) raises TypeError, so mimic that.
... | def resolve_path(self, file_path, allow_fd=False, raw_io=True) | 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 appen... | 3.906885 | 3.819273 | 1.02294 |
link_path = link.contents
sep = self._path_separator(link_path)
# For links to absolute paths, we want to throw out everything
# in the path built so far and replace with the link. For relative
# links, we have to append the link to what we have so far,
if not se... | def _follow_link(self, link_path_components, link) | 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 yi... | 7.127042 | 6.126386 | 1.163335 |
file_path = make_string_path(file_path)
if file_path == self.root.name:
return self.root
if file_path == self.dev_null.name:
return self.dev_null
file_path = self._original_path(file_path)
path_components = self._path_components(file_path)
... | def get_object_from_normpath(self, file_path) | 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.
... | 2.566631 | 2.587279 | 0.99202 |
file_path = make_string_path(file_path)
file_path = self.absnormpath(self._original_path(file_path))
return self.get_object_from_normpath(file_path) | def get_object(self, file_path) | 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. | 5.783728 | 8.071951 | 0.716522 |
if isinstance(file_path, int):
if allow_fd and sys.version_info >= (3, 3):
return self.get_open_file(file_path).get_object()
raise TypeError('path should be string, bytes or '
'os.PathLike (if supported), not int')
if follow_s... | def resolve(self, file_path, follow_symlinks=True, allow_fd=False) | 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 ... | 4.282808 | 4.503484 | 0.950999 |
path = make_string_path(path)
if path == self.root.name:
# The root directory will never be a link
return self.root
# remove trailing separator
path = self._path_without_trailing_separators(path)
path = self._original_path(path)
parent_d... | def lresolve(self, path) | 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 FakeFil... | 3.420427 | 3.515641 | 0.972917 |
error_fct = error_fct or self.raise_os_error
if not file_path:
target_directory = self.root
else:
target_directory = self.resolve(file_path)
if not S_ISDIR(target_directory.st_mode):
error = errno.ENOENT if self.is_windows_fs else errn... | def add_object(self, file_path, file_object, error_fct=None) | 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... | 3.50458 | 3.830026 | 0.915028 |
ends_with_sep = self.ends_with_path_separator(old_file_path)
old_file_path = self.absnormpath(old_file_path)
new_file_path = self.absnormpath(new_file_path)
if not self.exists(old_file_path, check_link=True):
self.raise_os_error(errno.ENOENT, old_file_path, 2)
... | def rename(self, old_file_path, new_file_path, force_replace=False) | 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 d... | 2.347044 | 2.357952 | 0.995374 |
file_path = self.absnormpath(self._original_path(file_path))
if self._is_root_path(file_path):
self.raise_os_error(errno.EBUSY, file_path)
try:
dirname, basename = self.splitpath(file_path)
target_directory = self.resolve(dirname)
target_d... | def remove_object(self, file_path) | 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 di... | 3.038493 | 3.113019 | 0.97606 |
directory_path = self.make_string_path(directory_path)
directory_path = self.absnormpath(directory_path)
self._auto_mount_drive_if_needed(directory_path)
if self.exists(directory_path, check_link=True):
self.raise_os_error(errno.EEXIST, directory_path)
path_c... | def create_dir(self, directory_path, perm_bits=PERM_DEF) | 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.
... | 3.129259 | 3.215786 | 0.973093 |
return self.create_file_internally(
file_path, st_mode, contents, st_size, create_missing_dirs,
apply_umask, encoding, errors, side_effect=side_effect) | def create_file(self, file_path, st_mode=S_IFREG | PERM_DEF_FILE,
contents='', st_size=None, create_missing_dirs=True,
apply_umask=False, encoding=None, errors=None,
side_effect=None) | 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... | 2.16239 | 3.182322 | 0.679501 |
target_path = target_path or source_path
source_path = make_string_path(source_path)
target_path = self.make_string_path(target_path)
real_stat = os.stat(source_path)
fake_file = self.create_file_internally(target_path,
rea... | def add_real_file(self, source_path, read_only=True, target_path=None) | 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 th... | 4.077146 | 4.032969 | 1.010954 |
source_path = self._path_without_trailing_separators(source_path)
if not os.path.exists(source_path):
self.raise_io_error(errno.ENOENT, source_path)
target_path = target_path or source_path
if lazy_read:
parent_path = os.path.split(target_path)[0]
... | def add_real_directory(self, source_path, read_only=True, lazy_read=True,
target_path=None) | 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 directo... | 2.341354 | 2.410004 | 0.971515 |
for path in path_list:
if os.path.isdir(path):
self.add_real_directory(path, read_only, lazy_dir_read)
else:
self.add_real_file(path, read_only) | def add_real_paths(self, path_list, read_only=True, lazy_dir_read=True) | 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 se... | 1.814133 | 1.961726 | 0.924764 |
error_fct = self.raise_os_error if raw_io else self.raise_io_error
file_path = self.make_string_path(file_path)
file_path = self.absnormpath(file_path)
if not is_int_type(st_mode):
raise TypeError(
'st_mode must be of int type - did you mean to set co... | def create_file_internally(self, file_path,
st_mode=S_IFREG | PERM_DEF_FILE,
contents='', st_size=None,
create_missing_dirs=True,
apply_umask=False, encoding=None, errors=None,
... | 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 i... | 2.874638 | 2.86289 | 1.004104 |
if not self._is_link_supported():
raise OSError("Symbolic links are not supported "
"on Windows before Python 3.2")
# the link path cannot end with a path separator
file_path = self.make_string_path(file_path)
link_target = self.make_string... | def create_symlink(self, file_path, link_target, create_missing_dirs=True) | 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
Re... | 2.990037 | 2.930587 | 1.020286 |
if not self._is_link_supported():
raise OSError(
"Links are not supported on Windows before Python 3.2")
new_path_normalized = self.absnormpath(new_path)
if self.exists(new_path_normalized, check_link=True):
self.raise_os_error(errno.EEXIST, new_p... | def link(self, old_path, new_path) | 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 somethi... | 2.822024 | 2.668858 | 1.05739 |
if path is None:
raise TypeError
try:
link_obj = self.lresolve(path)
except IOError as exc:
self.raise_os_error(exc.errno, path)
if S_IFMT(link_obj.st_mode) != S_IFLNK:
self.raise_os_error(errno.EINVAL, path)
if self.ends_... | def readlink(self, path) | 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, o... | 2.935302 | 2.97643 | 0.986182 |
dir_name = make_string_path(dir_name)
ends_with_sep = self.ends_with_path_separator(dir_name)
dir_name = self._path_without_trailing_separators(dir_name)
if not dir_name:
self.raise_os_error(errno.ENOENT, '')
if self.is_windows_fs:
dir_name = sel... | def makedir(self, dir_name, mode=PERM_DEF) | 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.
Rai... | 3.542042 | 3.458168 | 1.024254 |
ends_with_sep = self.ends_with_path_separator(dir_name)
dir_name = self.absnormpath(dir_name)
if (ends_with_sep and self.is_macos and
self.exists(dir_name, check_link=True) and
not self.exists(dir_name)):
# to avoid EEXIST exception, remove th... | def makedirs(self, dir_name, mode=PERM_DEF, exist_ok=False) | 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 i... | 3.939149 | 3.808972 | 1.034176 |
path = make_string_path(path)
if path is None:
raise TypeError
try:
obj = self.resolve(path, follow_symlinks)
if obj:
self.raise_for_filepath_ending_with_separator(
path, obj, macos_handling=not follow_symlinks)
... | def _is_of_type(self, path, st_flag, follow_symlinks=True) | 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 se... | 5.016561 | 6.261273 | 0.801205 |
return self._is_of_type(path, S_IFDIR, follow_symlinks) | def isdir(self, path, follow_symlinks=True) | 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. | 5.604362 | 9.912016 | 0.565411 |
return self._is_of_type(path, S_IFREG, follow_symlinks) | def isfile(self, path, follow_symlinks=True) | 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. | 5.501225 | 9.558235 | 0.575548 |
try:
directory = self.resolve(target_directory)
except IOError as exc:
self.raise_os_error(exc.errno, target_directory)
if not directory.st_mode & S_IFDIR:
if self.is_windows_fs and IS_PY2:
error_nr = errno.EINVAL
else:
... | def confirmdir(self, target_directory) | 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:
OSErr... | 4.096989 | 4.243064 | 0.965573 |
norm_path = self.absnormpath(path)
if self.ends_with_path_separator(path):
self._handle_broken_link_with_trailing_sep(norm_path)
if self.exists(norm_path):
obj = self.resolve(norm_path)
if S_IFMT(obj.st_mode) == S_IFDIR:
link_obj = sel... | def remove(self, path) | 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. | 2.909721 | 3.037276 | 0.958003 |
if target_directory in (b'.', u'.'):
error_nr = errno.EACCES if self.is_windows_fs else errno.EINVAL
self.raise_os_error(error_nr, target_directory)
ends_with_sep = self.ends_with_path_separator(target_directory)
target_directory = self.absnormpath(target_directo... | def rmdir(self, target_directory, allow_symlink=False) | 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 n... | 3.113236 | 3.158872 | 0.985553 |
target_directory = self.resolve_path(target_directory, allow_fd=True)
directory = self.confirmdir(target_directory)
directory_contents = directory.contents
return list(directory_contents.keys()) | def listdir(self, target_directory) | 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 t... | 5.52775 | 8.204695 | 0.67373 |
dir = [
'abspath', 'dirname', 'exists', 'expanduser', 'getatime',
'getctime', 'getmtime', 'getsize', 'isabs', 'isdir', 'isfile',
'islink', 'ismount', 'join', 'lexists', 'normcase', 'normpath',
'realpath', 'relpath', 'split', 'splitdrive'
]
... | def dir() | Return the list of patched function names. Used for patching
functions imported from the module. | 2.676979 | 2.632078 | 1.017059 |
try:
file_obj = self.filesystem.resolve(path)
if (self.filesystem.ends_with_path_separator(path) and
S_IFMT(file_obj.st_mode) != S_IFDIR):
error_nr = (errno.EINVAL if self.filesystem.is_windows_fs
else errno.ENOTDIR... | def getsize(self, path) | Return the file object size in bytes.
Args:
path: path to the file object.
Returns:
file size in bytes. | 3.600447 | 3.767091 | 0.955763 |
if self.filesystem.is_windows_fs:
path = self.splitdrive(path)[1]
path = make_string_path(path)
sep = self.filesystem._path_separator(path)
altsep = self.filesystem._alternative_path_separator(path)
if self.filesystem.is_windows_fs:
return len(pat... | def isabs(self, path) | Return True if path is an absolute pathname. | 3.357527 | 3.294059 | 1.019267 |
try:
file_obj = self.filesystem.resolve(path)
return file_obj.st_mtime
except IOError:
self.filesystem.raise_os_error(errno.ENOENT, winerror=3) | def getmtime(self, path) | 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. | 5.190369 | 6.058887 | 0.856654 |
try:
file_obj = self.filesystem.resolve(path)
except IOError:
self.filesystem.raise_os_error(errno.ENOENT)
return file_obj.st_atime | def getatime(self, path) | 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 ... | 4.127321 | 4.902571 | 0.841869 |
try:
file_obj = self.filesystem.resolve(path)
except IOError:
self.filesystem.raise_os_error(errno.ENOENT)
return file_obj.st_ctime | def getctime(self, path) | 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. | 4.207653 | 5.158571 | 0.815662 |
def getcwd():
# pylint: disable=undefined-variable
if IS_PY2 and isinstance(path, text_type):
return self.os.getcwdu()
elif not IS_PY2 and isinstance(path, bytes):
return self.os.getcwdb()
else:
... | def abspath(self, path) | Return the absolute version of a path. | 3.18971 | 3.146443 | 1.013751 |
path = self.filesystem.normcase(path)
if self.filesystem.is_windows_fs:
path = path.lower()
return path | def normcase(self, path) | Convert to lower case under windows, replaces additional path
separator. | 4.20464 | 3.960205 | 1.061723 |
if not path:
raise ValueError("no path specified")
path = make_string_path(path)
if start is not None:
start = make_string_path(start)
else:
start = self.filesystem.cwd
if self.filesystem.alternative_path_separator is not None:
... | def relpath(self, path, start=None) | We mostly rely on the native implementation and adapt the
path separator. | 1.991519 | 1.971085 | 1.010367 |
if self.filesystem.is_windows_fs:
return self.abspath(filename)
filename = make_string_path(filename)
path, ok = self._joinrealpath(filename[:0], filename, {})
return self.abspath(path) | def realpath(self, filename) | Return the canonical path of the specified filename, eliminating any
symbolic links encountered in the path. | 8.884166 | 8.749492 | 1.015392 |
curdir = self.filesystem._matching_string(path, '.')
pardir = self.filesystem._matching_string(path, '..')
sep = self.filesystem._path_separator(path)
if self.isabs(rest):
rest = rest[1:]
path = sep
while rest:
name, _, rest = rest.p... | def _joinrealpath(self, path, rest, seen) | Join two paths, normalizing and eliminating any symbolic links
encountered in the second path.
Taken from Python source and adapted. | 3.42254 | 3.291976 | 1.039661 |
return self._os_path.expanduser(path).replace(
self._os_path.sep, self.sep) | def expanduser(self, path) | Return the argument with an initial component of ~ or ~user
replaced by that user's home directory. | 4.794312 | 5.764659 | 0.831673 |
path = make_string_path(path)
if not path:
return False
normed_path = self.filesystem.absnormpath(path)
sep = self.filesystem._path_separator(path)
if self.filesystem.is_windows_fs:
if self.filesystem.alternative_path_separator is not None:
... | def ismount(self, path) | 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 exis... | 3.358984 | 3.404227 | 0.98671 |
dir = [
'access', 'chdir', 'chmod', 'chown', 'close', 'fstat', 'fsync',
'getcwd', 'lchmod', 'link', 'listdir', 'lstat', 'makedirs',
'mkdir', 'mknod', 'open', 'read', 'readlink', 'remove',
'removedirs', 'rename', 'rmdir', 'stat', 'symlink', 'umask',
... | def dir() | Return the list of patched function names. Used for patching
functions imported from the module. | 2.858774 | 2.814232 | 1.015827 |
if not is_int_type(args[0]):
raise TypeError('an integer is required')
return FakeFileOpen(self.filesystem)(*args, **kwargs) | def _fdopen(self, *args, **kwargs) | 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. | 8.370149 | 10.921403 | 0.766399 |
raise TypeError('an integer is required')
try:
return FakeFileOpen(self.filesystem).call(file_des, mode=mode)
except IOError as exc:
self.filesystem.raise_os_error(exc.errno, exc.filename) | def _fdopen_ver2(self, file_des, mode='r',
bufsize=None): # pylint: disable=unused-argument
if not is_int_type(file_des) | 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.
... | 7.026113 | 7.591384 | 0.925538 |
if self.filesystem.is_windows_fs:
# windows always returns 0 - it has no real notion of umask
return 0
if sys.platform == 'win32':
# if we are testing Unix under Windows we assume a default mask
return 0o002
else:
# under Unix,... | def _umask(self) | Return the current umask. | 7.737578 | 7.535858 | 1.026768 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.