def test_from_function(self): uut = FunctionMetadata.from_function(self.test_from_function) self.check_function_metadata_data_set(uut, "test_from_function") uut = FunctionMetadata.from_function(TestClass(5, 5).__init__) self.check_function_metadata_data_set(uut, "__init__", desc="Description", retval_desc="ret", non_optional_params={ "param1": (uut.str_nodesc, None), "param2": ("d", None) }, optional_params={ "param3": (uut.str_nodesc + " (" + uut.str_optional.format("5") + ")", None, 5), "param4": ("p4 desc (" + uut.str_optional.format("6") + ")", int, 6) }) uut = FunctionMetadata.from_function(TestClass(5, 5).__init__, omit=["param3", "param2"]) self.check_function_metadata_data_set(uut, "__init__", desc="Description", retval_desc="ret", non_optional_params={ "param1": (uut.str_nodesc, None) }, optional_params={ "param4": ("p4 desc (" + uut.str_optional.format("6") + ")", int, 6) })
def get_metadata(cls): return FunctionMetadata.merge( FunctionMetadata.from_function( cls.run, omit={"self", "dependency_results"}), cls.get_shortlog_checks_metadata(), cls.get_body_checks_metadata())
def run(self, filename, file, **kwargs): # Get the **kwargs params to forward to `generate_config()` # (from `_create_config()`). generate_config_kwargs = FunctionMetadata.filter_parameters( self._get_generate_config_metadata(), kwargs) with self._create_config( filename, file, **generate_config_kwargs) as config_file: # And now retrieve the **kwargs for `create_arguments()`. create_arguments_kwargs = ( FunctionMetadata.filter_parameters( self._get_create_arguments_metadata(), kwargs)) arguments = (self.get_executable(),) + tuple( self.create_arguments( filename, file, config_file, **create_arguments_kwargs)) self.debug("Running '{}'".format(' '.join(arguments))) output = run_shell_command( arguments, stdin="".join(file) if options["use_stdin"] else None) output = tuple(compress( output, (options["use_stdout"], options["use_stderr"]))) if len(output) == 1: output = output[0] process_output_kwargs = FunctionMetadata.filter_parameters( self._get_process_output_metadata(), kwargs) return self.process_output(output, filename, file, **process_output_kwargs)
def get_metadata(cls): metadata = FunctionMetadata( 'run', optional_params=cls.get_optional_params(), non_optional_params=cls.get_non_optional_params()) metadata.desc = inspect.getdoc(cls) return metadata
def get_metadata(cls): return FunctionMetadata.merge( FunctionMetadata.from_function( cls.run, omit={'self', 'dependency_results'}), cls.get_shortlog_checks_metadata(), cls.get_body_checks_metadata(), cls.get_issue_checks_metadata())
def test_add_deprecated_param(self): uut = FunctionMetadata( 'test', non_optional_params={'not_optional': ('desc', str)}, optional_params={'optional': ('desc2', str, 'default')}) uut.add_deprecated_param('optional', 'old_optional') uut.add_deprecated_param('not_optional', 'old_not_optional') self.assertEqual(uut.non_optional_params, {'not_optional': ('desc', str)}) self.assertEqual(uut.optional_params, {'optional': ('desc2', str, 'default'), 'old_optional': ('desc2', str, 'default'), 'old_not_optional': ('desc', str, None)})
def _func_decorator(func): @wraps(func) def _new_func(self, *args, **kwargs): if not self.section.aspects: return func(self, *args, **kwargs) aspects = self.section.aspects for arg, aspect_value in aspectable_settings.items(): # Explicit bear setting takes priority over aspects if arg in self.section: continue taste, aspect_settings = aspect_value aspect_instance = aspects.get(taste.aspect_name) if aspect_instance: value = aspect_instance.tastes[taste.name] for value_pair in aspect_value[1]: if value_pair[0] == value: kwargs[arg] = value_pair[1] return func(self, *args, **kwargs) # Keep metadata _new_func.__metadata__ = FunctionMetadata.from_function(func) return _new_func
def _deprecate_decorator(func): def wrapping_function(*args, **kwargs): for arg, depr_arg_and_modifier in depr_args.items(): deprecated_arg, _func = ( depr_arg_and_modifier if isinstance(depr_arg_and_modifier, tuple) else (depr_arg_and_modifier, lambda x: x)) if deprecated_arg in kwargs: print("The setting `{}` is deprecated. Please use `{}` " "instead.".format(deprecated_arg, arg)) depr_arg_value = _func.__call__(kwargs[deprecated_arg]) if arg in kwargs and depr_arg_value != kwargs[arg]: print('The value of `{}` and `{}` are conflicting.' ' `{}` will be used instead.'.format( deprecated_arg, arg, arg)) else: kwargs[arg] = depr_arg_value del kwargs[deprecated_arg] return func(*args, **kwargs) new_metadata = FunctionMetadata.from_function(func) for arg, depr_arg_and_modifier in depr_args.items(): deprecated_arg = (depr_arg_and_modifier[0] if isinstance(depr_arg_and_modifier, tuple) else depr_arg_and_modifier) new_metadata.add_alias(arg, deprecated_arg) wrapping_function.__metadata__ = new_metadata return wrapping_function
def get_metadata(cls): merged_metadata = FunctionMetadata.merge( cls._get_process_output_metadata(), cls._get_generate_config_metadata(), cls._get_create_arguments_metadata()) merged_metadata.desc = inspect.getdoc(cls) return merged_metadata
def test_create_params_from_section_invalid(self): section = Section("name") section.append(Setting("bad_param", "value")) uut = FunctionMetadata.from_function(TestClass(5, 5).bad_function) with self.assertRaises(ValueError): uut.create_params_from_section(section)
def get_metadata(cls): """ :return: Metadata for the run function. However parameters like ``self`` or parameters implicitly used by coala (e.g. filename for local bears) are already removed. """ return FunctionMetadata.from_function(cls.run, omit={"self", "dependency_results"})
def test_merge(self): metadata1 = FunctionMetadata( "main", "Desc of main.\n", "Returns 0 on success", {"argc": ("argc desc", None), "argv": ("argv desc", None)}, {"opt": ("opt desc", int, 88)}, {"self", "A"}, {"test1"}) metadata2 = FunctionMetadata( "process", "Desc of process.\n", "Returns the processed stuff.", {"argc": ("argc desc from process", int), "to_process": ("to_process desc", int)}, {"opt2": ("opt2 desc", str, "hello")}, {"self", "B"}, {"test2"}) metadata3 = FunctionMetadata("nodesc", "", "", {}, {}) merged_metadata = FunctionMetadata.merge(metadata1, metadata2, metadata3) self.assertEqual( merged_metadata.name, "<Merged signature of 'main', 'process', 'nodesc'>") self.assertEqual(merged_metadata.desc, "Desc of process.\n") self.assertEqual(merged_metadata.retval_desc, "Returns the processed stuff.") self.assertEqual( merged_metadata.non_optional_params, {"argc": ("argc desc from process", int), "argv": ("argv desc", None), "to_process": ("to_process desc", int)}) self.assertEqual( merged_metadata.optional_params, {"opt": ("opt desc", int, 88), "opt2": ("opt2 desc", str, "hello")}) self.assertEqual( merged_metadata.omit, frozenset({"self", "A", "B"})) self.assertEqual( merged_metadata.deprecated_params, frozenset({"test1", "test2"}))
def get_metadata(cls): """ :return: Metadata for the run function. However parameters like ``self`` or parameters implicitly used by coala (e.g. filename for local bears) are already removed. """ return FunctionMetadata.from_function( cls.run, omit={'self', 'dependency_results'})
def get_metadata(cls): """ :return: Metadata for the ``analyze`` function extracted from its signature. Excludes parameters ``self`` and ``files``. """ return FunctionMetadata.from_function(cls.analyze, omit={'self', 'files'})
def get_metadata(cls): """ :return: Metadata for the ``analyze`` function extracted from its signature. Excludes parameters ``self``, ``filename`` and ``file``. """ return FunctionMetadata.from_function( cls.analyze, omit={'self', 'dependency_bear', 'dependency_result'})
def test_construction(self): self.assertRaises(TypeError, FunctionMetadata, 5) self.assertRaises(TypeError, FunctionMetadata, "name", desc=5) self.assertRaises(TypeError, FunctionMetadata, "name", retval_desc=5) self.assertRaises(TypeError, FunctionMetadata, "name", non_optional_params=5) self.assertRaises(TypeError, FunctionMetadata, "name", optional_params=5) self.assertRaises(TypeError, FunctionMetadata.from_function, 5) self.assertRaises(TypeError, FunctionMetadata.from_function, self.test_construction, 5) self.check_function_metadata_data_set(FunctionMetadata("name"), "name")
def get_metadata(cls): """ :return: Metadata for the ``analyze`` function extracted from its signature. Excludes parameters ``self``, ``filename`` and ``file``. """ return FunctionMetadata.from_function( cls.analyze, omit={'self', 'filename', 'file'})
def _deprecate_decorator(func): logged_deprecated_args = set() @wraps(func) def wrapping_function(*args, **kwargs): for arg, depr_value in wrapping_function.__metadata__.depr_values: deprecated_arg = depr_value[0] _func = depr_value[1] if deprecated_arg in kwargs: if deprecated_arg not in logged_deprecated_args: logging.warning( 'The setting `{}` is deprecated. Please use `{}` ' 'instead.'.format(deprecated_arg, arg)) logged_deprecated_args.add(deprecated_arg) depr_arg_value = _func.__call__(kwargs[deprecated_arg]) if arg in kwargs and depr_arg_value != kwargs[arg]: logging.warning( 'The value of `{}` and `{}` are conflicting.' ' `{}` will be used instead.'.format( deprecated_arg, arg, arg)) else: kwargs[arg] = depr_arg_value del kwargs[deprecated_arg] return func(*args, **kwargs) new_metadata = FunctionMetadata.from_function(func) new_metadata.depr_values = [] for arg, depr_values in depr_args.items(): if not isinstance(depr_values, tuple): depr_values = (depr_values,) if callable(depr_values[-1]): deprecated_args = depr_values[:-1] default_modifier = depr_values[-1] else: deprecated_args = depr_values default_modifier = _do_nothing for depr_value in deprecated_args: if isinstance(depr_value, dict): deprecated_arg = list(depr_value.keys())[0] modifier = depr_value[deprecated_arg] new_metadata.depr_values.append((arg, (deprecated_arg, modifier))) else: deprecated_arg = depr_value new_metadata.depr_values.append((arg, (deprecated_arg, default_modifier))) new_metadata.add_deprecated_param(arg, deprecated_arg) wrapping_function.__metadata__ = new_metadata return wrapping_function
def run(self, filename, file, **kwargs): # Get the **kwargs params to forward to `generate_config()` # (from `_create_config()`). generate_config_kwargs = FunctionMetadata.filter_parameters( self._get_generate_config_metadata(), kwargs) with self._create_config( filename, file, **generate_config_kwargs) as config_file: # And now retrieve the **kwargs for `create_arguments()`. create_arguments_kwargs = ( FunctionMetadata.filter_parameters( self._get_create_arguments_metadata(), kwargs)) args = self.create_arguments(filename, file, config_file, **create_arguments_kwargs) try: args = tuple(args) except TypeError: self.err('The given arguments ' '{!r} are not iterable.'.format(args)) return arguments = (self.get_executable(),) + args self.debug("Running '{}'".format(' '.join(arguments))) output = run_shell_command( arguments, stdin=''.join(file) if options['use_stdin'] else None, cwd=self.get_config_dir()) output = tuple(compress( output, (options['use_stdout'], options['use_stderr']))) if len(output) == 1: output = output[0] process_output_kwargs = FunctionMetadata.filter_parameters( self._get_process_output_metadata(), kwargs) return self.process_output(output, filename, file, **process_output_kwargs)
def get_metadata(cls): merged_metadata = FunctionMetadata.merge( cls._get_process_output_metadata(), cls._get_generate_config_metadata(), cls._get_create_arguments_metadata()) merged_metadata.desc = ( "{}\n\nThis bear uses the {!r} tool.".format( inspect.getdoc(cls), cls.get_executable())) return merged_metadata
def run(self, filename, file, **kwargs): # Get the **kwargs params to forward to `generate_config()` # (from `_create_config()`). generate_config_kwargs = FunctionMetadata.filter_parameters( self._get_generate_config_metadata(), kwargs) with self._create_config( filename, file, **generate_config_kwargs) as config_file: # And now retrieve the **kwargs for `create_arguments()`. create_arguments_kwargs = ( FunctionMetadata.filter_parameters( self._get_create_arguments_metadata(), kwargs)) args = self.create_arguments(filename, file, config_file, **create_arguments_kwargs) try: args = tuple(args) except TypeError: self.err("The given arguments " "{!r} are not iterable.".format(args)) return arguments = (self.get_executable(),) + args self.debug("Running '{}'".format(' '.join(arguments))) output = run_shell_command( arguments, stdin="".join(file) if options["use_stdin"] else None, cwd=self.get_config_dir()) output = tuple(compress( output, (options["use_stdout"], options["use_stderr"]))) if len(output) == 1: output = output[0] process_output_kwargs = FunctionMetadata.filter_parameters( self._get_process_output_metadata(), kwargs) return self.process_output(output, filename, file, **process_output_kwargs)
def test_from_function(self): uut = FunctionMetadata.from_function(self.test_from_function) self.check_function_metadata_data_set(uut, "test_from_function") # setattr on bound methods will fail, vars() will use the dict from # the unbound method which is ok. vars(self.test_from_function)["__metadata__"] = ( FunctionMetadata("t")) uut = FunctionMetadata.from_function(self.test_from_function) self.check_function_metadata_data_set(uut, "t") uut = FunctionMetadata.from_function(TestClass(5, 5).__init__) self.check_function_metadata_data_set( uut, "__init__", desc="Description", retval_desc="ret", non_optional_params={ "param1": (uut.str_nodesc, None), "param2": ("d", None) }, optional_params={ "param3": (uut.str_nodesc + " (" + uut.str_optional.format("5") + ")", None, 5), "param4": ("p4 desc (" + uut.str_optional.format("6") + ")", int, 6)}) uut = FunctionMetadata.from_function(TestClass(5, 5).__init__, omit={"param3", "param2"}) self.check_function_metadata_data_set( uut, "__init__", desc="Description", retval_desc="ret", non_optional_params={ "param1": (uut.str_nodesc, None) }, optional_params={ "param4": ("p4 desc (" + uut.str_optional.format("6") + ")", int, 6)})
def test_from_function(self): uut = FunctionMetadata.from_function(self.test_from_function) self.check_function_metadata_data_set(uut, 'test_from_function') # setattr on bound methods will fail, vars() will use the dict from # the unbound method which is ok. vars(self.test_from_function)['__metadata__'] = ( FunctionMetadata('t')) uut = FunctionMetadata.from_function(self.test_from_function) self.check_function_metadata_data_set(uut, 't') uut = FunctionMetadata.from_function(TestClass(5, 5).__init__) self.check_function_metadata_data_set( uut, '__init__', desc='Description', retval_desc='ret', non_optional_params={ 'param1': (uut.str_nodesc, None), 'param2': ('d', None) }, optional_params={ 'param3': (uut.str_nodesc + ' (' + uut.str_optional.format('5') + ')', None, 5), 'param4': ('p4 desc (' + uut.str_optional.format('6') + ')', int, 6)}) uut = FunctionMetadata.from_function(TestClass(5, 5).__init__, omit={'param3', 'param2'}) self.check_function_metadata_data_set( uut, '__init__', desc='Description', retval_desc='ret', non_optional_params={ 'param1': (uut.str_nodesc, None) }, optional_params={ 'param4': ('p4 desc (' + uut.str_optional.format('6') + ')', int, 6)})
def test_from_function(self): uut = FunctionMetadata.from_function(self.test_from_function) self.check_function_metadata_data_set(uut, "test_from_function") # setattr on bound methods will fail, __dict__ will use the dict from # the unbound method which is ok. self.test_from_function.__dict__["__metadata__"] = ( FunctionMetadata("t")) uut = FunctionMetadata.from_function(self.test_from_function) self.check_function_metadata_data_set(uut, "t") uut = FunctionMetadata.from_function(TestClass(5, 5).__init__) self.check_function_metadata_data_set( uut, "__init__", desc="Description", retval_desc="ret", non_optional_params={ "param1": (uut.str_nodesc, None), "param2": ("d", None) }, optional_params={ "param3": (uut.str_nodesc + " (" + uut.str_optional.format("5") + ")", None, 5), "param4": ("p4 desc (" + uut.str_optional.format("6") + ")", int, 6)}) uut = FunctionMetadata.from_function(TestClass(5, 5).__init__, omit={"param3", "param2"}) self.check_function_metadata_data_set( uut, "__init__", desc="Description", retval_desc="ret", non_optional_params={ "param1": (uut.str_nodesc, None) }, optional_params={ "param4": ("p4 desc (" + uut.str_optional.format("6") + ")", int, 6)})
def test_create_params_from_section_valid(self): section = Section("name") section.append(Setting("a_param", "value")) uut = FunctionMetadata.from_function(TestClass(5, 5).good_function) with self.assertRaises(ValueError): uut.create_params_from_section(section) section.append(Setting("a_param", "5")) params = uut.create_params_from_section(section) self.assertEqual(params['a_param'], 5)
def test_from_function(self): uut = FunctionMetadata.from_function(self.test_from_function) self.check_function_metadata_data_set(uut, 'test_from_function') # setattr on bound methods will fail, vars() will use the dict from # the unbound method which is ok. vars(self.test_from_function)['__metadata__'] = (FunctionMetadata('t')) uut = FunctionMetadata.from_function(self.test_from_function) self.check_function_metadata_data_set(uut, 't') uut = FunctionMetadata.from_function(TestClass(5, 5).__init__) self.check_function_metadata_data_set( uut, '__init__', desc='Description', retval_desc='ret', non_optional_params={ 'param1': (uut.str_nodesc, None), 'param2': ('d', None) }, optional_params={ 'param3': (uut.str_nodesc + ' (' + uut.str_optional.format('5') + ')', None, 5), 'param4': ('p4 desc (' + uut.str_optional.format('6') + ')', int, 6) }) uut = FunctionMetadata.from_function(TestClass(5, 5).__init__, omit={'param3', 'param2'}) self.check_function_metadata_data_set( uut, '__init__', desc='Description', retval_desc='ret', non_optional_params={'param1': (uut.str_nodesc, None)}, optional_params={ 'param4': ('p4 desc (' + uut.str_optional.format('6') + ')', int, 6) })
def _get_process_output_metadata(cls): metadata = FunctionMetadata.from_function(cls.process_output) if options['output_format'] is None: omitted = {'self', 'output', 'filename', 'file'} else: # If a specific output format is provided, function signatures # from process_output functions should not appear in the help. omitted = set(chain(metadata.non_optional_params, metadata.optional_params)) metadata.omit = omitted return metadata
def _get_process_output_metadata(cls): metadata = FunctionMetadata.from_function(cls.process_output) if options["output_format"] is None: omitted = {"self", "output", "filename", "file"} else: # If a specific output format is provided, function signatures # from process_output functions should not appear in the help. omitted = set(chain(metadata.non_optional_params, metadata.optional_params)) metadata.omit = omitted return metadata
def get_metadata(cls): """ Retrieves metadata for the apply function. The description may be used to advertise this action to the user. The parameters and their help texts are additional information that are needed from the user. You can create a section out of the inputs from the user and use apply_from_section to apply :return A FunctionMetadata object. """ data = FunctionMetadata.from_function( cls.apply, omit=["self", "result", "original_file_dict", "file_diff_dict"]) data.name = cls.__name__ return data
def test_merge(self): metadata1 = FunctionMetadata('main', 'Desc of main.\n', 'Returns 0 on success', { 'argc': ('argc desc', None), 'argv': ('argv desc', None) }, {'opt': ('opt desc', int, 88)}, {'self', 'A'}, {'test1'}) metadata2 = FunctionMetadata( 'process', 'Desc of process.\n', 'Returns the processed stuff.', { 'argc': ('argc desc from process', int), 'to_process': ('to_process desc', int) }, {'opt2': ('opt2 desc', str, 'hello')}, {'self', 'B'}, {'test2'}) metadata3 = FunctionMetadata('nodesc', '', '', {}, {}) merged_metadata = FunctionMetadata.merge(metadata1, metadata2, metadata3) self.assertEqual(merged_metadata.name, "<Merged signature of 'main', 'process', 'nodesc'>") self.assertEqual(merged_metadata.desc, 'Desc of process.\n') self.assertEqual(merged_metadata.retval_desc, 'Returns the processed stuff.') self.assertEqual( merged_metadata.non_optional_params, { 'argc': ('argc desc from process', int), 'argv': ('argv desc', None), 'to_process': ('to_process desc', int) }) self.assertEqual(merged_metadata.optional_params, { 'opt': ('opt desc', int, 88), 'opt2': ('opt2 desc', str, 'hello') }) self.assertEqual(merged_metadata.omit, frozenset({'self', 'A', 'B'})) self.assertEqual(merged_metadata.deprecated_params, frozenset({'test1', 'test2'}))
def get_metadata(cls): """ Retrieves metadata for the apply function. The description may be used to advertise this action to the user. The parameters and their help texts are additional information that are needed from the user. You can create a section out of the inputs from the user and use apply_from_section to apply :return A FunctionMetadata object. """ data = FunctionMetadata.from_function( cls.apply, omit={'self', 'result', 'original_file_dict', 'file_diff_dict'}) data.name = cls.__name__ return data
def test_merge(self): metadata1 = FunctionMetadata( 'main', 'Desc of main.\n', 'Returns 0 on success', {'argc': ('argc desc', None), 'argv': ('argv desc', None)}, {'opt': ('opt desc', int, 88)}, {'self', 'A'}, {'test1'}) metadata2 = FunctionMetadata( 'process', 'Desc of process.\n', 'Returns the processed stuff.', {'argc': ('argc desc from process', int), 'to_process': ('to_process desc', int)}, {'opt2': ('opt2 desc', str, 'hello')}, {'self', 'B'}, {'test2'}) metadata3 = FunctionMetadata('nodesc', '', '', {}, {}) merged_metadata = FunctionMetadata.merge(metadata1, metadata2, metadata3) self.assertEqual( merged_metadata.name, "<Merged signature of 'main', 'process', 'nodesc'>") self.assertEqual(merged_metadata.desc, 'Desc of process.\n') self.assertEqual(merged_metadata.retval_desc, 'Returns the processed stuff.') self.assertEqual( merged_metadata.non_optional_params, {'argc': ('argc desc from process', int), 'argv': ('argv desc', None), 'to_process': ('to_process desc', int)}) self.assertEqual( merged_metadata.optional_params, {'opt': ('opt desc', int, 88), 'opt2': ('opt2 desc', str, 'hello')}) self.assertEqual( merged_metadata.omit, frozenset({'self', 'A', 'B'})) self.assertEqual( merged_metadata.deprecated_params, frozenset({'test1', 'test2'}))
def default(self, obj): if hasattr(obj, "__json__"): fdata = FunctionMetadata.from_function(obj.__json__) params = self._filter_params( fdata.optional_params, fdata.non_optional_params) return obj.__json__(**params) elif isinstance(obj, collections.Iterable): return list(obj) elif isinstance(obj, datetime): return obj.isoformat() elif hasattr(obj, "__getitem__") and hasattr(obj, "keys"): return dict(obj) elif hasattr(obj, "__dict__"): return {member: getattr(obj, member) for member in get_public_members(obj)} return json.JSONEncoder.default(self, obj)
def get_metadata(self): """ Retrieves metadata for the apply function. The description may be used to advertise this action to the user. The parameters and their help texts are additional information that are needed from the user. You can create a section out of the inputs from the user and use apply_from_section to apply :return: A FunctionMetadata object. """ data = FunctionMetadata.from_function( self.apply, omit={'self', 'result', 'original_file_dict', 'file_diff_dict'}) if hasattr(self, 'description'): data.desc = self.description data.name = self.__class__.__name__ data.id = id(self) return data
def default(self, obj): if hasattr(obj, "__json__"): fdata = FunctionMetadata.from_function(obj.__json__) params = self._filter_params(fdata.optional_params, fdata.non_optional_params) return obj.__json__(**params) elif isinstance(obj, collections.Iterable): return list(obj) elif isinstance(obj, datetime): return obj.isoformat() elif hasattr(obj, "__getitem__") and hasattr(obj, "keys"): return dict(obj) elif hasattr(obj, "__dict__"): return { member: getattr(obj, member) for member in get_public_members(obj) } return json.JSONEncoder.default(self, obj)
def test_add_deprecated_param(self): uut = FunctionMetadata( "test", non_optional_params={'not_optional': ('desc', str)}, optional_params={'optional': ('desc2', str, 'default')}) uut.add_deprecated_param('optional', 'old_optional') uut.add_deprecated_param('not_optional', 'old_not_optional') self.assertEqual(uut.non_optional_params, {'not_optional': ('desc', str)}) self.assertEqual(uut.optional_params, {'optional': ('desc2', str, 'default'), 'old_optional': ('desc2', str, 'default'), 'old_not_optional': ('desc', str, None)})
def _deprecate_decorator(func): def wrapping_function(*args, **kwargs): for arg, depr_arg_and_modifier in depr_args.items(): deprecated_arg, _func = ( depr_arg_and_modifier if isinstance(depr_arg_and_modifier, tuple) else (depr_arg_and_modifier, lambda x: x)) if deprecated_arg in kwargs and arg not in kwargs: print("The setting `{}` is deprecated. Please use `{}` " "instead.".format(deprecated_arg, arg)) kwargs[arg] = _func.__call__(kwargs[deprecated_arg]) del kwargs[deprecated_arg] return func(*args, **kwargs) new_metadata = FunctionMetadata.from_function(func) for arg, depr_arg_and_modifier in depr_args.items(): deprecated_arg = (depr_arg_and_modifier[0] if isinstance(depr_arg_and_modifier, tuple) else depr_arg_and_modifier) new_metadata.add_alias(arg, deprecated_arg) wrapping_function.__metadata__ = new_metadata return wrapping_function
def _func_decorator(func): @wraps(func) def _new_func(self, *args, **kwargs): if self.section.aspects: aspects = self.section.aspects for arg, aspect_value in aspectable_setting.items(): # Explicit setting takes priority if arg in self.section: continue if isinstance(aspect_value, aspectclass): kwargs[arg] = aspects.get(aspect_value) is not None if isinstance(aspect_value, Taste): aspect_instance = aspects.get(aspect_value.aspect_name) if aspect_instance: kwargs[arg] = aspect_instance.tastes[ aspect_value.name] return func(self, *args, **kwargs) # Keep metadata _new_func.__metadata__ = FunctionMetadata.from_function(func) return _new_func
def get_body_checks_metadata(cls): return FunctionMetadata.from_function( cls.check_body, omit={"self", "body"})
def get_metadata(cls): return FunctionMetadata.from_function(cls.run, omit={"self", "filename", "file", "dependency_results"})
def run(self, filename=None, file=None, **kwargs): """ Runs the wrapped tool. :param filename: The filename of the file being linted. ``None`` for project scope. :param file: The content of the file being linted. ``None`` for project scope. """ # Get the **kwargs params to forward to `generate_config()` # (from `_create_config()`). generate_config_kwargs = FunctionMetadata.filter_parameters( self._get_generate_config_metadata(), kwargs) with self._create_config( filename, file, **generate_config_kwargs) as config_file: # And now retrieve the **kwargs for `create_arguments()`. create_arguments_kwargs = ( FunctionMetadata.filter_parameters( self._get_create_arguments_metadata(), kwargs)) # The interface of create_arguments is different for local # and global bears, therefore we must check here, what kind # of bear we have. if isinstance(self, LocalBear): args = self.create_arguments(filename, file, config_file, **create_arguments_kwargs) else: args = self.create_arguments(config_file, **create_arguments_kwargs) try: args = tuple(args) except TypeError: self.err('The given arguments ' '{!r} are not iterable.'.format(args)) return arguments = (self.get_executable(),) + args self.debug("Running '{}'".format(' '.join(arguments))) output = run_shell_command( arguments, stdin=''.join(file) if options['use_stdin'] else None, cwd=self.get_config_dir()) output = tuple(compress( output, (options['use_stdout'], options['use_stderr']))) if len(output) == 1: output = output[0] process_output_kwargs = FunctionMetadata.filter_parameters( self._get_process_output_metadata(), kwargs) return self.process_output(output, filename, file, **process_output_kwargs)
def _get_generate_config_metadata(cls): return FunctionMetadata.from_function(cls.generate_config, omit={"filename", "file"})
def _get_generate_config_metadata(cls): return FunctionMetadata.from_function( cls.generate_config, omit={"filename", "file"})
def _get_create_arguments_metadata(cls): return FunctionMetadata.from_function( cls.create_arguments, omit={"self", "filename", "file", "config_file"})
def test_construction(self): self.check_function_metadata_data_set(FunctionMetadata('name'), 'name')
def get_shortlog_checks_metadata(cls): return FunctionMetadata.from_function( cls.check_shortlog, omit={"self", "shortlog"})
def get_issue_checks_metadata(cls): return FunctionMetadata.from_function( cls.check_issue_reference, omit={'self', 'body'})
def get_metadata(cls): return FunctionMetadata.from_function(cls.__init__, omit={"self"})