highlightjs-opl 1.0.2 → 1.0.4

package/.local/python/lib/python3.12/site-packages/virtualenv/app_data/via_disk_folder.py

@@ -0,0 +1,181 @@
+r"""A rough layout of the current storage goes as:
+
+::
+
+    virtualenv-app-data
+    ├── py - <version> <cache information about python interpreters>
+    │  └── *.json/lock
+    ├── wheel <cache wheels used for seeding>
+    │   ├── house
+    │   │   └── *.whl <wheels downloaded go here>
+    │   └── <python major.minor> -> 3.9
+    │       ├── img-<version>
+    │       │   └── image
+    │       │           └── <install class> -> CopyPipInstall / SymlinkPipInstall
+    │       │               └── <wheel name> -> pip-20.1.1-py2.py3-none-any
+    │       └── embed
+    │           └── 3 -> json format versioning
+    │               └── *.json -> for every distribution contains data about newer embed versions and releases
+    └─── unzip <in zip app we cannot refer to some internal files, so first extract them>
+         └── <virtualenv version>
+             ├── py_info.py
+             ├── debug.py
+             └── _virtualenv.py
+
+"""  # noqa: D415
+
+from __future__ import annotations
+
+import json
+import logging
+from abc import ABC
+from contextlib import contextmanager, suppress
+from hashlib import sha256
+from typing import TYPE_CHECKING, Any
+
+from virtualenv.util.lock import ReentrantFileLock
+from virtualenv.util.path import safe_delete
+from virtualenv.util.zipapp import extract
+from virtualenv.version import __version__
+
+from .base import AppData, ContentStore
+
+if TYPE_CHECKING:
+    from collections.abc import Generator
+    from pathlib import Path
+
+LOGGER = logging.getLogger(__name__)
+
+
+class AppDataDiskFolder(AppData):
+    """Store the application data on the disk within a folder layout."""
+
+    transient = False
+    can_update = True
+
+    def __init__(self, folder: str) -> None:
+        self.lock = ReentrantFileLock(folder)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self.lock.path})"
+
+    def __str__(self) -> str:
+        return str(self.lock.path)
+
+    def reset(self) -> None:
+        LOGGER.debug("reset app data folder %s", self.lock.path)
+        safe_delete(self.lock.path)
+
+    def close(self) -> None:
+        """Do nothing."""
+
+    @contextmanager
+    def locked(self, path: Path) -> Generator[None]:
+        path_lock = self.lock / path  # ty: ignore[unsupported-operator]
+        with path_lock:
+            yield path_lock.path
+
+    @contextmanager
+    def extract(self, path: Path, to_folder: Path | None) -> Generator[Path]:
+        root = ReentrantFileLock(to_folder()) if to_folder is not None else self.lock / "unzip" / __version__  # ty: ignore[call-non-callable]
+        with root.lock_for_key(path.name):
+            dest = root.path / path.name
+            if not dest.exists():
+                extract(path, dest)
+            yield dest
+
+    @property
+    def py_info_at(self) -> ReentrantFileLock:
+        return self.lock / "py_info" / "4"  # ty: ignore[invalid-return-type]
+
+    def py_info(self, path: Path) -> PyInfoStoreDisk:
+        return PyInfoStoreDisk(self.py_info_at, path)
+
+    def py_info_clear(self) -> None:
+        """clear py info."""
+        py_info_folder = self.py_info_at
+        with py_info_folder:
+            for filename in py_info_folder.path.iterdir():
+                if filename.suffix == ".json":
+                    with py_info_folder.lock_for_key(filename.stem):
+                        if filename.exists():
+                            filename.unlink()
+
+    def embed_update_log(self, distribution: str, for_py_version: str) -> EmbedDistributionUpdateStoreDisk:
+        return EmbedDistributionUpdateStoreDisk(self.lock / "wheel" / for_py_version / "embed" / "3", distribution)  # ty: ignore[invalid-argument-type]
+
+    @property
+    def house(self) -> Path:
+        path = self.lock.path / "wheel" / "house"
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+
+    def wheel_image(self, for_py_version: str, name: str) -> Path:
+        return self.lock.path / "wheel" / for_py_version / "image" / "1" / name
+
+
+class JSONStoreDisk(ContentStore, ABC):
+    def __init__(self, in_folder: ReentrantFileLock, key: str, msg_args: tuple[str, ...]) -> None:
+        self.in_folder = in_folder
+        self.key = key
+        self.msg_args = (*msg_args, self.file)
+
+    @property
+    def file(self) -> Path:
+        return self.in_folder.path / f"{self.key}.json"
+
+    def exists(self) -> bool:
+        return self.file.exists()
+
+    def read(self) -> Any:  # noqa: ANN401
+        data, bad_format = None, False
+        try:
+            data = json.loads(self.file.read_text(encoding="utf-8"))
+        except ValueError:
+            bad_format = True
+        except Exception:  # noqa: BLE001, S110
+            pass
+        else:
+            LOGGER.debug("got %s %s from %s", *self.msg_args)
+            return data
+        if bad_format:
+            with suppress(OSError):  # reading and writing on the same file may cause race on multiple processes
+                self.remove()
+        return None
+
+    def remove(self) -> None:
+        self.file.unlink()
+        LOGGER.debug("removed %s %s at %s", *self.msg_args)
+
+    @contextmanager
+    def locked(self) -> Generator[None]:
+        with self.in_folder.lock_for_key(self.key):
+            yield
+
+    def write(self, content: Any) -> None:  # noqa: ANN401
+        folder = self.file.parent
+        folder.mkdir(parents=True, exist_ok=True)
+        self.file.write_text(json.dumps(content, sort_keys=True, indent=2), encoding="utf-8")
+        LOGGER.debug("wrote %s %s at %s", *self.msg_args)
+
+
+class PyInfoStoreDisk(JSONStoreDisk):
+    def __init__(self, in_folder: ReentrantFileLock, path: Path) -> None:
+        key = sha256(str(path).encode("utf-8")).hexdigest()
+        super().__init__(in_folder, key, ("python info of", path))  # ty: ignore[invalid-argument-type]
+
+
+class EmbedDistributionUpdateStoreDisk(JSONStoreDisk):
+    def __init__(self, in_folder: ReentrantFileLock, distribution: str) -> None:
+        super().__init__(
+            in_folder,
+            distribution,
+            ("embed update of distribution", distribution),
+        )
+
+
+__all__ = [
+    "AppDataDiskFolder",
+    "JSONStoreDisk",
+    "PyInfoStoreDisk",
+]

