Normalize option values additionally by type

Now that the contract has narrowed for `utils.normalize_paths()`
and `utils.parse_comma_separated_list()`, `Option.normalize()` must
handle when the option value is either a singular value or a sequence
(i.e., `list`) of values.

The paths where `Option.normalize()` is called are:

1. options/config.py: `MergedConfigParser.parse_*_config()`
    There are 3 paths wehre eventually `_normalize_value()` is called.
2. options/manager.py: `OptionManager.parse_args()`

For (1), values are coming from the `configparser` module.  For (2),
values are coming from `optparse.OptionParser`.

Rudimentary investigation seems to implicate that
`optparse.OptionParser.parse_args()` always returns values in a `list`
because it accumulates values.  However, for `configparser`, the values
are a string due to the key-value nature of the INI format.

Given that `Option.normalize()` is the convergence point where
normalization of an option occurs, it is acceptable for the method to
also handle the parsing comma-separated values and path normalization by
the option value's type.

src/flake8/options/manager.py

@@ -2,7 +2,7 @@
 import collections
 import logging
 import optparse  # pylint: disable=deprecated-module
-from typing import Any, Callable, Dict, List, Optional, Set
+from typing import Dict, List, Optional, Set
 
 from flake8 import utils
 
@@ -142,14 +142,17 @@ class Option(object):
 
     def normalize(self, value, *normalize_args):
         """Normalize the value based on the option configuration."""
+        if self.comma_separated_list and isinstance(
+            value, utils.string_types
+        ):
+            value = utils.parse_comma_separated_list(value)
+
         if self.normalize_paths:
-            # Decide whether to parse a list of paths or a single path
-            normalize = utils.normalize_path  # type: Callable[..., Any]
-            if self.comma_separated_list:
-                normalize = utils.normalize_paths
-            return normalize(value, *normalize_args)
-        elif self.comma_separated_list:
-            return utils.parse_comma_separated_list(value)
+            if isinstance(value, list):
+                value = utils.normalize_paths(value, *normalize_args)
+            else:
+                value = utils.normalize_path(value, *normalize_args)
+
         return value
 
     def normalize_from_setuptools(self, value):

src/flake8/utils.py

@@ -39,9 +39,7 @@ def parse_comma_separated_list(value, regexp=COMMA_SEPARATED_LIST_RE):
     :rtype:
         list
     """
-    assert isinstance(  # nosec (for bandit)
-        value, (string_types, type(None))
-    ), value
+    assert isinstance(value, string_types), value  # nosec (for bandit)
 
     if not value:
         return []