def initialize(self, argv: List[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) config_finder = config.ConfigFileFinder( self.program, prelim_opts.append_config, config_file=prelim_opts.config, ignore_config_files=prelim_opts.isolated, ) self.find_plugins(config_finder) self.register_plugin_options() self.parse_configuration_and_cli( config_finder, remaining_args, ) self.make_formatter() self.make_guide() self.make_file_checker_manager()
def get_style_guide(**kwargs): r"""Provision a StyleGuide for use. :param \*\*kwargs: Keyword arguments that provide some options for the StyleGuide. :returns: An initialized StyleGuide :rtype: :class:`StyleGuide` """ application = app.Application() application.parse_preliminary_options_and_args([]) flake8.configure_logging( application.prelim_opts.verbose, application.prelim_opts.output_file ) application.make_config_finder() application.find_plugins() application.register_plugin_options() application.parse_configuration_and_cli([]) # We basically want application.initialize to be called but with these # options set instead before we make our formatter, notifier, internal # style guide and file checker manager. options = application.options for key, value in kwargs.items(): try: getattr(options, key) setattr(options, key, value) except AttributeError: LOG.error('Could not update option "%s"', key) application.make_formatter() application.make_guide() application.make_file_checker_manager() return StyleGuide(application)
def get_style_guide(**kwargs): r"""Provision a StyleGuide for use. :param \*\*kwargs: Keyword arguments that provide some options for the StyleGuide. :returns: An initialized StyleGuide :rtype: :class:`StyleGuide` """ application = app.Application() application.parse_preliminary_options_and_args([]) flake8.configure_logging(application.prelim_opts.verbose, application.prelim_opts.output_file) application.make_config_finder() application.find_plugins() application.register_plugin_options() application.parse_configuration_and_cli([]) # We basically want application.initialize to be called but with these # options set instead before we make our formatter, notifier, internal # style guide and file checker manager. options = application.options for key, value in kwargs.items(): try: getattr(options, key) setattr(options, key, value) except AttributeError: LOG.error('Could not update option "%s"', key) application.make_formatter() application.make_guide() application.make_file_checker_manager() return StyleGuide(application)
def get_style_guide(argv=None): # this is a fork of flake8.api.legacy.get_style_guide # to allow passing command line argument application = Application() if hasattr(application, 'parse_preliminary_options'): prelim_opts, remaining_args = application.parse_preliminary_options( argv) from flake8 import configure_logging configure_logging(prelim_opts.verbose, prelim_opts.output_file) from flake8.options import config config_finder = config.ConfigFileFinder( application.program, prelim_opts.append_config, config_file=prelim_opts.config, ignore_config_files=prelim_opts.isolated) application.find_plugins(config_finder) application.register_plugin_options() application.parse_configuration_and_cli(config_finder, remaining_args) else: application.parse_preliminary_options_and_args([]) application.make_config_finder() application.find_plugins() application.register_plugin_options() application.parse_configuration_and_cli(argv) application.make_formatter() application.make_guide() application.make_file_checker_manager() return StyleGuide(application)
def get_style_guide(argv=None): # this is a fork of flake8.api.legacy.get_style_guide # to allow passing command line argument application = Application() application.parse_preliminary_options_and_args(argv) configure_logging( application.prelim_opts.verbose, application.prelim_opts.output_file) application.make_config_finder() application.find_plugins() application.register_plugin_options() application.parse_configuration_and_cli(argv) application.make_formatter() application.make_guide() application.make_file_checker_manager() return StyleGuide(application)
def get_style_guide(argv=None): # this is a fork of flake8.api.legacy.get_style_guide # to allow passing command line argument application = Application() application.parse_preliminary_options_and_args(argv) configure_logging(application.prelim_opts.verbose, application.prelim_opts.output_file) application.make_config_finder() application.find_plugins() application.register_plugin_options() application.parse_configuration_and_cli(argv) application.make_formatter() application.make_guide() application.make_file_checker_manager() return StyleGuide(application)
def get_flake8_style_guide(argv): # This is a modified version of flake8.legacy.get_style_guide() in which we pass argv through # to parse_configuration_and_cli(), as opposed to a dict of flake8 options. # Since we are using config files and a mix plugins, it is not trivial to determine the # appropriate options to pass into the standard flake8.legacy.get_style_guide(); # passing argv gets it to determine the options for us. application = flake8_app.Application() application.parse_preliminary_options_and_args([]) flake8.configure_logging(application.prelim_opts.verbose, application.prelim_opts.output_file) application.make_config_finder() application.find_plugins() application.register_plugin_options() application.parse_configuration_and_cli(argv) application.make_formatter() application.make_guide() application.make_file_checker_manager() return StyleGuide(application)
def initialize(self, argv): # type: (Optional[List[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. self.parse_preliminary_options_and_args(argv) flake8.configure_logging(self.prelim_opts.verbose, self.prelim_opts.output_file) self.make_config_finder() self.find_plugins() self.register_plugin_options() self.parse_configuration_and_cli(argv) self.make_formatter() self.make_guide() self.make_file_checker_manager()
def initialize(self, argv): # type: (Optional[List[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. self.parse_preliminary_options_and_args(argv) flake8.configure_logging( self.prelim_opts.verbose, self.prelim_opts.output_file ) self.make_config_finder() self.find_plugins() self.register_plugin_options() self.parse_configuration_and_cli(argv) self.make_formatter() self.make_guide() self.make_file_checker_manager()
def test_flake8(): configure_logging(1) argv = [ '--extend-ignore=' + ','.join( ['A003', 'D100', 'D101', 'D102', 'D103', 'D104', 'D105', 'D107']), '--exclude', 'vcstool/compat/shutil.py', '--import-order-style=google' ] style_guide = get_style_guide(argv) base_path = os.path.join(os.path.dirname(__file__), '..') paths = [ os.path.join(base_path, 'setup.py'), os.path.join(base_path, 'test'), os.path.join(base_path, 'vcstool'), ] scripts_path = os.path.join(base_path, 'scripts') for script in os.listdir(scripts_path): if script.startswith('.'): continue paths.append(os.path.join(scripts_path, script)) report = style_guide.check_files(paths) assert report.total_errors == 0, \ 'Found %d code style warnings' % report.total_errors
def get_flake8_style_guide(argv): # This is a modified version of flake8.legacy.get_style_guide() in which we pass argv through # to parse_configuration_and_cli(), as opposed to a dict of flake8 options. # Since we are using config files and a mix plugins, it is not trivial to determine the # appropriate options to pass into the standard flake8.legacy.get_style_guide(); # passing argv gets it to determine the options for us. application = flake8_app.Application() application.parse_preliminary_options_and_args([]) flake8.configure_logging( application.prelim_opts.verbose, application.prelim_opts.output_file) application.make_config_finder() application.find_plugins() application.register_plugin_options() application.parse_configuration_and_cli(argv) application.make_formatter() try: # needed in older flake8 versions to populate the listener application.make_notifier() except AttributeError: pass application.make_guide() application.make_file_checker_manager() return StyleGuide(application)
def get_flake8_style_guide(argv): # This is a modified version of flake8.legacy.get_style_guide() in which we pass argv through # to parse_configuration_and_cli(), as opposed to a dict of flake8 options. # Since we are using config files and a mix plugins, it is not trivial to determine the # appropriate options to pass into the standard flake8.legacy.get_style_guide(); # passing argv gets it to determine the options for us. application = flake8_app.Application() if hasattr(application, 'parse_preliminary_options'): prelim_opts, remaining_args = application.parse_preliminary_options( argv) flake8.configure_logging(prelim_opts.verbose, prelim_opts.output_file) from flake8.options import config config_finder = config.ConfigFileFinder( application.program, prelim_opts.append_config, config_file=prelim_opts.config, ignore_config_files=prelim_opts.isolated) application.find_plugins(config_finder) application.register_plugin_options() application.parse_configuration_and_cli(config_finder, remaining_args) else: application.parse_preliminary_options_and_args([]) flake8.configure_logging(application.prelim_opts.verbose, application.prelim_opts.output_file) application.make_config_finder() application.find_plugins() application.register_plugin_options() application.parse_configuration_and_cli(argv) application.make_formatter() try: # needed in older flake8 versions to populate the listener application.make_notifier() except AttributeError: pass application.make_guide() application.make_file_checker_manager() return StyleGuide(application)
def __init__(self, program='flake8', version=flake8.__version__): # type: (str, str) -> NoneType """Initialize our application. :param str program: The name of the program/application that we're executing. :param str version: The version of the program/application we're executing. """ #: The timestamp when the Application instance was instantiated. self.start_time = time.time() #: The timestamp when the Application finished reported errors. self.end_time = None #: The name of the program being run self.program = program #: The version of the program being run self.version = version #: The instance of :class:`flake8.options.manager.OptionManager` used #: to parse and handle the options and arguments passed by the user self.option_manager = manager.OptionManager( prog='flake8', version=flake8.__version__ ) options.register_default_options(self.option_manager) # We haven't found or registered our plugins yet, so let's defer # printing the version until we aggregate options from config files # and the command-line. First, let's clone our arguments on the CLI, # then we'll attempt to remove ``--version`` so that we can avoid # triggering the "version" action in optparse. If it's not there, we # do not need to worry and we can continue. If it is, we successfully # defer printing the version until just a little bit later. # Similarly we have to defer printing the help text until later. args = sys.argv[:] try: args.remove('--version') except ValueError: pass try: args.remove('--help') except ValueError: pass try: args.remove('-h') except ValueError: pass preliminary_opts, _ = self.option_manager.parse_known_args(args) # Set the verbosity of the program flake8.configure_logging(preliminary_opts.verbose, preliminary_opts.output_file) #: The instance of :class:`flake8.plugins.manager.Checkers` self.check_plugins = None #: The instance of :class:`flake8.plugins.manager.Listeners` self.listening_plugins = None #: The instance of :class:`flake8.plugins.manager.ReportFormatters` self.formatting_plugins = None #: The user-selected formatter from :attr:`formatting_plugins` self.formatter = None #: The :class:`flake8.plugins.notifier.Notifier` for listening plugins self.listener_trie = None #: The :class:`flake8.style_guide.StyleGuide` built from the user's #: options self.guide = None #: The :class:`flake8.checker.Manager` that will handle running all of #: the checks selected by the user. self.file_checker_manager = None #: The user-supplied options parsed into an instance of #: :class:`optparse.Values` self.options = None #: The left over arguments that were not parsed by #: :attr:`option_manager` self.args = 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 #: Whether the program is processing a diff or not self.running_against_diff = False #: The parsed diff information self.parsed_diff = {}
"""Test configuration for py.test.""" import sys import flake8 flake8.configure_logging(2, 'test-logs-%s.%s.log' % sys.version_info[0:2])
from lsst.ts.hvac.enums import ( HvacTopic, TOPICS_ALWAYS_ENABLED, TOPICS_WITHOUT_CONFIGURATION, ) from lsst.ts.hvac.utils import to_camel_case import hvac_test_utils from lsst.ts.idl.enums.HVAC import DeviceId, DEVICE_GROUPS STD_TIMEOUT = 2 # standard command timeout (sec) logging.basicConfig(format="%(asctime)s:%(levelname)s:%(name)s:%(message)s", level=logging.DEBUG) # Make sure that flake8 log level is set to logging.INFO flake8.configure_logging(1) class CscTestCase(salobj.BaseCscTestCase, unittest.IsolatedAsyncioTestCase): def basic_make_csc(self, initial_state, simulation_mode, **kwargs): return hvac.HvacCsc( initial_state=initial_state, simulation_mode=simulation_mode, start_telemetry_publishing=False, ) async def test_standard_state_transitions(self): async with self.make_csc( initial_state=salobj.State.STANDBY, simulation_mode=1, ):