first commit

kivy_venv/lib/python3.11/site-packages/virtualenv/run/plugin/activators.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from argparse import ArgumentTypeError
+from collections import OrderedDict
+
+from .base import ComponentBuilder
+
+
+class ActivationSelector(ComponentBuilder):
+    def __init__(self, interpreter, parser) -> None:
+        self.default = None
+        possible = OrderedDict(
+            (k, v) for k, v in self.options("virtualenv.activate").items() if v.supports(interpreter)
+        )
+        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(
+            f"--{name}",
+            default=self.default,
+            metavar="comma_sep_list",
+            required=False,
+            help="activators to generate - default is all supported",
+            type=self._extract_activators,
+        )
+
+    def _extract_activators(self, entered_str):
+        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:
+            msg = f"the following activators are not available {','.join(missing)}"
+            raise ArgumentTypeError(msg)
+        return elements
+
+    def handle_selected_arg_parse(self, options):
+        selected_activators = (
+            self._extract_activators(self.default) if options.activators is self.default else options.activators
+        )
+        self.active = {k: v for k, v in self.possible.items() if k in selected_activators}
+        self.parser.add_argument(
+            "--prompt",
+            dest="prompt",
+            metavar="prompt",
+            help=(
+                "provides an alternative prompt prefix for this environment "
+                "(value of . means name of the current working directory)"
+            ),
+            default=None,
+        )
+        for activator in self.active.values():
+            activator.add_parser_arguments(self.parser, self.interpreter)
+
+    def create(self, options):
+        return [activator_class(options) for activator_class in self.active.values()]
+
+
+__all__ = [
+    "ActivationSelector",
+]

kivy_venv/lib/python3.11/site-packages/virtualenv/run/plugin/base.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import sys
+from collections import OrderedDict
+
+if sys.version_info >= (3, 8):
+    from importlib.metadata import entry_points
+
+    importlib_metadata_version = ()
+else:
+    from importlib_metadata import entry_points, version
+
+    importlib_metadata_version = tuple(int(i) for i in version("importlib_metadata").split(".")[:2])
+
+
+class PluginLoader:
+    _OPTIONS = None
+    _ENTRY_POINTS = None
+
+    @classmethod
+    def entry_points_for(cls, key):
+        if sys.version_info >= (3, 10) or importlib_metadata_version >= (3, 6):
+            return OrderedDict((e.name, e.load()) for e in cls.entry_points().select(group=key))
+        return OrderedDict((e.name, e.load()) for e in cls.entry_points().get(key, {}))
+
+    @staticmethod
+    def entry_points():
+        if PluginLoader._ENTRY_POINTS is None:
+            PluginLoader._ENTRY_POINTS = entry_points()
+        return PluginLoader._ENTRY_POINTS
+
+
+class ComponentBuilder(PluginLoader):
+    def __init__(self, interpreter, parser, name, possible) -> None:
+        self.interpreter = interpreter
+        self.name = name
+        self._impl_class = None
+        self.possible = possible
+        self.parser = parser.add_argument_group(title=name)
+        self.add_selector_arg_parse(name, list(self.possible))
+
+    @classmethod
+    def options(cls, key):
+        if cls._OPTIONS is None:
+            cls._OPTIONS = cls.entry_points_for(key)
+        return cls._OPTIONS
+
+    def add_selector_arg_parse(self, name, choices):
+        raise NotImplementedError
+
+    def handle_selected_arg_parse(self, options):
+        selected = getattr(options, self.name)
+        if selected not in self.possible:
+            msg = f"No implementation for {self.interpreter}"
+            raise RuntimeError(msg)
+        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 = 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__ = [
+    "ComponentBuilder",
+    "PluginLoader",
+]