package/.local/python/lib/python3.12/site-packages/virtualenv/app_data/via_tempdir.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+import logging
+from tempfile import mkdtemp
+from typing import TYPE_CHECKING
+
+from virtualenv.util.path import safe_delete
+
+from .via_disk_folder import AppDataDiskFolder
+
+if TYPE_CHECKING:
+    from typing import NoReturn
+
+LOGGER = logging.getLogger(__name__)
+
+
+class TempAppData(AppDataDiskFolder):
+    transient = True
+    can_update = False
+
+    def __init__(self) -> None:
+        super().__init__(folder=mkdtemp())
+        LOGGER.debug("created temporary app data folder %s", self.lock.path)
+
+    def reset(self) -> None:
+        """This is a temporary folder, is already empty to start with."""
+
+    def close(self) -> None:
+        LOGGER.debug("remove temporary app data folder %s", self.lock.path)
+        safe_delete(self.lock.path)
+
+    def embed_update_log(self, distribution: str, for_py_version: str) -> NoReturn:
+        raise NotImplementedError
+
+
+__all__ = [
+    "TempAppData",
+]

package/.local/python/lib/python3.12/site-packages/virtualenv/config/cli/parser.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import os
+from argparse import SUPPRESS, ArgumentDefaultsHelpFormatter, ArgumentParser, Namespace
+from collections import OrderedDict
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from argparse import Action
+    from collections.abc import Mapping, Sequence
+
+from virtualenv.config.convert import get_type
+from virtualenv.config.env_var import get_env_var
+from virtualenv.config.ini import IniConfig
+
+
+class VirtualEnvOptions(Namespace):
+    def __init__(self, **kwargs: Any) -> None:  # noqa: ANN401
+        super().__init__(**kwargs)
+        self._src: str | None = None
+        self._sources: dict[str, str] = {}
+
+    def set_src(self, key: str, value: Any, src: str) -> None:  # noqa: ANN401
+        """Set an option value and record where it came from.
+
+        :param key: the option name
+        :param value: the option value
+        :param src: the source of the value (e.g. ``"cli"``, ``"env var"``, ``"default"``)
+
+        """
+        setattr(self, key, value)
+        if src.startswith("env var"):
+            src = "env var"
+        self._sources[key] = src
+
+    def __setattr__(self, key: str, value: Any) -> None:  # noqa: ANN401
+        if (src := getattr(self, "_src", None)) is not None:
+            self._sources[key] = src
+        super().__setattr__(key, value)
+
+    def get_source(self, key: str) -> str | None:
+        """Return the source that provided a given option value.
+
+        :param key: the option name
+
+        :returns: the source string (e.g. ``"cli"``, ``"env var"``, ``"default"``), or ``None`` if not tracked
+
+        """
+        return self._sources.get(key)
+
+    @property
+    def verbosity(self) -> int | None:
+        """The verbosity level, computed as ``verbose - quiet``, clamped to zero.
+
+        :returns: the verbosity level, or ``None`` if neither ``--verbose`` nor ``--quiet`` has been parsed yet
+
+        """
+        if not hasattr(self, "verbose") and not hasattr(self, "quiet"):
+            return None
+        return max(self.verbose - self.quiet, 0)
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({', '.join(f'{k}={v}' for k, v in vars(self).items() if not k.startswith('_'))})"
+
+
+class VirtualEnvConfigParser(ArgumentParser):
+    """Custom option parser which updates its defaults by checking the configuration files and environmental vars."""
+
+    def __init__(
+        self,
+        options: VirtualEnvOptions | None = None,
+        env: Mapping[str, str] | None = None,
+        *args: Any,  # noqa: ANN401
+        **kwargs: Any,  # noqa: ANN401
+    ) -> None:
+        env = os.environ if env is None else env
+        self.file_config = IniConfig(env)
+        self.epilog_list = []
+        self.env = env
+        kwargs["epilog"] = self.file_config.epilog
+        kwargs["add_help"] = False
+        kwargs["formatter_class"] = HelpFormatter
+        kwargs["prog"] = "virtualenv"
+        super().__init__(*args, **kwargs)
+        self._fixed = set()
+        if options is not None and not isinstance(options, VirtualEnvOptions):
+            msg = "options must be of type VirtualEnvOptions"
+            raise TypeError(msg)
+        self.options = VirtualEnvOptions() if options is None else options
+        self._interpreter = None
+        self._app_data = None
+
+    def _fix_defaults(self) -> None:
+        for action in self._actions:
+            action_id = id(action)
+            if action_id not in self._fixed:
+                self._fix_default(action)
+                self._fixed.add(action_id)
+
+    def _fix_default(self, action: Action) -> None:
+        if hasattr(action, "default") and hasattr(action, "dest") and action.default != SUPPRESS:
+            as_type = get_type(action)
+            names = OrderedDict((i.lstrip("-").replace("-", "_"), None) for i in action.option_strings)
+            outcome = None
+            for name in names:
+                outcome = get_env_var(name, as_type, self.env)
+                if outcome is not None:
+                    break
+            if outcome is None and self.file_config:
+                for name in names:
+                    outcome = self.file_config.get(name, as_type)
+                    if outcome is not None:
+                        break
+            if outcome is not None:
+                action.default, action.default_source = outcome
+            else:
+                outcome = action.default, "default"
+            self.options.set_src(action.dest, *outcome)
+
+    def enable_help(self) -> None:
+        self._fix_defaults()
+        self.add_argument("-h", "--help", action="help", default=SUPPRESS, help="show this help message and exit")
+
+    def parse_known_args(
+        self, args: Sequence[str] | None = None, namespace: VirtualEnvOptions | None = None
+    ) -> tuple[VirtualEnvOptions, list[str]]:
+        if namespace is None:
+            namespace = self.options
+        elif namespace is not self.options:
+            msg = "can only pass in parser.options"
+            raise ValueError(msg)
+        self._fix_defaults()
+        self.options._src = "cli"  # noqa: SLF001
+        try:
+            namespace.env = self.env
+            return super().parse_known_args(args, namespace=namespace)
+        finally:
+            self.options._src = None  # noqa: SLF001
+
+
+class HelpFormatter(ArgumentDefaultsHelpFormatter):
+    def __init__(self, prog: str, **kwargs: Any) -> None:  # noqa: ANN401
+        super().__init__(prog, max_help_position=32, width=240, **kwargs)
+
+    def _get_help_string(self, action: Action) -> str | None:
+        text = super()._get_help_string(action)
+        if text is not None and hasattr(action, "default_source"):
+            default = " (default: %(default)s)"
+            if text.endswith(default):
+                text = f"{text[: -len(default)]} (default: %(default)s -> from %(default_source)s)"
+        return text
+
+
+__all__ = [
+    "HelpFormatter",
+    "VirtualEnvConfigParser",
+    "VirtualEnvOptions",
+]

