tox-dev-tox-3838-3842

tests/config/loader/ini/__init__.py
tests/config/loader/ini/conftest.py
tests/config/loader/ini/replace/__init__.py
tests/config/loader/ini/replace/test_replace_env_var.py
tests/config/loader/ini/replace/test_replace_glob.py
tests/config/loader/ini/replace/test_replace_os_pathsep.py
tests/config/loader/ini/replace/test_replace_os_sep.py
tests/config/loader/ini/replace/test_replace_posargs.py
tests/config/loader/ini/replace/test_replace_tox_env.py
tests/config/loader/ini/replace/test_replace_tty.py
tests/config/loader/ini/test_facto
…[3350 chars omitted]…
t_virtualenv_api.py
tests/tox_env/test_api.py
tests/tox_env/test_ci_passthrough.py
tests/tox_env/test_info.py
tests/tox_env/test_register.py
tests/tox_env/test_tox_env_api.py
tests/tox_env/test_tox_env_runner.py
tests/type_check/add_config_container_factory.py
tests/util/__init__.py
tests/util/test_ci.py
tests/util/test_cpu.py
tests/util/test_graph.py
tests/util/test_path.py
tests/util/test_spinner.py

from ._api import TomlTypes
from ._replace import TomlReplaceLoader, Unroll
from ._validate import validate

if TYPE_CHECKING:
    from collections.abc import Iterator, Mapping
    from types import UnionType

    from tox.config.loader.convert import Factory
    from tox.config.loader.section import Section
    from tox.config.main import Config

_T = TypeVar("_T")
_V = TypeVar("_V")


class TomlLoader(Loader[TomlTypes]):
    """Load configuration from a pyproject.toml file."""

    def __init__(
        self,

…[8629 chars omitted]…
y)


@impl
def tox_add_option(parser: ToxParser) -> None:
    override_short_option = "-x"
    parser.add_argument(
        override_short_option,
        "--override",
        action="append",
        type=Override,
        default=[],
        dest="override",
        help=f"configuration override(s), e.g., {override_short_option} testenv:pypy3.ignore_errors=True",
    )


_STR_CONVERT = StrConvert()

]
src/tox/config/loader/toml/_product.py
"""Expand TOML product dicts into environment name lists."""

from __future__ import annotations

from itertools import product
from typing import Any

from tox.config.loader.ini.factor import LATEST_PYTHON_MINOR_MAX, LATEST_PYTHON_MINOR_MIN


def expand_product(value: dict[str, Any]) -> list[str]:
    """Expand a product dict into a flat list of environment names.

    :param value: dict with ``product`` (list of factor groups) and optional ``exclude`` (list of env names to skip)

    :returns: list of environment names from the cartesian product of all factor g
…[8630 chars omitted]…
ce(item, str):
                envs.append(item)
            elif isinstance(item, dict) and "product" in item:
                envs.extend(expand_product(item))
            else:
                msg = f"env_list items must be strings or product dicts, got {type(item).__name__}"
                raise TypeError(msg)
        return EnvList(envs=envs)


__all__ = [
    "HandledError",
    "TomlLoader",
]

    get_origin,
)

from tox.config.types import Command

if TYPE_CHECKING:
    from ._api import TomlTypes


T = TypeVar("T")


def validate(val: TomlTypes, of_type: type[T]) -> T:  # noqa: C901, PLR0912
    casting_to = get_origin(of_type) or of_type.__class__
    type_args = get_args(of_type)
    msg = ""
    if casting_to in {list, list}:
        entry_type = type_args[0]
        if isinstance(val, list):
            for va in val:
                validate(va, entry_type)
        else:
            msg = f"{val!r} is not list"
    elif isclass(of_type) and issubclass(of_type, Command):
        # first we cast it to list then create commands, so for now validate it as a nested list
   
…[8630 chars omitted]…
gistered configs


class RawLoader:
    def __init__(self, loader: TomlLoader, section: str) -> None:
        self._loader = loader
        self._section = section

    def load(self, item: str, chain: list[str] | None = None) -> Any:  # noqa: ARG002
        return self._loader.load_raw_from_root(f"{self._section}{self._loader.section.SEP}{item}")


__all__ = [
    "TomlReplaceLoader",
    "Unroll",
]

_NO_MAPPING = object()
T = TypeVar("T")
V = TypeVar("V")

Factory = Callable[[object], T] | None  # note the argument is anything, due e.g. memory loader can inject anything


class Convert(ABC, Generic[T]):
    """A class that converts a raw type to a given tox (python) type."""

    def to(self, raw: T, of_type: type[V] | UnionType, factory: Factory[V]) -> V:  # noqa: PLR0911
        """Convert given raw type to python type.

        :param raw: the raw type
        :param of_type: python type
        :para
…[8629 chars omitted]…
-index-url",
    "-e",
    "--editable",
    "-c",
    "--constraint",
    "-r",
    "--requirement",
    "-f",
    "--find-links",
    "--trusted-host",
    "--use-feature",
    "--no-binary",
    "--only-binary",
}
ONE_ARG_ESCAPE = {
    "-c",
    "--constraint",
    "-r",
    "--requirement",
    "-f",
    "--find-links",
    "-e",
    "--editable",
}

__all__ = (
    "ONE_ARG",
    "PythonDeps",
)

from tox.report import HandledError, ToxHandler
from tox.session.state import State

if TYPE_CHECKING:
    from collections.abc import Sequence


def run(args: Sequence[str] | None = None) -> None:
    try:
        with ToxHandler.patch_thread():
            result = main(sys.argv[1:] if args is None else args)
    except Exception as exception:
        if isinstance(exception, HandledError):
            logging.error("%s| %s", type(exception).__name__, exception)  # noqa: TRY400
            result = -2
        else:
            raise
    except KeyboardInterrupt:
        result = -2
    finally:
        if "_TOX_SHOW_THREAD" in os.environ:  # pragma: no cover
            
…[8629 chars omitted]…
             )
                    continue
                if ignore_errors:
                    if exit_code == Outcome.OK:
                        exit_code = cast("int", exception.code)
                    break
                return cast("int", exception.code)
            else:
                break
    return exit_code


__all__ = (
    "ToxEnvRunResult",
    "run_command_set",
    "run_one",
)

from ._api import TomlTypes
from ._replace import TomlReplaceLoader, Unroll
from ._validate import validate

if TYPE_CHECKING:
    from collections.abc import Iterator, Mapping
    from types import UnionType

    from tox.config.loader.convert import Factory
    from tox.config.loader.section import Section
    from tox.config.main import Config

_T = TypeVar("_T")
_V = TypeVar("_V")


class TomlLoader(Loader[TomlTypes]):
    """Load configuration from a pyproject.toml file."""

    def __init__(
        self,

…[8630 chars omitted]…
SyncWrite]:
        prev = self._out, self._err
        if self._read_stdout is not None:  # pragma: no branch
            self._read_stdout.handler = out.handler
        if self._read_stderr is not None:  # pragma: no branch
            self._read_stderr.handler = err.handler
        return prev


def _pty(key: str) -> tuple[int, int] | None:
    """Allocate a virtual terminal (pty) for a subprocess.

@pytest.mark.parametrize("legacy_flag", ["-r", "-c"])
def test_legacy_requirement_file(tmp_path: Path, legacy_flag: str) -> None:
    python_deps = PythonDeps(f"{legacy_flag}a.txt", tmp_path)
    (tmp_path / "a.txt").write_text("b")
    assert python_deps.as_root_args == [legacy_flag, "a.txt"]
    assert vars(python_deps.options) == {}
    assert [str(i) for i in python_deps.requirements] == ["b" if legacy_flag == "-r" else "-c b"]


def test_deps_with_hash(tmp_path: Path) -> None:
    """deps with --hash should raise an exception."""
    python_deps = PythonDeps(
        raw="foo==1 --hash sha256:97a702083b0d906517b79672d8501eee470d60ae55df0fa9d4cfba56c7f65a82",
    
…[8628 chars omitted]…
bProcessExecutor(colored=False)
        request = ExecuteRequest(
            cmd=[sys.executable, "-c", "import os; print(os.get_terminal_size())"],
            cwd=Path(),
            env=os_env,
            stdin=StdinSource.OFF,
            run_id="",
        )
        out_err = FakeOutErr()
        with executor.call(request, show=False, out_err=out_err.out_err, env=_create_mock_env()) as status:

from threading import Thread, current_thread, local
from threading import enumerate as enumerate_threads
from typing import IO, TYPE_CHECKING, ClassVar, cast

from colorama import Fore, Style, init

if TYPE_CHECKING:
    from collections.abc import Iterator

LEVELS = {
    0: logging.CRITICAL,
    1: logging.ERROR,
    2: logging.WARNING,
    3: logging.INFO,
    4: logging.DEBUG,
    5: logging.NOTSET,
}

MAX_LEVEL = max(LEVELS.keys())
LOGGER = logging.getLogger()
OutErr = tuple[TextIOWrapper, TextIOWrapper]


class _LogThreadLocal(local):
    """A thread local variable that inherits values from its parent."""

    _ident_
…[8629 chars omitted]…
y)


@impl
def tox_add_option(parser: ToxParser) -> None:
    override_short_option = "-x"
    parser.add_argument(
        override_short_option,
        "--override",
        action="append",
        type=Override,
        default=[],
        dest="override",
        help=f"configuration override(s), e.g., {override_short_option} testenv:pypy3.ignore_errors=True",
    )


_STR_CONVERT = StrConvert()

def test_toml_loader_load_raw() -> None:
    loader = TomlLoader(TomlPyProjectSection.from_key("tox.env.A"), [], {"a": 1, "c": False}, {}, set())
    assert loader.load_raw("a", None, "A") == 1


def test_toml_loader_load_repr() -> None:
    loader = TomlLoader(TomlPyProjectSection.from_key("tox.env.A"), [], {"a": 1}, {}, set())
    assert repr(loader) == "TomlLoader(env.A, {'a': 1})"


def test_toml_loader_found_keys() -> None:
    loader = TomlLoader(TomlPyProjectSection.from_key("tox.env.A"), [], {"a": 1, "c": False}, {}, set())
    assert loader.foun
…[8629 chars omitted]…
ests/session/cmd/test_sequential.py:678:        "tox.toml": """
tests/session/cmd/test_show_config.py:121:            "tox.toml",
tests/session/cmd/test_show_config.py:128:            id="tox.toml",
tests/session/test_env_completer.py:40:    config = tmp_path / "tox.toml"
tests/session/test_env_completer.py:68:    mocker.patch("tox.plugin.manager.Plugin.tox_extend_envs", return_value=[["plugin-env"]])

    from types import UnionType

    from tox.config.loader.convert import Factory
    from tox.config.main import Config  # pragma: no cover


T = TypeVar("T")
V = TypeVar("V")


