docs: def parse_string_factory(
      alg, sep, splitter, input_transform, component_transform, final_transform
  ):
      """
      Create a function that will split and format a *str* into a tuple.
  
      Parameters
      ----------
      alg : ns enum
          Indicate how to format and split the *str*.
      sep : str
          The string character to be inserted between adjacent numeric
          objects in the returned tuple.
      splitter : callable
          A function the will accept a string and returns an iterable
          of strings where the numbers are separated from the non-numbers.
      input_transform : callable
          A function to apply to the string input *before* applying
          the *splitter* function. Must return a string.
      component_transform : callable
          A function that is operated elementwise on the output of
          *splitter*. It must accept a single string and return either
          a string or a number.
      final_transform : callable
          A function to operate on the return value as a whole. It
          must accept a tuple and a string argument - the tuple
          should be the result of applying the above functions, and the
          string is the original input value. It must return a tuple.
  
      Returns
      -------
      func : callable
          A function that accepts string input and returns a tuple
          containing the string split into numeric and non-numeric
          components, where the numeric components are converted into
          numeric objects. The first element is *always* a string,
          and then alternates number then string. Intended to be
          used as the *string_func* argument to *natsort_key*.
  
      See Also
      --------
      natsort_key
      input_string_transform_factory
      string_component_transform_factory
      final_data_transform_factory
  
      """
      # Sometimes we store the "original" input before transformation,
      # sometimes after.
      orig_after_xfrm = not (alg & NS_DUMB and alg & ns.LOCALEALPHA)
      original_func = input_transform if orig_after_xfrm else _no_op
      normalize_input = _normalize_input_factory(alg)
  
      def func(x):
          # Apply string input transformation function and return to x.
          # Original function is usually a no-op, but some algorithms require it
          # to also be the transformation function.
          x = normalize_input(x)
          x, original = input_transform(x), original_func(x)
          x = splitter(x)  # Split string into components.
          x = py23_filter(None, x)  # Remove empty strings.
          x = py23_map(component_transform, x)  # Apply transform on components.
          x = sep_inserter(x, sep)  # Insert '' between numbers.
          return final_transform(x, original)  # Apply the final transform.
  
      return func