text: """Option handling polyfill for Flake8 2.x and 3.x."""
  import optparse
  import os
  
  
  def register(parser, *args, **kwargs):
      r"""Register an option for the Option Parser provided by Flake8.
  
      :param parser:
          The option parser being used by Flake8 to handle command-line options.
      :param \*args:
          Positional arguments that you might otherwise pass to ``add_option``.
      :param \*\*kwargs:
          Keyword arguments you might otherwise pass to ``add_option``.
      """
      try:
          # Flake8 3.x registration
          parser.add_option(*args, **kwargs)
      except (optparse.OptionError, TypeError):
          # Flake8 2.x registration
          # Pop Flake8 3 parameters out of the kwargs so they don't cause a
          # conflict.
          parse_from_config = kwargs.pop("parse_from_config", False)
          comma_separated_list = kwargs.pop("comma_separated_list", False)
          normalize_paths = kwargs.pop("normalize_paths", False)
          # In the unlikely event that the developer has specified their own
          # callback, let's pop that and deal with that as well.
          base_callback = kwargs.pop("callback", store_callback)
          callback = generate_callback_from(
              comma_separated_list, normalize_paths, base_callback
          )
          kwargs["callback"] = callback
          kwargs["action"] = "callback"
  
          # We've updated our args and kwargs and can now rather confidently
          # call add_option.
          option = parser.add_option(*args, **kwargs)
          if parse_from_config:
              parser.config_options.append(option.get_opt_string().lstrip("-"))
  
  
  def parse_comma_separated_list(value):
      """Parse a comma-separated list.
  
      :param value:
          String or list of strings to be parsed and normalized.
      :returns:
          List of values with whitespace stripped.
      :rtype:
          list
      """
      if not value:
          return []
  
      if not isinstance(value, (list, tuple)):
          value = value.split(",")
  
      return [item.strip() for item in value]
  
  
  def normalize_path(path, parent=os.curdir):
      """Normalize a single-path.
  
      :returns:
          The normalized path.
      :rtype:
          str
      """
      # NOTE(sigmavirus24): Using os.path.sep allows for Windows paths to
      # be specified and work appropriately.
      separator = os.path.sep
      if separator in path:
          path = os.path.abspath(os.path.join(parent, path))
      return path.rstrip(separator)
  
  
  def parse_normalized_paths(value):
      """Normalize the path(s) value."""
      if isinstance(value, list):
          normalized = [normalize_path(s) for s in value]
      else:
          normalized = normalize_path(value)
      return normalized
  
  
  def store_callback(option, opt_str, value, parser, *args, **kwargs):
      """Implement optparse's "store" action as a callback."""
      setattr(parser.values, option.dest, value)
  
  
  def generate_callback_from(
      comma_separated_list, normalize_paths, base_callback
  ):
      """Generate a callback from parameters provided for the option."""
  
      def _callback(option, opt_str, value, parser, *args, **kwargs):
          """Wrap `base_callback` by transforming `value` for option params."""
          if comma_separated_list:
              value = parse_comma_separated_list(value)
          if normalize_paths:
              value = parse_normalized_paths(value)
          base_callback(option, opt_str, value, parser, *args, **kwargs)
  
      return _callback
  