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 """Submodule of built-in plugins and plugin managers."""	57 B	2026-01-20 12:58
📁 __pycache__	-	2026-03-21 15:45
📄 finder.py """Functions related to finding and loading plugins.""" import configparser import inspect import itertools import logging import re import sys from typing import Any from typing import Dict from typing import FrozenSet from typing import Generator from typing import Iterable from typing import List from typing import NamedTuple from typing import Optional from typing import Tuple from flake8 import utils from flake8._compat import importlib_metadata from flake8.exceptions import ExecutionError from flake8.exceptions import FailedToLoadPlugin LOG = logging.getLogger(__name__) VALID_CODE = re.compile("^[A-Z]{1,3}[0-9]{0,3}$", re.ASCII) FLAKE8_GROUPS = frozenset(("flake8.extension", "flake8.report")) BANNED_PLUGINS = { "flake8-colors": "5.0", "flake8-per-file-ignores": "3.7", } class Plugin(NamedTuple): """A plugin before loading.""" package: str version: str entry_point: importlib_metadata.EntryPoint class LoadedPlugin(NamedTuple): """Represents a plugin after being imported.""" plugin: Plugin obj: Any parameters: Dict[str, bool] @property def entry_name(self) -> str: """Return the name given in the packaging metadata.""" return self.plugin.entry_point.name @property def display_name(self) -> str: """Return the name for use in user-facing / error messages.""" return f"{self.plugin.package}[{self.entry_name}]" class Checkers(NamedTuple): """Classified plugins needed for checking.""" tree: List[LoadedPlugin] logical_line: List[LoadedPlugin] physical_line: List[LoadedPlugin] class Plugins(NamedTuple): """Classified plugins.""" checkers: Checkers reporters: Dict[str, LoadedPlugin] disabled: List[LoadedPlugin] def all_plugins(self) -> Generator[LoadedPlugin, None, None]: """Return an iterator over all :class:`LoadedPlugin`s.""" yield from self.checkers.tree yield from self.checkers.logical_line yield from self.checkers.physical_line yield from self.reporters.values() def versions_str(self) -> str: """Return a user-displayed list of plugin versions.""" return ", ".join( sorted( { f"{loaded.plugin.package}: {loaded.plugin.version}" for loaded in self.all_plugins() if loaded.plugin.package not in {"flake8", "local"} } ) ) class PluginOptions(NamedTuple): """Options related to plugin loading.""" local_plugin_paths: Tuple[str, ...] enable_extensions: FrozenSet[str] require_plugins: FrozenSet[str] @classmethod def blank(cls) -> "PluginOptions": """Make a blank PluginOptions, mostly used for tests.""" return cls( local_plugin_paths=(), enable_extensions=frozenset(), require_plugins=frozenset(), ) def _parse_option( cfg: configparser.RawConfigParser, cfg_opt_name: str, opt: Optional[str], ) -> List[str]: # specified on commandline: use that if opt is not None: return utils.parse_comma_separated_list(opt) else: # ideally this would reuse our config parsing framework but we need to # parse this from preliminary options before plugins are enabled for opt_name in (cfg_opt_name, cfg_opt_name.replace("_", "-")): val = cfg.get("flake8", opt_name, fallback=None) if val is not None: return utils.parse_comma_separated_list(val) else: return [] def parse_plugin_options( cfg: configparser.RawConfigParser, cfg_dir: str, , enable_extensions: Optional[str], require_plugins: Optional[str], ) -> PluginOptions: """Parse plugin loading related options.""" paths_s = cfg.get("flake8:local-plugins", "paths", fallback="").strip() paths = utils.parse_comma_separated_list(paths_s) paths = utils.normalize_paths(paths, cfg_dir) return PluginOptions( local_plugin_paths=tuple(paths), enable_extensions=frozenset( _parse_option(cfg, "enable_extensions", enable_extensions), ), require_plugins=frozenset( _parse_option(cfg, "require_plugins", require_plugins), ), ) def _flake8_plugins( eps: Iterable[importlib_metadata.EntryPoint], name: str, version: str, ) -> Generator[Plugin, None, None]: pyflakes_meta = importlib_metadata.distribution("pyflakes").metadata pycodestyle_meta = importlib_metadata.distribution("pycodestyle").metadata for ep in eps: if ep.group not in FLAKE8_GROUPS: continue if ep.name == "F": yield Plugin(pyflakes_meta["name"], pyflakes_meta["version"], ep) elif ep.name in "EW": # pycodestyle provides both `E` and `W` -- but our default select # handles those # ideally pycodestyle's plugin entrypoints would exactly represent # the codes they produce... yield Plugin( pycodestyle_meta["name"], pycodestyle_meta["version"], ep ) else: yield Plugin(name, version, ep) def _find_importlib_plugins() -> Generator[Plugin, None, None]: # some misconfigured pythons (RHEL) have things on `sys.path` twice seen = set() for dist in importlib_metadata.distributions(): # assigned to prevent continual reparsing eps = dist.entry_points # perf: skip parsing `.metadata` (slow) if no entry points match if not any(ep.group in FLAKE8_GROUPS for ep in eps): continue # assigned to prevent continual reparsing meta = dist.metadata if meta["name"] in seen: continue else: seen.add(meta["name"]) if meta["name"] in BANNED_PLUGINS: LOG.warning( "%s plugin is obsolete in flake8>=%s", meta["name"], BANNED_PLUGINS[meta["name"]], ) continue elif meta["name"] == "flake8": # special case flake8 which provides plugins for pyflakes / # pycodestyle yield from _flake8_plugins(eps, meta["name"], meta["version"]) continue for ep in eps: if ep.group in FLAKE8_GROUPS: yield Plugin(meta["name"], meta["version"], ep) def _find_local_plugins( cfg: configparser.RawConfigParser, ) -> Generator[Plugin, None, None]: for plugin_type in ("extension", "report"): group = f"flake8.{plugin_type}" for plugin_s in utils.parse_comma_separated_list( cfg.get("flake8:local-plugins", plugin_type, fallback="").strip(), regexp=utils.LOCAL_PLUGIN_LIST_RE, ): name, _, entry_str = plugin_s.partition("=") name, entry_str = name.strip(), entry_str.strip() ep = importlib_metadata.EntryPoint(name, entry_str, group) yield Plugin("local", "local", ep) def _check_required_plugins( plugins: List[Plugin], expected: FrozenSet[str], ) -> None: plugin_names = { utils.normalize_pypi_name(plugin.package) for plugin in plugins } expected_names = {utils.normalize_pypi_name(name) for name in expected} missing_plugins = expected_names - plugin_names if missing_plugins: raise ExecutionError( f"required plugins were not installed!\n" f"- installed: {', '.join(sorted(plugin_names))}\n" f"- expected: {', '.join(sorted(expected_names))}\n" f"- missing: {', '.join(sorted(missing_plugins))}" ) def find_plugins( cfg: configparser.RawConfigParser, opts: PluginOptions, ) -> List[Plugin]: """Discovers all plugins (but does not load them).""" ret = [_find_importlib_plugins(), *_find_local_plugins(cfg)] # for determinism, sort the list ret.sort() _check_required_plugins(ret, opts.require_plugins) return ret def _parameters_for(func: Any) -> Dict[str, bool]: """Return the parameters for the plugin. This will inspect the plugin and return either the function parameters if the plugin is a function or the parameters for ``__init__`` after ``self`` if the plugin is a class. :returns: A dictionary mapping the parameter name to whether or not it is required (a.k.a., is positional only/does not have a default). """ is_class = not inspect.isfunction(func) if is_class: func = func.__init__ parameters = { parameter.name: parameter.default is inspect.Parameter.empty for parameter in inspect.signature(func).parameters.values() if parameter.kind is inspect.Parameter.POSITIONAL_OR_KEYWORD } if is_class: parameters.pop("self", None) return parameters def _load_plugin(plugin: Plugin) -> LoadedPlugin: try: obj = plugin.entry_point.load() except Exception as e: raise FailedToLoadPlugin(plugin.package, e) if not callable(obj): err = TypeError("expected loaded plugin to be callable") raise FailedToLoadPlugin(plugin.package, err) return LoadedPlugin(plugin, obj, _parameters_for(obj)) def _import_plugins( plugins: List[Plugin], opts: PluginOptions, ) -> List[LoadedPlugin]: sys.path.extend(opts.local_plugin_paths) return [_load_plugin(p) for p in plugins] def _classify_plugins( plugins: List[LoadedPlugin], opts: PluginOptions, ) -> Plugins: tree = [] logical_line = [] physical_line = [] reporters = {} disabled = [] for loaded in plugins: if ( getattr(loaded.obj, "off_by_default", False) and loaded.plugin.entry_point.name not in opts.enable_extensions ): disabled.append(loaded) elif loaded.plugin.entry_point.group == "flake8.report": reporters[loaded.entry_name] = loaded elif "tree" in loaded.parameters: tree.append(loaded) elif "logical_line" in loaded.parameters: logical_line.append(loaded) elif "physical_line" in loaded.parameters: physical_line.append(loaded) else: raise NotImplementedError(f"what plugin type? {loaded}") for loaded in itertools.chain(tree, logical_line, physical_line): if not VALID_CODE.match(loaded.entry_name): raise ExecutionError( f"plugin code for `{loaded.display_name}` does not match " f"{VALID_CODE.pattern}" ) return Plugins( checkers=Checkers( tree=tree, logical_line=logical_line, physical_line=physical_line, ), reporters=reporters, disabled=disabled, ) def load_plugins( plugins: List[Plugin], opts: PluginOptions, ) -> Plugins: """Load and classify all flake8 plugins. - first: extends ``sys.path`` with ``paths`` (to import local plugins) - next: converts the ``Plugin``s to ``LoadedPlugins`` - finally: classifies plugins into their specific types """ return _classify_plugins(_import_plugins(plugins, opts), opts)	11.03 KB	2026-01-20 12:58
📄 pycodestyle.py """Generated using ./bin/gen-pycodestyle-plugin.""" # fmt: off from typing import Any from typing import Generator from typing import Tuple from pycodestyle import ambiguous_identifier as _ambiguous_identifier from pycodestyle import bare_except as _bare_except from pycodestyle import blank_lines as _blank_lines from pycodestyle import break_after_binary_operator as _break_after_binary_operator # noqa: E501 from pycodestyle import break_before_binary_operator as _break_before_binary_operator # noqa: E501 from pycodestyle import comparison_negative as _comparison_negative from pycodestyle import comparison_to_singleton as _comparison_to_singleton from pycodestyle import comparison_type as _comparison_type from pycodestyle import compound_statements as _compound_statements from pycodestyle import continued_indentation as _continued_indentation from pycodestyle import explicit_line_join as _explicit_line_join from pycodestyle import extraneous_whitespace as _extraneous_whitespace from pycodestyle import imports_on_separate_lines as _imports_on_separate_lines from pycodestyle import indentation as _indentation from pycodestyle import maximum_doc_length as _maximum_doc_length from pycodestyle import maximum_line_length as _maximum_line_length from pycodestyle import missing_whitespace as _missing_whitespace from pycodestyle import missing_whitespace_after_keyword as _missing_whitespace_after_keyword # noqa: E501 from pycodestyle import missing_whitespace_around_operator as _missing_whitespace_around_operator # noqa: E501 from pycodestyle import module_imports_on_top_of_file as _module_imports_on_top_of_file # noqa: E501 from pycodestyle import python_3000_async_await_keywords as _python_3000_async_await_keywords # noqa: E501 from pycodestyle import python_3000_backticks as _python_3000_backticks from pycodestyle import python_3000_has_key as _python_3000_has_key from pycodestyle import python_3000_invalid_escape_sequence as _python_3000_invalid_escape_sequence # noqa: E501 from pycodestyle import python_3000_not_equal as _python_3000_not_equal from pycodestyle import python_3000_raise_comma as _python_3000_raise_comma from pycodestyle import tabs_obsolete as _tabs_obsolete from pycodestyle import tabs_or_spaces as _tabs_or_spaces from pycodestyle import trailing_blank_lines as _trailing_blank_lines from pycodestyle import trailing_whitespace as _trailing_whitespace from pycodestyle import whitespace_around_comma as _whitespace_around_comma from pycodestyle import whitespace_around_keywords as _whitespace_around_keywords # noqa: E501 from pycodestyle import whitespace_around_named_parameter_equals as _whitespace_around_named_parameter_equals # noqa: E501 from pycodestyle import whitespace_around_operator as _whitespace_around_operator # noqa: E501 from pycodestyle import whitespace_before_comment as _whitespace_before_comment from pycodestyle import whitespace_before_parameters as _whitespace_before_parameters # noqa: E501 def pycodestyle_logical( blank_before: Any, blank_lines: Any, checker_state: Any, hang_closing: Any, indent_char: Any, indent_level: Any, indent_size: Any, line_number: Any, lines: Any, logical_line: Any, max_doc_length: Any, noqa: Any, previous_indent_level: Any, previous_logical: Any, previous_unindented_logical_line: Any, tokens: Any, verbose: Any, ) -> Generator[Tuple[int, str], None, None]: """Run pycodestyle logical checks.""" yield from _ambiguous_identifier(logical_line, tokens) yield from _bare_except(logical_line, noqa) yield from _blank_lines(logical_line, blank_lines, indent_level, line_number, blank_before, previous_logical, previous_unindented_logical_line, previous_indent_level, lines) # noqa: E501 yield from _break_after_binary_operator(logical_line, tokens) yield from _break_before_binary_operator(logical_line, tokens) yield from _comparison_negative(logical_line) yield from _comparison_to_singleton(logical_line, noqa) yield from _comparison_type(logical_line, noqa) yield from _compound_statements(logical_line) yield from _continued_indentation(logical_line, tokens, indent_level, hang_closing, indent_char, indent_size, noqa, verbose) # noqa: E501 yield from _explicit_line_join(logical_line, tokens) yield from _extraneous_whitespace(logical_line) yield from _imports_on_separate_lines(logical_line) yield from _indentation(logical_line, previous_logical, indent_char, indent_level, previous_indent_level, indent_size) # noqa: E501 yield from _maximum_doc_length(logical_line, max_doc_length, noqa, tokens) yield from _missing_whitespace(logical_line) yield from _missing_whitespace_after_keyword(logical_line, tokens) yield from _missing_whitespace_around_operator(logical_line, tokens) yield from _module_imports_on_top_of_file(logical_line, indent_level, checker_state, noqa) # noqa: E501 yield from _python_3000_async_await_keywords(logical_line, tokens) yield from _python_3000_backticks(logical_line) yield from _python_3000_has_key(logical_line, noqa) yield from _python_3000_invalid_escape_sequence(logical_line, tokens, noqa) yield from _python_3000_not_equal(logical_line) yield from _python_3000_raise_comma(logical_line) yield from _whitespace_around_comma(logical_line) yield from _whitespace_around_keywords(logical_line) yield from _whitespace_around_named_parameter_equals(logical_line, tokens) yield from _whitespace_around_operator(logical_line) yield from _whitespace_before_comment(logical_line, tokens) yield from _whitespace_before_parameters(logical_line, tokens) def pycodestyle_physical( indent_char: Any, line_number: Any, lines: Any, max_line_length: Any, multiline: Any, noqa: Any, physical_line: Any, total_lines: Any, ) -> Generator[Tuple[int, str], None, None]: """Run pycodestyle physical checks.""" ret = _maximum_line_length(physical_line, max_line_length, multiline, line_number, noqa) # noqa: E501 if ret is not None: yield ret ret = _tabs_obsolete(physical_line) if ret is not None: yield ret ret = _tabs_or_spaces(physical_line, indent_char) if ret is not None: yield ret ret = _trailing_blank_lines(physical_line, lines, line_number, total_lines) if ret is not None: yield ret ret = _trailing_whitespace(physical_line) if ret is not None: yield ret	6.37 KB	2026-01-20 12:58
📄 pyflakes.py """Plugin built-in to Flake8 to treat pyflakes as a plugin.""" import argparse import ast import os import tokenize from typing import Any from typing import Generator from typing import List from typing import Tuple from typing import Type import pyflakes.checker from flake8 import utils from flake8.options.manager import OptionManager FLAKE8_PYFLAKES_CODES = { "UnusedImport": "F401", "ImportShadowedByLoopVar": "F402", "ImportStarUsed": "F403", "LateFutureImport": "F404", "ImportStarUsage": "F405", "ImportStarNotPermitted": "F406", "FutureFeatureNotDefined": "F407", "PercentFormatInvalidFormat": "F501", "PercentFormatExpectedMapping": "F502", "PercentFormatExpectedSequence": "F503", "PercentFormatExtraNamedArguments": "F504", "PercentFormatMissingArgument": "F505", "PercentFormatMixedPositionalAndNamed": "F506", "PercentFormatPositionalCountMismatch": "F507", "PercentFormatStarRequiresSequence": "F508", "PercentFormatUnsupportedFormatCharacter": "F509", "StringDotFormatInvalidFormat": "F521", "StringDotFormatExtraNamedArguments": "F522", "StringDotFormatExtraPositionalArguments": "F523", "StringDotFormatMissingArgument": "F524", "StringDotFormatMixingAutomatic": "F525", "FStringMissingPlaceholders": "F541", "MultiValueRepeatedKeyLiteral": "F601", "MultiValueRepeatedKeyVariable": "F602", "TooManyExpressionsInStarredAssignment": "F621", "TwoStarredExpressions": "F622", "AssertTuple": "F631", "IsLiteral": "F632", "InvalidPrintSyntax": "F633", "IfTuple": "F634", "BreakOutsideLoop": "F701", "ContinueOutsideLoop": "F702", "ContinueInFinally": "F703", "YieldOutsideFunction": "F704", "ReturnOutsideFunction": "F706", "DefaultExceptNotLast": "F707", "DoctestSyntaxError": "F721", "ForwardAnnotationSyntaxError": "F722", "CommentAnnotationSyntaxError": "F723", "RedefinedWhileUnused": "F811", "UndefinedName": "F821", "UndefinedExport": "F822", "UndefinedLocal": "F823", "DuplicateArgument": "F831", "UnusedVariable": "F841", "RaiseNotImplemented": "F901", } class FlakesChecker(pyflakes.checker.Checker): """Subclass the Pyflakes checker to conform with the flake8 API.""" with_doctest = False include_in_doctest: List[str] = [] exclude_from_doctest: List[str] = [] def __init__( self, tree: ast.AST, file_tokens: List[tokenize.TokenInfo], filename: str, ) -> None: """Initialize the PyFlakes plugin with an AST tree and filename.""" filename = utils.normalize_path(filename) with_doctest = self.with_doctest included_by = [ include for include in self.include_in_doctest if include != "" and filename.startswith(include) ] if included_by: with_doctest = True for exclude in self.exclude_from_doctest: if exclude != "" and filename.startswith(exclude): with_doctest = False overlaped_by = [ include for include in included_by if include.startswith(exclude) ] if overlaped_by: with_doctest = True super().__init__( tree, filename=filename, withDoctest=with_doctest, file_tokens=file_tokens, ) @classmethod def add_options(cls, parser: OptionManager) -> None: """Register options for PyFlakes on the Flake8 OptionManager.""" parser.add_option( "--builtins", parse_from_config=True, comma_separated_list=True, help="define more built-ins, comma separated", ) parser.add_option( "--doctests", default=False, action="store_true", parse_from_config=True, help="also check syntax of the doctests", ) parser.add_option( "--include-in-doctest", default="", dest="include_in_doctest", parse_from_config=True, comma_separated_list=True, normalize_paths=True, help="Run doctests only on these files", ) parser.add_option( "--exclude-from-doctest", default="", dest="exclude_from_doctest", parse_from_config=True, comma_separated_list=True, normalize_paths=True, help="Skip these files when running doctests", ) @classmethod def parse_options(cls, options: argparse.Namespace) -> None: """Parse option values from Flake8's OptionManager.""" if options.builtins: cls.builtIns = cls.builtIns.union(options.builtins) cls.with_doctest = options.doctests included_files = [] for included_file in options.include_in_doctest: if included_file == "": continue if not included_file.startswith((os.sep, "./", "~/")): included_files.append(f"./{included_file}") else: included_files.append(included_file) cls.include_in_doctest = utils.normalize_paths(included_files) excluded_files = [] for excluded_file in options.exclude_from_doctest: if excluded_file == "": continue if not excluded_file.startswith((os.sep, "./", "~/")): excluded_files.append(f"./{excluded_file}") else: excluded_files.append(excluded_file) cls.exclude_from_doctest = utils.normalize_paths(excluded_files) inc_exc = set(cls.include_in_doctest).intersection( cls.exclude_from_doctest ) if inc_exc: raise ValueError( f"{inc_exc!r} was specified in both the " f"include-in-doctest and exclude-from-doctest " f"options. You are not allowed to specify it in " f"both for doctesting." ) def run(self) -> Generator[Tuple[int, int, str, Type[Any]], None, None]: """Run the plugin.""" for message in self.messages: col = getattr(message, "col", 0) yield ( message.lineno, col, "{} {}".format( FLAKE8_PYFLAKES_CODES.get(type(message).__name__, "F999"), message.message % message.message_args, ), message.__class__, )	6.51 KB	2026-01-20 12:58
📄 reporter.py """Functions for construcing the requested report plugin.""" import argparse import logging from typing import Dict from flake8.formatting.base import BaseFormatter from flake8.plugins.finder import LoadedPlugin LOG = logging.getLogger(__name__) def make( reporters: Dict[str, LoadedPlugin], options: argparse.Namespace, ) -> BaseFormatter: """Make the formatter from the requested user options. - if :option:`flake8 --quiet` is specified, return the ``quiet-filename`` formatter. - if :option:`flake8 --quiet` is specified at least twice, return the ``quiet-nothing`` formatter. - otherwise attempt to return the formatter by name. - failing that, assume it is a format string and return the ``default`` formatter. """ format_name = options.format if options.quiet == 1: format_name = "quiet-filename" elif options.quiet >= 2: format_name = "quiet-nothing" try: format_plugin = reporters[format_name] except KeyError: LOG.warning( "%r is an unknown formatter. Falling back to default.", format_name, ) format_plugin = reporters["default"] return format_plugin.obj(options)	1.2 KB	2026-01-20 12:58

Terminal