kivy_venv/lib/python3.11/site-packages/virtualenv/run/plugin/creators.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from collections import OrderedDict, defaultdict
+from typing import TYPE_CHECKING, NamedTuple
+
+from virtualenv.create.describe import Describe
+from virtualenv.create.via_global_ref.builtin.builtin_way import VirtualenvBuiltin
+
+from .base import ComponentBuilder
+
+if TYPE_CHECKING:
+    from virtualenv.create.creator import Creator, CreatorMeta
+
+
+class CreatorInfo(NamedTuple):
+    key_to_class: dict[str, type[Creator]]
+    key_to_meta: dict[str, CreatorMeta]
+    describe: type[Describe] | None
+    builtin_key: str
+
+
+class CreatorSelector(ComponentBuilder):
+    def __init__(self, interpreter, parser) -> None:
+        creators, self.key_to_meta, self.describe, self.builtin_key = self.for_interpreter(interpreter)
+        super().__init__(interpreter, parser, "creator", creators)
+
+    @classmethod
+    def for_interpreter(cls, interpreter):
+        key_to_class, key_to_meta, builtin_key, describe = OrderedDict(), {}, None, None
+        errors = defaultdict(list)
+        for key, creator_class in cls.options("virtualenv.create").items():
+            if key == "builtin":
+                msg = "builtin creator is a reserved name"
+                raise RuntimeError(msg)
+            meta = creator_class.can_create(interpreter)
+            if meta:
+                if meta.error:
+                    errors[meta.error].append(creator_class)
+                else:
+                    if "builtin" not in key_to_class and issubclass(creator_class, VirtualenvBuiltin):
+                        builtin_key = key
+                        key_to_class["builtin"] = creator_class
+                        key_to_meta["builtin"] = meta
+                    key_to_class[key] = creator_class
+                    key_to_meta[key] = meta
+            if describe is None and issubclass(creator_class, Describe) and creator_class.can_describe(interpreter):
+                describe = creator_class
+        if not key_to_meta:
+            if errors:
+                rows = [f"{k} for creators {', '.join(i.__name__ for i in v)}" for k, v in errors.items()]
+                raise RuntimeError("\n".join(rows))
+            msg = f"No virtualenv implementation for {interpreter}"
+            raise RuntimeError(msg)
+        return CreatorInfo(
+            key_to_class=key_to_class,
+            key_to_meta=key_to_meta,
+            describe=describe,
+            builtin_key=builtin_key,
+        )
+
+    def add_selector_arg_parse(self, name, choices):
+        # prefer the built-in venv if present, otherwise fallback to first defined type
+        choices = sorted(choices, key=lambda a: 0 if a == "builtin" else 1)
+        default_value = self._get_default(choices)
+        self.parser.add_argument(
+            f"--{name}",
+            choices=choices,
+            default=default_value,
+            required=False,
+            help=f"create environment via{'' if self.builtin_key is None else f' (builtin = {self.builtin_key})'}",
+        )
+
+    @staticmethod
+    def _get_default(choices):
+        return next(iter(choices))
+
+    def populate_selected_argparse(self, selected, app_data):
+        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().create(options)
+
+
+__all__ = [
+    "CreatorInfo",
+    "CreatorSelector",
+]

kivy_venv/lib/python3.11/site-packages/virtualenv/run/plugin/discovery.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from .base import PluginLoader
+
+
+class Discovery(PluginLoader):
+    """Discovery plugins."""
+
+
+def get_discover(parser, args):
+    discover_types = Discovery.entry_points_for("virtualenv.discovery")
+    discovery_parser = parser.add_argument_group(
+        title="discovery",
+        description="discover and provide a target interpreter",
+    )
+    choices = _get_default_discovery(discover_types)
+    # prefer the builtin if present, otherwise fallback to first defined type
+    choices = sorted(choices, key=lambda a: 0 if a == "builtin" else 1)
+    discovery_parser.add_argument(
+        "--discovery",
+        choices=choices,
+        default=next(iter(choices)),
+        required=False,
+        help="interpreter discovery method",
+    )
+    options, _ = parser.parse_known_args(args)
+    discover_class = discover_types[options.discovery]
+    discover_class.add_parser_arguments(discovery_parser)
+    options, _ = parser.parse_known_args(args, namespace=options)
+    return discover_class(options)
+
+
+def _get_default_discovery(discover_types):
+    return list(discover_types.keys())
+
+
+__all__ = [
+    "Discovery",
+    "get_discover",
+]

kivy_venv/lib/python3.11/site-packages/virtualenv/run/plugin/seeders.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+from .base import ComponentBuilder
+
+
+class SeederSelector(ComponentBuilder):
+    def __init__(self, interpreter, parser) -> None:
+        possible = self.options("virtualenv.seed")
+        super().__init__(interpreter, parser, "seeder", possible)
+
+    def add_selector_arg_parse(self, name, choices):
+        self.parser.add_argument(
+            f"--{name}",
+            choices=choices,
+            default=self._get_default(),
+            required=False,
+            help="seed packages install method",
+        )
+        self.parser.add_argument(
+            "--no-seed",
+            "--without-pip",
+            help="do not install seed packages",
+            action="store_true",
+            dest="no_seed",
+        )
+
+    @staticmethod
+    def _get_default():
+        return "app-data"
+
+    def handle_selected_arg_parse(self, options):
+        return super().handle_selected_arg_parse(options)
+
+    def create(self, options):
+        return self._impl_class(options)
+
+
+__all__ = [
+    "SeederSelector",
+]