docs: def get_calling_prototype(acallable):
      """Returns actual working calling prototype
  
      This means that the prototype given can be used directly
      in the same way by bound method, method, function, lambda::
  
          >>> def f1(a, b, c=1): pass
          >>> get_calling_prototype(f1)
          (['a', 'b', 'c'], (1,))
          >>> get_calling_prototype(lambda a, b: None)
          (['a', 'b'], ())
          >>> get_calling_prototype(lambda a=None: None)
          (['a'], (None,))
          >>> get_calling_prototype(lambda : None)
          ([], ())
          >>> class A(object):
          ...     def m1(self, a, b, c=None): pass
          ...     @classmethod
          ...     def cm(cls, a, b, c=None): pass
          ...     @staticmethod
          ...     def st(a, b, c=None): pass
          ...     def __call__(self, a, b, c=None): pass
  
          >>> get_calling_prototype(A.m1)
          (['self', 'a', 'b', 'c'], (None,))
          >>> A.m1(A(), 1, 2, 3)
          >>> get_calling_prototype(A().m1)
          (['a', 'b', 'c'], (None,))
          >>> get_calling_prototype(A.cm)
          (['a', 'b', 'c'], (None,))
          >>> get_calling_prototype(A().cm)
          (['a', 'b', 'c'], (None,))
          >>> get_calling_prototype(A.st)
          (['a', 'b', 'c'], (None,))
          >>> get_calling_prototype(A().st)
          (['a', 'b', 'c'], (None,))
          >>> get_calling_prototype(A())
          (['a', 'b', 'c'], (None,))
  
  
  
      """
      assert callable(acallable)
      if inspect.ismethod(acallable) or inspect.isfunction(acallable):
          args, vargs, vkwargs, defaults = inspect.getargspec(acallable)
      elif not inspect.isfunction(acallable) and hasattr(acallable, "__call__"):
          ## a class instance ? which is callable...
          args, vargs, vkwargs, defaults = inspect.getargspec(acallable.__call__)
          ## remove the 'self' argument
          args = args[1:]
      else:
          raise ValueError("Hum, %r is a callable, but not a function/method, "
                           "nor a instance with __call__ arg..."
                           % acallable)
  
      if vargs or vkwargs:
          raise SyntaxError("variable *arg or **kwarg are not supported.")
  
      if is_bound(acallable):
          args = args[1:]
  
      if defaults is None:
          defaults = ()  ## be coherent
  
      return args, defaults