Drop support of running under Python 2.7 (#2382)

7 files changed, 60 insertions, 50 deletions

diff --git a/src/virtualenv/run/__init__.py b/src/virtualenv/run/__init__.py
index e8e7ab1..8f18cd9 100644
--- a/src/virtualenv/run/__init__.py
+++ b/src/virtualenv/run/__init__.py
@@ -1,5 +1,3 @@
-from __future__ import absolute_import, unicode_literals
-
 import logging
 import os
 from functools import partial
@@ -69,7 +67,7 @@ def build_parser(args=None, options=None, setup_logging=True, env=None):
     discover = get_discover(parser, args)
     parser._interpreter = interpreter = discover.interpreter
     if interpreter is None:
-        raise RuntimeError("failed to find interpreter for {}".format(discover))
+        raise RuntimeError(f"failed to find interpreter for {discover}")
     elements = [
         CreatorSelector(interpreter, parser),
         SeederSelector(interpreter, parser),
@@ -130,13 +128,13 @@ def add_version_flag(parser):
     parser.add_argument(
         "--version",
         action="version",
-        version="%(prog)s {} from {}".format(__version__, virtualenv.__file__),
+        version=f"%(prog)s {__version__} from {virtualenv.__file__}",
         help="display the version of the virtualenv package and its location, then exit",
     )
 
 
 def _do_report_setup(parser, args, setup_logging):
-    level_map = ", ".join("{}={}".format(logging.getLevelName(l), c) for c, l in sorted(list(LEVELS.items())))
+    level_map = ", ".join(f"{logging.getLevelName(l)}={c}" for c, l in sorted(list(LEVELS.items())))
     msg = "verbosity = verbose - quiet, default {}, mapping => {}"
     verbosity_group = parser.add_argument_group(
         title="verbosity",
@@ -150,7 +148,7 @@ def _do_report_setup(parser, args, setup_logging):
         setup_report(option.verbosity)
 
 
-__all__ = (
+__all__ = [
     "cli_run",
     "session_via_cli",
-)
+]
diff --git a/src/virtualenv/run/plugin/activators.py b/src/virtualenv/run/plugin/activators.py
index 8180981..320cae7 100644
--- a/src/virtualenv/run/plugin/activators.py
+++ b/src/virtualenv/run/plugin/activators.py
@@ -1,5 +1,3 @@
-from __future__ import absolute_import, unicode_literals
-
 from argparse import ArgumentTypeError
 from collections import OrderedDict
 
@@ -12,14 +10,14 @@ class ActivationSelector(ComponentBuilder):
         possible = OrderedDict(
             (k, v) for k, v in self.options("virtualenv.activate").items() if v.supports(interpreter)
         )
-        super(ActivationSelector, self).__init__(interpreter, parser, "activators", possible)
+        super().__init__(interpreter, parser, "activators", possible)
         self.parser.description = "options for activation scripts"
         self.active = None
 
     def add_selector_arg_parse(self, name, choices):
         self.default = ",".join(choices)
         self.parser.add_argument(
-            "--{}".format(name),
+            f"--{name}",
             default=self.default,
             metavar="comma_sep_list",
             required=False,
@@ -31,7 +29,7 @@ class ActivationSelector(ComponentBuilder):
         elements = [e.strip() for e in entered_str.split(",") if e.strip()]
         missing = [e for e in elements if e not in self.possible]
         if missing:
-            raise ArgumentTypeError("the following activators are not available {}".format(",".join(missing)))
+            raise ArgumentTypeError(f"the following activators are not available {','.join(missing)}")
         return elements
 
     def handle_selected_arg_parse(self, options):
@@ -54,3 +52,8 @@ class ActivationSelector(ComponentBuilder):
 
     def create(self, options):
         return [activator_class(options) for activator_class in self.active.values()]
+
+
+__all__ = [
+    "ActivationSelector",
+]
diff --git a/src/virtualenv/run/plugin/base.py b/src/virtualenv/run/plugin/base.py
index 048c76a..5fbf81b 100644
--- a/src/virtualenv/run/plugin/base.py
+++ b/src/virtualenv/run/plugin/base.py
@@ -1,5 +1,3 @@
-from __future__ import absolute_import, unicode_literals
-
 import sys
 from collections import OrderedDict
 
@@ -13,7 +11,7 @@ else:
     importlib_metadata_version = tuple(int(i) for i in version("importlib_metadata").split(".")[:2])
 
 
-class PluginLoader(object):
+class PluginLoader:
     _OPTIONS = None
     _ENTRY_POINTS = None
 
@@ -52,14 +50,20 @@ class ComponentBuilder(PluginLoader):
     def handle_selected_arg_parse(self, options):
         selected = getattr(options, self.name)
         if selected not in self.possible:
-            raise RuntimeError("No implementation for {}".format(self.interpreter))
+            raise RuntimeError(f"No implementation for {self.interpreter}")
         self._impl_class = self.possible[selected]
         self.populate_selected_argparse(selected, options.app_data)
         return selected
 
     def populate_selected_argparse(self, selected, app_data):
-        self.parser.description = "options for {} {}".format(self.name, selected)
+        self.parser.description = f"options for {self.name} {selected}"
         self._impl_class.add_parser_arguments(self.parser, self.interpreter, app_data)
 
     def create(self, options):
         return self._impl_class(options, self.interpreter)
+
+
+__all__ = [
+    "PluginLoader",
+    "ComponentBuilder",
+]
diff --git a/src/virtualenv/run/plugin/creators.py b/src/virtualenv/run/plugin/creators.py
index ef4177a..8953064 100644
--- a/src/virtualenv/run/plugin/creators.py
+++ b/src/virtualenv/run/plugin/creators.py
@@ -1,5 +1,3 @@
-from __future__ import absolute_import, unicode_literals
-
 from collections import OrderedDict, defaultdict, namedtuple
 
 from virtualenv.create.describe import Describe
@@ -13,7 +11,7 @@ CreatorInfo = namedtuple("CreatorInfo", ["key_to_class", "key_to_meta", "describ
 class CreatorSelector(ComponentBuilder):
     def __init__(self, interpreter, parser):
         creators, self.key_to_meta, self.describe, self.builtin_key = self.for_interpreter(interpreter)
-        super(CreatorSelector, self).__init__(interpreter, parser, "creator", creators)
+        super().__init__(interpreter, parser, "creator", creators)
 
     @classmethod
     def for_interpreter(cls, interpreter):
@@ -37,10 +35,10 @@ class CreatorSelector(ComponentBuilder):
                 describe = creator_class
         if not key_to_meta:
             if errors:
-                rows = ["{} for creators {}".format(k, ", ".join(i.__name__ for i in v)) for k, v in errors.items()]
+                rows = [f"{k} for creators {', '.join(i.__name__ for i in v)}" for k, v in errors.items()]
                 raise RuntimeError("\n".join(rows))
             else:
-                raise RuntimeError("No virtualenv implementation for {}".format(interpreter))
+                raise RuntimeError(f"No virtualenv implementation for {interpreter}")
         return CreatorInfo(
             key_to_class=key_to_class,
             key_to_meta=key_to_meta,
@@ -53,13 +51,11 @@ class CreatorSelector(ComponentBuilder):
         choices = sorted(choices, key=lambda a: 0 if a == "builtin" else 1)
         default_value = self._get_default(choices)
         self.parser.add_argument(
-            "--{}".format(name),
+            f"--{name}",
             choices=choices,
             default=default_value,
             required=False,
-            help="create environment via{}".format(
-                "" if self.builtin_key is None else " (builtin = {})".format(self.builtin_key),
-            ),
+            help=f"create environment via{'' if self.builtin_key is None else f' (builtin = {self.builtin_key})'}",
         )
 
     @staticmethod
@@ -67,11 +63,17 @@ class CreatorSelector(ComponentBuilder):
         return next(iter(choices))
 
     def populate_selected_argparse(self, selected, app_data):
-        self.parser.description = "options for {} {}".format(self.name, selected)
+        self.parser.description = f"options for {self.name} {selected}"
         self._impl_class.add_parser_arguments(self.parser, self.interpreter, self.key_to_meta[selected], app_data)
 
     def create(self, options):
         options.meta = self.key_to_meta[getattr(options, self.name)]
         if not issubclass(self._impl_class, Describe):
             options.describe = self.describe(options, self.interpreter)
-        return super(CreatorSelector, self).create(options)
+        return super().create(options)
+
+
+__all__ = [
+    "CreatorSelector",
+    "CreatorInfo",
+]
diff --git a/src/virtualenv/run/plugin/discovery.py b/src/virtualenv/run/plugin/discovery.py
index ac9b7f5..13f39ed 100644
--- a/src/virtualenv/run/plugin/discovery.py
+++ b/src/virtualenv/run/plugin/discovery.py
@@ -1,10 +1,8 @@
-from __future__ import absolute_import, unicode_literals
-
 from .base import PluginLoader
 
 
 class Discovery(PluginLoader):
-    """ """
+    """Discovery plugins"""
 
 
 def get_discover(parser, args):
@@ -33,3 +31,9 @@ def get_discover(parser, args):
 
 def _get_default_discovery(discover_types):
     return list(discover_types.keys())
+
+
+__all__ = [
+    "get_discover",
+    "Discovery",
+]
diff --git a/src/virtualenv/run/plugin/seeders.py b/src/virtualenv/run/plugin/seeders.py
index d182c6f..1a51d2e 100644
--- a/src/virtualenv/run/plugin/seeders.py
+++ b/src/virtualenv/run/plugin/seeders.py
@@ -1,16 +1,14 @@
-from __future__ import absolute_import, unicode_literals
-
 from .base import ComponentBuilder
 
 
 class SeederSelector(ComponentBuilder):
     def __init__(self, interpreter, parser):
         possible = self.options("virtualenv.seed")
-        super(SeederSelector, self).__init__(interpreter, parser, "seeder", possible)
+        super().__init__(interpreter, parser, "seeder", possible)
 
     def add_selector_arg_parse(self, name, choices):
         self.parser.add_argument(
-            "--{}".format(name),
+            f"--{name}",
             choices=choices,
             default=self._get_default(),
             required=False,
@@ -29,7 +27,12 @@ class SeederSelector(ComponentBuilder):
         return "app-data"
 
     def handle_selected_arg_parse(self, options):
-        return super(SeederSelector, self).handle_selected_arg_parse(options)
+        return super().handle_selected_arg_parse(options)
 
     def create(self, options):
         return self._impl_class(options)
+
+
+__all__ = [
+    "SeederSelector",
+]
diff --git a/src/virtualenv/run/session.py b/src/virtualenv/run/session.py
index 24836d2..84777fe 100644
--- a/src/virtualenv/run/session.py
+++ b/src/virtualenv/run/session.py
@@ -1,12 +1,8 @@
-from __future__ import absolute_import, unicode_literals
-
 import json
 import logging
 
-from virtualenv.util.six import ensure_text
-
 
-class Session(object):
+class Session:
     """Represents a virtual environment creation session"""
 
     def __init__(self, verbosity, app_data, interpreter, creator, seeder, activators):
@@ -49,7 +45,7 @@ class Session(object):
         self.creator.pyenv_cfg.write()
 
     def _create(self):
-        logging.info("create virtual environment via %s", ensure_text(str(self.creator)))
+        logging.info("create virtual environment via %s", self.creator)
         self.creator.run()
         logging.debug(_DEBUG_MARKER)
         logging.debug("%s", _Debug(self.creator))
@@ -61,10 +57,8 @@ class Session(object):
 
     def _activate(self):
         if self.activators:
-            logging.info(
-                "add activators for %s",
-                ", ".join(type(i).__name__.replace("Activator", "") for i in self.activators),
-            )
+            active = ", ".join(type(i).__name__.replace("Activator", "") for i in self.activators)
+            logging.info("add activators for %s", active)
             for activator in self.activators:
                 activator.generate(self.creator)
 
@@ -78,14 +72,16 @@ class Session(object):
 _DEBUG_MARKER = "=" * 30 + " target debug " + "=" * 30
 
 
-class _Debug(object):
+class _Debug:
     """lazily populate debug"""
 
     def __init__(self, creator):
         self.creator = creator
 
-    def __unicode__(self):
-        return ensure_text(repr(self))
-
     def __repr__(self):
         return json.dumps(self.creator.debug, indent=2)
+
+
+__all__ = [
+    "Session",
+]