Coverage for /home/ionel/open-source/pytest-cov/examples/adhoc-layout/.tox/py27/lib/python2.7/site-packages/py/_path/common.py : 35%

Hot-keys on this page
r m x p toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
""" """ import warnings import os import sys import posixpath import fnmatch import py
# Moved from local.py. iswin32 = sys.platform == "win32" or (getattr(os, '_name', False) == 'nt')
try: from os import fspath except ImportError: def fspath(path): """ Return the string representation of the path. If str or bytes is passed in, it is returned unchanged. This code comes from PEP 519, modified to support earlier versions of python.
This is required for python < 3.6. """
# Work from the object's type to match method resolution of other magic # methods. except AttributeError: if hasattr(path_type, '__fspath__'): raise try: import pathlib except ImportError: pass else: if isinstance(path, pathlib.PurePath): return py.builtin.text(path)
raise TypeError("expected str, bytes or os.PathLike object, not " + path_type.__name__)
class Checkers: _depend_on_existence = 'exists', 'link', 'dir', 'file'
def __init__(self, path):
def dir(self): raise NotImplementedError
def file(self): raise NotImplementedError
def dotfile(self): return self.path.basename.startswith('.')
def ext(self, arg): if not arg.startswith('.'): arg = '.' + arg return self.path.ext == arg
def exists(self): raise NotImplementedError
def basename(self, arg): return self.path.basename == arg
def basestarts(self, arg): return self.path.basename.startswith(arg)
def relto(self, arg): return self.path.relto(arg)
def fnmatch(self, arg):
def endswith(self, arg): return str(self.path).endswith(arg)
def _evaluate(self, kw): except AttributeError: if name[:3] == 'not': invert = True try: meth = getattr(self, name[3:]) except AttributeError: pass raise TypeError( "no %r checker available for %r" % (name, self.path)) else: if bool(value) ^ bool(meth()) ^ invert: return False except (py.error.ENOENT, py.error.ENOTDIR, py.error.EBUSY): # EBUSY feels not entirely correct, # but its kind of necessary since ENOMEDIUM # is not accessible in python for name in self._depend_on_existence: if name in kw: if kw.get(name): return False name = 'not' + name if name in kw: if not kw.get(name): return False return True
class NeverRaised(Exception): pass
class PathBase(object): """ shared implementation for filesystem path objects.""" Checkers = Checkers
def __div__(self, other): return self.join(fspath(other)) __truediv__ = __div__ # py3k
def basename(self): """ basename part of path. """ basename = property(basename, None, None, basename.__doc__)
def dirname(self): """ dirname part of path. """ dirname = property(dirname, None, None, dirname.__doc__)
def purebasename(self): """ pure base name of the path.""" purebasename = property(purebasename, None, None, purebasename.__doc__)
def ext(self): """ extension of the path (including the '.').""" ext = property(ext, None, None, ext.__doc__)
def dirpath(self, *args, **kwargs): """ return the directory path joined with any given path arguments. """ return self.new(basename='').join(*args, **kwargs)
def read_binary(self): """ read and return a bytestring from reading the path. """ with self.open('rb') as f: return f.read()
def read_text(self, encoding): """ read and return a Unicode string from reading the path. """ with self.open("r", encoding=encoding) as f: return f.read()
def read(self, mode='r'): """ read and return a bytestring from reading the path. """ with self.open(mode) as f: return f.read()
def readlines(self, cr=1): """ read and return a list of lines from the path. if cr is False, the newline will be removed from the end of each line. """ if sys.version_info < (3, ): mode = 'rU' else: # python 3 deprecates mode "U" in favor of "newline" option mode = 'r'
if not cr: content = self.read(mode) return content.split('\n') else: f = self.open(mode) try: return f.readlines() finally: f.close()
def load(self): """ (deprecated) return object unpickled from self.read() """ f = self.open('rb') try: import pickle return py.error.checked_call(pickle.load, f) finally: f.close()
def move(self, target): """ move this path to target. """ if target.relto(self): raise py.error.EINVAL( target, "cannot move path into a subdirectory of itself") try: self.rename(target) except py.error.EXDEV: # invalid cross-device link self.copy(target) self.remove()
def __repr__(self): """ return a string representation of this path. """ return repr(str(self))
def check(self, **kw): """ check a path for existence and properties.
Without arguments, return True if the path exists, otherwise False.
valid checkers::
file=1 # is a file file=0 # is not a file (may not even exist) dir=1 # is a dir link=1 # is a link exists=1 # exists
You can specify multiple checker definitions, for example::
path.check(file=1, link=1) # a link pointing to a file """ kw = {'exists': 1}
def fnmatch(self, pattern): """return true if the basename/fullname matches the glob-'pattern'.
valid pattern characters::
* matches everything ? matches any single character [seq] matches any character in seq [!seq] matches any char not in seq
If the pattern contains a path-separator then the full path is used for pattern matching and a '*' is prepended to the pattern.
if the pattern doesn't contain a path-separator the pattern is only matched against the basename. """
def relto(self, relpath): """ return a string which is the relative part of the path to the given 'relpath'. """ raise TypeError("%r: not a string or path object" %(relpath,)) #assert strrelpath[-1] == self.sep #assert strrelpath[-2] != self.sep if os.path.normcase(strself).startswith( os.path.normcase(strrelpath)): return strself[len(strrelpath):]
def ensure_dir(self, *args): """ ensure the path joined with args is a directory. """ return self.ensure(*args, **{"dir": True})
def bestrelpath(self, dest): """ return a string which is a relative path from self (assumed to be a directory) to dest such that self.join(bestrelpath) == dest and if not such path can be determined return dest. """ return os.curdir return str(dest) n = self2base.count(self.sep) + 1 else: except AttributeError: return str(dest)
def exists(self):
def isdir(self):
def isfile(self):
def parts(self, reverse=False): """ return a root-first list of all ancestor directories plus the path itself. """
def common(self, other): """ return the common part shared with the other path or None if there is no common part. """ return last
def __add__(self, other): """ return new path object with 'other' added to the basename""" return self.new(basename=self.basename+str(other))
def __cmp__(self, other): """ return sort value (-1, 0, +1). """ try: return cmp(self.strpath, other.strpath) except AttributeError: return cmp(str(self), str(other)) # self.path, other.path)
def __lt__(self, other): try: return self.strpath < other.strpath except AttributeError: return str(self) < str(other)
def visit(self, fil=None, rec=None, ignore=NeverRaised, bf=False, sort=False): """ yields all paths below the current one
fil is a filter (glob pattern or callable), if not matching the path will not be yielded, defaulting to None (everything is returned)
rec is a filter (glob pattern or callable) that controls whether a node is descended, defaulting to None
ignore is an Exception class that is ignoredwhen calling dirlist() on any of the paths (by default, all exceptions are reported)
bf if True will cause a breadthfirst search instead of the default depthfirst. Default: False
sort if True will sort entries within each directory level. """
def _sortlist(self, res, sort): if hasattr(sort, '__call__'): warnings.warn(DeprecationWarning( "listdir(sort=callable) is deprecated and breaks on python3" ), stacklevel=3) res.sort(sort) else: res.sort()
def samefile(self, other): """ return True if other refers to the same stat object as self. """ return self.strpath == str(other)
def __fspath__(self):
class Visitor: def __init__(self, fil, rec, ignore, bf, sort): fil = FNMatcher(fil) self.rec = FNMatcher(rec) self.rec = lambda path: True else:
def gen(self, path): except self.ignore: return if p.check(dir=1) and (rec is None or rec(p))]) for subdir in dirs: for p in self.gen(subdir): yield p
class FNMatcher: def __init__(self, pattern):
def __call__(self, path):
iswin32 and pattern.find(posixpath.sep) != -1): # Running on Windows, the pattern has no Windows path separators, # and the pattern has one or more Posix path separators. Replace # the Posix path separators with the Windows path separator. pattern = pattern.replace(posixpath.sep, path.sep)
else: name = str(path) # path.strpath # XXX svn? if not os.path.isabs(pattern): pattern = '*' + path.sep + pattern |