Wala shell

Advanced PHP File Manager

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

Name	Size	Last Modified	Actions
📁 ..	-	2026-03-21 15:45
📄 __init__.py """Module containing the logic for the Flake8 entry-points."""	63 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 application.py """Module containing the application logic for Flake8.""" import argparse import configparser import json import logging import time from typing import Dict from typing import List from typing import Optional from typing import Sequence from typing import Set from typing import Tuple import flake8 from flake8 import checker from flake8 import defaults from flake8 import exceptions from flake8 import style_guide from flake8 import utils from flake8.formatting.base import BaseFormatter from flake8.main import debug from flake8.main import options from flake8.options import aggregator from flake8.options import config from flake8.options import manager from flake8.plugins import finder from flake8.plugins import reporter LOG = logging.getLogger(__name__) class Application: """Abstract our application into a class.""" def __init__(self) -> None: """Initialize our application.""" #: The timestamp when the Application instance was instantiated. self.start_time = time.time() #: The timestamp when the Application finished reported errors. self.end_time: Optional[float] = None #: The prelimary argument parser for handling options required for #: obtaining and parsing the configuration file. self.prelim_arg_parser = options.stage1_arg_parser() #: The instance of :class:`flake8.options.manager.OptionManager` used #: to parse and handle the options and arguments passed by the user self.option_manager: Optional[manager.OptionManager] = None self.plugins: Optional[finder.Plugins] = None #: The user-selected formatter from :attr:`formatting_plugins` self.formatter: Optional[BaseFormatter] = None #: The :class:`flake8.style_guide.StyleGuideManager` built from the #: user's options self.guide: Optional[style_guide.StyleGuideManager] = None #: The :class:`flake8.checker.Manager` that will handle running all of #: the checks selected by the user. self.file_checker_manager: Optional[checker.Manager] = None #: The user-supplied options parsed into an instance of #: :class:`argparse.Namespace` self.options: Optional[argparse.Namespace] = None #: The number of errors, warnings, and other messages after running #: flake8 and taking into account ignored errors and lines. self.result_count = 0 #: The total number of errors before accounting for ignored errors and #: lines. self.total_result_count = 0 #: Whether or not something catastrophic happened and we should exit #: with a non-zero status code self.catastrophic_failure = False #: The parsed diff information self.parsed_diff: Dict[str, Set[int]] = {} def parse_preliminary_options( self, argv: Sequence[str] ) -> Tuple[argparse.Namespace, List[str]]: """Get preliminary options from the CLI, pre-plugin-loading. We need to know the values of a few standard options so that we can locate configuration files and configure logging. Since plugins aren't loaded yet, there may be some as-yet-unknown options; we ignore those for now, they'll be parsed later when we do real option parsing. :param argv: Command-line arguments passed in directly. :returns: Populated namespace and list of remaining argument strings. """ args, rest = self.prelim_arg_parser.parse_known_args(argv) # XXX (ericvw): Special case "forwarding" the output file option so # that it can be reparsed again for the BaseFormatter.filename. if args.output_file: rest.extend(("--output-file", args.output_file)) return args, rest def exit_code(self) -> int: """Return the program exit code.""" if self.catastrophic_failure: return 1 assert self.options is not None if self.options.exit_zero: return 0 else: return int(self.result_count > 0) def find_plugins( self, cfg: configparser.RawConfigParser, cfg_dir: str, *, enable_extensions: Optional[str], require_plugins: Optional[str], ) -> None: """Find and load the plugins for this application. Set :attr:`plugins` based on loaded plugins. """ opts = finder.parse_plugin_options( cfg, cfg_dir, enable_extensions=enable_extensions, require_plugins=require_plugins, ) raw = finder.find_plugins(cfg, opts) self.plugins = finder.load_plugins(raw, opts) def register_plugin_options(self) -> None: """Register options provided by plugins to our option manager.""" assert self.plugins is not None self.option_manager = manager.OptionManager( version=flake8.__version__, plugin_versions=self.plugins.versions_str(), parents=[self.prelim_arg_parser], ) options.register_default_options(self.option_manager) self.option_manager.register_plugins(self.plugins) def parse_configuration_and_cli( self, cfg: configparser.RawConfigParser, cfg_dir: str, argv: List[str], ) -> None: """Parse configuration files and the CLI options.""" assert self.option_manager is not None assert self.plugins is not None self.options = aggregator.aggregate_options( self.option_manager, cfg, cfg_dir, argv, ) if self.options.bug_report: info = debug.information(flake8.__version__, self.plugins) print(json.dumps(info, indent=2, sort_keys=True)) raise SystemExit(0) if self.options.diff: LOG.warning( "the --diff option is deprecated and will be removed in a " "future version." ) self.parsed_diff = utils.parse_unified_diff() for loaded in self.plugins.all_plugins(): parse_options = getattr(loaded.obj, "parse_options", None) if parse_options is None: continue # XXX: ideally we wouldn't have two forms of parse_options try: parse_options( self.option_manager, self.options, self.options.filenames, ) except TypeError: parse_options(self.options) def make_formatter(self) -> None: """Initialize a formatter based on the parsed options.""" assert self.plugins is not None assert self.options is not None self.formatter = reporter.make(self.plugins.reporters, self.options) def make_guide(self) -> None: """Initialize our StyleGuide.""" assert self.formatter is not None assert self.options is not None self.guide = style_guide.StyleGuideManager( self.options, self.formatter ) if self.options.diff: self.guide.add_diff_ranges(self.parsed_diff) def make_file_checker_manager(self) -> None: """Initialize our FileChecker Manager.""" assert self.guide is not None assert self.plugins is not None self.file_checker_manager = checker.Manager( style_guide=self.guide, plugins=self.plugins.checkers, ) def run_checks(self) -> None: """Run the actual checks with the FileChecker Manager. This method encapsulates the logic to make a :class:`~flake8.checker.Manger` instance run the checks it is managing. """ assert self.options is not None assert self.file_checker_manager is not None if self.options.diff: files: Optional[List[str]] = sorted(self.parsed_diff) if not files: return else: files = None self.file_checker_manager.start(files) try: self.file_checker_manager.run() except exceptions.PluginExecutionFailed as plugin_failed: print(str(plugin_failed)) print("Run flake8 with greater verbosity to see more details") self.catastrophic_failure = True LOG.info("Finished running") self.file_checker_manager.stop() self.end_time = time.time() def report_benchmarks(self) -> None: """Aggregate, calculate, and report benchmarks for this run.""" assert self.options is not None if not self.options.benchmark: return assert self.file_checker_manager is not None assert self.end_time is not None time_elapsed = self.end_time - self.start_time statistics = [("seconds elapsed", time_elapsed)] add_statistic = statistics.append for statistic in defaults.STATISTIC_NAMES + ("files",): value = self.file_checker_manager.statistics[statistic] total_description = f"total {statistic} processed" add_statistic((total_description, value)) per_second_description = f"{statistic} processed per second" add_statistic((per_second_description, int(value / time_elapsed))) assert self.formatter is not None self.formatter.show_benchmarks(statistics) def report_errors(self) -> None: """Report all the errors found by flake8 3.0. This also updates the :attr:`result_count` attribute with the total number of errors, warnings, and other messages found. """ LOG.info("Reporting errors") assert self.file_checker_manager is not None results = self.file_checker_manager.report() self.total_result_count, self.result_count = results LOG.info( "Found a total of %d violations and reported %d", self.total_result_count, self.result_count, ) def report_statistics(self) -> None: """Aggregate and report statistics from this run.""" assert self.options is not None if not self.options.statistics: return assert self.formatter is not None assert self.guide is not None self.formatter.show_statistics(self.guide.stats) def initialize(self, argv: Sequence[str]) -> None: """Initialize the application to be run. This finds the plugins, registers their options, and parses the command-line arguments. """ # NOTE(sigmavirus24): When updating this, make sure you also update # our legacy API calls to these same methods. prelim_opts, remaining_args = self.parse_preliminary_options(argv) flake8.configure_logging(prelim_opts.verbose, prelim_opts.output_file) cfg, cfg_dir = config.load_config( config=prelim_opts.config, extra=prelim_opts.append_config, isolated=prelim_opts.isolated, ) self.find_plugins( cfg, cfg_dir, enable_extensions=prelim_opts.enable_extensions, require_plugins=prelim_opts.require_plugins, ) self.register_plugin_options() self.parse_configuration_and_cli(cfg, cfg_dir, remaining_args) self.make_formatter() self.make_guide() self.make_file_checker_manager() def report(self) -> None: """Report errors, statistics, and benchmarks.""" assert self.formatter is not None self.formatter.start() self.report_errors() self.report_statistics() self.report_benchmarks() self.formatter.stop() def _run(self, argv: Sequence[str]) -> None: self.initialize(argv) self.run_checks() self.report() def run(self, argv: Sequence[str]) -> None: """Run our application. This method will also handle KeyboardInterrupt exceptions for the entirety of the flake8 application. If it sees a KeyboardInterrupt it will forcibly clean up the :class:`~flake8.checker.Manager`. """ try: self._run(argv) except KeyboardInterrupt as exc: print("... stopped") LOG.critical("Caught keyboard interrupt from user") LOG.exception(exc) self.catastrophic_failure = True except exceptions.ExecutionError as exc: print("There was a critical error during execution of Flake8:") print(exc) LOG.exception(exc) self.catastrophic_failure = True except exceptions.EarlyQuit: self.catastrophic_failure = True print("... stopped while processing files") else: assert self.options is not None if self.options.count: print(self.result_count)	12.71 KB	2026-01-20 12:58
📄 cli.py """Command-line implementation of flake8.""" import sys from typing import Optional from typing import Sequence from flake8.main import application def main(argv: Optional[Sequence[str]] = None) -> int: """Execute the main bit of the application. This handles the creation of an instance of :class:`Application`, runs it, and then exits the application. :param argv: The arguments to be passed to the application for parsing. """ if argv is None: argv = sys.argv[1:] app = application.Application() app.run(argv) return app.exit_code()	594 B	2026-01-20 12:58
📄 debug.py """Module containing the logic for our debugging logic.""" import platform from typing import Any from typing import Dict from flake8.plugins.finder import Plugins def information(version: str, plugins: Plugins) -> Dict[str, Any]: """Generate the information to be printed for the bug report.""" versions = sorted( { (loaded.plugin.package, loaded.plugin.version) for loaded in plugins.all_plugins() if loaded.plugin.package not in {"flake8", "local"} } ) return { "version": version, "plugins": [ {"plugin": plugin, "version": version} for plugin, version in versions ], "platform": { "python_implementation": platform.python_implementation(), "python_version": platform.python_version(), "system": platform.system(), }, }	899 B	2026-01-20 12:58
📄 options.py """Contains the logic for all of the default options for Flake8.""" import argparse from flake8 import defaults from flake8.options.manager import OptionManager def stage1_arg_parser() -> argparse.ArgumentParser: """Register the preliminary options on our OptionManager. The preliminary options include: - ``-v``/``--verbose`` - ``--output-file`` - ``--append-config`` - ``--config`` - ``--isolated`` - ``--enable-extensions`` """ parser = argparse.ArgumentParser(add_help=False) parser.add_argument( "-v", "--verbose", default=0, action="count", help="Print more information about what is happening in flake8. " "This option is repeatable and will increase verbosity each " "time it is repeated.", ) parser.add_argument( "--output-file", default=None, help="Redirect report to a file." ) # Config file options parser.add_argument( "--append-config", action="append", default=[], help="Provide extra config files to parse in addition to the files " "found by Flake8 by default. These files are the last ones read " "and so they take the highest precedence when multiple files " "provide the same option.", ) parser.add_argument( "--config", default=None, help="Path to the config file that will be the authoritative config " "source. This will cause Flake8 to ignore all other " "configuration files.", ) parser.add_argument( "--isolated", default=False, action="store_true", help="Ignore all configuration files.", ) # Plugin enablement options parser.add_argument( "--enable-extensions", help="Enable plugins and extensions that are otherwise disabled " "by default", ) parser.add_argument( "--require-plugins", help="Require specific plugins to be installed before running", ) return parser class JobsArgument: """Type callback for the --jobs argument.""" def __init__(self, arg: str) -> None: """Parse and validate the --jobs argument. :param arg: The argument passed by argparse for validation """ self.is_auto = False self.n_jobs = -1 if arg == "auto": self.is_auto = True elif arg.isdigit(): self.n_jobs = int(arg) else: raise argparse.ArgumentTypeError( f"{arg!r} must be 'auto' or an integer.", ) def __repr__(self) -> str: """Representation for debugging.""" return f"{type(self).__name__}({str(self)!r})" def __str__(self) -> str: """Format our JobsArgument class.""" return "auto" if self.is_auto else str(self.n_jobs) def register_default_options(option_manager: OptionManager) -> None: """Register the default options on our OptionManager. The default options include: - ``-q``/``--quiet`` - ``--color`` - ``--count`` - ``--diff`` - ``--exclude`` - ``--extend-exclude`` - ``--filename`` - ``--format`` - ``--hang-closing`` - ``--ignore`` - ``--extend-ignore`` - ``--per-file-ignores`` - ``--max-line-length`` - ``--max-doc-length`` - ``--indent-size`` - ``--select`` - ``--extend-select`` - ``--disable-noqa`` - ``--show-source`` - ``--statistics`` - ``--exit-zero`` - ``-j``/``--jobs`` - ``--tee`` - ``--benchmark`` - ``--bug-report`` """ add_option = option_manager.add_option add_option( "-q", "--quiet", default=0, action="count", parse_from_config=True, help="Report only file names, or nothing. This option is repeatable.", ) add_option( "--color", choices=("auto", "always", "never"), default="auto", help="Whether to use color in output. Defaults to `%(default)s`.", ) add_option( "--count", action="store_true", parse_from_config=True, help="Print total number of errors to standard output and " "set the exit code to 1 if total is not empty.", ) add_option( "--diff", action="store_true", help="(DEPRECATED) Report changes only within line number ranges in " "the unified diff provided on standard in by the user.", ) add_option( "--exclude", metavar="patterns", default=",".join(defaults.EXCLUDE), comma_separated_list=True, parse_from_config=True, normalize_paths=True, help="Comma-separated list of files or directories to exclude. " "(Default: %(default)s)", ) add_option( "--extend-exclude", metavar="patterns", default="", parse_from_config=True, comma_separated_list=True, normalize_paths=True, help="Comma-separated list of files or directories to add to the list " "of excluded ones.", ) add_option( "--filename", metavar="patterns", default="*.py", parse_from_config=True, comma_separated_list=True, help="Only check for filenames matching the patterns in this comma-" "separated list. (Default: %(default)s)", ) add_option( "--stdin-display-name", default="stdin", help="The name used when reporting errors from code passed via stdin. " "This is useful for editors piping the file contents to flake8. " "(Default: %(default)s)", ) # TODO(sigmavirus24): Figure out --first/--repeat # NOTE(sigmavirus24): We can't use choices for this option since users can # freely provide a format string and that will break if we restrict their # choices. add_option( "--format", metavar="format", default="default", parse_from_config=True, help="Format errors according to the chosen formatter.", ) add_option( "--hang-closing", action="store_true", parse_from_config=True, help="Hang closing bracket instead of matching indentation of opening " "bracket's line.", ) add_option( "--ignore", metavar="errors", parse_from_config=True, comma_separated_list=True, help=( f"Comma-separated list of error codes to ignore (or skip). " f"For example, ``--ignore=E4,E51,W234``. " f"(Default: {','.join(defaults.IGNORE)})" ), ) add_option( "--extend-ignore", metavar="errors", parse_from_config=True, comma_separated_list=True, help="Comma-separated list of error codes to add to the list of " "ignored ones. For example, ``--extend-ignore=E4,E51,W234``.", ) add_option( "--per-file-ignores", default="", parse_from_config=True, help="A pairing of filenames and violation codes that defines which " "violations to ignore in a particular file. The filenames can be " "specified in a manner similar to the ``--exclude`` option and the " "violations work similarly to the ``--ignore`` and ``--select`` " "options.", ) add_option( "--max-line-length", type=int, metavar="n", default=defaults.MAX_LINE_LENGTH, parse_from_config=True, help="Maximum allowed line length for the entirety of this run. " "(Default: %(default)s)", ) add_option( "--max-doc-length", type=int, metavar="n", default=None, parse_from_config=True, help="Maximum allowed doc line length for the entirety of this run. " "(Default: %(default)s)", ) add_option( "--indent-size", type=int, metavar="n", default=defaults.INDENT_SIZE, parse_from_config=True, help="Number of spaces used for indentation (Default: %(default)s)", ) add_option( "--select", metavar="errors", parse_from_config=True, comma_separated_list=True, help=( f"Comma-separated list of error codes to enable. " f"For example, ``--select=E4,E51,W234``. " f"(Default: {','.join(defaults.SELECT)})" ), ) add_option( "--extend-select", metavar="errors", parse_from_config=True, comma_separated_list=True, help=( "Comma-separated list of error codes to add to the list " "of selected ones. For example, ``--extend-select=E4,E51,W234``." ), ) add_option( "--disable-noqa", default=False, parse_from_config=True, action="store_true", help='Disable the effect of "# noqa". This will report errors on ' 'lines with "# noqa" at the end.', ) # TODO(sigmavirus24): Decide what to do about --show-pep8 add_option( "--show-source", action="store_true", parse_from_config=True, help="Show the source generate each error or warning.", ) add_option( "--no-show-source", action="store_false", dest="show_source", parse_from_config=False, help="Negate --show-source", ) add_option( "--statistics", action="store_true", parse_from_config=True, help="Count errors.", ) # Flake8 options add_option( "--exit-zero", action="store_true", help='Exit with status code "0" even if there are errors.', ) add_option( "-j", "--jobs", default="auto", parse_from_config=True, type=JobsArgument, help="Number of subprocesses to use to run checks in parallel. " 'This is ignored on Windows. The default, "auto", will ' "auto-detect the number of processors available to use. " "(Default: %(default)s)", ) add_option( "--tee", default=False, parse_from_config=True, action="store_true", help="Write to stdout and output-file.", ) # Benchmarking add_option( "--benchmark", default=False, action="store_true", help="Print benchmark information about this run of Flake8", ) # Debugging add_option( "--bug-report", action="store_true", help="Print information necessary when preparing a bug report", )	10.4 KB	2026-01-20 12:58

Terminal