shell bypass 403
# -*- coding: utf-8 -*-
import os
from prospector.pathutils import is_virtualenv
class SingleFiles(object):
"""
When prospector is run in 'single file mode' - that is,
the argument is a python module rather than a directory -
then we'll use this object instead of the FoundFiles to
give all the functionality needed to check a single file.
"""
# The 'even if ignored' parameters are kept to show this is meant
# to be API compatible with FoundFiles, but pylint will warn, so
# let's disable
# pylint:disable=unused-argument
def __init__(self, files, rootpath):
self.files = files
self.rootpath = rootpath
def _check(self, checkpath, abspath=True):
if abspath:
checkpath = os.path.abspath(checkpath)
return checkpath in map(os.path.abspath, self.files)
return checkpath in self.files
def check_module(self, filepath, abspath=True, even_if_ignored=False):
return self._check(filepath, abspath)
def check_package(self, filepath, abspath=True, even_if_ignored=False):
return self._check(filepath, abspath)
def check_file(self, filepath, abspath=True, even_if_ignored=False):
return self._check(filepath, abspath)
def iter_file_paths(self, abspath=True, include_ignored=False):
for filepath in self.files:
yield os.path.abspath(filepath) if abspath else filepath
def iter_package_paths(self, abspath=True, include_ignored=False):
for filepath in self.files:
yield os.path.abspath(filepath) if abspath else filepath
def iter_directory_paths(self, abspath=True, include_ignored=False):
for filepath in self.files:
filepath = os.path.dirname(filepath)
yield os.path.abspath(filepath) if abspath else filepath
def iter_module_paths(self, abspath=True, include_ignored=False):
for filepath in self.files:
yield os.path.abspath(filepath) if abspath else filepath
def to_absolute_path(self, path):
return os.path.abspath(os.path.join(self.rootpath, path))
def get_minimal_syspath(self, absolute_paths=True):
paths = list(set(map(os.path.dirname, self.files)))
if absolute_paths:
paths = list(map(os.path.abspath, paths))
return [self.rootpath] + paths
class FoundFiles(object):
def __init__(self, rootpath, files, modules, packages, directories, ignores):
self.rootpath = rootpath
self._files = files
self._modules = modules
self._packages = packages
self._directories = directories
self._ignores = ignores
def _check(self, filepath, pathlist, abspath=True, even_if_ignored=False):
path = os.path.relpath(filepath, self.rootpath) if abspath else filepath
for checkpath, ignored in pathlist:
if path == checkpath:
if ignored and not even_if_ignored:
break
return True
return False
def check_module(self, filepath, abspath=True, even_if_ignored=False):
return self._check(filepath, self._modules, abspath, even_if_ignored)
def check_package(self, filepath, abspath=True, even_if_ignored=False):
return self._check(filepath, self._packages, abspath, even_if_ignored)
def check_file(self, filepath, abspath=True, even_if_ignored=False):
return self._check(filepath, self._files, abspath, even_if_ignored)
def _iter_paths(self, pathlist, abspath=True, include_ignored=False):
for path, ignored in pathlist:
if ignored and not include_ignored:
continue
if abspath:
path = self.to_absolute_path(path)
yield path
def iter_file_paths(self, abspath=True, include_ignored=False):
return self._iter_paths(self._files, abspath, include_ignored)
def iter_package_paths(self, abspath=True, include_ignored=False):
return self._iter_paths(self._packages, abspath, include_ignored)
def iter_directory_paths(self, abspath=True, include_ignored=False):
return self._iter_paths(self._directories, abspath, include_ignored)
def iter_module_paths(self, abspath=True, include_ignored=False):
return self._iter_paths(self._modules, abspath, include_ignored)
def to_absolute_path(self, path):
return os.path.abspath(os.path.join(self.rootpath, path))
def get_minimal_syspath(self, absolute_paths=True):
"""
Provide a list of directories that, when added to sys.path, would enable
any of the discovered python modules to be found
"""
# firstly, gather a list of the minimum path to each package
package_list = set()
packages = [p[0] for p in self._packages if not p[1]]
for package in sorted(packages, key=len):
parent = os.path.split(package)[0]
if parent not in packages and parent not in package_list:
package_list.add(parent)
# now add the directory containing any modules who are not in packages
module_list = []
modules = [m[0] for m in self._modules if not m[1]]
for module in modules:
dirname = os.path.dirname(module)
if dirname not in packages:
module_list.append(dirname)
full_list = sorted(set(module_list) | package_list | {self.rootpath}, key=len)
if absolute_paths:
full_list = [os.path.join(self.rootpath, p).rstrip(os.path.sep) for p in full_list]
return full_list
def _find_paths(ignore, curpath, rootpath):
files, modules, packages, directories = [], [], [], []
for filename in os.listdir(curpath):
fullpath = os.path.join(curpath, filename)
try:
relpath = os.path.relpath(fullpath, rootpath)
except ValueError:
# relpath breaks on long paths in Windows
continue
if filename.startswith('.') and os.path.isdir(fullpath):
continue
if os.path.islink(fullpath):
continue
ignored = any([m.search(relpath) for m in ignore])
if os.path.isdir(fullpath):
# is it probably a virtualenvironment?
if is_virtualenv(fullpath) or '.tox' in fullpath:
continue
# this is a directory
directories.append((relpath, ignored))
# is it also a package?
initpy = os.path.join(fullpath, '__init__.py')
if os.path.exists(initpy) and os.path.isfile(initpy):
packages.append((relpath, ignored))
# do the same for this directory
recurse = _find_paths(ignore, os.path.join(curpath, filename), rootpath)
files += recurse[0]
modules += recurse[1]
packages += recurse[2]
directories += recurse[3]
else:
# this is a file, is it a python module?
if fullpath.endswith('.py'):
modules.append((relpath, ignored))
files.append((relpath, ignored))
return files, modules, packages, directories
def find_python(ignores, paths, explicit_file_mode, workdir=''):
"""
Returns a FoundFiles class containing a list of files, packages, directories,
where files are simply all python (.py) files, packages are directories
containing an `__init__.py` file, and directories is a list of all directories.
All paths are relative to the dirpath argument.
"""
if explicit_file_mode:
return SingleFiles(paths, workdir or os.getcwd())
else:
assert len(paths) == 1
files, modules, directories, packages = _find_paths(ignores, paths[0], workdir)
return FoundFiles(workdir, files, modules, directories, packages, ignores)