code: def _get_parser_call_method(self, parser_to_method):
          
          def inner_call(args=None, instance=None):
              """Allows to call the method invoked from the command line or
              provided argument.
  
              Args:
                  args: list of arguments to parse, defaults to command line
                  arguments
                  instance: an instance of the decorated class. If instance is
                  None, the default, and __init__ is decorated the object will be
                  instantiated on the fly from the command line arguments
              """
              parser = self._cls.parser
              namespace = parser.parse_args(_get_args_to_parse(args, sys.argv))
              if instance is None:
                  # If the __init__ method is not part of the method to
                  # decorate we cannot instantiate the class
                  if "__init__" not in parser_to_method:
                      raise ParseThisError(("'__init__' method is not decorated. "
                                            "Please provide an instance to "
                                            "'{}.parser.call' or decorate the "
                                            "'__init___' method with "
                                            "'create_parser'"
                                            .format(self._cls.__name__)))
                  # We instantiate the class from the command line arguments
                  instance = _call_method_from_namespace(self._cls, "__init__",
                                                         namespace)
              method_name = parser_to_method[namespace.method]
              return _call_method_from_namespace(instance, method_name, namespace)
          return inner_call
docs: Return the parser special method 'call' that handles sub-command
              calling.
  
          Args:
              parser_to_method: mapping of the parser registered name
              to the method it is linked to