class_docstr: A Signature object represents the overall signature of a function.
  It stores a Parameter object for each parameter accepted by the
  function, as well as information specific to the function itself.
  
  A Signature object has the following public attributes and methods:
  
  * parameters : OrderedDict
      An ordered mapping of parameters' names to the corresponding
      Parameter objects (keyword-only arguments are in the same order
      as listed in `code.co_varnames`).
  * return_annotation : object
      The annotation for the return type of the function if specified.
      If the function has no annotation for its return type, this
      attribute is not set.
  * bind(*args, **kwargs) -> BoundArguments
      Creates a mapping from positional and keyword arguments to
      parameters.
  * bind_partial(*args, **kwargs) -> BoundArguments
      Creates a partial mapping from positional and keyword arguments
      to parameters (simulating 'functools.partial' behavior.)
code: def __str__(self):
      result = []
      render_kw_only_separator = True
      for idx, param in enumerate(self.parameters.values()):
          formatted = str(param)
  
          kind = param.kind
          if kind == _VAR_POSITIONAL:
              # OK, we have an '*args'-like parameter, so we won't need
              # a '*' to separate keyword-only arguments
              render_kw_only_separator = False
          elif kind == _KEYWORD_ONLY and render_kw_only_separator:
              # We have a keyword-only parameter to render and we haven't
              # rendered an '*args'-like parameter before, so add a '*'
              # separator to the parameters list ("foo(arg1, *, arg2)" case)
              result.append("*")
              # This condition should be only triggered once, so
              # reset the flag
              render_kw_only_separator = False
  
          result.append(formatted)
  
      rendered = "({0})".format(", ".join(result))
  
      if self.return_annotation is not _empty:
          anno = formatannotation(self.return_annotation)
          rendered += " -> {0}".format(anno)
  
      return rendered
  
imports: from __future__ import absolute_import, division, print_function
  import itertools
  import functools
  import re
  import types
label_desc: Use image node_id 12 for calling the Signature obj's underlying member method code with example usage: obj.__str__() and returns: rendered