package/.local/python/lib/python3.12/site-packages/virtualenv/config/convert.py

@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import logging
+import os
+from typing import TYPE_CHECKING, ClassVar
+
+if TYPE_CHECKING:
+    from argparse import Action
+    from typing import Any
+
+LOGGER = logging.getLogger(__name__)
+
+
+class TypeData:
+    def __init__(self, default_type: type, as_type: type) -> None:
+        self.default_type = default_type
+        self.as_type = as_type
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(base={self.default_type}, as={self.as_type})"
+
+    def convert(self, value: str) -> Any:  # noqa: ANN401
+        return self.default_type(value)
+
+
+class BoolType(TypeData):
+    BOOLEAN_STATES: ClassVar[dict[str, bool]] = {
+        "1": True,
+        "yes": True,
+        "true": True,
+        "on": True,
+        "0": False,
+        "no": False,
+        "false": False,
+        "off": False,
+    }
+
+    def convert(self, value: str) -> bool:
+        if value.lower() not in self.BOOLEAN_STATES:
+            msg = f"Not a boolean: {value}"
+            raise ValueError(msg)
+        return self.BOOLEAN_STATES[value.lower()]
+
+
+class NoneType(TypeData):
+    def convert(self, value: str) -> str | None:
+        if not value:
+            return None
+        return str(value)
+
+
+class ListType(TypeData):
+    def _validate(self) -> None:
+        """no op."""
+
+    def convert(self, value: str | list[str], flatten: bool = True) -> list[Any]:  # noqa: ARG002, FBT002
+        values = self.split_values(value)
+        result = []
+        for a_value in values:
+            sub_values = a_value.split(os.pathsep)
+            result.extend(sub_values)
+        return [self.as_type(i) for i in result]
+
+    def split_values(self, value: str | bytes | list[str]) -> list[str]:
+        """Split the provided value into a list.
+
+        First this is done by newlines. If there were no newlines in the text, then we next try to split by comma.
+
+        """
+        if isinstance(value, (str, bytes)):
+            # Use `splitlines` rather than a custom check for whether there is
+            # more than one line. This ensures that the full `splitlines()`
+            # logic is supported here.
+            values = value.splitlines()
+            if len(values) <= 1:
+                values = value.split(",")  # ty: ignore[invalid-argument-type]
+            values = filter(None, [x.strip() for x in values])
+        else:
+            values = list(value)
+
+        return values  # ty: ignore[invalid-return-type]
+
+
+def convert(value: str, as_type: TypeData, source: str) -> Any:  # noqa: ANN401
+    """Convert the value as a given type where the value comes from the given source."""
+    try:
+        return as_type.convert(value)
+    except Exception as exception:
+        LOGGER.warning("%s failed to convert %r as %r because %r", source, value, as_type, exception)
+        raise
+
+
+_CONVERT = {bool: BoolType, type(None): NoneType, list: ListType}
+
+
+def get_type(action: Action) -> TypeData:
+    default_type = type(action.default)
+    as_type = default_type if action.type is None else action.type
+    return _CONVERT.get(default_type, TypeData)(default_type, as_type)  # ty: ignore[invalid-argument-type]
+
+
+__all__ = [
+    "convert",
+    "get_type",
+]