class ConfigDefinition(ABC, Generic[T]):  # noqa: PLW1641
    """Abstract base class for configuration definitions."""

    def __init__(self, keys: Iterable[str], desc: str) -> None:
        self.keys = keys
        self.desc = desc

    @abstractmethod
    def __call__(self, conf: Config, loaders: list[Load
…[8629 chars omitted]…
lean logic."""
    try:
        tree = ast.parse(expr, mode="eval")
    except SyntaxError:
        msg = f"Invalid condition expression: {expr}"
        raise MatchError(msg) from None

    def _eval(node: ast.expr) -> str | bool:  # noqa: PLR0911, C901
        if isinstance(node, ast.BoolOp):
            if isinstance(node.op, ast.And):
                return all(bool(_eval(v)) for v in node.values)

from tox.config.types import MissingRequiredConfigKeyError
from tox.report import HandledError

from .api import Source

if sys.version_info >= (3, 11):  # pragma: no cover (py311+)
    import tomllib
else:  # pragma: no cover (py311+)
    import tomli as tomllib

if TYPE_CHECKING:
    from collections.abc import Iterable
    from pathlib import Path

    from tox.config.loader.api import Loader, OverrideMap
    from tox.config.sets import CoreConfigSet


class TomlSection(Section):
    SEP: str = "."
    
…[8629 chars omitted]…
e NotImplementedError

    @abstractmethod
    def get_tox_env_section(self, item: str) -> tuple[Section, list[str], list[str]]:
        """:returns: the section for a tox environment"""
        raise NotImplementedError

    @abstractmethod
    def get_core_section(self) -> Section:
        """:returns: the core section"""
        raise NotImplementedError


__all__ = [
    "Section",
    "Source",
]

class Section:  # noqa: PLW1641
    """tox configuration section."""

    SEP = ":"  #: string used to separate the prefix and the section in the key

    def __init__(self, prefix: str | None, name: str) -> None:
        self._prefix = prefix
        self._name = name

    @classmethod
    def from_key(cls: type[Self], key: str) -> Self:
        """Create a section from a section key.

        :param key: the section key

        :returns: the constructed section

        """
        sep_at = key.find(cls.SEP)
        if sep_at == -1:
            prefix, name = None, key
        else:
            prefix,
…[8629 chars omitted]…
 "magic+=2")
    assert len(parsed.override) == 2


def test_override_equals() -> None:
    assert Override("a=b") == Override("a=b")


def test_override_not_equals() -> None:
    assert Override("a=b") != Override("c=d")


def test_override_not_equals_different_type() -> None:
    assert Override("a=b") != 1


def test_override_repr() -> None:
    assert repr(Override("b.a=c")) == "Override('b.a=c')"

            signal(SIGINT, previous)
    return exit_code


class ToxSpinner(Spinner):
    def __init__(self, enabled: bool, state: State, total: int) -> None:  # noqa: FBT001
        super().__init__(
            enabled=enabled,
            colored=state.conf.options.is_colored,
            stream=state._options.log_handler.stdout,  # noqa: SLF001
            total=total,
        )

    def update_spinner(self, result: ToxEnvRunResult, succ
…[8629 chars omitted]…
ror(msg) from exc
src/tox/session/env_select.py:464:                raise HandledError(msg)
src/tox/session/env_select.py:492:                    raise HandledError(msg)  # pragma: no cover
src/tox/session/env_select.py:585:            raise HandledError(msg)
src/tox/tox_env/python/runner.py:124:            raise HandledError(msg)
src/tox/tox_env/python/runner.py:15:from tox.report import HandledError

if TYPE_CHECKING:
    from types import UnionType

    from tox.config.cli.parser import ToxParser
    from tox.config.main import Config

    from .section import Section


class Override:  # noqa: PLW1641
    """An override for config definitions."""

    def __init__(self, value: str) -> None:
        key, equal, self.value = value.partition("=")
        if not equal:
            msg = f"override {value} has no = sign in it"
            raise ArgumentTypeError(msg)

        self.append = False
        if key.endswith("+"): 
…[8629 chars omitted]…
S)

    @staticmethod
    def to_bool(value: str) -> bool:
        norm = str(value).strip().lower()
        if norm in StrConvert.TRUTHFUL_VALUES:
            return True
        if norm in StrConvert.FALSE_VALUES:
            return False

        msg = f"value {value!r} cannot be transformed to bool, valid: {', '.join(StrConvert.VALID_BOOL)}"
        raise TypeError(msg)


__all__ = ("StrConvert",)

from .api import ToxEnv, ToxEnvCreateArgs
from .package import Package, PackageToxEnv, PathPackage
from .util import add_change_dir_conf

if TYPE_CHECKING:
    from collections.abc import Iterable
    from pathlib import Path

    from tox.journal import EnvJournal


class RunToxEnv(ToxEnv, ABC):
    def __init__(self, create_args: ToxEnvCreateArgs) -> None:
        self.package_env: PackageToxEnv | None = None
        self._packages: list[Package] = []
        super().__init__(create_args)
        self._package_envs: list[PackageToxEnv | Exception] | None = None

    def register_config(self) -> None:
        def ensure_one_line(v
…[7291 chars omitted]…
def _setup_pkg(self) -> None:
        self._packages = self._build_packages()
        if not self.options.package_only:
            self._install(self._packages, RunToxEnv.__name__, "package")
        self._handle_journal_package(self.journal, self._packages)
src/tox/tox_env/python/runner.py:15:from tox.report import HandledError
src/tox/tox_env/python/runner.py:124:            raise HandledError(msg)

        from tox.plugin.manager import MANAGER  # noqa: PLC0415

        MANAGER.tox_on_install(self, arguments, section, of_type)
        self.installer.install(arguments, section, of_type)

    def __repr__(self) -> str:
        return f"{self.__class__.__name__}(name={self.conf['env_name']})"

    def register_config(self) -> None:
        self.conf.add_constant(
            keys=["env_name"
…[8629 chars omitted]…
ge_env = self.package_env
            assert package_env is not None  # noqa: S101
            with package_env.display_context(self._has_display_suspended):
                deps = package_env.load_deps_for_env(self.conf)
        if deps and not self.options.package_only:
            self._install(deps, PythonRun.__name__, "package_deps")

    def _setup_env(self) -> None:
        super()._setup_env()

        """Setup the tox environment."""
        if self._run_state["setup"] is False:  # pragma: no branch
            self._platform_check()
            recreate = cast("bool", self.conf["recreate"])
            if recreate:
                self._clean(transitive=True)
            try:
                self._setup_env()
                self._setup_with_env()
            except Recreate as exception:  # once we might try over
                if not recreate:  # pragma: no cov
…[8628 chars omitted]…
a: T201

    successful, skipped = [], []
    for run in runs:
        successful.append(run.code == Outcome.OK or run.ignore_outcome or run.unavailable)
        skipped.append(run.skipped)
        duration_individual = [o.elapsed for o in run.outcomes] if verbosity >= 2 else []  # noqa: PLR2004
        extra = f"+cmd[{','.join(f'{i:.2f}' for i in duration_individual)}]" if duration_individual else ""

…[1587 chars omitted]…
eturn self._selector


@impl
def tox_add_option(parser: ToxParser) -> None:
    from tox.tox_env.register import REGISTER  # noqa: PLC0415

    parser.add_argument(
        "--runner",
        dest="default_runner",
        help="the tox run engine to use when not explicitly stated in tox env configuration",
        default=REGISTER.default_env_runner,
        choices=list(REGISTER.env_runners),
    )

from typing import TYPE_CHECKING, Any, Literal, TypeVar, cast

from colorama import Fore

from tox.plugin import NAME
from tox.util.ci import is_ci

from .env_var import get_env_var
from .ini import IniConfig

if sys.version_info >= (3, 11):  # pragma: >=3.11 cover
    from typing import Self
else:  # pragma: <3.11 cover
    from typing_extensions import Self

if TYPE_CHECKING:
    from collections.abc import Callable, Sequence

    from tox.session.state import State


class ArgumentParserWithEnvAndConfig(ArgumentParser):
    """Argument parser which
…[8038 chars omitted]…
urce.USER: None, StdinSource.OFF: DEVNULL, StdinSource.API: PIPE}[self.request.stdin],
src/tox/execute/request.py:22:        return StdinSource.USER if sys.stdin.isatty() else StdinSource.OFF
src/tox/provision.py:166:                cmd=args, stdin=StdinSource.user_only(), show=True, run_id="provision", cwd=Path.cwd()
src/tox/session/cmd/run/single.py:117:                stdin=StdinSource.user_only(),

def test_config_in_toml_replace_ref_env(tox_project: ToxProjectCreator, monkeypatch: pytest.MonkeyPatch) -> None:
    project = tox_project({
        "pyproject.toml": """
        [tool.tox.env.b]
        extras = ["{env_name}"]
        [tool.tox.env.a]
        extras = [{ replace = "ref", env = "b", "key" = "extras", extend = true }, "a"]
        """
    })

src/tox/config/loader/toml/__init__.py:110:        result = validate(value, cast("type[dict[Any, Any]]", dict[of_type[0], of_type[1]]))  # ty: ignore[invalid-type-form] # runtime generic from type variables

env_dir = /tmp/tmp.utp7jYCVAr/.tox/py
env_tmp_dir = /tmp/tmp.utp7jYCVAr/.tox/py/tmp
env_log_dir = /tmp/tmp.utp7jYCVAr/.tox/py/log
suicide_timeout = 0.0
interrupt_timeout = 0.3
terminate_timeout = 0.2
platform = 
pass_env =
  CC
  CCSHARED
  CFLAGS
  CPPFLAGS
  CURL_CA_BUNDLE
  CXX
  FORCE_COLOR
  HOME
  LANG
  LANGUAGE
  LDFLAGS
  LD_LIBRARY_PATH
  NETRC
  NIX_LD
  NIX_LD_LIBRARY_PATH
  NO_COLOR
  PIP_*
  PKG_CONFIG
  PKG_CONFIG_PATH
  PKG_CONFIG_SYSROOT_DIR
  PYTHON_GIL
  REQUESTS_CA_BUNDLE
  SSH_AGENT_PID
  SSH_AUTH_SOCK
  SSL_CERT_FILE
  TMPDIR
  VIRTUALENV_*
  http_proxy
  https_proxy
  no_proxy
disallow_pass_env = 
parallel_show_output = False
recreat
…[906 chars omitted]…
[1])
dependency_groups = 
extras = 
pylock = 
extra_setup_commands = 
skip_missing_interpreters = True
system_site_packages = False
always_copy = False
download = False
virtualenv_spec = 
skip_install = False
use_develop = False
package = skip
--- run ---
ROOT: HandledError| unrecognized arguments: --no-test
hint: if you tried to pass arguments to a command use -- to separate them from tox ones
rc=254

        depth += 1
        MatchRecursionError.check(depth, value)
        if isinstance(value, str):
            if not skip_str and self.conf is not None:  # core config does not support string substitution
                reference = TomlReplaceLoader(self.conf, self.loader)
                value = replace(self.conf, reference, value, self.args)
        elif isinstance(value, (int, 
…[4507 chars omitted]…
          raise TypeError(raw)
src/tox/tox_env/python/pip/req_file.py:252:            raise TypeError(raw)
grep: src/tox/tox_env/python/pip/__pycache__/req_file.cpython-312.pyc: binary file matches
src/tox/tox_env/python/runner.py:46:            factory=partial(PythonDeps.factory, root),
src/tox/tox_env/python/virtual_env/package/cmd_builder.py:53:            factory=partial(PythonDeps.factory, root),

    def factory(cls, root: Path, raw: object) -> PythonDeps:
        if not (
            isinstance(raw, str)
            or (
                isinstance(raw, list)
                and (all(isinstance(i, str) for i in raw) or all(isinstance(i, Requirement) for i in raw))
            )
        ):
            raise TypeError(raw)
        return cls(cast("str | list[str] | list[Requirement]", raw), root)


class PythonConstraints(
…[8629 chars omitted]…
g_targz(
    tox_project: ToxProjectCreator,
    pkg_with_sdist: Path,
    enable_pip_pypi_access: str | None,  # noqa: ARG001
) -> None:
    project = tox_project({
        "tox.ini": """
     [tox]
    envlist = base, flake8
    [testenv]
    package = sdist
    [testenv:base]
    [testenv:flake8]
    """
    })
    outcome = project.run(f"--installpkg={pkg_with_sdist}")
    outcome.assert_success()

src/tox/tox_env/runner.py:107:            of_type=bool,
src/tox/tox_env/runner.py:127:            of_type=str,
src/tox/tox_env/runner.py:133:            of_type=str,
src/tox/tox_env/runner.py:210:            of_type=bool,
src/tox/tox_env/runner.py:219:            of_type=bool,
src/tox/tox_env/util.py:18:        of_type=Path,

labels = 
env_dir = /tmp/tmp.XKJeFWtuKK/.tox/py
env_tmp_dir = /tmp/tmp.XKJeFWtuKK/.tox/py/tmp
env_log_dir = /tmp/tmp.XKJeFWtuKK/.tox/py/log
suicide_timeout = 0.0
interrupt_timeout = 0.3
terminate_timeout = 0.2
platform = 
pass_env =
  CC
  CCSHARED
  CFLAGS
  CPPFLAGS
  CURL_CA_BUNDLE
  CXX
  FORCE_COLOR
  HOME
  LANG
  LANGUAGE
  LDFLAGS
  LD_LIBRARY_PATH
  NETRC
  NIX_LD
  NIX_LD_LIBRARY_PATH
  NO_COLOR
  PIP_*
  PKG_CONFIG
  PKG_CONFIG_PATH
  PKG_CONFIG_SYSROOT_DIR
  PYTHON_GIL
  REQUESTS_CA_BUNDLE
  SSH_AGENT_PID
  SSH_AUTH_SOCK
  SSL_CERT_FILE
  TMPDIR
  VIRTUALENV_*
  http_proxy
  https_proxy
  no_proxy
disallow_pass_env = 
parallel_show_output = False
recrea
…[2720 chars omitted]…
^^^^^^^
  File "/repo/src/tox/config/loader/convert.py", line 56, in to
    return factory(raw)
           ^^^^^^^^^^^^
  File "/repo/src/tox/tox_env/python/pip/req_file.py", line 145, in factory
    raise TypeError(raw)
TypeError: [1]
  py: FAIL code 2 (0.22 seconds)
  evaluation failed :( (0.30 seconds)
r rc=2
--- nested c ---
[testenv:py]
deps = # Exception: TypeError([['extra-pkg']])
nested rc=255

from tox.session.cmd.run.common import env_run_create_flags
from tox.session.env_select import CliEnv, register_env_select_flags

if TYPE_CHECKING:
    from collections.abc import Iterable

    from tox.config.cli.parser import ToxParser
    from tox.config.sets import ConfigSet
    from tox.session.state import State
    from tox.tox_env.api import ToxEnv


@impl
def tox_add_option(parser: ToxParser) -> None:
    our = parser.add_command("config", ["c"], "show tox configuration", show_config)
    our.add_argument(
        "-k",
        nargs="+",
        help="list just configuration keys specified",
        dest="l
…[3547 chars omitted]…
sion/cmd/run/common.py:378:            except BaseException:  # pragma: no cover
src/tox/session/cmd/run/single.py:63:        except Exception:  # pragma: no cover
src/tox/session/cmd/show_config.py:115:            as_str, multi_line = _colored(is_colored, Fore.LIGHTRED_EX, f"# Exception: {exception!r}"), False
src/tox/session/env_select.py:405:                        except Exception:  # noqa: BLE001

Replacer = Callable[[str, ConfigLoadArgs], str]
SetEnvRaw = str | dict[str, Any] | list[dict[str, Any]]


class SetEnv:
    def __init__(  # noqa: C901, PLR0912
        self, raw: SetEnvRaw, name: str, env_name: str | None, root: Path
    ) -> None:
        self.changed = False
        self._materialized: dict[str, str] = {}  # env vars we already loaded
        self._raw: dict[str, str] = {}  # could still need replacement
        self._defined_keys: set[str] = set()  # keys explicitly defined during parsing (survives load() draining _raw)
        self._markers: dict[str, Marker] = {}  # PEP-496
…[8630 chars omitted]…
"env.TAG_NAME", then = "production", else = "testing" }
tests/config/source/test_toml_pyproject.py:615:    outcome = project.run("c", "-e", "A", "-k", "set_env")
tests/config/source/test_toml_pyproject.py:621:    monkeypatch.setenv("V", "1")
tests/config/source/test_toml_pyproject.py:759:    monkeypatch.setenv("CI", "1")
tests/config/source/test_toml_tox.py:83:    monkeypatch.setenv("MAGICAL", "YEAH")

tests/config/loader/test_toml_loader.py:125:    with pytest.raises(TypeError, match="env_list items must be strings or product dicts, got int"):
tests/config/loader/test_toml_loader.py:134:    with pytest.raises(TypeError, match="1 is not union of str, NoneType"):
tests/config/loader/test_toml_loader.py:143:    with pytest.raises(TypeError, match="'c' is not one of literal 'a','b'"):

        args = ToxEnvCreateArgs(pkg_conf, self._state.conf.core, self._state.conf.options, journal, self._log_handler)
        pkg_env: PackageToxEnv = package_type(args)
        pkg_env.register_config()

    """circular chain in config"""


class MissingRequiredConfigKeyError(ValueError):
    """missing required config key

    Used by the two toml loaders in order to identify if config keys are present.

    """


class Command:  # noqa: PLW1641
    """A command to execute."""

    def __init__(self, args: list[str]) -> None:
        """Create a new command to execute.

        :param args: the command line arguments (first value can be ``-`` to indicate ignore the exit code)

        """
        self.ignore_exit_code: bool = args[0] == "-"  #: a flag indicating if the exit code should be ignored
        self.invert_exit_code: boo
…[8628 chars omitted]…
() if a and isinstance(envs[n].env, PackageToxEnv)]
        if invalid:
            msg = f"cannot run packaging environment(s) {','.join(invalid)}"
            raise HandledError(msg)

    def _mark_provision(self, on: bool, provision_tox_env: str) -> None:  # noqa: FBT001
        self._provision = on, provision_tox_env


__all__ = [
    "CliEnv",
    "EnvSelector",
    "register_env_select_flags",
]

            nonlocal module
            module = load_inline(path)
            return module

        mocker.patch.object(manager, "_load_inline", _load_inline)
        yield
        if module is not None and manager.MANAGER.manager.is_regist
…[3380 chars omitted]…
:
            def __init__(self, colored: bool, exit_code: int) -> None:  # noqa: FBT001
tests/test_call_modes.py:13:    subprocess.check_output([sys.executable, "-m", "tox", "-h"])
tests/test_call_modes.py:17:    subprocess.check_output([str(Path(sys.executable).parent / "tox"), "-h"])
tests/test_provision.py:391:def test_provision_colored_passed_to_subprocess(tox_project: ToxProjectCreator) -> None:

        try:
            yield
        finally:
            os.chdir(cur_dir)

    def run(self, *args: str, from_cwd: Path | None = None, raise_on_config_fail: bool = True) -> ToxRunOutcome:
        if raise_on_config_fail and args and args[0] in {"c", "config"}:
            self.monkeypatch.setenv("_TOX_SHOW_CONFIG_RAISE", "1")

        with self.chdir(from_cwd):
            state = None
            self._capfd.readouterr()  # start with a cl
…[3015 chars omitted]…
.manager.load_inline", return_value=plugin)


LogCaptureFixture = pytest.LogCaptureFixture
TempPathFactory = pytest.TempPathFactory
MonkeyPatch = pytest.MonkeyPatch

__all__ = (
    "CaptureFixture",
    "LogCaptureFixture",
    "MonkeyPatch",
    "SubRequest",
    "TempPathFactory",
    "ToxProject",
    "ToxProjectCreator",
    "ToxRunOutcome",
    "check_os_environ",
    "register_inline_plugin",
)

            else:
                yield self._Section(prefix=core_prefix or None, name=entry.removeprefix(strip))
                if in_section.prefix is not None:
                    yield self._Section(prefix=in_section.prefix, name=entry)

    def g
…[1356 chars omitted]…
ames = ["-".join(combo) for combo in product(*expanded)]
        else:
            names = [str(f) for f in factors_raw]
        for factor_suffix in names:
            result[f"{base_name}-{factor_suffix}"] = base_name
    return result


__all__ = [
    "TomlPyProject",
]
src/tox/config/source/toml_pyproject.py:167:    def get_tox_env_section(self, item: str) -> tuple[Section, list[str], list[str]]:

    def __init__(self, create_args: ToxEnvCreateArgs) -> None:
        """Create a new tox environment.

        :param create_args: tox env create args

        """
        self.journal: EnvJournal = create_args.journal  #: handler to the tox reporting system
        self.conf: EnvConfigSet = create_args.conf  #: the config set to use for this environment
        self.core: CoreConfigSet = create_args.core  #: the core tox config set
        self.options: Parsed = create_args.options  #: CLI options
        self.log_handler: ToxHandler = create_args.log_handler  #: handler to the tox reporting system

        #
…[3632 chars omitted]…
:
            if level >= logging.ERROR:
                color = Fore.RED
            elif level >= logging.WARNING:
                color = Fore.CYAN
            else:
                color = Fore.WHITE

        def _c(val: int) -> str:
            return str(val) if color else ""

        fmt = f"{color} %(message)s{_c(Style.RESET_ALL)}"
        if enabled_level <= logging.DEBUG:
            fmt = (

    @contextmanager
    def display_context(self, suspend: bool) -> Iterator[None]:  # noqa: FBT001
        with self._log_context(), self.log_handler.suspend_out_err(suspend, self._suspended_out_err) as out_err:
            if suspend:  # only set if suspended
                self._suspended_out_err = out_err
            yield

    def close_and_read_out_err(self) -> tuple[bytes, bytes] | None:
        if self._suspended_out_err is None:  # pragma: no branch
            return None  # pragma: no cover
        (out, err), self._suspended_out_err = self._suspended_out_e
…[2734 chars omitted]…
rser import ToxParser
    from tox.session.state import State


@impl
def tox_add_option(parser: ToxParser) -> None:
    our = parser.add_command("run", ["r"], "run environments", run_sequential)
    register_env_select_flags(our, default=CliEnv())
    env_run_create_flags(our, mode="run")


def run_sequential(state: State) -> int:
    return execute(state, max_workers=1, has_spinner=False, live=True)

…[1673 chars omitted]…
/session/cmd/test_sequential.py:173:def test_rerun_sequential_skip(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
tests/session/cmd/test_sequential.py:181:def test_rerun_sequential_wheel(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:
tests/session/cmd/test_sequential.py:194:def test_rerun_sequential_sdist(tox_project: ToxProjectCreator, demo_pkg_inline: Path) -> None:

class Fail(Exception):  # noqa: N818
    """Failed creating env."""


class RunnerUnavailable(Exception):  # noqa: N818
    """Runner for this environment is not available."""

from tox.config.types import CircularChainError
from tox.execute.request import shell_cmd

if TYPE_CHECKING:
    from tox.config.loader.api import ConfigLoadArgs
    from tox.config.main import Config
    from tox.config.set_env import SetEnv


LOGGER = logging.getLogger(__name__)

# split alongside :, unless it is preceded by a single capital letter (Windows drive letters in paths)
ARG_DELIMITER: Final[str] = ":"
REPLACE_START: Final[str] = "{"
REPLACE_END: Final[str] = "}"
BACKSLASH_ESCAPE_CHARS: Final[tuple[str, ...]] = (ARG_DELIMITER, REPLACE_START, REPLACE_END, "[", "]")
MAX_REPLACE_DEPTH
…[4860 chars omitted]…
raise MatchError(msg)
src/tox/config/loader/toml/_replace.py:153:        raise MatchError(msg)
src/tox/config/loader/toml/_replace.py:165:        raise MatchError(msg) from None
src/tox/config/loader/toml/_replace.py:182:            raise MatchError(msg)
src/tox/config/loader/toml/_replace.py:189:            raise MatchError(msg)
src/tox/config/loader/toml/_replace.py:193:        raise MatchError(msg)

from tox.config.types import Command
from tox.execute.request import StdinSource
from tox.tox_env.errors import Fail, Recreate
from tox.tox_env.installer import Installer
from tox.tox_env.python.api import Python
from tox.tox_env.python.package import EditableLegacyPackage, EditablePackage, SdistPackage, WheelPackage
from tox.tox_env.python.pip.req_file import PythonConstraints, PythonDeps
from tox.tox_env.python.pylock import Pylock

if TYPE_CHECKING:
    from tox.config.main import Config
    from tox.tox_env.package import PathPackage


class PythonInsta
…[3290 chars omitted]…
    except ValueError:
tests/config/loader/test_str_convert.py:46:        pytest.param("a", Command(["a"]), Command, id="str_a_to_command"),
tests/config/loader/test_str_convert.py:103:    result = StrConvert().to_command(value)
tests/config/loader/test_str_convert.py:218:    result = StrConvert().to_command(value)
tests/config/loader/test_str_convert.py:227:    result = StrConvert().to_command(value)

    def requires(self) -> tuple[Requirement, ...] | PythonDeps:
        raise NotImplementedError

    @abstractmethod
    def load_deps_for_env(self, for_env: EnvConfigSet) -> list[Requirement]:
        raise NotImplementedError

    def register_run_env(self, run_env: RunToxEnv) -> Generator[tuple[str, str], PackageToxEnv, None]:
        yield from super().register_run_env(run_env
…[5877 chars omitted]…
rement],
src/tox/tox_env/python/virtual_env/package/util.py:24:) -> list[Requirement]:
src/tox/tox_env/python/virtual_env/package/util.py:36:) -> list[Requirement]:
src/tox/tox_env/python/virtual_env/package/util.py:45:    result: list[Requirement] = []
src/tox/tox_env/python/virtual_env/package/util.py:65:def extract_extra_markers(deps: list[Requirement]) -> list[tuple[Requirement, set[str | None]]]:

labels = 
env_dir = /tmp/tmp.bhmW2Omttz/.tox/py
env_tmp_dir = /tmp/tmp.bhmW2Omttz/.tox/py/tmp
env_log_dir = /tmp/tmp.bhmW2Omttz/.tox/py/log
suicide_timeout = 0.0
interrupt_timeout = 0.3
terminate_timeout = 0.2
platform = 
pass_env =
  CC
  CCSHARED
  CFLAGS
  CPPFLAGS
  CURL_CA_BUNDLE
  CXX
  FORCE_COLOR
  HOME
  LANG
  LANGUAGE
  LDFLAGS
  LD_LIBRARY_PATH
  NETRC
  NIX_LD
  NIX_LD_LIBRARY_PATH
  NO_COLOR
  PIP_*
  PKG_CONFIG
  PKG_CONFIG_PATH
  PKG_CONFIG_SYSROOT_DIR
  PYTHON_GIL
  REQUESTS_CA_BUNDLE
  SSH_AGENT_PID
  SSH_AUTH_SOCK
  SSL_CERT_FILE
  TMPDIR
  VIRTUALENV_*
  http_proxy
  https_proxy
  no_proxy
disallow_pass_env = 
parallel_show_output = False
recreat
…[814 chars omitted]…

py_dot_ver = 3.12
py_impl = cpython
py_free_threaded = False
ROOT: HandledError| failed to load py.deps: deps expected str, list[str], or list[Requirement], got list with invalid items: [0] int
rc=254
--- r ---
py: failed to load py.deps: deps expected str, list[str], or list[Requirement], got list with invalid items: [0] int
  py: FAIL code 1 (0.08 seconds)
  evaluation failed :( (0.15 seconds)
rc=1

en if a sub-command exits with non-zero exit code"
482:        "commands_retry": {
514:        "deps": {
536:        "extra_setup_commands": {
544:          "description": "commands to execute after setup (deps and package install) but before test commands"
591:          "description": "package installation mode - wheel | sdist | sdist-wheel | editable | editable-legacy | deps-only | skip | external "

    "tox_root": {
      "type": "string",
      "description": "the root directory (where the configuration file is found)"
    },
    "toxinidir": {
      "$ref": "#/properties/tox_root",
      "description": "Deprecated: use 'tox_root' instead",
      "deprecated": true
    },
    "work_dir": {
      "type": "string",
      "description": "working directory"
    },
    "toxworkdir": {
      "$ref": "#/properties/work_dir",
      "description": "Deprecated: use 'work_dir' instead",
      "deprec
…[2399 chars omitted]…
": {
      "type": "string",
      "description": "Name of the virtual environment used to provision a tox."
    },
    "requires": {
      "type": "array",
      "items": {
        "$ref": "#/definitions/subs"
      },
      "description": "Name of the virtual environment used to provision a tox."
35:    "env_list": {
361:        "pass_env": {
413:        "constraints": {
502:        "base_python": {

405-        },
406:        "install_command": {
407-          "type": "array",
408-          "items": {
409-            "$ref": "#/definitions/subs"
410-          },
411-          "description": "command used to install packages"
412-        },
413-        "constraints": {
414-          "type": "string",
415-          "description": "constraints to apply to installed pytho
…[2007 chars omitted]…
stall_command = ["echo", "CUSTOM", "{packages}"]
tests/session/cmd/test_show_config.py:144:def test_show_config_install_command_toml(tox_project: ToxProjectCreator, filename: str, content: str) -> None:
tests/session/cmd/test_show_config.py:146:    outcome = project.run("c", "-k", "install_command")
tests/session/cmd/test_show_config.py:149:    assert f"install_command = {expected_cmd}" in outcome.out

from .toml_pyproject import TomlPyProject
from .toml_tox import TomlTox
from .tox_ini import ToxIni

if TYPE_CHECKING:
    from .api import Source

SOURCE_TYPES: tuple[type[Source], ...] = (
    ToxIni,
    SetupCfg,
    TomlPyProject,
    LegacyToml,
    TomlTox,
)


def discover_source(config_file: Path | None, root_dir: Path | None) -> Source:
    """Discover a source for configuration.

    :param config_file: the file storing the source
    :param root_dir: the root directory as set by the user (None means not set)

    :returns: the source of the config

    """
    if config_file i
…[5779 chars omitted]…
 None:
        if path.name != self.FILENAME or not path.exists():
            raise ValueError
        with path.open("rb") as file_handler:
            self._content = tomllib.load(file_handler)
        try:
            our_content: Mapping[str, Any] = self._content
            for key in self._Section.PREFIX:
                our_content = our_content[key]
            self._our_content = our_content

 src/tox/config/loader/toml/_validate.py | 33 +++++++++--------
 src/tox/config/sets.py                  | 24 ++++++------
 src/tox/session/cmd/run/single.py       | 13 ++++++-
 src/tox/session/cmd/show_config.py      |  3 ++
 src/tox/tox_env/python/pip/req_file.py  | 43 +++++++++++++--------
 6 files changed, 120 insertions(+), 62 deletions(-)
diff --git a/src/tox/config/loader/toml/__init__.py b/src/tox/config/loader/toml/__init__.py
index dac45ac..84a1577 100644
--- a/src/tox/config/loader/tom
…[8629 chars omitted]…
 ]
+    if not invalid_items and raw and not (
+        all(isinstance(item, str) for item in raw) or all(isinstance(item, Requirement) for item in raw)
+    ):
+        invalid_items = [f"[{index}] {type(item).__name__}" for index, item in enumerate(raw)]
+    return f"{field} expected {expected}, got list with invalid items: {', '.join(invalid_items)}"
+
+
 ONE_ARG = {
     "-i",
     "--index-url",

            """
        })
        outcome = project.run("c", "-k", "requires", "--core")
>       outcome.assert_success()

tests/config/source/test_toml_pyproject.py:395: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = code: 1
cmd: /usr/local/bin/python -m tox c -k 
…[3361 chars omitted]…
atchRecursionError('circular chain between set env a, b, b')
E         
E       assert False

src/tox/pytest.py:366: AssertionError
=========================== short test summary info ============================
FAILED tests/config/source/test_toml_pyproject.py::test_config_requires - Ass...
FAILED tests/config/test_set_env.py::test_set_env_circular_use_os_environ - A...
2 failed, 130 passed in 6.16s

format.docstring-code-line-length = 100
format.docstring-code-format = true
lint.select = [
  "ALL",
]
lint.ignore = [
  "ANN401",  # Dynamically typed expressions (typing.Any) are disallowed in `arg`"
  "COM812",  # conflicts with formatter
  "CPY",     # No copyright header
  "D",       # ignore documentation for now
  "D203",    # `one-blank-line-before-class` (D203) and `no-blank-line-before-class` (D211) are incompatible
  "D212",    # `multi-line-summary-first-line` (D212) and `multi-line-summary-second-line` (D213) are incompatible
  "DOC201",  # no restructuredtext support yet
  "DOC402",  # no restructuredtext sup
…[2281 chars omitted]…
ontent = true },
  { directory = "packaging", name = "Packaging updates and notes for downstreams", showcontent = true },
  { directory = "contrib", name = "Contributor-facing changes", showcontent = true },
  { directory = "misc", name = "Miscellaneous internal changes", showcontent = true },
]

[tool.ty]
environment.python-version = "3.14"
src.exclude = []
/usr/local/bin/python: No module named ruff

          "items": {
            "type": "array",
            "items": {
              "$ref": "#/definitions/subs"
            }
          },
          "description": "the commands to be called for testing"
        },
        "commands_post": {
          "type": "array",
          "items": {
            "type": "array",
            "items": {
              "$ref": "#/definitions/subs"
            }
          },
          "description": "the commands to be called after testing"
        },
        "recreate_commands": {
          "type": "array",
          "items": {

…[2034 chars omitted]…
ck.whl"], extend = true }]]
2313:    commands = [["pytest", { replace = "if", condition = "env.VERBOSE", then = ["--verbose", "--debug"], "else" = ["--quiet"], extend = true }]]
2332:    commands = [
2345:    commands = [["pytest", { replace = "if", condition = "factor.linux and env.CI", then = ["--numprocesses=auto"], "else" = [], extend = true }]]
2448:      commands =
2620:        commands = pytest

    from collections.abc import Iterator

    from tox.config.main import Config


class MemoryLoader(Loader[Any]):
    """Loads configuration directly from data in memory."""

    def __init__(self, **kwargs: Any) -> None:
        super().__init__(Section(prefix="<memory>", name=str(id(self))), [])
        self.raw: dict[str, Any] = {**kwargs}

    def load_raw(self, key: Any, conf: Config | None, env_name: str | None) -> Any:  # noqa: ARG002
        return self.raw[key]

    def found_keys(self) -> set[str]:
        return set(self.raw.keys())

    @staticmethod
    def to_bool(value: Any) -> bool:
        return bool(value)

    @s
…[2146 chars omitted]…
memory import MemoryLoader  # noqa: PLC0415
tests/plugin/test_inline.py:58:            in_memory_config_loader = MemoryLoader(
tests/plugin/test_plugin.py:12:from tox.config.loader.memory import MemoryLoader
tests/plugin/test_plugin.py:136:        core_conf.loaders.insert(0, MemoryLoader(**{dir_name: tmp_path}))
tests/plugin/test_plugin.py:191:        env_conf.loaders.insert(0, MemoryLoader(deps=[1]))

    """
    })

    outcome = project.run("c", "--core")
    outcome.assert_success()
    assert "# Exception: " not in outcome.out, outcome.out
    assert "# !!! unused: " not in outcome.out, outcome.out


def test_config_in_toml_non_default(tox_project: ToxProjectCreator) -> None:
    project = tox_project({
        "pyproject.toml": """
    [tool.tox.env.C]
    description = "Do magical things in C"
    commands = [
        ["python", "--version"]
    ]
    """
    })

    outcome = project.run("c", "-e", "C", "--core")
    outcome
…[2272 chars omitted]…
posargs", default = ["python", "patch.py"]},
            ["pytest"]
        ]

When running ``tox run -e A`` it will invoke ``python patch.py`` followed by pytest. When running ``tox run -e A --`` it
will invoke only pytest.

Environment variable reference
==============================

.. versionadded:: 4.21

You can reference environment variables via the ``env`` replacement:

.. code-block:: toml

                msg = (
                    f"set_env {path} expected str or a dictionary with a string 'value', "
                    f"got {type(value).__name__}: {value!r}"
                )
                return TypeError(msg)

            def validate_dict(values: dict[object, object], path: 
…[2526 chars omitted]…
_str, multi_line = _colored(is_colored, Fore.LIGHTRED_EX, f"# Exception: {exception!r}"), False
            has_exception = True
        if multi_line and "\n" not in as_str:
            multi_line = False
        print_key_value(is_colored, key, as_str, multi_line=multi_line)
    unused = conf.unused()
    if unused and not keys:
        print_comment(is_colored, f"# !!! unused: {', '.join(unused)}")

        )
    if mode != "depends":
        parser.add_argument(
            "--no-recreate-pkg",
            dest="no_recreate_pkg",
            help="if recreate is set do not recreate packaging tox environment(s)",
            action="store_true",
        )
    if mode not in {"devenv", "config", "depends"}:
        parser.add_argument(
            "--skip-pkg-install",
            dest="skip_pkg_install",
            help="skip package installation for this run",
            ac
…[6883 chars omitted]…
 or tox_env.conf["parallel_show_output"] or state.conf.options.list_dependencies:
            for pkg_out_err in pkg_out_err_list:
                state._options.log_handler.write_out_err(pkg_out_err)  # pragma: no cover  # noqa: SLF001
            if out_err is not None:  # pragma: no branch # first show package build
                state._options.log_handler.write_out_err(out_err)  # noqa: SLF001

        "pyproject.toml": """
        [tool.tox.env.A]
        commands = [["python", { replace = "posargs", default = ["a", "b"], extend = true } ]]
        """
    })
    outcome = project.run("c", "-e", "A", "-k", "commands")
    outcome.assert_success()
    outcome.assert_out_err("[testenv:A]\ncommands = python a b\n", "")


def test_config_in_toml_replace_posargs_empty(tox_project: ToxProjectCreator) -> None:
    project = tox_project({
        "pyproject.toml": ""
…[8629 chars omitted]…
    [tool.tox.env_run_base]
           set_env = { file = "conf{/}local.env", TEST_TIMEOUT = "30" }

     .. tab:: INI

        .. code-block:: ini

           [testenv]
           set_env = file|conf{/}local.env
                TEST_TIMEOUT = 30


     The env file path may include previously defined tox variables:


     .. tab:: TOML

        .. code-block:: toml

           [tool.tox.env_run_base]

            with pytest.raises(TypeError, match="1"):
                assert env_conf["deps"]
    
        register_inline_plugin(mocker, tox_add_env_c
…[5052 chars omitted]…
ement tox (from versions: none)\nERROR: No matching distribution found for tox\n.success

src/tox/pytest.py:362: AssertionError
=========================== short test summary info ============================
FAILED tests/plugin/test_plugin.py::test_plugin_injects_invalid_python_run - ...
FAILED tests/config/source/test_toml_pyproject.py::test_config_requires - Ass...
2 failed, 88 passed in 3.90s

from ._api import TomlTypes
from ._replace import TomlReplaceLoader, Unroll
from ._validate import validate

if TYPE_CHECKING:
    from collections.abc import Iterator, Mapping
    from types import UnionType

    from tox.config.loader.convert import Factory
    from tox.config.loader.section import Section
    from tox.config.main import Config

_T = TypeVar("_T")
_V = TypeVar("_V")


class TomlLoader(Loader[TomlTypes]):
    """Load configuration from a pyproject.toml file."""

    def __init__(
  
…[8121 chars omitted]…
-index-url",
    "-e",
    "--editable",
    "-c",
    "--constraint",
    "-r",
    "--requirement",
    "-f",
    "--find-links",
    "--trusted-host",
    "--use-feature",
    "--no-binary",
    "--only-binary",
}
ONE_ARG_ESCAPE = {
    "-c",
    "--constraint",
    "-r",
    "--requirement",
    "-f",
    "--find-links",
    "-e",
    "--editable",
}

__all__ = (
    "ONE_ARG",
    "PythonDeps",
)

if TYPE_CHECKING:
    from pathlib import Path

    from tox.config.types import Command
    from tox.tox_env.api import ToxEnv
    from tox.tox_env.runner import RunToxEnv

LOGGER = logging.getLogger(__name__)


class ToxEnvRunResult(NamedTuple):
    name: str
    skipped: bool
    code: int
    outcomes: list[Outcome]
    duration: float
    ignore_outcome: bool = False
    fail_fast: bool = False
    unavailable: bool = False


def run_one(
    tox_env: RunToxEnv,
    no_test: bool,
    suspend_display: bool,
    ex
…[5385 chars omitted]…
or index, item in enumerate(raw)]
    return f"{field} expected {expected}, got list with invalid items: {', '.join(invalid_items)}"


ONE_ARG = {
    "-i",
    "--index-url",
    "--extra-index-url",
    "-e",
    "--editable",
    "-c",
    "--constraint",
    "-r",
    "--requirement",
    "-f",
    "--find-links",
    "--trusted-host",
    "--use-feature",
    "--no-binary",
    "--only-binary",
}

    def add_tox_requires_min_version(reqs: list[Requirement]) -> list[Requirement]:
        min_version: Version = state.conf.core["min_version"]
        reqs.append(Requirement(f"tox{f'>={min_version}' if min_version else ''}"))
        return reqs

    state.conf.core.add_config(
        keys="requires",
        of_type=list[Requirement],
        default=[],
        desc="Name of the virtual env
…[2325 chars omitted]…
project.toml": """
        [tool.tox.env_run_base]
        deps = ['-r requirements.txt']
        """
    })
    outcome = project.run("c", "-k", "deps")
    outcome.assert_success()
    outcome.assert_out_err("[testenv:py]\ndeps = -r requirements.txt\n", "")


def test_config_requires(tox_project: ToxProjectCreator) -> None:
    project = tox_project({
        "pyproject.toml": """
        [tool.tox]

            [env_base.task]
            factors = ["x", "y"]
            package = "skip"
            commands = [["python", "-c", "print('ok')"]]
        """),
    })
    result = project.run("l")
    result.assert_success()
    assert "task-x" in result.out
    assert "task-y" in result.out


def test_env_base_cartesian_product(tox_project: ToxProjectCreator) -> None:
    project = tox_project({
        "tox.toml": textwrap.dedent("""\
            [env_base.task]
            factors = [["a", "b"], ["x", "y"]]
            package = "skip"
            commands = [["python", "-c", "print('ok')"]]

…[7028 chars omitted]…
rs = [["py312", "py313"], ["django42", "django50"]]
tests/config/source/test_toml_env_base.py:335:            factors = [
tests/config/source/test_toml_env_base.py:358:            factors = [
tests/config/source/test_toml_env_base.py:379:            factors = [["x86", "x64"]]
tests/config/source/test_toml_env_base.py:396:            factors = [["a", "b"], {"prefix" = "py3", "start" = 12, "stop" = 13}]

    project = tox_project({
        "tox.toml": textwrap.dedent("""\
            [env_base.django]
            factors = [
                {"prefix" = "py3", "start" = 13, "stop" = 14},
                ["django42", "django50"],
            ]
            package = "skip"
            deps = [
                "pytest",
                {replace = "if", condition = "factor.django42", then = ["Django>=4.2,<4.3"]},
             
…[3885 chars omitted]…
jango>=4.2,<4.3"] },
        { replace = "if", condition = "factor.django50", then = ["Django>=5.0,<5.1"] },
    ]
    commands = [["pytest"]]

This generates 4 environments: ``django-py312-django42``, ``django-py312-django50``, ``django-py313-django42``,
``django-py313-django50``.

**Inheritance chain:** settings resolve in this order: ``[env.{name}]`` (explicit overrides) → ``[env_base.{template}]``

      "description": "base configuration for run environments",
      "x-taplo": {
        "links": {
          "key": "https://tox.wiki/en/stable/config.html#run-environment"
        }
      },
      "properties": {
        "set_env": {
          "type": "object",
          "additionalProperties": {
            "$ref": "#/definitions/subs"
          },
          "description": "environment variables to set when running commands in the tox environment"
        },
        "setenv": {
          "$ref": "#/prope
…[2433 chars omitted]…
 be found in :ref:`environment variable substitutions`.

.. _injected-environment-variables:

13:from typing import TYPE_CHECKING, Any, Literal, NoReturn, cast
147:            of_type=Path,
153:            of_type=Path,
161:            of_type=bool,
176:                of_type=dict[str, str],
455:        target: Literal["editable", "wheel"] = "editable" if for_env["package"] == "editable" else "wheel"

src/tox/config/main.py
src/tox/config/of_type.py
src/tox/config/sets.py
src/tox/config/set_env.py
src/tox/config/types.py
src/tox/config/__init__.py
src/tox/execute/api.py
src/tox/execute/pep517_backend.py
src/tox/execute/request.py
src/tox/execute/stream.py
src/tox/execute/util.py
src/tox/execute/__init__.py
src/tox/journal/env.py
src/tox/journal/main.py
src/tox/journal/__init__.py
src/tox/plugin/inline.py
src/tox/plugin/manager.py
src/tox/plugin/spec.py
src/tox/plugin/__init__.py
src/tox/provision.py
src/tox/py.typed
src/tox/pytest.py
src/tox/report.py
src/tox/run.py
src/tox/session/env_select.py
src/tox/session/state.py
src/tox/session/__init__.py
src/tox/tox.schema.json
src/tox/tox_env/api.py
src/tox/tox_env/errors.py
src/tox/tox_env/info.py
src/tox/tox_env/installer.py
src/tox/tox_env/package.py
src/tox/tox_env/register.py
src/tox/tox_env/runner.py
src/tox/tox_env/util.py
src/tox/tox_env/__init__.py
src/tox/util/ci.py
src/tox/util/cpu.py
src/tox/util/file_view.py
src/tox/util/graph.py
src/tox/util/path.py
src/tox/util/spinner.py
src/tox/util/__init__.py
src/tox/version.py
src/tox/__init__.py
src/tox/__main__.py

src/tox/config/loader/section.py
src/tox/config/loader/stringify.py
src/tox/config/loader/str_convert.py
src/tox/config/loader/toml/_api.py
src/tox/config/loader/toml/_product.py
src/tox/config/loader/toml/_replace.py
src/tox/config/loader/toml/_validate.py
src/tox/config/loader/toml/__init__.py
src/tox/config/loader/__init__.py
src/tox/config/main.py
src/tox/config/of_type.py
src/tox/config/sets.py
src/tox/config/set_env.py
src/tox/config/source/api.py
src/tox/config/source/discover.py
src/tox/config/source/
…[1350 chars omitted]…
name__ for a in args)}"
src/tox/config/loader/toml/_validate.py:61:            msg = f"{val!r} is not one of literal {','.join(repr(i) for i in choice)}"
src/tox/config/loader/toml/_validate.py:72:            msg = f"{val!r} is not of type {of_type.__name__!r}"
src/tox/config/loader/toml/__init__.py:137:                msg = f"env_list items must be strings or product dicts, got {type(item).__name__}"

    get_origin,
)

from tox.config.types import Command

if TYPE_CHECKING:
    from ._api import TomlTypes


T = TypeVar("T")


def validate(val: TomlTypes, of_type: type[T]) -> T:  # noqa: C901, PLR0912
    casting_to = get_origin(of_type) or of_type.__class__
    type_args = get_args(of_type)
    msg = ""
    if casting_to in {list, list}:
        entry_type = type_args[0]
        if isinstance(val, list):
            for va in val:
                validate(va, entry_type)
        else:
            msg = f"{val!r} is not list"
    elif isclass(of_type) and issubclass(of_type, Command):
        # first we cast it to list then create commands, so for now validate it as a nested list
   
…[6147 chars omitted]…
ce(item, str):
                envs.append(item)
            elif isinstance(item, dict) and "product" in item:
                envs.extend(expand_product(item))
            else:
                msg = f"env_list items must be strings or product dicts, got {type(item).__name__}"
                raise TypeError(msg)
        return EnvList(envs=envs)


__all__ = [
    "HandledError",
    "TomlLoader",
]

src/tox/config/loader/toml/__init__.py:105:        result = validate(value, cast("type[list[Any]]", list[of_type]))  # ty: ignore[invalid-type-form] # runtime generic from type variable
src/tox/config/loader/toml/__init__.py:110:        result = validate(value, cast("type[dict[Any, Any]]", dict[of_type[0], of_type[1]]))  # ty: ignore[invalid-type-form] # runtime generic from type variables

    ( \s )      # capture whitespace
    """,
    re.VERBOSE,
)

if TYPE_CHECKING:
    from argparse import ArgumentParser, Namespace
    from pathlib import Path
    from typing import Final


class PythonDeps(RequirementsFile):
    # these options are valid in requirements.txt, but not via pip cli and
    # thus cannot be used in the testenv `deps` list
    _illegal_options: Final[list[str]] = ["hash"]

    def __init__(self, raw: str | list[str] | list[Requirement], root: Path) -> None:
        super().__init__(root / "tox.ini", constraint=False)
        got = raw if isinstance(raw, str) else 
…[8628 chars omitted]…
-index-url",
    "-e",
    "--editable",
    "-c",
    "--constraint",
    "-r",
    "--requirement",
    "-f",
    "--find-links",
    "--trusted-host",
    "--use-feature",
    "--no-binary",
    "--only-binary",
}
ONE_ARG_ESCAPE = {
    "-c",
    "--constraint",
    "-r",
    "--requirement",
    "-f",
    "--find-links",
    "-e",
    "--editable",
}

__all__ = (
    "ONE_ARG",
    "PythonDeps",
)

        self._raw += "\n" + other._raw
        return self

    @classmethod
    def factory(cls, root: Path, raw: object) -> PythonDeps:
        if not (
            isinstance(raw, str)
            or (
                isinstance(raw, list)
                and (all(isinstance(i, str) for i in raw) or all(isinstance(i, Requi
…[8400 chars omitted]…

        record.env_name = "root" if self._local.name is None else self._local.name
        basename = str(Path(record.pathname).parent)
        len_sys_path_match = max((len(p) for p in sys.path if basename.startswith(p)), default=-1)
        record.pathname = record.pathname[len_sys_path_match + 1 :]

        if record.levelno >= logging.ERROR:
            return self._error_formatter.format(record)

            yield

    def update_verbosity(self, verbosity: int) -> None:
        level = _get_level(verbosity)
        LOGGER.setLevel(level)
        self._setup_level(self._is_colored, level)


def setup_report(verbosity: int, is_colored: bool) -> ToxHandler:  # noqa: FBT001
    _clean_handlers(LOGGER)
    level = _get_level(verbosity)
    LOGGER.setL
…[338 chars omitted]…
tLevelName(level), os.getpid())
    return handler


def _get_level(verbosity: int) -> int:
    return LEVELS[min(verbosity, MAX_LEVEL)]


def _clean_handlers(log: logging.Logger) -> None:
    for log_handler in list(log.handlers):  # remove handlers of libraries
        log.removeHandler(log_handler)


class HandledError(RuntimeError):
    """Error that has been handled so no need for stack trace."""

…[1837 chars omitted]…
ror(msg) from exc
src/tox/session/env_select.py:464:                raise HandledError(msg)
src/tox/session/env_select.py:492:                    raise HandledError(msg)  # pragma: no cover
src/tox/session/env_select.py:585:            raise HandledError(msg)
src/tox/tox_env/python/runner.py:15:from tox.report import HandledError
src/tox/tox_env/python/runner.py:124:            raise HandledError(msg)

from tox.report import HandledError, ToxHandler
from tox.session.state import State

if TYPE_CHECKING:
    from collections.abc import Sequence


def run(args: Sequence[str] | None = None) -> None:
    try:
        with ToxHandler.patch_thread():
            result = main(sys.argv[1:] if args is None else args)
    except Exception as exception:
        if isinstance(exception, HandledError):
            logging.error("%s| %s", type(exception).__name__, exception)  # noqa: TRY400
            result = -2
        else:
            raise
    except KeyboardInterrupt:
        result = -2
    finally:
        if "_TOX_SHOW_THREAD" in os.environ:  # pragma: no cover
            
…[7312 chars omitted]…
nvs[envs[0]].conf
    conf.loaders.insert(0, loader)
    to_path: Path | None = conf["change_dir"] if conf["args_are_paths"] else None
    pos_args = state.conf.pos_args(to_path)
    if not pos_args:
        msg = "You must specify a command as positional arguments, use -- <command>"
        raise HandledError(msg)
    loader.raw["commands"] = [Command(list(pos_args))]
    return run_sequential(state)

src/tox/tox_env/api.py:455:        stdin: StdinSource,
src/tox/tox_env/api.py:461:        with self.execute_async(cmd, stdin, show, cwd, run_id, executor) as status:
src/tox/tox_env/api.py:479:        stdin: StdinSource,
src/tox/tox_env/api.py:491:        request = ExecuteRequest(cmd, cwd, self.environment_variables, stdin, run_id, allow=self._allow_externals)

class StdinSource(Enum):
    OFF = 0  #: input disabled
    USER = 1  #: input via the standard input
    API = 2  #: input via programmatic access

    @staticmethod
    def user_only() -> StdinSource:
        """:returns: ``USER`` if the standard input is tty type else ``OFF``"""
        return StdinSource.USER if sys.stdin.isatty() else StdinSource.OFF


class ExecuteRequest:
    """Defines a commands execution request."""

    def __init__(  # noqa: PLR0913
        self,
        cmd: Sequence[str | Path],
        cwd: Path,
        env: dict[str, str],
        stdin: StdinSource,
        run_id: str,
        allow: list[str] | None = None,
   
…[8629 chars omitted]…
SyncWrite]:
        prev = self._out, self._err
        if self._read_stdout is not None:  # pragma: no branch
            self._read_stdout.handler = out.handler
        if self._read_stderr is not None:  # pragma: no branch
            self._read_stderr.handler = err.handler
        return prev


def _pty(key: str) -> tuple[int, int] | None:
    """Allocate a virtual terminal (pty) for a subprocess.

test_commands_retry.py
test_depends.py
test_devenv.py
test_exec_.py
test_legacy.py
test_list_envs.py
test_parallel.py
test_quickstart.py
test_schema.py
test_sequential.py
test_show_config.py
test_state.py

@pytest.mark.parametrize("trail", [[], ["--"]], ids=["no_posargs", "empty_posargs"])
def test_exec_fail_no_posargs(tox_project: ToxProjectCreator, trail: list[str]) -> None:
    outcome = tox_project({"tox.ini": ""}).run("e", "-e", "py39", *trail)
    outcome.assert_failed()
    msg = "ROOT: HandledError| You must specify a command as positional arguments, use -- <command>\n"
    outcome.assert_out_err(msg, "")


def test_exec_fail_multiple_target(tox_project: ToxProjectCreator) -> None:
    outcome = tox_project({"tox.ini": ""}).run("e", "-e", "py39,py38", "--", "py")
    outcome.assert_failed()
    msg = "ROOT: HandledError| exactly one target environment allowed in exec mode but foun
…[1089 chars omitted]…
patch_execute(capture_options)
    result = project.run("e", "-e", "py", "--", "python", "--version")
    result.assert_success()

    assert execute_calls.call_count > 0
    for call in execute_calls.call_args_list:
        _, kwargs = call
        env_instance = kwargs.get("self")
        if env_instance and hasattr(env_instance, "options"):
            assert env_instance.options.no_capture is True

d=cmd.args, stdin=StdinSource.OFF, run_id="freeze", show=False)
src/tox/tox_env/python/pip/pip_install.py:279:        outcome = self._env.execute(cmd, stdin=StdinSource.OFF, run_id=f"install_{of_type}")
src/tox/tox_env/python/virtual_env/package/pyproject.py:26:from tox.execute.request import StdinSource
src/tox/tox_env/python/virtual_env/package/pyproject.py:529:                stdin=StdinSource.API,

            defaults.update(
                result_json=None,
                hash_seed=hashseed_default,
                discover=[],
                list_dependencies=is_ci(),
            )
            return

        sub_parser.add_argument(
            "--result-json",

…[6230 chars omitted]…
rser import ToxParser
    from tox.session.state import State


@impl
def tox_add_option(parser: ToxParser) -> None:
    our = parser.add_command("run", ["r"], "run environments", run_sequential)
    register_env_select_flags(our, default=CliEnv())
    env_run_create_flags(our, mode="run")


def run_sequential(state: State) -> int:
    return execute(state, max_workers=1, has_spinner=False, live=True)

from pathlib import Path
from typing import TYPE_CHECKING, Any, NamedTuple, cast

from tox.execute.request import ExecuteRequest
from tox.tox_env.errors import Fail, Recreate, Skip
from tox.tox_env.info import Info
from tox.util.path import ensure_cachedir_tag, ensure_empty_dir, ensure_gitignore

if TYPE_CHECKING:
    from collections.abc import Iterator, Sequence
    from io import BytesIO

    from tox.config.cli.parser import Parsed
    from tox.config.main import Config
    from tox.config.set_env import SetEnv
    from tox.config.sets import CoreConfigSet, EnvConfigSet
    from tox.execute.api import Execute, ExecuteStatus, Outcome, Stdi
…[8130 chars omitted]…
:        if disallow := self.conf["disallow_pass_env"]:
420:        result["TOX_ENV_DIR"] = str(self.conf["env_dir"])
444:        result.extend(i.strip() for i in self.conf["allowlist_externals"])
470:        logging.warning("interrupt tox environment: %s", self.conf.name)
490:            show = self.options.verbosity > 3  # noqa: PLR2004
585:        with self.log_handler.with_context(self.conf.name):

…[4836 chars omitted]…

            default = " (default: %(default)s)"
            if text.endswith(default):  # pragma: no branch
                text = f"{text[: -len(default)]} (default: %(default)s -> from %(default_source)s)"
        return text

    def add_raw_text(self, text: str | None) -> None:
        def keep(content: str) -> str:
            return content

        if text is not SUPPRESS and text is not None:

from tox.config.loader.ini.factor import find_factor_groups
from tox.config.loader.replacer import (
    MatchError,
    MatchRecursionError,
    ReplaceReference,
    load_posargs,
    replace,
    replace_env,
)
from tox.config.loader.stringify import stringify

from ._validate import validate

if TYPE_CHECKING:
    from collections.abc import Iterator

    from tox.config.loader.api import ConfigLoadArgs
    from tox.config.loader.toml import TomlLoader
    from tox.config.main import Config
    from tox.config.sets import ConfigSet
    from tox.config.source.toml_pyproject import TomlSection

    from ._api import TomlTypes


class Unroll:
    def __init__(self, conf: Config | No
…[8629 chars omitted]…
   if not isinstance(start, int):
        msg = f"range 'start' must be an integer, got {type(start).__name__}"
        raise TypeError(msg)
    if not isinstance(stop, int):
        msg = f"range 'stop' must be an integer, got {type(stop).__name__}"
        raise TypeError(msg)
    return [f"{prefix}{i}" for i in range(start, stop + 1)]


__all__ = [
    "expand_factor_group",
    "expand_product",
]

            res_dict: dict[str, TomlTypes] = {}
            for key, val in value.items():  # appl
…[4183 chars omitted]…
 self.conf = conf
        self.loader = loader

    def __call__(self, value: str, conf_args: ConfigLoadArgs) -> str | None:
        if match := _REFERENCE_PATTERN.search(value):
            settings = match.groupdict()
            exception: Exception | None = None
            try:
                for src in self._config_value_sources(settings["section"], conf_args.env_name):
                    try:

src/tox/config/loader/toml/__init__.py:49:    def load_raw(self, key: str, conf: Config | None, env_name: str | None) -> TomlTypes:  # noqa: ARG002
src/tox/config/loader/toml/__init__.py:52:    def load_raw_from_root(self, path: str) -> TomlTypes:
src/tox/config/loader/toml/__init__.py:58:                msg = f"Failed to load key {key} as not dictionary {current!r}"

if TYPE_CHECKING:
    from types import UnionType

    from tox.config.cli.parser import ToxParser
    from tox.config.main import Config

    from .section import Section


class Override:  # noqa: PLW1641
    """An override for config definitions."""

    def __init__(self, value: str) -> None:
        key, equal, self.value = value.partition("=")
        if not equal:
            msg = f"override {value} has no = sign in it"
            raise ArgumentTypeError(msg)

        self.append = False
        if key.endswith("+"): 
…[8629 chars omitted]…
od
    @abstractmethod
    def to_path(value: T) -> Path:
        """Convert to path.

        :param value: the value to convert

        :returns: path representation of the value

        """
        raise NotImplementedError

    @staticmethod
    @abstractmethod
    def to_command(value: T) -> Command | None:
        """Convert to a command to execute.

        :param value: the value to convert

        """Load a value (raw and then convert).

        :param key: the key under it lives
        :param of_type: the type to convert to
        :param factory: factory method to build the object
        :param conf: the configuration object of this tox session (needed to manifest the value)
        :param args: the config load arguments
        :param all_keys: all alias keys for this config entry (to collect overrides from any alias)

        :returns: the converted type

        """
        from tox.config.set_env import SetEnv  # noqa: PLC0415

        over
…[6776 chars omitted]…
 -> str:
        """Convert to string.

        :param value: the value to convert

        :returns: a string representation of the value

        """
        raise NotImplementedError

    @staticmethod
    @abstractmethod
    def to_bool(value: T) -> bool:
        """Convert to boolean.

        :param value: the value to convert

        :returns: a boolean representation of the value

        """

    from collections.abc import Callable, Generator, Iterator, Mapping, Sequence
    from types import UnionType

    from tox.config.loader.api import Loader
    from tox.config.main import Config

    from .loader.convert import Factory
    from .loader.section import Section

V = TypeVar("V")


class ConfigSet(ABC):
    """A set of configuration that belong together (such as a tox environment settings, core tox settings)."""

    def __init__(self, conf: Config, section: Section, env_name: str | None) -> None:
        self._se
…[8629 chars omitted]…
ed(is_colored, Fore.LIGHTRED_EX, f"# Exception: {exception!r}"), False
            has_exception = True
        if multi_line and "\n" not in as_str:
            multi_line = False
        print_key_value(is_colored, key, as_str, multi_line=multi_line)
    unused = conf.unused()
    if unused and not keys:
        print_comment(is_colored, f"# !!! unused: {', '.join(unused)}")
    return has_exception

    from types import UnionType

    from tox.config.loader.convert import Factory
    from tox.config.main import Config  # pragma: no cover


T = TypeVar("T")
V = TypeVar("V")


class ConfigDefinition(ABC, Generic[T]):  # noqa: PLW1641
    """Abstract base class for configuration definitions."""

    def __init__(self, keys: Iterable[str], desc: str) -> None:
        self.keys = keys
        self.desc = desc

    @abstractmethod
    def __call__(self, conf: Config, loaders: list[Load
…[8629 chars omitted]…
ge: a flag indicating if the environment is of type packaging or not (only used for creation)
        :param loaders: loaders to use for this configuration (only used for creation)

        :returns: the tox environments config

        """
        if item in self._env_to_conf_set:
            return self._env_to_conf_set[item]
        section, base_test, base_pkg = self._src.get_tox_env_section(item)

        "\nenv_site_packages_dir = # Exception: "
        "Skip(\"failed to find interpreter for Builtin discover of python_spec='missing-python'"
    )
    assert txt in outcome.out


def test_show_config_empty_install_command_exception(tox_project: ToxProjectCreator) -> None:
    project = tox_project({"tox.ini": "[testenv:a]\ninstall_command="})
    outcome = project.run("c", "-e", "a", "-k", "install_command", raise_on_config_fail=False)
    outcome.assert_failed(code=-1)
    txt = "\ninstall_command = # Exception: 
…[2804 chars omitted]…
 of type 'str'"):
tests/config/loader/test_toml_loader.py:125:    with pytest.raises(TypeError, match="env_list items must be strings or product dicts, got int"):
tests/config/loader/test_toml_loader.py:134:    with pytest.raises(TypeError, match="1 is not union of str, NoneType"):
tests/config/loader/test_toml_loader.py:143:    with pytest.raises(TypeError, match="'c' is not one of literal 'a','b'"):

def test_toml_loader_load_raw() -> None:
    loader = TomlLoader(TomlPyProjectSection.from_key("tox.env.A"), [], {"a": 1, "c": False}, {}, set())
    assert loader.load_raw("a", None, "A") == 1


def test_toml_loader_load_repr() -> None:
    loader = TomlLoader(TomlPyProjectSection.from_key("tox.env.A"), [], {"a": 1}, {}, set())
    assert repr(loader) == "TomlLoader(env.A, {'a': 1})"


def test_toml_loader_found_keys() -> None:
    loader = TomlLoader(TomlPyProjectSection.from_key("tox.env.A"), [], {"a": 1, "c": False}, {}, set())
    assert loader.foun
…[6308 chars omitted]…
conftest.py:15:def pkg_with_extras_project(tmp_path_factory: pytest.TempPathFactory) -> Path:
tests/tox_env/python/virtual_env/package/conftest.py:38:    tmp_path = tmp_path_factory.mktemp("prj")
tests/tox_env/python/virtual_env/package/conftest.py:49:    tmp_path_factory: pytest.TempPathFactory,
tests/tox_env/python/virtual_env/package/conftest.py:52:    tmp_path = tmp_path_factory.mktemp("skeleton")

    assert conf["setenv"].load("c") == "d"
    assert conf["setenv"].load("e") == "f"


def test_config_override_appends_to_empty_setenv(tox_ini_conf: ToxIniCreator) -> None:
    conf = tox_ini_conf("[testenv]", override=[Override("testenv.setenv+=foo=bar")]).get_env("testenv")
    assert conf["setenv"].load("foo") == "bar"


def test_config_override_appends_to_pythondeps(tox_ini_conf: 
…[2231 chars omitted]…
s, from_cwd=project.path / "w")
    result.assert_success()
    assert result.out == f"[testenv:py]\ncommands = magic.py {project.path} ..{os.sep}tox.ini .. ..{os.sep}..\n"


def test_args_are_paths_when_from_child_dir(tox_project: ToxProjectCreator) -> None:
tests/config/loader/test_toml_loader.py:125:    with pytest.raises(TypeError, match="env_list items must be strings or product dicts, got int"):

        msg, color = _get_outcome_message(run)
        out = f"  {run.name}: {msg} ({run.duration:.2f}{f'=setup[{setup:.2f}]{extra}' if extra else ''
…[8629 chars omitted]…
, to_run: list[str], completed: set[str]) -> Iterator[list[str]]:
    """Generate tox environments ready to run."""
    order, todo = run_order(state, to_run)
    while order:
        ready_to_run: list[str] = []
        new_order: list[str] = []
        for env in order:  # collect next batch of ready to run
            if todo[env] - completed:
                new_order.append(env)
            else:

            max_workers = len(to_run_list) if max_workers is None else max_workers
            completed: set[str] = set()
            envs_to_run_generator = ready_to_run_envs(state, to_run_list, completed)

            def _run(tox_env: RunToxEnv) -> ToxEnvRunResult:
                spinner.add(tox_env.conf.name)
               
…[3616 chars omitted]…
ging.exception("Internal Error")  # pragma: no cover
                raise  # pragma: no cover
            finally:
                executor.shutdown(wait=True)
    finally:
        try:
            # call teardown - configuration only environments for example could not be finished
            for name in to_run_list:
                state.envs[name].teardown()
        finally:
            done.set()

from tox.config.cli.parser import Parsed
from tox.config.loader.ini.factor import extend_factors
from tox.config.main import Config
from tox.config.source.discover import discover_source
from tox.config.types import EnvList
from tox.report import HandledError
from tox.tox_env.api import ToxEnvCreateArgs
from tox.tox_env.errors import RunnerUnavailable, Skip
from tox.tox_env.package import PackageToxEnv
from tox.tox_env.register import REGISTER
from tox.tox_env.runner import RunToxEnv

if TYPE_CHECKING:
    import sys
    from argparse import Action, ArgumentParser, Namespace
    from collections.abc
…[8630 chars omitted]…
:  # noqa: C901
        labels = set(getattr(self._state.conf.options, "labels", []))
        factors = self._parse_factors()

        assert self._defined_envs_ is not None  # noqa: S101
        if labels or factors:
            for env_info in self._defined_envs_.values():
                env_info.is_active = False  # if any was selected reset
            # ignore labels when provisioning will occur

            previous, has_previous = signal(SIGINT, Handlers.SIG_IGN), True
            spinner.print_report = False  # no need to print reports at this point, final report coming up
            logger.error("[%s] KeyboardInterrupt - teardown started", os.getpid())  # noqa: TRY400
            interrupt.set()
            # cancel in reverse order to not allow submitting new jobs as we cancel running ones
            for future, tox_env in reversed(list(future_to_env.i
…[2591 chars omitted]…
str], dict[str, set[str]]]:
    to_run_set = set(to_run)
    todo: dict[str, set[str]] = {}
    for env in to_run:
        run_env = cast("RunToxEnv", state.envs[env])
        depends = set(cast("EnvList", run_env.conf["depends"]).envs)
        todo[env] = {name for dep in depends for name in to_run_set if fnmatchcase(name, dep)} - {env}
    order = stable_topological_sort(todo)
    return order, todo

from tox.report import HandledError
from tox.tox_env.errors import Skip

if TYPE_CHECKING:
    from configparser import ConfigParser, SectionProxy
    from types import UnionType

    from tox.config.loader.convert import Factory
    from tox.config.loader.section import Section
    from tox.config.main import Config

V = TypeVar("V")
_COMMENTS = re.compile(
    r"""
    ( \s )*     # optional leading whitespace
    (?<! \\ )   # not preceded by backslash
    \# .* 
…[4503 chars omitted]…
 EnvList):
        return "\n".join(e for e in value.envs), True
    if isinstance(value, Command):
        return value.shell, True
    if isinstance(value, SetEnv):
        env_var_keys = sorted(value)
        return stringify({k: value.load(k) for k in env_var_keys})
    if isinstance(value, PythonDeps):
        return stringify(value.lines())
    return str(value), False


__all__ = ("stringify",)

        """Get the primary key for a config key.

        :param key: the config key

        :returns: the key that's considered the primary for the input key

        """
        return self._alias[key]

    @property
    def name(self) -> str:
        return self._section.name

    @property
    def env_name(self) -> str | None:
        return se
…[3860 chars omitted]…
 default=SetEnv("", self.name, self.env_name, root),
            desc="environment variables to set when running commands in the tox environment",
            post_process=set_env_post_process,
        )

    def __repr__(self) -> str:
        return f"{self.__class__.__name__}(name={self._env_name!r}, loaders={self.loaders!r})"


__all__ = (
    "ConfigSet",
    "CoreConfigSet",
    "EnvConfigSet",
)

154-
155-        :param item: the config key
156-        :param chain: a chain of configuration keys already loaded for this load operation (used to detect circles)
157-
158-        :returns: the configuration value
159-
160-        """
161-        config_definition = self._defined[item]
162-        return config_definition.__call__(self._conf, self.loaders, ConfigLoadArgs(chain, self.name, self.env_name))  # noqa: PL
…[1056 chars omitted]…
 found.update(loader.found_keys())
189-        found -= self._defined.keys()
190-        return sorted(found)
191-
192-    def primary_key(self, key: str) -> str:
193-        """Get the primary key for a config key.
194-
195-        :param key: the config key
196-
197-        :returns: the key that's considered the primary for the input key
198-
199-        """
200-        return self._alias[key]
201-

    get_origin,
)

from tox.config.types import Command
from tox.report import HandledError

if TYPE_CHECKING:
    from ._api import TomlTypes


T = TypeVar("T")


def validate(val: TomlTypes, of_type: type[T]) -> T:  # noqa: C901, PLR0912
    casting_to = get_origin(of_type) or of_type.__class__
    type_args = get_args(of_type)
    msg = ""
    if casting_to in {list, list}:
        entry_type = type_args[0]
        if isinstance(val, list):
            for va in val:
                validate(va, entry_type)
        else:
            msg = f"{val!r} is not list"
    elif isclass(of_type) and issubclass(of_type, Command):
        # first we cast it to list then create commands, so for 
…[1978 chars omitted]…
item, str):
                envs.append(item)
            elif isinstance(item, dict) and "product" in item:
                envs.extend(expand_product(item))
            else:
                msg = f"env_list items must be strings or product dicts, got {type(item).__name__}"
                raise HandledError(msg)
        return EnvList(envs=envs)


__all__ = [
    "HandledError",
    "TomlLoader",
]

    ( \s )      # capture whitespace
    """,
    re.VERBOSE,
)

if TYPE_CHECKING:
    from argparse import ArgumentParser, Namespace
    from pathlib import Path
    from typing import Final


def _factory_type_error(field: str, raw: object) -> str:
    expected = f"{field} expected str, list[str], or list[Requirement]"
    if isinstance(raw, list):
        invalid = [f"[{at}] {type(item).__name__}" for at, item in enumerate(raw) if not isinstance(item, (str, Requirement))]
        return f"{expected}, got list with invalid items: {', '.join(invalid)}"
    return f"{expected}, got {type(raw).__n
…[2108 chars omitted]…
actory_type_error("constraints", raw))
        return cls(cast("str | list[str] | list[Requirement]", raw), root)


ONE_ARG = {
    "-i",
    "--index-url",
    "--extra-index-url",
    "-e",
    "--editable",
    "-c",
    "--constraint",
    "-r",
    "--requirement",
    "-f",
    "--find-links",
    "--trusted-host",
    "--use-feature",
    "--no-binary",
    "--only-binary",
}
ONE_ARG_ESCAPE = {

 .github/ISSUE_TEMPLATE/bug-report.md               |   45 +
 .github/ISSUE_TEMPLATE/config.yml                  |   10 +
 .github/ISSUE_TEMPLATE/feature-request.md          |   26 +
 .github/PULL_REQUEST_TEMPLATE.md                   |   10 +
 .github/SECURITY.md                                |   23 +
 .github/config.yml                                 |    3 +
 .github
…[827 chars omitted]…
          |   23 +
 docs/_static/img/tox.png                           |  Bin 0 -> 53348 bytes
 docs/_static/img/tox.svg                           |  515 ++++
 docs/_static/img/toxfavi.ico                       |  Bin 0 -> 15086 bytes
 docs/_static/mermaid-reset.js                      |  115 +
 docs/changelog.rst                                 | 2571 +++++++++++++++++
3837.bugfix.rst
template.jinja2

- Add code style guide for contributors - by :user:`gaborbernat`. (:issue:`1734`)

***********************
 v4.0.0a3 (2021-01-
…[6461 chars omitted]…
tnovak`. (:issue:`3474`)
857:- Fix error when using ``requires`` within a TOML configuration file - by :user:`gaborbernat`. (:issue:`3386`)
858:- Fix error when using ``deps`` within a TOML configuration file - by :user:`gaborbernat`. (:issue:`3387`)
859:- Multiple fixes for the TOML configuration by :user:`gaborbernat`.:
874:- Native TOML configuration support - by :user:`gaborbernat`. (:issue:`999`)

Bug fixes - 4.46.3
==================

- Fix SchemaStore update workflow creating PRs with merge conflicts by branching from upstream master - by
  :user:`gaborbernat`. (:issue:`3828`)
- Fixed the minimum version of virtualenv, to avoid incompatibility. (:issue:`3829`)

**********************
 v4.46.2 (2026-02-25)
**********************

Bug fixes - 4.46.2
==================

- Fix SchemaStore update workflow authentication and PR creation for fork repositories - by :user:`gaborbernat`.
  (:issue:`3826`)

**********************
 v4.46.1 (2026-02-25)
**********************

Bug fixes - 4.46.1
==================

- Allow glob patterns (``*``, ``?``) in ``depends`` configuration for ini files - by :user:
…[8626 chars omitted]…
n key that allows pinning a specific virtualenv version per environment (e.g.
  ``virtualenv_spec = "virtualenv<20.22.0"``). When set, tox bootstraps the specified version in an isolated environment
  and drives it via subprocess, enabling environments targeting Python versions incompatible with the installed
  virtualenv - by :user:`gaborbernat`. (:issue:`3656`)

Bug fixes - 4.42.0
==================

    from collections.abc import Callable, Iterable
    from types import UnionType

    from tox.config.loader.convert import Factory
    from tox.config.main import Config  # pragma: no cover


T = TypeVar("T")
        args: ConfigLoadArgs,
    ) -> T:
        if self._cache is _PLACE_HOLDER:
            primary_key, *alias_keys = self.keys
            for loader in loaders:
                chain_key = f"{loader.section.key}.{primary_key}"
                try:
                    if chain_key in arg
…[2283 chars omitted]…
oqa: TRY400
            code = 2
        except Exception:  # pragma: no cover
            LOGGER.exception("internal error")  # pragma: no cover
            code = 2  # pragma: no cover
        finally:
            tox_env.teardown()
    except SystemExit as exception:  # setup command fails (interrupted or via invocation)
        code = cast("int", exception.code)
    return skipped, code, outcomes

) -> int:
    exit_code = Outcome.OK
    command_set: list[Command] = tox_env.conf[key]
    stdin = StdinSource.USER if getattr(tox_env.options, "command", None) == "exec" else StdinSource.user_only()
    for at, cmd in enumerate(command_set):
        max_attempts = 1 if cmd.ignore_exit_code else retry_count + 1
        for attempt in range(1, max_attempts + 1):
            current_outcome = tox_env.execute(
                cmd.args,
                cwd=cwd,
                stdin=stdin,
                show=True,
                run_id=f"{key}[{at}]",
            )
            outcomes.append(current_outcome)
            try:
                if cmd.invert_exit_code:
                    current_outcome.assert_failure()
                else:

env_dir = /tmp/toxrepro/.tox/py
env_tmp_dir = /tmp/toxrepro/.tox/py/tmp
env_log_dir = /tmp/toxrepro/.tox/py/log
suicide_timeout = 0.0
interrupt_timeout = 0.3
terminate_timeout = 0.2
platform = 
pass_env =
  CC
  CCSHARED
  CFLAGS
  CPPFLAGS
  CURL_CA_BUNDLE
  CXX
  FORCE_COLOR
  HOME
  LANG
  LANGUAGE
  LDFLAGS
  LD_LIBRARY_PATH
  NETRC
  NIX_LD
  NIX_LD_LIBRARY_PATH
  NO_COLOR
  PIP_*
  PKG_CONFIG
  PKG_CONFIG_PATH
  PKG_CONFIG_SYSROOT_DIR
  PYTHON_GIL
  REQUESTS_CA_BUNDLE
  SSH_AGENT_PID
  SSH_AUTH_SOCK
  SSL_CERT_FILE
  TMPDIR
  VIRTUALENV_*
  http_proxy
  https_proxy
  no_proxy
disallow_pass_env = 
parallel_show_output = False
recreate = False
allowlist
…[624 chars omitted]…

env_site_packages_dir_plat = /tmp/toxrepro/.tox/py/lib/python3.12/site-packages
env_bin_dir = /tmp/toxrepro/.tox/py/bin
env_python = /tmp/toxrepro/.tox/py/bin/python
py_dot_ver = 3.12
py_impl = cpython
py_free_threaded = False
deps = # Exception: HandledError('failed to load tool.tox.env_run_base.deps: deps expected str, list[str], or list[Requirement], got list with invalid items: [0] int')
EXIT:255

from tox.config.types import MissingRequiredConfigKeyError
from tox.report import HandledError

from .api import Source

if sys.version_info >= (3, 11):  # pragma: no cover (py311+)
    import tomllib
else:  # pragma: no cover (py311+)
    import tomli as tomllib

if TYPE_CHECKING:
    from collections.abc import Iterable
    from pathlib import Path

    from tox.config.loader.api import Loader, OverrideMap
    from tox.config.sets import CoreConfigSet


class TomlSection(Section):
    SEP: str = "."
    
…[8544 chars omitted]…
one)

    def __str__(self) -> str:
        return self.key

    def __repr__(self) -> str:
        return f"{self.__class__.__name__}(prefix={self._prefix!r}, name={self._name!r})"

    def __eq__(self, other: object) -> bool:
        return isinstance(other, self.__class__) and (self._prefix, self._name) == (
            other._prefix,
            other.name,
        )


__all__ = [
    "Section",
]

src/tox/config/of_type.py:118:                    msg = f"failed to load {chain_key}: {exception}"
src/tox/config/types.py:13:    """circular chain in config"""

    def validate(val: TomlTypes, of_type: type[T]) -> T:  # noqa: C901, PLR0912
        casting_to = get_origin(of_type) or of_type.__class__
      
…[2813 chars omitted]…
/test_toml_loader.py::test_toml_loader_path_nok - t...
FAILED tests/config/loader/test_toml_loader.py::test_toml_loader_command_nok
FAILED tests/config/loader/test_toml_loader.py::test_toml_loader_env_list_nok
FAILED tests/config/loader/test_toml_loader.py::test_toml_loader_list_optional_nok
FAILED tests/config/loader/test_toml_loader.py::test_toml_loader_list_literal_nok
12 failed, 73 passed in 5.40s

PythonConstraints {} -> constraints expected str, list[str], or list[Requirement], got dict: {}
PythonConstraints [1] -> constraints expected str, list[str], or list[Requirement], got list with invalid items: [0] int
PythonConstraints [['extra-pkg']] -> constraints expected str, list[str], or list[Requirement], got list with invalid items: [0] list

279-                state = previous_setup_state(value)
280-                return state
281-
282-            with self.monkeypatch.context() as m:
283-                m.setattr(tox_env_api, "_CWD", self.path)
284-                m.setattr(tox.run, "setup_state", our_setup_state)
285-                m.setattr(sys, "
…[2203 chars omitted]…
te | None,
337-    ) -> None:
338-        extended_cmd = [sys.executable, "-m", "tox"]
339-        extended_cmd.extend(cmd)
340-        self.cmd: list[str] = extended_cmd
341-        self.cwd: Path = cwd
342-        self.code: int = code
343-        self.out: str = out
344-        self.err: str = err
345-        self._state: State | None = state
346-
347-    @property
348-    def state(self) -> State:

env_dir = /tmp/toxrepro2/.tox/py
env_tmp_dir = /tmp/toxrepro2/.tox/py/tmp
env_log_dir = /tmp/toxrepro2/.tox/py/log
suicide_timeout = 0.0
interrupt_timeout = 0.3
terminate_timeout = 0.2
platform = 
pass_env =
EXIT:254

            requires = ['tox>=4']
            """
        })
        outcome = project.run("c", "-k", "requires", "--core")
>       outcome.assert_success()

tests/config/source/test_toml_pyproject.py:395: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
…[1802 chars omitted]…
\nstandard error\nERROR: Could not find a version that satisfies the requirement tox (from versions: none)\nERROR: No matching distribution found for tox\n.success

src/tox/pytest.py:362: AssertionError
=========================== short test summary info ============================
FAILED tests/config/source/test_toml_pyproject.py::test_config_requires - Ass...
1 failed, 170 passed in 7.37s

         if not isinstance(value, list):
             msg = f"env_list must be a list, got {type(value).__name__}"
-            raise TypeError(msg)
+            raise HandledError(msg)
         envs: list[str] = []
         for item in value:
             if isinstance(item, str):
@@ -135,7 +1
…[5932 chars omitted]…
       and (all(isinstance(i, str) for i in raw) or all(isinstance(i, Requirement) for i in raw))
-            )
+            or (isinstance(raw, list) and all(isinstance(i, (str, Requirement)) for i in raw))
         ):
-            raise TypeError(raw)
+            raise TypeError(_factory_type_error("constraints", raw))
         return cls(cast("str | list[str] | list[Requirement]", raw), root)

71:def eval_set_env(tox_project: ToxProjectCreator) -> EvalSetEnv:
80:        result = prj.run("c", "-k", "set_env", "-e", "py", from_cwd=None if from_cwd is None else prj.path / from_cwd)
82:        set_env: SetEnv = result.env_conf("py")["set_env"]
83:        ret
…[4652 chars omitted]…
   set_env = result.env_conf("check")["set_env"]
297:    content = {k: set_env.load(k) for k in set_env}
317:            f"[testenv]\npackage=skip\nset_env=CONDITIONAL=value; sys_platform == '{sys.platform}'",
324:            "[testenv]\npackage=skip\nset_env=CONDITIONAL=value; sys_platform == 'nonexistent'",
331:            f'[env_run_base]\npackage="skip"\nset_env.CONDITIONAL = {{ value = "value", '

    exp = "MagicConfigSet(loaders=[IniLoader(section=magic, overrides={}), IniLoader(section=A, overrides={})])"
    assert repr(conf) == exp

    assert isinstance(result.state.conf._options, Parsed)  # noqa: SLF001


def test_do_not_allow_create_config_set(mocker: MockerFixture) -> None:
    with pytest.raises(TypeError, match="Can't instantia
…[1621 chars omitted]…
= "{env_site_packages_dir}{/}mypackage"
435:    outcome = project.run("c", "-e", "py", "-k", "set_env")
607:def test_config_in_toml_replace_if_set_env(tox_project: ToxProjectCreator, monkeypatch: pytest.MonkeyPatch) -> None:
612:        set_env.MATURITY = { replace = "if", condition = "env.TAG_NAME", then = "production", else = "testing" }
615:    outcome = project.run("c", "-e", "A", "-k", "set_env")

self = ConfigDynamicDefinition(keys=['set_env', 'setenv'], desc=environment variables to set when running commands in the tox... object at 0x753a1fa5fc80>, factory=<function EnvConfigSet.register_config.<locals>.set_env_factory at 0x753a1fb989a0>)
conf = <MagicMock spec='Config' id='128
…[1427 chars omitted]…
hort test summary info ============================
FAILED tests/config/test_sets.py::test_config_bad_type - tox.report.HandledEr...
FAILED tests/config/test_sets.py::test_config_bad_dict - tox.report.HandledEr...
FAILED tests/config/test_sets.py::test_config_bad_bool - tox.report.HandledEr...
FAILED tests/config/test_sets.py::test_set_env_raises_on_non_str - tox.report...
4 failed, 16 passed in 1.68s

86-    config_set.add_config(keys="bad_dict", of_type=dict[str, str], default={}, desc="bad_dict")
87-    with pytest.raises(TypeError) as context:
88-        assert config_set["bad_dict"]
89-    assert str(context.value) == "dictionary lines must be of form key=value, fo
…[752 chars omitted]…
nt(conf_builder: ConfBuilder) -> None:
109-    config_set = conf_builder("")
110-    config_set.add_constant(keys="b", value=lambda: 2, desc="ok")
111-    lazy_const = config_set["b"]
112-    assert lazy_const == 2
113-
114-
115-def test_config_constant_repr(conf_builder: ConfBuilder) -> None:
116-    config_set = conf_builder("")
117-    defined = config_set.add_constant(keys="a", value=1, desc="ok")

                fail = not isinstance(val, of_type)
            else:
                try:  # check if it can be converted
                    of_type(val)
                    fail = False
                except Exception:  # noqa: BLE001
                    fail = True
            if fail:
                msg = f"{val!r} is not of type {of_typ
…[867 chars omitted]…
/test_toml_loader.py::test_toml_loader_path_nok - t...
FAILED tests/config/loader/test_toml_loader.py::test_toml_loader_command_nok
FAILED tests/config/loader/test_toml_loader.py::test_toml_loader_env_list_nok
FAILED tests/config/loader/test_toml_loader.py::test_toml_loader_list_optional_nok
FAILED tests/config/loader/test_toml_loader.py::test_toml_loader_list_literal_nok
12 failed, 32 passed in 3.02s

EXIT:0

EXIT:255
py: skipped because could not find python interpreter with spec(s): /usr/local/bin/python
  py: SKIP (0.00 seconds)
  evaluation failed :( (0.08 seconds)
EXIT:1

    def teardown(self) -> None:
        if not self._run_state["teardown"]:
            try:
                self._teardown()
            finally:
                from tox.plugin.manager import MANAGER  # noqa: PLC0415

                MANAGER.tox_env_teardown(self)
                self._run_state["teardown"] = True

    def _teardown(self) -> None:  # noqa: B027 # empty abstract base class
  
…[3277 chars omitted]…
   try:
            return self.creator
        except RuntimeError as exc:
            raise Skip(str(exc)) from exc

    @property
    def runs_on_platform(self) -> str:
        return sys.platform

    @property
    def environment_variables(self) -> dict[str, str]:
        environment_variables = super().environment_variables
        environment_variables["VIRTUAL_ENV"] = str(self.conf["env_dir"])

from virtualenv import __version__ as virtualenv_version
from virtualenv import app_data, session_via_cli
from virtualenv.discovery.py_spec import PythonSpec

from tox.config.loader.str_convert import StrConvert
from tox.execute.local_sub_process import LocalSubProcessExecutor
from tox.tox_env.errors import Skip
from tox.tox_env.python.api import Python, PythonInfo, VersionInfo
from tox.tox_env.python.pip.pip_install import Pip
from tox.tox_env.python.virtual_env.subprocess_adapter import SubprocessCreator, SubprocessSession

if TYPE_CHECKING:
    from virtuale
…[1346 chars omitted]…
         self.environment_variables.get(
                    "VIRTUALENV_COPIES",
                    self.environment_variables.get("VIRTUALENV_ALWAYS_COPY", "False"),
                ),
143:            raise RuntimeError(msg) from exc
170:        except (FileNotFoundError, RuntimeError):  # Unable to find the interpreter
215:        except RuntimeError as exc:
263:            raise RuntimeError(msg)

            raise RuntimeError(msg) from exc

    def virtualenv_env_vars(self) -> dict[str, str]:
        env = self.environment_variables.copy()
        base_python: list[str] = self.conf["b
…[1755 chars omitted]…
.py_info import PythonInfo as VirtualenvPythonInfo  # noqa: PLC0415

        result = cached_py_info.from_exe(
            VirtualenvPythonInfo,
            app_data.make_app_data(None, read_only=False, env=os.environ),
            str(path),
        )
        if result is None:
            msg = f"could not query python information for {path}"
            raise RuntimeError(msg)
        return result

     ) -> _T:
         delay_replace = inspect.isclass(of_type) and issubclass(of_type, SetEnv)
         unroll = Unroll(conf=conf, loader=self, args=args)
-        exploded = unroll(raw, skip_str=True) if delay_replace else u
…[3103 chars omitted]…
find the interpreter
             return None
         if (sys_exe := interpreter.system_executable) is None:
@@ -212,6 +215,8 @@ class VirtualEnv(Python, ABC):
     def _creator_with_skip(self) -> Creator | SubprocessCreator:
         try:
             return self.creator
+        except HandledError:
+            raise
         except RuntimeError as exc:
             raise Skip(str(exc)) from exc

        outcome = project.run("c", "-k", "requires", "--core")
>       outcome.assert_success()

tests/config/source/test_toml_pyproject.py:395: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = code: 1
cmd: /usr/local/bin/python -m tox c -k requires --core
cwd: /tmp/pytest-of-root/pytest-4/test_config_requires0... a version that satisfies the requirement tox (from versions: none)
ERROR: No matching distribution found for
…[2529 chars omitted]…
t_toml_loader_command_nok
FAILED tests/config/loader/test_toml_loader.py::test_toml_loader_env_list_nok
FAILED tests/config/loader/test_toml_loader.py::test_toml_loader_list_optional_nok
FAILED tests/config/loader/test_toml_loader.py::test_toml_loader_list_literal_nok
FAILED tests/config/source/test_toml_pyproject.py::test_config_requires - Ass...
13 failed, 6459 passed, 2 skipped in 139.38s (0:02:19)

        ignore_outcome = tox_env.conf["ignore_outcome"]
        fail_fast = tox_env.conf["fail_fast"]
    except HandledError as exception:
        LOGGER.error("%s", exception)  # noqa: TRY400
        return ToxEnvRunResult(name, False, 2, [], time.monotonic() - start_one)
    return ToxEnvRunResult(name, skipped, code, outcomes, duration, ignore_outcome, fail_fast)


def _evaluate(tox_env: RunToxEnv, no_test: bool) -> tuple[bool, int, list[Outcome]]:  # noqa: FBT001
    skipped = False
    code: int = 0
    outcomes: list[Outcome] = []
    try:
        try:

    return cast("V", self.to_bool(raw))
                     ^^^^^^^^^^^^^^^^^
  File "/repo/src/tox/config/loader/toml/__init__.py", line 99, in
…[346 chars omitted]…
"/repo/src/tox/session/cmd/run/common.py", line 319, in _queue_and_wait
    fail_fast_enabled = options.parsed.fail_fast or any(
                                                    ^^^^
  File "/repo/src/tox/session/cmd/run/common.py", line 320, in <genexpr>
    cast("RunToxEnv", state.envs[env]).conf["fail_fast"] for env in to_run_list
    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^
EXIT:120