Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2026-03-27 02:38
📄 __init__.py	0 B	2026-01-20 12:58
📄 __main__.py from prospector.run import main if __name__ == "__main__": main()	71 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 autodetect.py import os import re import warnings from pathlib import Path from requirements_detector import find_requirements from requirements_detector.detect import RequirementsNotFound from prospector import encoding from prospector.exceptions import PermissionMissing from prospector.pathutils import is_virtualenv POSSIBLE_LIBRARIES = ("django", "celery", "flask") # see http://docs.python.org/2/reference/lexical_analysis.html#identifiers _FROM_IMPORT_REGEX = re.compile(r"^\sfrom ([\._a-zA-Z0-9]+) import .$") _IMPORT_REGEX = re.compile(r"^\simport ([\._a-zA-Z0-9]+)$") _IMPORT_MULTIPLE_REGEX = re.compile(r"^\simport ([\._a-zA-Z0-9]+(, ){1})+") def find_from_imports(file_contents): names = set() for line in file_contents.split("\n"): match = _IMPORT_MULTIPLE_REGEX.match(line) if match: import_names = [] first = match.group(1) import_names.append(first[:-2]) for name in line.split(first)[1].split(","): import_names.append(name.strip()) else: match = _IMPORT_REGEX.match(line) or _FROM_IMPORT_REGEX.match(line) if match is None: continue import_names = match.group(1).split(".") for import_name in import_names: if import_name in POSSIBLE_LIBRARIES: names.add(import_name) return names def find_from_path(path: Path): names = set() try: for item in path.iterdir(): if item.is_dir(): if is_virtualenv(item): continue names \|= find_from_path(item) elif not item.is_symlink() and item.suffix == ".py": try: contents = encoding.read_py_file(item) names \|= find_from_imports(contents) except encoding.CouldNotHandleEncoding as err: # TODO: this output will break output formats such as JSON warnings.warn(f"{err.path}: {err.__cause__}", ImportWarning) if len(names) == len(POSSIBLE_LIBRARIES): # don't continue on recursing, there's no point! break except PermissionError as err: raise PermissionMissing(path) from err return names def find_from_requirements(path): reqs = find_requirements(path) names = [] for requirement in reqs: if requirement.name is not None and requirement.name.lower() in POSSIBLE_LIBRARIES: names.append(requirement.name.lower()) return names def autodetect_libraries(path): if os.path.isfile(path): path = os.path.dirname(path) if path == "": path = "." libraries = [] try: libraries = find_from_requirements(path) except RequirementsNotFound: pass if len(libraries) < len(POSSIBLE_LIBRARIES): libraries = find_from_path(path) return libraries	2.89 KB	2026-01-20 12:58
📄 blender.py # This module contains the logic for "blending" of errors. # Since prospector runs multiple tools with overlapping functionality, this # module exists to merge together equivalent warnings from different tools for # the same line. For example, both pyflakes and pylint will generate an # "Unused Import" warning on the same line. This is obviously redundant, so we # remove duplicates. from collections import defaultdict import pkg_resources import yaml __all__ = ( "blend", "BLEND_COMBOS", ) def blend_line(messages, blend_combos=None): """ Given a list of messages on the same line, blend them together so that we end up with one message per actual problem. Note that we can still return more than one message here if there are two or more different errors for the line. """ blend_combos = blend_combos or BLEND_COMBOS blend_lists = [[] for _ in range(len(blend_combos))] blended = [] # first we split messages into each of the possible blendable categories # so that we have a list of lists of messages which can be blended together for message in messages: key = (message.source, message.code) found = False for blend_combo_idx, blend_combo in enumerate(blend_combos): if key in blend_combo: found = True blend_lists[blend_combo_idx].append(message) # note: we use 'found=True' here rather than a simple break/for-else # because this allows the same message to be put into more than one # 'bucket'. This means that the same message from pycodestyle can 'subsume' # two from pylint, for example. if not found: # if we get here, then this is not a message which can be blended, # so by definition is already blended blended.append(message) # we should now have a list of messages which all represent the same # problem on the same line, so we will sort them according to the priority # in BLEND and pick the first one for blend_combo_idx, blend_list in enumerate(blend_lists): if len(blend_list) == 0: continue # pylint:disable=cell-var-from-loop blend_list.sort( key=lambda msg: blend_combos[blend_combo_idx].index( (msg.source, msg.code), ), ) if blend_list[0] not in blended: # We may have already added this message if it represents # several messages in other tools which are not being run - # for example, pylint missing-docstring is blended with pydocstyle # D100, D101 and D102, but should not appear 3 times! blended.append(blend_list[0]) # Some messages from a tool point out an error that in another tool is handled by two # different errors or more. For example, pylint emits the same warning (multiple-statements) # for "two statements on a line" separated by a colon and a semi-colon, while pycodestyle has E701 # and E702 for those cases respectively. In this case, the pylint error will not be 'blended' as # it will appear in two blend_lists. Therefore we mark anything not taken from the blend list # as "consumed" and then filter later, to avoid such cases. for now_used in blend_list[1:]: now_used.used = True return [m for m in blended if not getattr(m, "used", False)] def blend(messages, blend_combos=None): blend_combos = blend_combos or BLEND_COMBOS # group messages by file and then line number msgs_grouped = defaultdict(lambda: defaultdict(list)) for message in messages: msgs_grouped[message.location.path][message.location.line].append( message, ) # now blend together all messages on the same line out = [] for by_line in msgs_grouped.values(): for messages_on_line in by_line.values(): out += blend_line(messages_on_line, blend_combos) return out def get_default_blend_combinations(): combos = yaml.safe_load(pkg_resources.resource_string(__name__, "blender_combinations.yaml")) combos = combos.get("combinations", []) defaults = [] for combo in combos: toblend = [] for msg in combo: toblend += msg.items() defaults.append(tuple(toblend)) return tuple(defaults) BLEND_COMBOS = get_default_blend_combinations()	4.34 KB	2026-01-20 12:58
📄 blender_combinations.yaml # 'combinations' is a list of lists of codes to merge together. The earlier # codes will take priority, so if all are found, only the first one will be # left after blending. # # Note that since not all tools will necessarily be run, the first message for # a line as sorted by the code list will be the one remaining after blending. combinations: - # Unused Import - pylint: unused-import - pyflakes: F401 - frosted: E101 - # Syntax Error - dodgy: diff - pylint: syntax-error - pyflakes: F999 - pep8: E901 - pycodestyle: E901 - mccabe: MC0000 - frosted: E402 - # Undefined local variable - pylint: undefined-variable - pyflakes: F821 - frosted: E303 - # Unused variable - pylint: unused-variable - vulture: unused-variable - pyflakes: F841 - frosted: E307 - # Mixed tabs and spaces - pep257: D206 - pydocstyle: D206 - pep8: E101 - pycodestyle: E101 - pylint: indentation-mixture - # Import from __future__ not first import - pylint: misplaced-future - pyflakes: F404 - frosted: E207 - # Line too long - pep8: E501 - pycodestyle: E501 - pylint: line-too-long - # Trailing whitespace - pep8: W291 - pycodestyle: W291 - pylint: trailing-whitespace - # Blank line contains whitespace - pep8: W293 - pycodestyle: W293 - pylint: trailing-whitespace - # No newline at end of file - pep8: W292 - pycodestyle: W292 - pylint: missing-final-newline - # line ends with semi-colon - pep8: E703 - pycodestyle: E703 - pylint: unnecessary-semicolon - # multiple statements on one line (colon) - pep8: E701 - pycodestyle: E701 - pylint: multiple-statements - # multiple statements on one line (semicolon) - pep8: E702 - pycodestyle: E702 - pylint: multiple-statements - # incorrect indentation - pep257: D207 - pydocstyle: D207 - pep8: E111 - pycodestyle: E111 - pylint: bad-indentation - # incorrect indentation - pep257: D208 - pydocstyle: D208 - pep8: E111 - pycodestyle: E111 - pylint: bad-indentation - # comma not followed by a space - pep8: E231 - pycodestyle: E231 - pylint: C0324 - pylint: bad-whitespace - # missing whitespace around operator - pep8: E225 - pycodestyle: E225 - pylint: C0322 - pylint: bad-whitespace - # missing whitespace around operator - pep8: E225 - pycodestyle: E225 - pylint: C0323 - pylint: bad-whitespace - # undefined name in __all__ - pylint: undefined-all-variable - pyflakes: F822 - frosted: E304 - # duplicate argument in function definition - pylint: duplicate-argument-name - pyflakes: F831 - frosted: E206 - # redefinition of unused function - pyflakes: F811 - pylint: function-redefined - # f-string is missing placeholders - pylint: f-string-without-interpolation - pyflakes: F541 - # Duplicate key in dictionary - pylint: duplicate-key - pyflakes: F601 - # More than one starred expression in assignment - pylint: too-many-star-expressions - pyflakes: F622 - # Assert called on a tuple - pylint: assert-on-tuple - pyflakes: F631 - # 'break' outside loop - pylint: not-in-loop - pyflakes: F701 - # 'continue' not properly in loop - pylint: not-in-loop - pyflakes: F702 - # 'continue' not supported inside 'finally' clause - pylint: continue-in-finally - pyflakes: F703 - # Yield outside function - pylint: yield-outside-function - pyflakes: F704 - # Return outside function - pylint: return-outside-function - pyflakes: F706 - # default 'except:' must be last - pylint: bad-except-order - pyflakes: F707 - # NotImplemented raised - should raise NotImplementedError - pylint: notimplemented-raised - pyflakes: F901 - # first argument of a classmethod should be named 'cls' - pep8: N804 - pycodestyle: N804 - pylint: bad-classmethod-argument - # '<>' is deprecated, use '!=' - pep8: W603 - pycodestyle: W603 - pylint: W0331 - # backticks are deprecated, use 'repr()' - pep8: W604 - pycodestyle: W604 - pylint: W0333 - # Redefining name from outer scope - pylint: redefined-outer-name - pyflakes: F810 - frosted: E306 - # Wildcard import - pylint: wildcard-import - pyflakes: F403 - frosted: E103 - # Return with argument inside generator - pylint: return-arg-in-generator - frosted: E208 - # Too many positional arguments for function call - pylint: too-many-function-args - frosted: E203 - # Passing unexpected keyword argument - pylint: unexpected-keyword-arg - frosted: E204 - # Missing mandatory keyword argument - pylint: missing-kwoa - frosted: E205 - # No exception type(s) specified - pylint: bare-except - frosted: W101 - pep8: E722 - pycodestyle: E722 - # Spaces around keyword/parameter equals - pep8: E251 - pycodestyle: E251 - pylint: bad-whitespace - # Missing space after a comma - pep8: E231 - pycodestyle: E231 - pylint: bad-whitespace - # redefinition of unused %r from line %r - pyflakes: F811 - frosted: E301 - # list comprehension redefines %r from line %r - pyflakes: F812 - frosted: E302 - # import %r from line %r shadowed by loop variable - pyflakes: F402 - frosted: E102 - # syntax error in doctest - pyflakes: FL0007 - frosted: E401 - # local variable %r referenced before assignment - pyflakes: F823 - frosted: E305 - # pep8-naming incorrectly suggests that the first argument of a metaclass __new__ method should be 'cls' - pylint: bad-mcs-classmethod-argument - pep8: N804 - pycodestyle: N804 - # class names should be camelcase - pep8: N801 - pycodestyle: N801 - pylint: invalid-name - # too complex - mccabe: MC0001 - pylint: too-many-branches - - mccabe: MC0001 - pylint: too-many-statements - # pep257 takes preference over pylint documentation warnings - pep257: D100 - pydocstyle: D100 - pylint: missing-docstring - - pep257: D101 - pydocstyle: D101 - pylint: missing-docstring - - pep257: D102 - pydocstyle: D102 - pylint: missing-docstring - - pep257: D103 - pydocstyle: D103 - pylint: missing-docstring - - pylint: singleton-comparison - pep8: E711 - pycodestyle: E711	6.4 KB	2026-01-20 12:58
📄 compat.py from pathlib import Path def is_relative_to(relpath: Path, otherpath: Path) -> bool: # is_relative_to was only added to Path in Python 3.9 if hasattr(relpath, "is_relative_to"): return relpath.is_relative_to(otherpath) try: relpath.relative_to(otherpath) except ValueError: return False else: return True	360 B	2026-01-20 12:58
📁 config	-	2026-03-21 15:45
📄 encoding.py import tokenize from pathlib import Path from prospector.exceptions import CouldNotHandleEncoding, PermissionMissing # note: annotating return type with AnyStr does not work here for reasons I can't be bothered to work out # mypy complains with 'Incompatible return value type (got "str", expected "bytes")' def read_py_file(filepath: Path): # see https://docs.python.org/3/library/tokenize.html#tokenize.detect_encoding # first just see if the file is properly encoded try: with open(filepath, "rb") as bfile_: tokenize.detect_encoding(bfile_.readline) except PermissionError as err: raise PermissionMissing(filepath) from err except SyntaxError as err: # this warning is issued: # (1) in badly authored files (contains non-utf8 in a comment line) # (2) a coding is specified, but wrong and # (3) no coding is specified, and the default # 'utf-8' fails to decode. # (4) the encoding specified by a pep263 declaration did not match # with the encoding detected by inspecting the BOM raise CouldNotHandleEncoding(filepath) from err try: with tokenize.open(filepath) as file_: return file_.read() # this warning is issued: # (1) if utf-8 is specified, but latin1 is used with something like \x0e9 appearing # (see http://stackoverflow.com/a/5552623) except UnicodeDecodeError as err: raise CouldNotHandleEncoding(filepath) from err	1.51 KB	2026-01-20 12:58
📄 exceptions.py import os from pathlib import Path class FatalProspectorException(Exception): """ Exception used to indicate an internal prospector problem. Problems in prospector itself should raise this to notify the user directly. Errors in dependent tools should be caught and the user notified elegantly. """ # (see also the --die-on-tool-error flag) def __init__(self, message: str): super().__init__(message) self.message = message class CouldNotHandleEncoding(Exception): def __init__(self, path: Path): super().__init__() self.path = path class PermissionMissing(Exception): def __init__(self, path: Path): docs_url = "https://prospector.landscape.io/en/master/profiles.html#ignoring-paths-and-patterns" if os.path.isdir(path): what = f"directory {path}" else: what = f"the file {path}" error_msg = ( f"The current user {os.getlogin()} does not have permission to open " f"{what}. Either fix permissions or tell prospector to skip it " f"by adding this path to `--ignore-paths` on the commandline " f"or in `ignore-paths` in the prospector profile (see {docs_url})" ) super().__init__(error_msg)	1.26 KB	2026-01-20 12:58
📄 finder.py from pathlib import Path from typing import Callable, Iterable, Iterator, List from prospector.exceptions import PermissionMissing from prospector.pathutils import is_python_module, is_python_package, is_virtualenv _SKIP_DIRECTORIES = (".git", ".tox", ".mypy_cache", ".pytest_cache", ".venv", "__pycache__", "node_modules") class FileFinder: """ This class is responsible for taking a combination of command-line arguments and configuration loaded from a profile to discover all files and modules which should be inspected. Individual tools can be told to ignore certain files, so the job of this class is basically to know which files to pass to which tools to be inspected. """ def __init__(self, *provided_paths: Path, exclusion_filters: Iterable[Callable] = None): """ :param provided_paths: A list of Path objects to search for files and modules - can be either directories or files :param exclusion_filters: An optional list of filters. All paths will be checked against this list - if any return True, the path is excluded. """ self._provided_files = [] self._provided_dirs = [] self._exclusion_filters = [ # we always want to ignore some things lambda _path: _path.is_dir() and _path.name in _SKIP_DIRECTORIES, is_virtualenv, ] + list(exclusion_filters or []) for path in provided_paths: if not path.exists(): raise FileNotFoundError(path) # ensure all paths from now one are absolute paths; they can be converted # to relative paths for output purposes later path = path.absolute() if path.is_file(): self._provided_files.append(path) if path.is_dir(): self._provided_dirs.append(path) def make_syspath(self) -> List[Path]: paths = set() for path in self._provided_dirs: paths.add(path) for module in self.python_modules: paths.add(module.parent) return sorted(paths) def is_excluded(self, path: Path) -> bool: return any(filt(path) for filt in self._exclusion_filters) def _filter(self, paths: Iterable[Path]) -> List[Path]: return [path for path in paths if not self.is_excluded(path)] def _walk(self, directory: Path) -> Iterator[Path]: if not self.is_excluded(directory): yield directory for path in directory.iterdir(): if self.is_excluded(path): continue if path.is_dir(): yield from self._walk(path) else: yield path @property def files(self) -> List[Path]: """ List every individual file found from the given configuration. This method is useful for tools which require an explicit list of files to check. """ files = set() for path in self._provided_files: files.add(path) for directory in self.directories: for path in self._walk(directory): if path.is_file(): files.add(path) return self._filter(files) @property def python_packages(self) -> List[Path]: """ Lists every directory found in the given configuration which is a python module (that is, contains an `__init__.py` file). This method is useful for passing to tools which will do their own discovery of python files. """ return self._filter(d for d in self.directories if is_python_package(d)) @property def python_modules(self) -> List[Path]: """ Lists every directory found in the given configuration which is a python module (that is, contains an `__init__.py` file). This method is useful for passing to tools which will do their own discovery of python files. """ return self._filter(f for f in self.files if is_python_module(f)) @property def directories(self) -> List[Path]: """ Lists every directory found from the given configuration, regardless of its contents. This method is useful for passing to tools which will do their own discovery of python files. """ dirs = set() for directory in self._provided_dirs: dirs.add(directory) try: for obj in self._walk(directory): if obj.is_dir(): dirs.add(obj) except PermissionError as err: raise PermissionMissing(obj) from err return self._filter(dirs)	4.61 KB	2026-01-20 12:58
📁 formatters	-	2026-03-21 15:45
📄 message.py from pathlib import Path from typing import Optional, Union class Location: def __init__( self, path: Union[Path, str], module: Optional[str], function: Optional[str], line: int, character: int ): if isinstance(path, Path): self._path = path elif isinstance(path, str): self._path = Path(path) else: raise ValueError self.module = module or None self.function = function or None self.line = None if line == -1 else line self.character = None if character == -1 else character @property def path(self): return self._path def absolute_path(self) -> Path: return self._path.absolute() def relative_path(self, root: Path) -> Path: return self._path.relative_to(root) def __repr__(self) -> str: return f"{self._path}:L{self.line}:{self.character}" def __hash__(self) -> int: return hash((self._path, self.line, self.character)) def __eq__(self, other: object) -> bool: if not isinstance(other, Location): return False return self._path == other._path and self.line == other.line and self.character == other.character def __lt__(self, other: object) -> bool: if not isinstance(other, Location): raise ValueError if self._path == other._path: if self.line == other.line: return (self.character or -1) < (other.character or -1) return (self.line or -1) < (other.line or -1) # line can be None if it's a file-global warning return self._path < other._path class Message: def __init__(self, source: str, code: str, location: Location, message: str): self.source = source self.code = code self.location = location self.message = message def __repr__(self) -> str: return f"{self.source}-{self.code}" def __eq__(self, other: object) -> bool: if not isinstance(other, Message): return False if self.location == other.location: return self.code == other.code return False def __lt__(self, other) -> bool: if self.location == other.location: return self.code < other.code return self.location < other.location def make_tool_error_message( filepath: Union[Path, str], source: str, code: str, message: str, line: int = 0, character: int = 0, module: str = None, function: str = None, ) -> Message: location = Location(path=filepath, module=module, function=function, line=line, character=character) return Message(source=source, code=code, location=location, message=message)	2.67 KB	2026-01-20 12:58
📄 pathutils.py import os from pathlib import Path def is_python_package(path: Path) -> bool: return path.is_dir() and (path / "__init__.py").exists() def is_python_module(path: Path) -> bool: # TODO: is this too simple? return path.suffix == ".py" def is_virtualenv(path: Path) -> bool: if os.name == "nt": # Windows! clues = ("Scripts", "lib", "include") else: clues = ("bin", "lib", "include") try: # just get the name, iterdir returns absolute paths by default dircontents = [obj.name for obj in path.iterdir()] except (OSError, TypeError): # listdir failed, probably due to path length issues in windows return False if not all(clue in dircontents for clue in clues): # we don't have the 3 directories which would imply # this is a virtualenvironment return False if not all((path / clue).is_dir() for clue in clues): # some of them are not actually directories return False # if we do have all three directories, make sure that it's not # just a coincidence by doing some heuristics on the rest of # the directory if len(dircontents) > 7: # if there are more than 7 things it's probably not a virtualenvironment return False return True	1.28 KB	2026-01-20 12:58
📄 postfilter.py from pathlib import Path from typing import List from prospector.message import Message from prospector.suppression import get_suppressions def filter_messages(filepaths: List[Path], messages: List[Message]) -> List[Message]: """ This method post-processes all messages output by all tools, in order to filter out any based on the overall output. The main aim currently is to use information about messages suppressed by pylint due to inline comments, and use that to suppress messages from other tools representing the same problem. For example: import banana # pylint:disable=unused-import In this situation, pylint will not warn about an unused import as there is inline configuration to disable the warning. Pyflakes will still raise that error, however, because it does not understand pylint disabling messages. This method uses the information about suppressed messages from pylint to squash the unwanted redundant error from pyflakes and frosted. """ paths_to_ignore, lines_to_ignore, messages_to_ignore = get_suppressions(filepaths, messages) filtered = [] for message in messages: # first get rid of the pylint informational messages relative_message_path = Path(message.location.path) if message.source == "pylint" and message.code in ( "suppressed-message", "file-ignored", ): continue # some files are skipped entirely by messages if relative_message_path in paths_to_ignore: continue # some lines are skipped entirely by messages if relative_message_path in lines_to_ignore: if message.location.line in lines_to_ignore[relative_message_path]: continue # and some lines have only certain messages explicitly ignored if relative_message_path in messages_to_ignore: if message.location.line in messages_to_ignore[relative_message_path]: if message.code in messages_to_ignore[relative_message_path][message.location.line]: continue # otherwise this message was not filtered filtered.append(message) return filtered	2.18 KB	2026-01-20 12:58
📁 profiles	-	2026-03-21 15:45
📄 run.py import codecs import os.path import sys import warnings from datetime import datetime from pathlib import Path from typing import TextIO from prospector import blender, postfilter, tools from prospector.compat import is_relative_to from prospector.config import ProspectorConfig from prospector.config import configuration as cfg from prospector.exceptions import FatalProspectorException from prospector.finder import FileFinder from prospector.formatters import FORMATTERS, Formatter from prospector.message import Location, Message from prospector.tools import DEPRECATED_TOOL_NAMES from prospector.tools.utils import CaptureOutput class Prospector: def __init__(self, config: ProspectorConfig): self.config = config self.summary = None self.messages = config.messages def process_messages(self, found_files, messages): if self.config.blending: messages = blender.blend(messages) if self.config.legacy_tool_names: updated = [] new_names = {v: k for k, v in DEPRECATED_TOOL_NAMES.items()} for msg in messages: msg.source = new_names.get(msg.source, msg.source) updated.append(msg) messages = updated return postfilter.filter_messages(found_files.python_modules, messages) def execute(self): deprecated_names = self.config.replace_deprecated_tool_names() summary = { "started": datetime.now(), } summary.update(self.config.get_summary_information()) paths = [Path(p) for p in self.config.paths] found_files = FileFinder(*paths, exclusion_filters=[self.config.make_exclusion_filter()]) messages = [] # see if any old tool names are run for deprecated_name in deprecated_names: loc = Location(self.config.workdir, None, None, None, None) new_name = DEPRECATED_TOOL_NAMES[deprecated_name] msg = ( f"Tool {deprecated_name} has been renamed to {new_name}. " f"The old name {deprecated_name} is now deprecated and will be removed in Prospector 2.0. " f"Please update your prospector configuration." ) message = Message( "prospector", "Deprecation", loc, message=msg, ) messages.append(message) warnings.warn(msg, category=DeprecationWarning) # Run the tools for tool in self.config.get_tools(found_files): for name, cls in tools.TOOLS.items(): if cls == tool.__class__: toolname = name break else: toolname = "Unknown" try: # Tools can output to stdout/stderr in unexpected places, for example, # pydocstyle emits warnings about __all__ and as pyroma exec's the setup.py # file, it will execute any print statements in that, etc etc... with CaptureOutput(hide=not self.config.direct_tool_stdout) as capture: messages += tool.run(found_files) if self.config.include_tool_stdout: loc = Location(self.config.workdir, None, None, None, None) if capture.get_hidden_stderr(): msg = f"stderr from {toolname}:\n{capture.get_hidden_stderr()}" messages.append(Message(toolname, "hidden-output", loc, message=msg)) if capture.get_hidden_stdout(): msg = f"stdout from {toolname}:\n{capture.get_hidden_stdout()}" messages.append(Message(toolname, "hidden-output", loc, message=msg)) except FatalProspectorException as fatal: sys.stderr.write(str(fatal)) sys.exit(2) except Exception as ex: # pylint:disable=broad-except if self.config.die_on_tool_error: raise FatalProspectorException(f"Tool {toolname} failed to run.") from ex loc = Location(self.config.workdir, None, None, None, None) msg = ( f"Tool {toolname} failed to run " f"(exception was raised, re-run prospector with -X to see the stacktrace)" ) message = Message( toolname, "failure", loc, message=msg, ) messages.append(message) messages = self.process_messages(found_files, messages) summary["message_count"] = len(messages) summary["completed"] = datetime.now() delta = summary["completed"] - summary["started"] summary["time_taken"] = "%0.2f" % delta.total_seconds() external_config = [] for tool, configured_by in self.config.configured_by.items(): if configured_by is not None: external_config.append((tool, configured_by)) if len(external_config) > 0: summary["external_config"] = ", ".join(["%s: %s" % info for info in external_config]) self.summary = summary self.messages = self.messages + messages def get_summary(self): return self.summary def get_messages(self): return self.messages def print_messages(self): output_reports = self.config.get_output_report() for report in output_reports: output_format, output_files = report self.summary["formatter"] = output_format relative_to = None # use relative paths by default unless explicitly told otherwise (with a --absolute-paths flag) # or if some paths passed to prospector are not relative to the CWD if not self.config.absolute_paths and all( is_relative_to(p, self.config.workdir) for p in self.config.paths ): relative_to = self.config.workdir formatter = FORMATTERS[output_format](self.summary, self.messages, self.config.profile, relative_to) if not output_files and not self.config.quiet: self.write_to(formatter, sys.stdout) for output_file in output_files: with codecs.open(output_file, "w+") as target: self.write_to(formatter, target) def write_to(self, formatter: Formatter, target: TextIO): # Produce the output target.write( formatter.render( summary=not self.config.messages_only, messages=not self.config.summary_only, profile=self.config.show_profile, ) ) target.write("\n") def get_parser(): """ This is a helper method to return an argparse parser, to be used with the Sphinx argparse plugin for documentation. """ manager = cfg.build_manager() source = cfg.build_command_line_source(prog="prospector", description=None) return source.build_parser(manager.settings, None) def main(): # Get our configuration config = ProspectorConfig() paths = config.paths if len(paths) > 1 and not all(os.path.isfile(path) for path in paths): sys.stderr.write("\nIn multi-path mode, all inputs must be files, " "not directories.\n\n") get_parser().print_usage() sys.exit(2) # Make it so prospector = Prospector(config) prospector.execute() prospector.print_messages() if config.exit_with_zero_on_success(): # if we ran successfully, and the user wants us to, then we'll # exit cleanly sys.exit(0) # otherwise, finding messages is grounds for exiting with an error # code, to make it easier for bash scripts and similar situations # to know if any errors have been found. if len(prospector.get_messages()) > 0: sys.exit(1) sys.exit(0) if __name__ == "__main__": main()	7.91 KB	2026-01-20 12:58
📄 suppression.py r""" Each tool has its own method of ignoring errors and warnings. For example, pylint requires a comment of the form # pylint disable=<error codes> PEP8 will not warn on lines with # noqa Additionally, flake8 follows that convention for pyflakes errors, but pyflakes itself does not. Finally, an entire file is ignored by flake8 if this line is found in the file: # flake8\: noqa (the \ is needed to stop prospector ignoring this file :)) This module's job is to attempt to collect all of these methods into a single coherent list of error suppression locations. """ import re import warnings from collections import defaultdict from pathlib import Path from typing import List from prospector import encoding from prospector.exceptions import FatalProspectorException from prospector.message import Message _FLAKE8_IGNORE_FILE = re.compile(r"flake8[:=]\s*noqa", re.IGNORECASE) _PEP8_IGNORE_LINE = re.compile(r"#\s+noqa", re.IGNORECASE) _PYLINT_SUPPRESSED_MESSAGE = re.compile(r"^Suppressed \'([a-z0-9-]+)\' $from line \d+$$") def get_noqa_suppressions(file_contents): """ Finds all pep8/flake8 suppression messages :param file_contents: A list of file lines :return: A pair - the first is whether to ignore the whole file, the second is a set of (0-indexed) line numbers to ignore. """ ignore_whole_file = False ignore_lines = set() for line_number, line in enumerate(file_contents): if _FLAKE8_IGNORE_FILE.search(line): ignore_whole_file = True if _PEP8_IGNORE_LINE.search(line): ignore_lines.add(line_number + 1) return ignore_whole_file, ignore_lines _PYLINT_EQUIVALENTS = { # TODO: blending has this info already? "unused-import": ( ("pyflakes", "FL0001"), ("frosted", "E101"), ) } def _parse_pylint_informational(messages: List[Message]): ignore_files = set() ignore_messages: dict = defaultdict(lambda: defaultdict(list)) for message in messages: if message.source == "pylint": if message.code == "suppressed-message": # this is a message indicating that a message was raised # by pylint but suppressed by configuration in the file match = _PYLINT_SUPPRESSED_MESSAGE.match(message.message) if not match: raise FatalProspectorException(f"Could not parsed suppressed message from {message.message}") suppressed_code = match.group(1) line_dict = ignore_messages[message.location.path] line_dict[message.location.line].append(suppressed_code) elif message.code == "file-ignored": ignore_files.add(message.location.path) return ignore_files, ignore_messages def get_suppressions(filepaths: List[Path], messages): """ Given every message which was emitted by the tools, and the list of files to inspect, create a list of files to ignore, and a map of filepath -> line-number -> codes to ignore """ paths_to_ignore = set() lines_to_ignore: dict = defaultdict(set) messages_to_ignore: dict = defaultdict(lambda: defaultdict(set)) # first deal with 'noqa' style messages for filepath in filepaths: try: file_contents = encoding.read_py_file(filepath).split("\n") except encoding.CouldNotHandleEncoding as err: # TODO: this output will break output formats such as JSON warnings.warn(f"{err.path}: {err.__cause__}", ImportWarning) continue ignore_file, ignore_lines = get_noqa_suppressions(file_contents) if ignore_file: paths_to_ignore.add(filepath) lines_to_ignore[filepath] \|= ignore_lines # now figure out which messages were suppressed by pylint pylint_ignore_files, pylint_ignore_messages = _parse_pylint_informational(messages) paths_to_ignore \|= pylint_ignore_files for filepath, line in pylint_ignore_messages.items(): for line_number, codes in line.items(): for code in codes: messages_to_ignore[filepath][line_number].add(("pylint", code)) if code in _PYLINT_EQUIVALENTS: for equivalent in _PYLINT_EQUIVALENTS[code]: messages_to_ignore[filepath][line_number].add(equivalent) return paths_to_ignore, lines_to_ignore, messages_to_ignore	4.36 KB	2026-01-20 12:58
📁 tools	-	2026-03-21 15:45

Edit File:

Terminal