package/.local/python/lib/python3.12/site-packages/virtualenv/config/env_var.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+from contextlib import suppress
+from typing import TYPE_CHECKING
+
+from .convert import convert
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+    from typing import Any
+
+    from .convert import TypeData
+
+
+def get_env_var(key: str, as_type: TypeData, env: Mapping[str, str]) -> tuple[Any, str] | None:
+    """Get the environment variable option.
+
+    :param key: the config key requested
+    :param as_type: the type we would like to convert it to
+    :param env: environment variables to use
+
+    :returns: the converted value and source, or None if not set
+
+    """
+    environ_key = f"VIRTUALENV_{key.upper()}"
+    if env.get(environ_key):
+        value = env[environ_key]
+
+        with suppress(Exception):  # note the converter already logs a warning when failures happen
+            source = f"env var {environ_key}"
+            as_type = convert(value, as_type, source)
+            return as_type, source
+    return None
+
+
+__all__ = [
+    "get_env_var",
+]

package/.local/python/lib/python3.12/site-packages/virtualenv/config/ini.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import logging
+import os
+from configparser import ConfigParser
+from pathlib import Path
+from typing import TYPE_CHECKING, ClassVar
+
+from platformdirs import user_config_dir
+
+from .convert import convert
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+    from typing import Any
+
+    from .convert import TypeData
+
+LOGGER = logging.getLogger(__name__)
+
+
+class IniConfig:
+    VIRTUALENV_CONFIG_FILE_ENV_VAR: ClassVar[str] = "VIRTUALENV_CONFIG_FILE"
+    STATE: ClassVar[dict[bool | None, str]] = {None: "failed to parse", True: "active", False: "missing"}
+
+    section = "virtualenv"
+
+    def __init__(self, env: Mapping[str, str] | None = None) -> None:
+        env = os.environ if env is None else env
+        config_file = env.get(self.VIRTUALENV_CONFIG_FILE_ENV_VAR, None)
+        self.is_env_var = config_file is not None
+        if config_file is None:
+            config_file = Path(user_config_dir(appname="virtualenv", appauthor="pypa")) / "virtualenv.ini"
+        else:
+            config_file = Path(config_file)
+        self.config_file = config_file
+        self._cache = {}
+
+        exception = None
+        self.has_config_file = None
+        try:
+            self.has_config_file = self.config_file.exists()
+        except OSError as exc:
+            exception = exc
+        else:
+            if self.has_config_file:
+                self.config_file = self.config_file.resolve()
+                self.config_parser = ConfigParser()
+                try:
+                    self._load()
+                    self.has_virtualenv_section = self.config_parser.has_section(self.section)
+                except Exception as exc:  # noqa: BLE001
+                    exception = exc
+        if exception is not None:
+            LOGGER.error("failed to read config file %s because %r", config_file, exception)
+
+    def _load(self) -> None:
+        with self.config_file.open("rt", encoding="utf-8") as file_handler:
+            return self.config_parser.read_file(file_handler)
+
+    def get(self, key: str, as_type: TypeData) -> tuple[Any, str] | None:
+        cache_key = key, as_type
+        if cache_key in self._cache:
+            return self._cache[cache_key]
+        try:
+            source = "file"
+            raw_value = self.config_parser.get(self.section, key.lower())
+            value = convert(raw_value, as_type, source)
+            result = value, source
+        except Exception:  # noqa: BLE001
+            result = None
+        self._cache[cache_key] = result
+        return result
+
+    def __bool__(self) -> bool:
+        return bool(self.has_config_file) and bool(self.has_virtualenv_section)
+
+    @property
+    def epilog(self) -> str:
+        return (
+            f"\nconfig file {self.config_file} {self.STATE[self.has_config_file]} "
+            f"(change{'d' if self.is_env_var else ''} via env var {self.VIRTUALENV_CONFIG_FILE_ENV_VAR})"
+        )