/usr/lib/python3/dist-packages/flake8_polyfill/options.py is in python3-flake8-polyfill 1.0.2-1.
This file is owned by root:root, with mode 0o644.
The actual contents of the file can be viewed below.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 | """Option handling polyfill for Flake8 2.x and 3.x."""
import optparse
import os
def register(parser, *args, **kwargs):
r"""Register an option for the Option Parser provided by Flake8.
:param parser:
The option parser being used by Flake8 to handle command-line options.
:param \*args:
Positional arguments that you might otherwise pass to ``add_option``.
:param \*\*kwargs:
Keyword arguments you might otherwise pass to ``add_option``.
"""
try:
# Flake8 3.x registration
parser.add_option(*args, **kwargs)
except (optparse.OptionError, TypeError):
# Flake8 2.x registration
# Pop Flake8 3 parameters out of the kwargs so they don't cause a
# conflict.
parse_from_config = kwargs.pop('parse_from_config', False)
comma_separated_list = kwargs.pop('comma_separated_list', False)
normalize_paths = kwargs.pop('normalize_paths', False)
# In the unlikely event that the developer has specified their own
# callback, let's pop that and deal with that as well.
base_callback = kwargs.pop('callback', store_callback)
callback = generate_callback_from(comma_separated_list,
normalize_paths,
base_callback)
kwargs['callback'] = callback
kwargs['action'] = 'callback'
# We've updated our args and kwargs and can now rather confidently
# call add_option.
option = parser.add_option(*args, **kwargs)
if parse_from_config:
parser.config_options.append(option.get_opt_string().lstrip('-'))
def parse_comma_separated_list(value):
"""Parse a comma-separated list.
:param value:
String or list of strings to be parsed and normalized.
:returns:
List of values with whitespace stripped.
:rtype:
list
"""
if not value:
return []
if not isinstance(value, (list, tuple)):
value = value.split(',')
return [item.strip() for item in value]
def normalize_path(path, parent=os.curdir):
"""Normalize a single-path.
:returns:
The normalized path.
:rtype:
str
"""
# NOTE(sigmavirus24): Using os.path.sep allows for Windows paths to
# be specified and work appropriately.
separator = os.path.sep
if separator in path:
path = os.path.abspath(os.path.join(parent, path))
return path.rstrip(separator)
def parse_normalized_paths(value):
"""Normalize the path(s) value."""
if isinstance(value, list):
normalized = [normalize_path(s) for s in value]
else:
normalized = normalize_path(value)
return normalized
def store_callback(option, opt_str, value, parser, *args, **kwargs):
"""Implement optparse's "store" action as a callback."""
setattr(parser.values, option.dest, value)
def generate_callback_from(comma_separated_list, normalize_paths,
base_callback):
"""Generate a callback from parameters provided for the option."""
def _callback(option, opt_str, value, parser, *args, **kwargs):
"""Wrap `base_callback` by transforming `value` for option params."""
if comma_separated_list:
value = parse_comma_separated_list(value)
if normalize_paths:
value = parse_normalized_paths(value)
base_callback(option, opt_str, value, parser, *args, **kwargs)
return _callback
|