docs: def parse_args(method_name, param_defs, args, kwargs, external_param_processor,
      extra_parameter_errors):
      """
      Parse arguments for suds web service operation invocation functions.
  
      Suds prepares Python function objects for invoking web service operations.
      This function implements generic binding agnostic part of processing the
      arguments passed when calling those function objects.
  
      Argument parsing rules:
        * Each input parameter element should be represented by single regular
          Python function argument.
        * At most one input parameter belonging to a single choice parameter
          structure may have its value specified as something other than None.
        * Positional arguments are mapped to choice group input parameters the
          same as is done for a simple all/sequence group - each in turn.
  
      Expects to be passed the web service operation's parameter definitions
      (parameter name, type & optional ancestry information) in order and, based
      on that, extracts the values for those parameter from the arguments
      provided in the web service operation invocation call.
  
      Ancestry information describes parameters constructed based on suds
      library's automatic input parameter structure unwrapping. It is expected to
      include the parameter's XSD schema 'ancestry' context, i.e. a list of all
      the parent XSD schema tags containing the parameter's <element> tag. Such
      ancestry context provides detailed information about how the parameter's
      value is expected to be used, especially in relation to other input
      parameters, e.g. at most one parameter value may be specified for
      parameters directly belonging to the same choice input group.
  
      Rules on acceptable ancestry items:
        * Ancestry item's choice() method must return whether the item
          represents a <choice> XSD schema tag.
        * Passed ancestry items are used 'by address' internally and the same XSD
          schema tag is expected to be identified by the exact same ancestry item
          object during the whole argument processing.
  
      During processing, each parameter's definition and value, together with any
      additional pertinent information collected from the encountered parameter
      definition structure, is passed on to the provided external parameter
      processor function. There that information is expected to be used to
      construct the actual binding specific web service operation invocation
      request.
  
      Raises a TypeError exception in case any argument related errors are
      detected. The exceptions raised have been constructed to make them as
      similar as possible to their respective exceptions raised during regular
      Python function argument checking.
  
      Does not support multiple same-named input parameters.
  
      """
      arg_parser = _ArgParser(method_name, param_defs, external_param_processor)
      return arg_parser(args, kwargs, extra_parameter_errors)