我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用inspect.getargspec()。
def add(self, categorize): """Add given method to categorize messages. When a message is received, each of the added methods (most recently added method first) is called with the message. The method should return a category (any hashable object) or None (in which case next recently added method is called with the same message). If all the methods return None for a given message, the message is queued with category=None, so that 'receive' method here works just as Task.receive. """ if inspect.isfunction(categorize): argspec = inspect.getargspec(categorize) if len(argspec.args) != 1: categorize = None elif type(categorize) != partial_func: categorize = None if categorize: self._categorize.insert(0, categorize) else: logger.warning('invalid categorize function ignored')
def run(self): "Run cli, processing arguments and executing subcommands." arguments = self.argument_parser.parse_args() argspec = inspect.getargspec(arguments.func) vargs = [] for arg in argspec.args: vargs.append(getattr(arguments, arg)) if argspec.varargs: vargs.extend(getattr(arguments, argspec.varargs)) output = arguments.func(*vargs) if getattr(arguments.func, '_cli_test_command', False): self.exit_code = 0 if output else 1 output = '' if getattr(arguments.func, '_cli_no_output', False): output = '' self.formatter.format_output(output, arguments.format) if charmhelpers.core.unitdata._KV: charmhelpers.core.unitdata._KV.flush()
def describe_arguments(func): """ Analyze a function's signature and return a data structure suitable for passing in as arguments to an argparse parser's add_argument() method.""" argspec = inspect.getargspec(func) # we should probably raise an exception somewhere if func includes **kwargs if argspec.defaults: positional_args = argspec.args[:-len(argspec.defaults)] keyword_names = argspec.args[-len(argspec.defaults):] for arg, default in zip(keyword_names, argspec.defaults): yield ('--{}'.format(arg),), {'default': default} else: positional_args = argspec.args for arg in positional_args: yield (arg,), {} if argspec.varargs: yield (argspec.varargs,), {'nargs': '*'}
def parse_argspec(callable_): """ Takes a callable and returns a tuple with the list of Argument objects, the name of *args, and the name of **kwargs. If *args or **kwargs is not present, it will be None. This returns a namedtuple called Argspec that has three fields named: args, starargs, and kwargs. """ args, varargs, keywords, defaults = inspect.getargspec(callable_) defaults = list(defaults or []) if getattr(callable_, '__self__', None) is not None: # This is a bound method, drop the self param. args = args[1:] first_default = len(args) - len(defaults) return Argspec( [Argument(arg, Argument.no_default if n < first_default else defaults[n - first_default]) for n, arg in enumerate(args)], varargs, keywords, )
def getargspec(func): params = signature(func).parameters args, varargs, keywords, defaults = [], None, None, [] for name, param in params.items(): if param.kind == param.VAR_POSITIONAL: varargs = name elif param.kind == param.VAR_KEYWORD: keywords = name else: args.append(name) if param.default is not param.empty: defaults.append(param.default) return (args, varargs, keywords, tuple(defaults) or None)
def yieldroutes(func): """ Return a generator for routes that match the signature (name, args) of the func parameter. This may yield more than one route if the function takes optional keyword arguments. The output is best described by example:: a() -> '/a' b(x, y) -> '/b/<x>/<y>' c(x, y=5) -> '/c/<x>' and '/c/<x>/<y>' d(x=5, y=6) -> '/d' and '/d/<x>' and '/d/<x>/<y>' """ path = '/' + func.__name__.replace('__', '/').lstrip('/') spec = getargspec(func) argc = len(spec[0]) - len(spec[3] or []) path += ('/<%s>' * argc) % tuple(spec[0][:argc]) yield path for arg in spec[0][argc:]: path += '/<%s>' % arg yield path
def getargspec_init(method): """inspect.getargspec with considerations for typical __init__ methods Wraps inspect.getargspec with error handling for typical __init__ cases:: object.__init__ -> (self) other unreflectable (usually C) -> (self, *args, **kwargs) """ try: return compat.inspect_getargspec(method) except TypeError: if method is object.__init__: return (['self'], None, None, None) else: return (['self'], 'args', 'kwargs', None)
def analyse_action(func): """Analyse a function.""" description = inspect.getdoc(func) or 'undocumented action' arguments = [] args, varargs, kwargs, defaults = inspect.getargspec(func) if varargs or kwargs: raise TypeError('variable length arguments for action not allowed.') if len(args) != len(defaults or ()): raise TypeError('not all arguments have proper definitions') for idx, (arg, definition) in enumerate(zip(args, defaults or ())): if arg.startswith('_'): raise TypeError('arguments may not start with an underscore') if not isinstance(definition, tuple): shortcut = None default = definition else: shortcut, default = definition argument_type = argument_types[type(default)] if isinstance(default, bool) and default is True: arg = 'no-' + arg arguments.append((arg.replace('_', '-'), shortcut, default, argument_type)) return func, description, arguments
def enableAttributes(genfunc): """Wrapper for generators to enable classlike attribute access. The generator definition should specify 'self' as the first parameter. Calls to a wrapped generator should ignore the self parameter. """ old = getargspec(genfunc) old[0].pop(0) new = getargspec(genfunc) new[0][0] = 'wrapped' specs = {'name': genfunc.func_name, 'oldargs': formatargspec(*old), 'newargs': formatargspec(*new)} exec(_redefinition % specs, genfunc.func_globals) #### A minimal, complete example
def signature(function): """Build a string with source code of the function declaration""" desc = inspect.getargspec(function) if desc[3]: ldefault = len(desc[3]) default = desc[3] sign = ','.join(desc[0][:-ldefault]) else: ldefault = 0 default=[] sign = ','.join(desc[0]) for n,v in zip(desc[0][-ldefault:],default): sign += ','+n+"="+str(v) if desc[1]: sign +=',*'+desc[1] if desc[2]: sign +=',**'+desc[2] if sign and sign[0]==',': sign = sign[1:] return sign
def describe_builtin(obj): """ Describe a builtin function """ wi('+Built-in Function: %s' % obj.__name__) # Built-in functions cannot be inspected by # inspect.getargspec. We have to try and parse # the __doc__ attribute of the function. docstr = obj.__doc__ args = '' if docstr: items = docstr.split('\n') if items: func_descr = items[0] s = func_descr.replace(obj.__name__,'') idx1 = s.find('(') idx2 = s.find(')',idx1) if idx1 != -1 and idx2 != -1 and (idx2>idx1+1): args = s[idx1+1:idx2] wi('\t-Method Arguments:', args) if args=='': wi('\t-Method Arguments: None') print
def _conspect_param_defaults(func_to, func_from): # .. result = {} defaults = inspect.getargspec(func_from).defaults if defaults: # .. args = inspect.getargspec(func_from).args # .. defaults_enum = list(enumerate(defaults)) defaults_length = len(defaults_enum) result = dict((args[-defaults_length + id],value) for id, value in defaults_enum) # ... setattr(func_to, JSON_ARGS_DEFAULTS, result) # ... # ... # ...
def item_triggered(item_name, event_types=None, result_item_name=None): event_types = event_types or [ITEM_CHANGE] event_bus = scope.events if hasattr(event_types, '__iter__'): event_types = ",".join(event_types) def decorator(fn): nargs = len(inspect.getargspec(fn).args) def callback(module, inputs): fn_args = [] event = inputs.get('event') if event and nargs == 1: fn_args.append(event) result_value = fn(*fn_args) if result_item_name: event_bus.postUpdate(result_item_name, unicode(result_value)) rule = _FunctionRule(callback, [ItemEventTrigger(item_name, event_types)], extended=True) get_automation_manager().addRule(rule) return fn return decorator
def item_group_triggered(group_name, event_types=None, result_item_name=None): event_types = event_types or [ITEM_CHANGE] event_bus = scope.events if hasattr(event_types, '__iter__'): event_types = ",".join(event_types) def decorator(fn): nargs = len(inspect.getargspec(fn).args) def callback(module, inputs): fn_args = [] event = inputs.get('event') if event and nargs == 1: fn_args.append(event) result_value = fn(*fn_args) if result_item_name: event_bus.postUpdate(result_item_name, unicode(result_value)) group_triggers = [] group = scope.itemRegistry.getItem(group_name) for i in group.getAllMembers(): group_triggers.append(ItemEventTrigger(i.name, event_types)) rule = _FunctionRule(callback, group_triggers, extended=True) get_automation_manager().addRule(rule) return fn return decorator
def getargspec(func): if six.PY2: return inspect.getargspec(func) sig = inspect.signature(func) args = [ p.name for p in sig.parameters.values() if p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD ] varargs = [ p.name for p in sig.parameters.values() if p.kind == inspect.Parameter.VAR_POSITIONAL ] varargs = varargs[0] if varargs else None varkw = [ p.name for p in sig.parameters.values() if p.kind == inspect.Parameter.VAR_KEYWORD ] varkw = varkw[0] if varkw else None defaults = [ p.default for p in sig.parameters.values() if p.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD and p.default is not p.empty ] or None return args, varargs, varkw, defaults
def func_accepts_kwargs(func): if six.PY2: # Not all callables are inspectable with getargspec, so we'll # try a couple different ways but in the end fall back on assuming # it is -- we don't want to prevent registration of valid but weird # callables. try: argspec = inspect.getargspec(func) except TypeError: try: argspec = inspect.getargspec(func.__call__) except (TypeError, AttributeError): argspec = None return not argspec or argspec[2] is not None return any( p for p in inspect.signature(func).parameters.values() if p.kind == p.VAR_KEYWORD )
def mergeFunctionMetadata(f, g): """ Overwrite C{g}'s docstring and name with values from C{f}. Update C{g}'s instance dictionary with C{f}'s. """ try: g.__doc__ = f.__doc__ except (TypeError, AttributeError): pass try: g.__dict__.update(f.__dict__) except (TypeError, AttributeError): pass try: g.__name__ = f.__name__ except TypeError: try: g = new.function( g.func_code, g.func_globals, f.__name__, inspect.getargspec(g)[-1], g.func_closure) except TypeError: pass return g
def commit(self, request, node, data): """ It has been determined that the input for the entire form is completely valid; it is now safe for all handlers to commit changes to the model. """ if self._commit is None: data = str(data) if data != self.view.getData(): self.model.setData(data) self.model.notify({'request': request, self.submodel: data}) else: func = self._commit if hasattr(func, 'im_func'): func = func.im_func args, varargs, varkw, defaults = inspect.getargspec(func) if args[1] == 'request': self._commit(request, data) else: self._commit(data)
def strip_defaults(self): """ Returns self.parameters list with all default values stripped from right side. That means, if last parameter is default, it's removed from list; if before-last parameter is default, it's removed as well; et cetera et cetera until first non-default parameter is reached. if as_strings is set to True, all parameters are converted to apropriate strings (x.name for enums, x.encode('string_escape') for strings, """ argspec = inspect.getargspec(self.__class__.__init__) required_count = len(argspec.args) - len(argspec.defaults) - 1 d = list(argspec.defaults) l = list(self.parameters) while len(d) and len(l) > required_count and d[-1] == l[-1]: d, l = d[:-1], l[:-1] return l
def get_args(self, func): """ Get the arguments of a method and return it as a dictionary with the supplied defaults, method arguments with no default are assigned None """ def reverse(iterable): if iterable: iterable = list(iterable) while len(iterable): yield iterable.pop() args, varargs, varkw, defaults = inspect.getargspec(func) result = {} for default in reverse(defaults): result[args.pop()] = default for arg in reverse(args): if arg == 'self': continue result[arg] = None return result
def analyse_action(func): """Analyse a function.""" _deprecated() description = inspect.getdoc(func) or 'undocumented action' arguments = [] args, varargs, kwargs, defaults = inspect.getargspec(func) if varargs or kwargs: raise TypeError('variable length arguments for action not allowed.') if len(args) != len(defaults or ()): raise TypeError('not all arguments have proper definitions') for idx, (arg, definition) in enumerate(zip(args, defaults or ())): if arg.startswith('_'): raise TypeError('arguments may not start with an underscore') if not isinstance(definition, tuple): shortcut = None default = definition else: shortcut, default = definition argument_type = argument_types[type(default)] if isinstance(default, bool) and default is True: arg = 'no-' + arg arguments.append((arg.replace('_', '-'), shortcut, default, argument_type)) return func, description, arguments
def get_kwarg_names(func): """ Return a list of valid kwargs to function func """ try: # Python 3.5 sig = inspect.signature(func) except AttributeError: # Below Python 3.5 args, _, _, defaults = inspect.getargspec(func) if defaults: kwonlyargs = args[-len(defaults):] else: kwonlyargs = [] else: kwonlyargs = [p.name for p in sig.parameters.values() if p.default is not p.empty] return kwonlyargs
def quick_init(self, locals_): if getattr(self, "_serializable_initialized", False): return if sys.version_info >= (3, 0): spec = inspect.getfullargspec(self.__init__) # Exclude the first "self" parameter if spec.varkw: kwargs = locals_[spec.varkw] else: kwargs = dict() else: spec = inspect.getargspec(self.__init__) if spec.keywords: kwargs = locals_[spec.keywords] else: kwargs = dict() if spec.varargs: varargs = locals_[spec.varargs] else: varargs = tuple() in_order_args = [locals_[arg] for arg in spec.args][1:] self.__args = tuple(in_order_args) + varargs self.__kwargs = kwargs setattr(self, "_serializable_initialized", True)
def __init__(self, func, role='func', doc=None, config={}): self._f = func self._role = role # e.g. "func" or "meth" if doc is None: if func is None: raise ValueError("No function or docstring given") doc = inspect.getdoc(func) or '' NumpyDocString.__init__(self, doc) if not self['Signature'] and func is not None: func, func_name = self.get_func() try: # try to read signature argspec = inspect.getargspec(func) argspec = inspect.formatargspec(*argspec) argspec = argspec.replace('*','\*') signature = '%s%s' % (func_name, argspec) except TypeError, e: signature = '%s()' % func_name self['Signature'] = signature
def __init__(self, docstring, class_name, class_object): super(NumpyClassDocString, self).__init__(docstring) self.class_name = class_name methods = dict((name, func) for name, func in inspect.getmembers(class_object)) self.has_parameters = False if '__init__' in methods: # verify if __init__ is a Python function. If it isn't # (e.g. the function is implemented in C), getargspec will fail if not inspect.ismethod(methods['__init__']): return args, varargs, keywords, defaults = inspect.getargspec( methods['__init__']) if (args and args != ['self']) or varargs or keywords or defaults: self.has_parameters = True
def __init__(self, func, role='func', doc=None, config={}): self._f = func self._role = role # e.g. "func" or "meth" if doc is None: if func is None: raise ValueError("No function or docstring given") doc = inspect.getdoc(func) or '' NumpyDocString.__init__(self, doc) if not self['Signature'] and func is not None: func, func_name = self.get_func() try: # try to read signature argspec = inspect.getargspec(func) argspec = inspect.formatargspec(*argspec) argspec = argspec.replace('*', '\*') signature = '%s%s' % (func_name, argspec) except TypeError as e: signature = '%s()' % func_name self['Signature'] = signature
def filter_chain(filters, token, func, *args, **kwargs): if token == -1: return func() else: def _inner_method(): fm = filters[token] fargs = getargspec(fm)[0] if len(fargs) == 1: # Only self arg result = func() if result is None: return fm() else: raise IncorrectPluginArg(u'Plugin filter method need a arg to receive parent method result.') else: return fm(func if fargs[1] == '__' else func(), *args, **kwargs) return filter_chain(filters, token - 1, _inner_method, *args, **kwargs)
def register_handler( self, # type: BaseSocket method # type: Callable[..., Union[bool, None]] ): # type: (...) -> None """Register a handler for incoming method. Args: method: A function with two given arguments. Its signature should be of the form ``handler(msg, handler)``, where msg is a :py:class:`py2p.base.Message` object, and handler is a :py:class:`py2p.base.BaseConnection` object. It should return ``True`` if it performed an action, to reduce the number of handlers checked. Raises: ValueError: If the method signature doesn't parse correctly """ args = inspect.getargspec(method) if (args[1:] != (None, None, None) or len(args[0]) != (3 if args[0][0] == 'self' else 2)): raise ValueError( "This method must contain exactly two arguments " "(or three if first is self)") self.__handlers.append(method)
def _create_body(task, task_class): body = None args_list = inspect.getargspec(task_class.__init__).args len_args_list = len(args_list) # Skip first parameter 'self' of the __init__ method which is a convention in Python for that method. if len_args_list > 1: body = str(getattr(task, args_list[1])) if len_args_list > 2: # Ordering of the arguments from the __init__ method is relevant! # getattr throws an exception if an argument is not found in the task object. for index in range(2, len(args_list)): body += BaseMessage.field_separator + str(getattr(task, args_list[index])) return body
def yieldroutes(func): """ Return a generator for routes that match the signature (name, args) of the func parameter. This may yield more than one route if the function takes optional keyword arguments. The output is best described by example:: a() -> '/a' b(x, y) -> '/b/<x>/<y>' c(x, y=5) -> '/c/<x>' and '/c/<x>/<y>' d(x=5, y=6) -> '/d' and '/d/<x>' and '/d/<x>/<y>' """ path = '/' + func.__name__.replace('__','/').lstrip('/') spec = getargspec(func) argc = len(spec[0]) - len(spec[3] or []) path += ('/<%s>' * argc) % tuple(spec[0][:argc]) yield path for arg in spec[0][argc:]: path += '/<%s>' % arg yield path
def mocked_method(path, name, count): parent_method = getattr(NetworkDriver, name) parent_method_args = inspect.getargspec(parent_method) modifier = 0 if 'self' not in parent_method_args.args else 1 def _mocked_method(*args, **kwargs): # Check len(args) if len(args) + len(kwargs) + modifier > len(parent_method_args.args): raise TypeError( "{}: expected at most {} arguments, got {}".format( name, len(parent_method_args.args), len(args) + modifier)) # Check kwargs unexpected = [x for x in kwargs if x not in parent_method_args.args] if unexpected: raise TypeError("{} got an unexpected keyword argument '{}'".format(name, unexpected[0])) return mocked_data(path, name, count) return _mocked_method
