Python os.path 模块，sep() 实例源码
我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用os.path.sep()。
def api_get_spec(context, method_list):
'''Generates and Returns the spec file data
:param context: Dictionary with app, session, version and api fields
:type: ```dict
:param method_list: List of API methods to call
:type: ```list```
:return: generated spec file
:rtype: ```basestring```
'''
_generate_documentation(context, method_list)
with open(tempfile.gettempdir() + op.sep + 'spec.yaml') as stream:
try:
spec_file = yaml.load(stream)
except yaml.YAMLError as ex:
raise Exception("Please try again. Exception: {}".format(ex))
return json.dumps(spec_file)```
def write_temp(self):
'''
Stores changes to the spec in a temp file.
'''
spec = {
"swagger": self.api.__getattribute__('swagger'),
"info": self.api.__getattribute__('info'),
"host": self.api.__getattribute__('host'),
"schemes": self.api.__getattribute__('schemes'),
"consumes": self.api.__getattribute__('consumes'),
"produces": self.api.__getattribute__('produces'),
"paths": self.api.__getattribute__('paths'),
"definitions": self.api.__getattribute__('definitions')
}
stream = file((tempfile.gettempdir() + op.sep + 'temp.yaml'), 'w')
for x in self.order:
yaml.dump({x: spec[x]}, stream, default_flow_style=False)
def update_spec(self):
'''
Updates the specification from the temp file.
'''
try:
os.rename(
tempfile.gettempdir() +
op.sep +
'temp.yaml',
tempfile.gettempdir() +
op.sep +
'spec.yaml')
except Exception as e:
raise Exception(
"Spec file not found, please try again."
" Exception: {}".format(e))
def api_get_spec(context, method_list):
'''Generates and Returns the spec file data
:param context: Dictionary with app, session, version and api fields
:type: ```dict
:param method_list: List of API methods to call
:type: ```list```
:return: generated spec file
:rtype: ```basestring```
'''
_generate_documentation(context, method_list)
with open(tempfile.gettempdir() + op.sep + 'spec.yaml') as stream:
try:
spec_file = yaml.load(stream)
except yaml.YAMLError as ex:
raise Exception("Please try again. Exception: {}".format(ex))
return json.dumps(spec_file)```
def write_temp(self):
'''
Stores changes to the spec in a temp file.
'''
spec = {
"swagger": self.api.__getattribute__('swagger'),
"info": self.api.__getattribute__('info'),
"host": self.api.__getattribute__('host'),
"schemes": self.api.__getattribute__('schemes'),
"consumes": self.api.__getattribute__('consumes'),
"produces": self.api.__getattribute__('produces'),
"paths": self.api.__getattribute__('paths'),
"definitions": self.api.__getattribute__('definitions')
}
stream = file((tempfile.gettempdir() + op.sep + 'temp.yaml'), 'w')
for x in self.order:
yaml.dump({x: spec[x]}, stream, default_flow_style=False)
def update_spec(self):
'''
Updates the specification from the temp file.
'''
try:
os.rename(
tempfile.gettempdir() +
op.sep +
'temp.yaml',
tempfile.gettempdir() +
op.sep +
'spec.yaml')
except Exception as e:
raise Exception(
"Spec file not found, please try again."
" Exception: {}".format(e))
def list_templates(self):
found = set()
for searchpath in self.searchpath:
walk_dir = os.walk(searchpath, followlinks=self.followlinks)
for dirpath, dirnames, filenames in walk_dir:
for filename in filenames:
template = os.path.join(dirpath, filename) \
[len(searchpath):].strip(os.path.sep) \
.replace(os.path.sep, '/')
if template[:2] == './':
template = template[2:]
if template not in found:
found.add(template)
return sorted(found)
def proc(tsk):
env = tsk.env
gen = tsk.generator
inc_nodes = gen.to_incnodes(Utils.to_list(getattr(gen,'includes',[])) + env['INCLUDES'])
# FIXME the if-else construct will not work in python 2
cmd = (
[env.PROC] +
['SQLCHECK=SEMANTICS'] +
(['SYS_INCLUDE=(' + ','.join(env.PROC_INCLUDES) + ')']
if env.PROC_INCLUDES else []) +
['INCLUDE=(' + ','.join(
[i.bldpath() for i in inc_nodes]
) + ')'] +
['userid=' + env.PROC_CONNECTION] +
['INAME=' + tsk.inputs[0].bldpath()] +
['ONAME=' + tsk.outputs[0].bldpath()]
)
exec_env = {
'ORACLE_HOME': env.PROC_ORACLE,
'LD_LIBRARY_PATH': env.PROC_ORACLE + path.sep + 'lib',
}
if env.PROC_TNS_ADMIN:
exec_env['TNS_ADMIN'] = env.PROC_TNS_ADMIN
return tsk.exec_command(cmd, env=exec_env)
def proc(tsk):
env = tsk.env
gen = tsk.generator
inc_nodes = gen.to_incnodes(Utils.to_list(getattr(gen,'includes',[])) + env['INCLUDES'])
# FIXME the if-else construct will not work in python 2
cmd = (
[env.PROC] +
['SQLCHECK=SEMANTICS'] +
(['SYS_INCLUDE=(' + ','.join(env.PROC_INCLUDES) + ')']
if env.PROC_INCLUDES else []) +
['INCLUDE=(' + ','.join(
[i.bldpath() for i in inc_nodes]
) + ')'] +
['userid=' + env.PROC_CONNECTION] +
['INAME=' + tsk.inputs[0].bldpath()] +
['ONAME=' + tsk.outputs[0].bldpath()]
)
exec_env = {
'ORACLE_HOME': env.PROC_ORACLE,
'LD_LIBRARY_PATH': env.PROC_ORACLE + path.sep + 'lib',
}
if env.PROC_TNS_ADMIN:
exec_env['TNS_ADMIN'] = env.PROC_TNS_ADMIN
return tsk.exec_command(cmd, env=exec_env)
def list_examples(self):
if isdir(self.examples_dir):
# examples = sorted(os.listdir(self.examples_dir))
examples = [dirname(y).replace(self.examples_dir + sep, '')
for x in os.walk(self.examples_dir)
for y in glob.glob(util.safe_join(x[0], 'info'))]
click.secho('')
for example in examples:
example_dir = util.safe_join(self.examples_dir, example)
if isdir(example_dir):
info_path = util.safe_join(example_dir, 'info')
info = ''
if isfile(info_path):
with codecs.open(info_path, 'r', 'utf-8') as info_file:
info = info_file.read().replace('\n', '')
click.secho(' ' + example, fg='blue', bold=True)
click.secho('-' * click.get_terminal_size()[0])
click.secho(' ' + info)
click.secho('')
click.secho(EXAMPLE_DIR_FILE, fg='green')
click.secho(EXAMPLE_OF_USE_CAD, fg='green')
else:
util._check_package('examples')
return 1
return 0
def probably_a_local_import(self, imp_name):
"""
Like the corresponding method in the base class, but this also
supports Cython modules.
"""
if imp_name.startswith(u"."):
# Relative imports are certainly not local imports.
return False
imp_name = imp_name.split(u".", 1)[0]
base_path = dirname(self.filename)
base_path = join(base_path, imp_name)
# If there is no __init__.py next to the file its not in a package
# so can't be a relative import.
if not exists(join(dirname(base_path), "__init__.py")):
return False
for ext in [".py", sep, ".pyc", ".so", ".sl", ".pyd", ".pyx"]:
if exists(base_path + ext):
return True
return False
def walk_directories(root):
"""'find' in a generator function."""
for child in os.listdir(root):
if child.startswith("."):
continue
full_path = path.join(root, child)
if path.isfile(full_path):
yield full_path
elif full_path.endswith((path.sep+".", path.sep+"..")):
continue
elif path.islink(full_path):
continue
else:
for fp in walk_directories(full_path):
yield fp
def main():
args = parseArgs()
toIgnore = set(args.toIgnore)
while True:
try:
item = SlurpItem.readIn()
ignoredDir = False
for directory in item.path.split(sep):
if directory in toIgnore:
ignoredDir = True
break
if not ignoredDir:
item.print()
except(EOFError):
break
def getFilesInDir(self, excludePath=None):
'''
Recursively returns all files under a given directory.
'''
path = self._dir
if not path.endswith(pathSeparator):
path = path + pathSeparator
files = [path]
for file in iglob(path + '**' + pathSeparator + '*', recursive=True):
if excludePath is not None and file.startswith(excludePath):
continue
files.append(file)
return files
def probably_a_local_import(self, imp_name):
"""
Like the corresponding method in the base class, but this also
supports Cython modules.
"""
if imp_name.startswith(u"."):
# Relative imports are certainly not local imports.
return False
imp_name = imp_name.split(u".", 1)[0]
base_path = dirname(self.filename)
base_path = join(base_path, imp_name)
# If there is no __init__.py next to the file its not in a package
# so can't be a relative import.
if not exists(join(dirname(base_path), "__init__.py")):
return False
for ext in [".py", sep, ".pyc", ".so", ".sl", ".pyd", ".pyx"]:
if exists(base_path + ext):
return True
return False
def _find_new_data_files(root, timestamp,
ignoredirs=[".smt", ".hg", ".svn", ".git", ".bzr"],
ignore_extensions=[".pyc"]):
"""Finds newly created/changed files in root."""
length_root = len(root) + len(path.sep)
new_files = []
for root, dirs, files in os.walk(root):
for igdir in ignoredirs:
if igdir in dirs:
dirs.remove(igdir)
for file in files:
if path.splitext(file)[1] not in ignore_extensions:
full_path = path.join(root, file)
relative_path = path.join(root[length_root:], file)
last_modified = datetime.fromtimestamp(os.stat(full_path).st_mtime)
if last_modified >= timestamp:
new_files.append(relative_path)
return new_files
def doc2path(self, docname, base=True, suffix=None):
"""Return the filename for the document name.
If *base* is True, return absolute path under self.srcdir.
If *base* is None, return relative path to self.srcdir.
If *base* is a path string, return absolute path under that.
If *suffix* is not None, add it instead of config.source_suffix.
"""
docname = docname.replace(SEP, path.sep)
if suffix is None:
for candidate_suffix in self.config.source_suffix:
if path.isfile(path.join(self.srcdir, docname) +
candidate_suffix):
suffix = candidate_suffix
break
else:
# document does not exist
suffix = self.config.source_suffix[0]
if base is True:
return path.join(self.srcdir, docname) + suffix
elif base is None:
return docname + suffix
else:
return path.join(base, docname) + suffix
def relfn2path(self, filename, docname=None):
"""Return paths to a file referenced from a document, relative to
documentation root and absolute.
In the input "filename", absolute filenames are taken as relative to the
source dir, while relative filenames are relative to the dir of the
containing document.
"""
if filename.startswith('/') or filename.startswith(os.sep):
rel_fn = filename[1:]
else:
docdir = path.dirname(self.doc2path(docname or self.docname,
base=None))
rel_fn = path.join(docdir, filename)
try:
# the path.abspath() might seem redundant, but otherwise artifacts
# such as ".." will remain in the path
return rel_fn, path.abspath(path.join(self.srcdir, rel_fn))
except UnicodeDecodeError:
# the source directory is a bytestring with non-ASCII characters;
# let's try to encode the rel_fn in the file system encoding
enc_rel_fn = rel_fn.encode(sys.getfilesystemencoding())
return rel_fn, path.abspath(path.join(self.srcdir, enc_rel_fn))
def probably_a_local_import(self, imp_name):
"""
Like the corresponding method in the base class, but this also
supports Cython modules.
"""
if imp_name.startswith(u"."):
# Relative imports are certainly not local imports.
return False
imp_name = imp_name.split(u".", 1)[0]
base_path = dirname(self.filename)
base_path = join(base_path, imp_name)
# If there is no __init__.py next to the file its not in a package
# so can't be a relative import.
if not exists(join(dirname(base_path), "__init__.py")):
return False
for ext in [".py", sep, ".pyc", ".so", ".sl", ".pyd", ".pyx"]:
if exists(base_path + ext):
return True
return False
def api_get_spec(context, method_list):
'''Generates and Returns the spec file data
:param context: Dictionary with app, session, version and api fields
:type: ```dict
:param method_list: List of API methods to call
:type: ```list```
:return: generated spec file
:rtype: ```basestring```
'''
_generate_documentation(context, method_list)
with open(tempfile.gettempdir() + op.sep + 'spec.yaml') as stream:
try:
spec_file = yaml.load(stream)
except yaml.YAMLError as ex:
raise Exception("Please try again. Exception: {}".format(ex))
return json.dumps(spec_file)```
def write_temp(self):
'''
Stores changes to the spec in a temp file.
'''
spec = {
"swagger": self.api.__getattribute__('swagger'),
"info": self.api.__getattribute__('info'),
"host": self.api.__getattribute__('host'),
"schemes": self.api.__getattribute__('schemes'),
"consumes": self.api.__getattribute__('consumes'),
"produces": self.api.__getattribute__('produces'),
"paths": self.api.__getattribute__('paths'),
"definitions": self.api.__getattribute__('definitions')
}
stream = file((tempfile.gettempdir() + op.sep + 'temp.yaml'), 'w')
for x in self.order:
yaml.dump({x: spec[x]}, stream, default_flow_style=False)
def update_spec(self):
'''
Updates the specification from the temp file.
'''
try:
os.rename(
tempfile.gettempdir() +
op.sep +
'temp.yaml',
tempfile.gettempdir() +
op.sep +
'spec.yaml')
except Exception as e:
raise Exception(
"Spec file not found, please try again."
" Exception: {}".format(e))
def probably_a_local_import(self, imp_name):
"""
Like the corresponding method in the base class, but this also
supports Cython modules.
"""
if imp_name.startswith(u"."):
# Relative imports are certainly not local imports.
return False
imp_name = imp_name.split(u".", 1)[0]
base_path = dirname(self.filename)
base_path = join(base_path, imp_name)
# If there is no __init__.py next to the file its not in a package
# so can't be a relative import.
if not exists(join(dirname(base_path), "__init__.py")):
return False
for ext in [".py", sep, ".pyc", ".so", ".sl", ".pyd", ".pyx"]:
if exists(base_path + ext):
return True
return False
def background_render(self, context, cls, preset):
generator = path.dirname(path.realpath(__file__)) + path.sep + "archipack_thumbs.py"
addon_name = __name__.split('.')[0]
matlib_path = context.user_preferences.addons[addon_name].preferences.matlib_path
# Run external instance of blender like the original thumbnail generator.
cmd = [
bpy.app.binary_path,
"--background",
"--factory-startup",
"-noaudio",
"--python", generator,
"--",
"addon:" + addon_name,
"matlib:" + matlib_path,
"cls:" + cls,
"preset:" + preset
]
popen = subprocess.Popen(cmd, stdout=subprocess.PIPE, universal_newlines=True)
for stdout_line in iter(popen.stdout.readline, ""):
yield stdout_line
popen.stdout.close()
popen.wait()
def scan_files(self, category):
file_list = []
# load default presets
dir_path = path.dirname(path.realpath(__file__))
sub_path = "presets" + path.sep + category
presets_path = path.join(dir_path, sub_path)
if path.exists(presets_path):
file_list += [presets_path + path.sep + f[:-3]
for f in listdir(presets_path)
if f.endswith('.py') and
not f.startswith('.')]
# load user def presets
preset_paths = bpy.utils.script_paths("presets")
for preset in preset_paths:
presets_path = path.join(preset, category)
if path.exists(presets_path):
file_list += [presets_path + path.sep + f[:-3]
for f in listdir(presets_path)
if f.endswith('.py') and
not f.startswith('.')]
file_list.sort()
return file_list
def probably_a_local_import(self, imp_name):
"""
Like the corresponding method in the base class, but this also
supports Cython modules.
"""
if imp_name.startswith(u"."):
# Relative imports are certainly not local imports.
return False
imp_name = imp_name.split(u".", 1)[0]
base_path = dirname(self.filename)
base_path = join(base_path, imp_name)
# If there is no __init__.py next to the file its not in a package
# so can't be a relative import.
if not exists(join(dirname(base_path), "__init__.py")):
return False
for ext in [".py", sep, ".pyc", ".so", ".sl", ".pyd", ".pyx"]:
if exists(base_path + ext):
return True
return False
def files(self):
"""A generator function for iterating over the individual files of
the FileSet.
The generator yields a tuple of ``(rel_dir_name, file_name)``:
1. *rel_dir_name*: The path relative to the starting directory
2. *file_name*: The unqualified file name
"""
directory = self.get_directory()
prefix = len(directory) + (0 if is_root(directory) else 1)
include = None
exclude = None
for root, dirs, files in self.walk(directory):
# Remove the constant part of the path inluding the first path sep
rel_dir_name = root[prefix:]
matched, include, exclude = self._receive(directory,
rel_dir_name,
dirs,
files,
include,
exclude)
for file_name in matched:
yield rel_dir_name, file_name
def _filter_selection(self, folders=True, files=True):
"""Filter the list of selected objects
:param folders: if True - folders will be included in selection
:param files: if True - files will be included in selection
"""
if folders and files:
return
t = []
for entry in self.selection:
if entry == '..' + path.sep:
pass
elif folders and self.browser.file_system.is_dir(entry):
t.append(entry)
elif files and not self.browser.file_system.is_dir(entry):
t.append(entry)
self.selection = t
def probably_a_local_import(self, imp_name):
"""
Like the corresponding method in the base class, but this also
supports Cython modules.
"""
if imp_name.startswith(u"."):
# Relative imports are certainly not local imports.
return False
imp_name = imp_name.split(u".", 1)[0]
base_path = dirname(self.filename)
base_path = join(base_path, imp_name)
# If there is no __init__.py next to the file its not in a package
# so can't be a relative import.
if not exists(join(dirname(base_path), "__init__.py")):
return False
for ext in [".py", sep, ".pyc", ".so", ".sl", ".pyd", ".pyx"]:
if exists(base_path + ext):
return True
return False
def splitstrip(string, sep=','):
"""return a list of stripped string by splitting the string given as
argument on `sep` (',' by default). Empty string are discarded.
>>> splitstrip('a, b, c , 4,,')
['a', 'b', 'c', '4']
>>> splitstrip('a')
['a']
>>>
:type string: str or unicode
:param string: a csv line
:type sep: str or unicode
:param sep: field separator, default to the comma (',')
:rtype: str or unicode
:return: the unquoted string (or the input string if it wasn't quoted)
"""
return [word.strip() for word in string.split(sep) if word.strip()]
def meta_autodetect_platform(cls):
"""
Dark magic to autodetect the platform for built-in shellcodes.
User-defined shellcodes must define *arch* and *os*.
"""
abspath = path.abspath
join = path.join
split = path.split
splitext = path.splitext
sep = path.sep
module = cls.__module__
if module != '__main__':
tokens = cls.__module__.split('.')
if len(tokens) < 2 or tokens[0] != base_package or \
tokens[1] == base_file:
return
tokens.insert(-1, 'any')
tokens = tokens[1:3]
else:
module = abspath(sys.modules[module].__file__)
if not module.startswith(base_dir):
return
tokens = module.split(sep)
tokens = tokens[len(base_dir.split(sep)):-1]
while len(tokens) < 2:
tokens.append('any')
cls.arch, cls.os = tokens
def probably_a_local_import(self, imp_name):
if imp_name.startswith(u"."):
# Relative imports are certainly not local imports.
return False
imp_name = imp_name.split(u".", 1)[0]
base_path = dirname(self.filename)
base_path = join(base_path, imp_name)
# If there is no __init__.py next to the file its not in a package
# so can't be a relative import.
if not exists(join(dirname(base_path), "__init__.py")):
return False
for ext in [".py", sep, ".pyc", ".so", ".sl", ".pyd"]:
if exists(base_path + ext):
return True
return False
def split_template_path(template):
"""Split a path into segments and perform a sanity check. If it detects
'..' in the path it will raise a `TemplateNotFound` error.
"""
pieces = []
for piece in template.split('/'):
if path.sep in piece \
or (path.altsep and path.altsep in piece) or \
piece == path.pardir:
raise TemplateNotFound(template)
elif piece and piece != '.':
pieces.append(piece)
return pieces
def configure(cnf):
env = cnf.env
if not env.PROC_ORACLE:
env.PROC_ORACLE = cnf.options.oracle_home
if not env.PROC_TNS_ADMIN:
env.PROC_TNS_ADMIN = cnf.options.tns_admin
if not env.PROC_CONNECTION:
env.PROC_CONNECTION = cnf.options.connection
cnf.find_program('proc', var='PROC', path_list=env.PROC_ORACLE + path.sep + 'bin')
def configure(cnf):
env = cnf.env
if not env.PROC_ORACLE:
env.PROC_ORACLE = cnf.options.oracle_home
if not env.PROC_TNS_ADMIN:
env.PROC_TNS_ADMIN = cnf.options.tns_admin
if not env.PROC_CONNECTION:
env.PROC_CONNECTION = cnf.options.connection
cnf.find_program('proc', var='PROC', path_list=env.PROC_ORACLE + path.sep + 'bin')
def configure(cnf):
env = cnf.env
if not env.PROC_ORACLE:
env.PROC_ORACLE = cnf.options.oracle_home
if not env.PROC_TNS_ADMIN:
env.PROC_TNS_ADMIN = cnf.options.tns_admin
if not env.PROC_CONNECTION:
env.PROC_CONNECTION = cnf.options.connection
cnf.find_program('proc', var='PROC', path_list=env.PROC_ORACLE + path.sep + 'bin')
def split_template_path(template):
"""Split a path into segments and perform a sanity check. If it detects
'..' in the path it will raise a `TemplateNotFound` error.
"""
pieces = []
for piece in template.split('/'):
if path.sep in piece \
or (path.altsep and path.altsep in piece) or \
piece == path.pardir:
raise TemplateNotFound(template)
elif piece and piece != '.':
pieces.append(piece)
return pieces
def list_templates(self):
found = set()
for searchpath in self.searchpath:
walk_dir = os.walk(searchpath, followlinks=self.followlinks)
for dirpath, dirnames, filenames in walk_dir:
for filename in filenames:
template = os.path.join(dirpath, filename) \
[len(searchpath):].strip(os.path.sep) \
.replace(os.path.sep, '/')
if template[:2] == './':
template = template[2:]
if template not in found:
found.add(template)
return sorted(found)
def split_template_path(template):
"""Split a path into segments and perform a sanity check. If it detects
'..' in the path it will raise a `TemplateNotFound` error.
"""
pieces = []
for piece in template.split('/'):
if path.sep in piece \
or (path.altsep and path.altsep in piece) or \
piece == path.pardir:
raise TemplateNotFound(template)
elif piece and piece != '.':
pieces.append(piece)
return pieces
def list_templates(self):
found = set()
for searchpath in self.searchpath:
walk_dir = os.walk(searchpath, followlinks=self.followlinks)
for dirpath, dirnames, filenames in walk_dir:
for filename in filenames:
template = os.path.join(dirpath, filename) \
[len(searchpath):].strip(os.path.sep) \
.replace(os.path.sep, '/')
if template[:2] == './':
template = template[2:]
if template not in found:
found.add(template)
return sorted(found)
def safe_join(base, *paths):
"""
Joins one or more path components to the base path component intelligently.
Returns a normalized, absolute version of the final path.
The final path must be located inside of the base path component (otherwise
a ValueError is raised).
"""
base = force_text(base)
paths = [force_text(p) for p in paths]
final_path = abspathu(join(base, *paths))
base_path = abspathu(base)
# Ensure final_path starts with base_path (using normcase to ensure we
# don't false-negative on case insensitive operating systems like Windows),
# further, one of the following conditions must be true:
# a) The next character is the path separator (to prevent conditions like
# safe_join("/dir", "/../d"))
# b) The final path must be the same as the base path.
# c) The base path must be the most root path (meaning either "/" or "C:\\")
if (not normcase(final_path).startswith(normcase(base_path + sep)) and
normcase(final_path) != normcase(base_path) and
dirname(normcase(base_path)) != normcase(base_path)):
raise SuspiciousFileOperation(
'The joined path ({}) is located outside of the base path '
'component ({})'.format(final_path, base_path))
return final_path
def split_template_path(template):
"""Split a path into segments and perform a sanity check. If it detects
'..' in the path it will raise a `TemplateNotFound` error.
"""
pieces = []
for piece in template.split('/'):
if path.sep in piece \
or (path.altsep and path.altsep in piece) or \
piece == path.pardir:
raise TemplateNotFound(template)
elif piece and piece != '.':
pieces.append(piece)
return pieces
def list_templates(self):
found = set()
for searchpath in self.searchpath:
walk_dir = os.walk(searchpath, followlinks=self.followlinks)
for dirpath, dirnames, filenames in walk_dir:
for filename in filenames:
template = os.path.join(dirpath, filename) \
[len(searchpath):].strip(os.path.sep) \
.replace(os.path.sep, '/')
if template[:2] == './':
template = template[2:]
if template not in found:
found.add(template)
return sorted(found)
def makedir(self, name):
""" return a directory path object with the given name. If the
directory does not yet exist, it will be created. You can use it
to manage files likes e. g. store/retrieve database
dumps across test sessions.
:param name: must be a string not containing a ``/`` separator.
Make sure the name contains your plugin or application
identifiers to prevent clashes with other cache users.
"""
if _sep in name or _altsep is not None and _altsep in name:
raise ValueError("name is not allowed to contain path separators")
return self._cachedir.ensure_dir("d", name)
def split_template_path(template):
"""Split a path into segments and perform a sanity check. If it detects
'..' in the path it will raise a `TemplateNotFound` error.
"""
pieces = []
for piece in template.split('/'):
if path.sep in piece \
or (path.altsep and path.altsep in piece) or \
piece == path.pardir:
raise TemplateNotFound(template)
elif piece and piece != '.':
pieces.append(piece)
return pieces
def list_templates(self):
found = set()
for searchpath in self.searchpath:
walk_dir = os.walk(searchpath, followlinks=self.followlinks)
for dirpath, dirnames, filenames in walk_dir:
for filename in filenames:
template = os.path.join(dirpath, filename) \
[len(searchpath):].strip(os.path.sep) \
.replace(os.path.sep, '/')
if template[:2] == './':
template = template[2:]
if template not in found:
found.add(template)
return sorted(found)
def split_template_path(template):
"""Split a path into segments and perform a sanity check. If it detects
'..' in the path it will raise a `TemplateNotFound` error.
"""
pieces = []
for piece in template.split('/'):
if path.sep in piece \
or (path.altsep and path.altsep in piece) or \
piece == path.pardir:
raise TemplateNotFound(template)
elif piece and piece != '.':
pieces.append(piece)
return pieces
def list_templates(self):
found = set()
for searchpath in self.searchpath:
walk_dir = os.walk(searchpath, followlinks=self.followlinks)
for dirpath, dirnames, filenames in walk_dir:
for filename in filenames:
template = os.path.join(dirpath, filename) \
[len(searchpath):].strip(os.path.sep) \
.replace(os.path.sep, '/')
if template[:2] == './':
template = template[2:]
if template not in found:
found.add(template)
return sorted(found)
def test_1(self):
n = lambda path: path.replace('/', sep)
assert_equal(minrelpath(n('aa/bb')), n('aa/bb'))
assert_equal(minrelpath('..'), '..')
assert_equal(minrelpath(n('aa/..')), '')
assert_equal(minrelpath(n('aa/../bb')), 'bb')
assert_equal(minrelpath(n('aa/bb/..')), 'aa')
assert_equal(minrelpath(n('aa/bb/../..')), '')
assert_equal(minrelpath(n('aa/bb/../cc/../dd')), n('aa/dd'))
assert_equal(minrelpath(n('.././..')), n('../..'))
assert_equal(minrelpath(n('aa/bb/.././../dd')), n('dd'))
def split_template_path(template):
"""Split a path into segments and perform a sanity check. If it detects
'..' in the path it will raise a `TemplateNotFound` error.
"""
pieces = []
for piece in template.split('/'):
if path.sep in piece \
or (path.altsep and path.altsep in piece) or \
piece == path.pardir:
raise TemplateNotFound(template)
elif piece and piece != '.':
pieces.append(piece)
return pieces