tox-dev-tox-3825-3838

-rw-r--r-- 1 root root 1059 Nov  6 08:43 SECURITY.md
drwxr-xr-x 1 root root 4096 Nov  6 08:43 docs
-rw-r--r-- 1 root root   14 Nov  6 08:43 ignore-words.txt
-rw-r--r-- 1 root root 7908 Nov  6 08:43 pyproject.toml
drwxr-xr-x 1 root root 4096 Nov  6 08:43 src
drwxr-xr-x 1 root root 4096 Nov  6 08:43 tasks
drwxr-xr-x
…[176 chars omitted]…

./.git/refs
./.github
./.github/ISSUE_TEMPLATE
./.github/workflows
./docs
./docs/changelog
./docs/how-to
./docs/man
./docs/plugin
./docs/reference
./docs/tutorial
./docs/_static
./src
./src/tox
./tasks
./tests
./tests/config
./tests/demo_pkg_inline
./tests/demo_pkg_setuptools
./tests/execute
./tests/journal
./tests/plugin
./tests/pytest_
./tests/session
./tests/tox_env
./tests/type_check
./tests/util

src/tox/config/loader/replacer.py
src/tox/config/loader/section.py
src/tox/config/loader/str_convert.py
src/tox/config/loader/stringify.py
src/tox/config/main.py
src/tox/config/of_type.py
src/tox/config/set_env.py
src/tox/config/sets.py
src/tox/config/source/__init__.py
src/tox/config/source/api.py
src/tox/config/source/discover.py
src/tox/config/source/ini.py
src/tox/config/source/ini_section.py
src/tox/config/source/legacy_toml.py
src/tox/config/source/setup_cfg.py
src/tox/config/source/toml_pyproject.py
src/tox/config/source/toml_tox.py
src/tox/conf
…[1510 chars omitted]…
rc/tox/tox_env/python/runner.py
src/tox/tox_env/register.py
src/tox/tox_env/runner.py
src/tox/tox_env/util.py
src/tox/util/__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/version.py
---
__init__.py
cli
conftest.py
loader
source
test_main.py
test_of_types.py
test_set_env.py
test_sets.py
test_types.py

    """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
…[1379 chars omitted]…
, other: object) -> bool:
        if not isinstance(other, EnvList):
            return False
        return self.envs == other.envs

    def __ne__(self, other: object) -> bool:
        return not (self == other)

    def __iter__(self) -> Iterator[str]:
        """:returns: iterator that goes through the defined env-list"""
        return iter(self.envs)


__all__ = (
    "Command",
    "EnvList",
)

src/tox/config/loader/ini/factor.py
src/tox/config/loader/ini/replace.py
src/tox/config/loader/memory.py
src/tox/config/loader/replacer.py
src/tox/config/loader/section.py
src/tox/config/loader/str_convert.py
src/tox/config/loader/stringify.py
src/tox/config/loader/toml/__init__.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/main.py
src/tox/config/of_type.py
src/tox/config/set_env.py
src/tox/config/sets.py
src/tox/config/sou
…[2563 chars omitted]…
c/tox/tox_env/python/virtual_env/package/util.py
src/tox/tox_env/python/virtual_env/runner.py
src/tox/tox_env/python/virtual_env/subprocess_adapter.py
src/tox/tox_env/register.py
src/tox/tox_env/runner.py
src/tox/tox_env/util.py
src/tox/util/__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/version.py

_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
…[5212 chars omitted]…
urns: command representation of the value

        """
        raise NotImplementedError

    @staticmethod
    @abstractmethod
    def to_env_list(value: T) -> EnvList:
        """Convert to a tox EnvList.

        :param value: the value to convert

        :returns: a list of tox environments from the value

        """
        raise NotImplementedError


__all__ = [
    "Convert",
    "Factory",
]

    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
   
…[8628 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."""

 !c: c
tests/session/cmd/test_parallel.py:137:    depends=py
tests/session/cmd/test_sequential.py:683:        depends = ["env1"]
tests/session/cmd/test_sequential.py:686:        depends = ["env2"]
tests/session/cmd/test_sequential.py:689:        depends = ["env3"]
tests/tox_env/python/virtual_env/package/test_package_pyproject.py:603:    assert build_env  # has a value (name depends on Python version)

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
…[3143 chars omitted]…
h="1 is not union of str, NoneType"):
        perform_load(["a", None, 1], list[str | None])


def test_toml_loader_list_literal_ok() -> None:
    assert perform_load(["a", "b"], list[Literal["a", "b"]]) == ["a", "b"]


def test_toml_loader_list_literal_nok() -> None:
    with pytest.raises(TypeError, match="'c' is not one of literal 'a','b'"):
        perform_load(["a", "c"], list[Literal["a", "b"]])

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)*(?<!\\)#.*")


class IniLoader(StrConvert, Loader[str]):
    """Load configuration from an ini section 
…[2881 chars omitted]…
str]:
        return set(self._section_proxy.keys())

    def get_section(self, name: str) -> SectionProxy | None:
        # needed for non tox environment replacements
        if self._parser.has_section(name):
            return self._parser[name]
        return None

    def __repr__(self) -> str:
        return f"{self.__class__.__name__}(section={self._section.key}, overrides={self.overrides!r})"

from tox.config.types import Command, EnvList

if TYPE_CHECKING:
    from collections.abc import Iterator
    from io import StringIO
    from typing import Final


class StrConvert(Convert[str]):
    """A class converting string values to tox types."""

    @staticmethod
    def to_str(value: str) -> str:
        return str(value).strip()

    @staticmethod
    def to_path(value: str) -> Path:
        return Path(value)

    @staticmethod
    def to_list(value: str, of_type: type[Any]) -> Iterator[str]:
        splitter = "\n" if (isclass(of_type) and issubclass(of_type, Comman
…[8629 chars omitted]…
h(pattern).is_absolute():
        pattern = str(conf.core["tox_root"] / pattern)
    if matches := sorted(glob.glob(pattern, recursive=True)):  # noqa: PTH207
        return " ".join(matches)
    return ARG_DELIMITER.join(default_args) if default_args else ""


__all__ = [
    "MatchExpression",
    "MatchRecursionError",
    "find_replace_expr",
    "load_posargs",
    "replace",
    "replace_env",
]

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
…[6661 chars omitted]…
lue = os.pathsep
        elif of_type == "env":
            replace_value = replace_env(self.conf, args, conf_args)
        elif of_type == "tty":
            replace_value = replace_tty(args)
        elif of_type == "posargs":
            replace_value = replace_pos_args(self.conf, args, conf_args)
        elif of_type == "glob":
            replace_value = replace_glob(self.conf, args)
        else:

    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 "\n".join(str(i) for i in raw)
        self._raw = self._normalize_raw(got)
        self._unroll: tuple[list[str], list[str]] | None = None
        self
…[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",
)

tests/config/test_main.py:171:        factory=partial(PythonDeps.factory, tmp_path),
tests/config/test_main.py:188:        factory=partial(PythonDeps.factory, tmp_path),
tests/config/test_main.py:203:        factory=partial(PythonDeps.factory, tmp_path),

…[4128 chars omitted]…
ession/test_env_completer.py:57:    mocker.patch("tox.session.env_select.discover_source", side_effect=HandledError("bad config"))
tests/session/test_env_select.py:395:        "ROOT: HandledError| provided environments not found in configuration file:\n"
tests/test_run.py:7:from tox.report import HandledError
tests/test_run.py:18:@pytest.mark.parametrize("exception", [HandledError, KeyboardInterrupt])

    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]…
 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",
)

    """Configuration sourced from a pyproject.toml files."""

    FILENAME = "tox.toml"
    _Section = TomlToxSection


__all__ = [
    "TomlTox",
]
=====PYPROJECT=====
"""Load from a pyproject.toml file, native format."""

from __future__ import annotations

import sys
from collections.abc import Iterator, Mapping
from itertools import product
from typing import TYPE_CHECKING, Any, Final, cast

from tox.config.loader.section import Section
from tox.config.loader.toml import TomlLoader
from tox.config.loader.toml._product import expand_factor_group
from tox.config.types import MissingRequiredConfigKeyError
from tox.report import HandledError

from .api import Source

if sys.vers
…[6783 chars omitted]…
aw and isinstance(factors_raw[0], list | dict):
            expanded = [expand_factor_group(g) for g in factors_raw]
            names = ["-".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",
]

    "__version__",
    "__version_tuple__",
    "version",
    "version_tuple",
    "__commit_id__",
    "commit_id",
]

version: str
__version__: str
__version_tuple__: tuple[int | str, ...]
version_tuple: tuple[int | str, ...]
commit_id: str | None
__commit_id__: str | None

__version__ = version = '0.1.dev1+g179c682f7'
__version_tuple__ = version_tuple = (0, 1, 'dev1', 'g179c682f7')

__commit_id__ = commit_id = None

 .github/ISSUE_TEMPLATE/config.yml                  |   10 +
 .github/ISSUE_TEMPLATE/feature-request.md          |   26 +
 .github/PULL_REQUEST_TEMPLATE.md                   |   10 +
 .github/config.yml                                 |    3 +
 .github/dependabot.yml                             |    6 +
 .github/release.yml                                |    5 +
 .github/workflows/check.yaml                       |  118 +
 .github/workflows/prep
…[1619 chars omitted]…
  |  954 +++++++
 docs/plugin/api.rst                                |  155 ++
 docs/plugin/getting_started.rst                    |   83 +
 docs/plugin/howto.rst                              |  353 +++
 docs/plugin/index.rst                              |   56 +
 docs/reference/cli.rst                             |   55 +
 docs/reference/config.rst                          | 2892 ++++++++++++++++++++

            if pkg_out_err is not None:  # pragma: no branch
                pkg_out_err_list.append(pkg_out_err)
        if not success or tox_env.conf["parallel_show_output"] or state.conf.options.list_dependencies:
            for pkg_out_err in pkg_out_err_list:
                state._option
…[5267 chars omitted]…
d/run/common.py:410:        for package_env in tox_env.package_envs:
src/tox/session/cmd/run/common.py:421:def ready_to_run_envs(state: State, to_run: list[str], completed: set[str]) -> Iterator[list[str]]:
src/tox/session/cmd/run/common.py:440:        run_env = cast("RunToxEnv", state.envs[env])
src/tox/session/cmd/run/common.py:441:        depends = set(cast("EnvList", run_env.conf["depends"]).envs)

LATEST_PYTHON_MINOR_MIN: int = 10
LATEST_PYTHON_MINOR_MAX: int = 14


def filter_for_env(value: str, name: str | None) -> str:
    current = (
        set(chain.from_iterable([(i for i, _ in a) for a in find_factor_groups(name)])) if name is not None else set()
    )
    current.add(sys.platform)
    parts = sysconfig.get_platform().rsplit("-", 1)
    if len(parts) > 1:
        current.add(parts[-1])
    overall: list[str] = []
    active_continuation = False
    pending_skip = False
    for factors, content in expand_factors(value):
        if factors is None:
            if pending_skip and not active_continuati
…[5440 chars omitted]…
 default=[],
            desc="the commands to be called for testing",
        )
        self.conf.add_config(
            keys=["commands_post"],
            of_type=list[Command],
            default=[],
            desc="the commands to be called after testing",
        )
        self.conf.add_config(
            keys=["recreate_commands"],
            of_type=list[Command],
            default=[],

Features - 4.46.0
=================

- Add architecture (ISA) awareness to Python discovery. tox now propagates the ``machine`` field (e.g. ``arm64``,
  ``x86_64``) from :pypi:`virtualenv`'s interpreter info — derived from :func:`python:sysconfig.get_platform` — through
  the Python specification, validation, and journal. This allows selecting a Python interpreter by CPU architecture via
  :ref:`base_python` (e.g. ``cpython3.12-64-arm64``) and ensures tox validates the running interpreter's architecture
  matches the requested one. Requires ``virtualenv >= 20.39`` - by :user:`rahuldevikar`. (:issue:`3069`)
- Add ``env_base`` TOML sections for named environment templates that generate multiple environm
…[3369 chars omitted]…
environment variables after ``pass_env`` glob
2153:- Fix list/depends commands can create tox package environment as runtime environment and display an error message - by
2277:  ``--install-option`` and ``--global-option`` flags) - by :user:`gaborbernat`. (:issue:`1929`)
2496:  - updated ``depends`` to use the packaging logic,
2497:  - add support skip missing interpreters for depends and show config,

Documentation - 4.36.1
======================

- Add Unix man page generation and installation support using sphinx-argparse-cli - by :user:`gaborbernat`.
  (:issue:`1409`)
- Document use of Python :mod:`logging` for plugin authors in the how-to guides, covering verbosity levels, coloring,
  and best practices — by :user:`rahuldevikar`. (:issue:`3449`)
- Add architecture documentation for new contributors under the development section - by :user:`rahuldevikar`
  (:issue:`3707`)

**********************
 v4.36.0 (2026-02-
…[2626 chars omitted]…
388`)
131:  shown with status "NOT AVAILABLE". If such an environment is explicitly requested with ``-e``, a clear error message
394:- Validate that configured extras exist in package metadata, raising a clear error for unknown extras - by
690:- Fix ``TypeError`` for ``HelpFormatter`` with Python 3.14 (:issue:`3523`)
2292:- Fix regex validation for SHA 512 hashes - by :user:`jugmac00`. (:issue:`2018`)

/usr/local/lib/python3.12/lib2to3/fixer_base.py
/usr/local/lib/python3.12/lib2to3/pgen2/token.py
/usr/local/lib/python3.12/lib2to3/pgen2/grammar.py
/usr/local/lib/python3.12/lib2to3/pgen2/tokenize.py
/usr/local/lib/python3.12/lib2to3/pgen2/driver.py
/usr/local/lib/python3.12/lib2to3/pgen2/conv.py
/usr/local/lib/python3.12/lib2to3/pgen2/parse.py
/usr/local/lib/python3.12/lib2to3/pgen2/__init__.py
/usr/local/lib/pytho
…[4080 chars omitted]…
sr/local/lib/python3.12/importlib/metadata/_text.py
/usr/local/lib/python3.12/importlib/metadata/_adapters.py
total 24
drwx------ 1 root root 4096 Nov  6 08:44 .
drwxr-xr-x 1 root root 4096 Nov  6 08:44 ..
-rw-r--r-- 1 root root  607 Jul  4 09:05 .bashrc
drwxr-xr-x 3 root root 4096 Nov  6 08:44 .cache
-rw-r--r-- 1 root root  132 Jul  4 09:05 .profile
-rw-r--r-- 1 root root  169 Aug  5 01:04 .wget-hsts

translationstring     1.4
trove-classifiers     2026.9.21.13
typing_extensions     4.16.0
tzdata                2026.6
urllib3               2.8.0
vcs-versioning        2.6.0
venusian              3.1.1
virtualenv            21.15.5
waitress              3.0.2
WebOb                 1.8.11
wheel                 0.48.0
zope.deprecation      6.0
zope.interface        8.7

    order, todo = run_order(state, to_run_list)
                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/tox/session/cmd/run/common.py", line 441, in run_order
    depends = set(cast("EnvList", run_env.conf["depends"]).envs)
                                  ~~~~~~~~~~~~^^^^^^^^^^^
  File "/repo/src/tox/config/sets.py", line 150, in __getitem__
    r
…[1485 chars omitted]…
or group in find_factor_groups(value):
                 ^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/tox/config/loader/ini/factor.py", line 87, in find_factor_groups
    for env in expand_env_with_negation(value):
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/tox/config/loader/ini/factor.py", line 105, in expand_env_with_negation
    raise ValueError(variant_str)
ValueError: 3.*
rc:1

  SSL_CERT_FILE
  TMPDIR
  VIRTUALENV_*
  http_proxy
  https_proxy
  no_proxy
disallow_pass_env = 
parallel_show_output = False
recreate = False
allowlist_externals = 
list_dependencies_command = python -m pip freeze --all
pip_pre = False
install_command = python -I -m pip install '{packages}'
constraints = -c /tmp/repro2/tox.ini
constrain_package_deps = False
use_frozen_constraints = False
commands_pre = 
commands = 
commands_post = 
recreate_commands = 
change_dir = /tmp/repro2
args_are_paths = True
ignore_errors = False
commands_retry = 0
ignore_outcome = False
fail_fast = False
default_base_python = /usr/local/bin/python
base_python = /usr/local/bin/python
env_site_packages_dir = /tmp/repro2/.tox/py/lib/
…[1996 chars omitted]…
ld
    result = self.to(exploded, of_type, factory)
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  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 137, in factory
    raise TypeError(raw)
TypeError: [1]
  py: FAIL code 2 (0.28 seconds)
  evaluation failed :( (0.38 seconds)
rc:2

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
…[8517 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",
)

drwxr-xr-x 3 root root  4096 Nov  6 08:56 repro2
/tmp/repro2/tox.toml
/tmp/repro2/.tox
/tmp/repro1/tox.ini

            type=str,
            nargs="+",
            action="append",
        )
    help_msg = "exclude all environments selected that match this regular expression"
    add_to.add_argument("--skip-env", dest="skip_env", metavar="re", help=help_msg, default="", type=str)
    return add_to


def _env_completer(
    prefix: str,  # noqa: ARG001
    action: Action,  # noqa: ARG001
    parser: ArgumentParser,  # noq
…[8087 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",
]

            "LDFLAGS",  # linker flags
            "HOME",  # needed for `os.path.expanduser()` on non-Windows systems
            "FORCE_COLOR",  # force color output
            "NO_COLOR",  # disable color output
            "NETRC",  # used by pip and netrc modules
            "PYTHON_GIL",  # allows controlling 
…[5365 chars omitted]…
(msg)
src/tox/session/env_select.py:471:                    raise HandledError(msg)  # pragma: no cover
src/tox/session/env_select.py:564:            raise HandledError(msg)

grep: src/tox/tox_env/python/runner.py:15:from tox.report import HandledError
src/tox/tox_env/python/runner.py:124:            raise HandledError(msg)
src/tox/tox_env/python/__pycache__/runner.cpython-312.pyc: binary file matches

        return result

    @contextmanager
    def chdir(self, to: Path | None = None) -> Iterator[None]:
        cur_dir = Path.cwd()
        os.chdir(to or self.path)
        try:
            yield
        finally:
            os.chdir(cur_dir)

  
…[5572 chars omitted]…
tox_project")
def init_fixture(
    tmp_path: Path,
    capfd: CaptureFixture,
    monkeypatch: pytest.MonkeyPatch,
    mocker: MockerFixture,
) -> ToxProjectCreator:
    def _init(files: dict[str, Any], base: Path | None = None, prj_path: Path | None = None) -> ToxProject:
        """Create tox projects."""
        return ToxProject(files, base, prj_path or tmp_path / "p", capfd, monkeypatch, mocker)

tests/session/cmd/test_show_config.py:258:    outcome = tox_project({"tox.ini": ""}).run("c", "-e", "py", "-k", "setenv")
tests/session/cmd/test_show_config.py:265:    outcome = tox_project({"tox.ini": tox_ini}).run("c", "-e", "py", "-k", "description")

        """,
        },
    )
    outcome = project.run("c", "-e", "a", "-k", "env_site_packages_dir", raise_on_config_fail=False)
    outcome.assert_failed(code=-1)
    txt = (
        "\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 
…[5085 chars omitted]…
ng_expected_oserror_msg = (
        "[WinError 2] The system cannot find the file specified"
        if sys.platform == "win32"
        else "[Errno 2] No such file or directory: 'sentinel-cmd'"
    )
    expected_cmd_lookup_error_txt = (
        f"sentinel-env-name: Exception running subprocess {underlying_expected_oserror_msg!s}\n"
    )
    assert expected_cmd_lookup_error_txt in tox_run_result.out

tests/config/test_sets.py:186:    with pytest.raises(TypeError, match="1"):
tests/session/cmd/test_parallel.py:4:from argparse import ArgumentTypeError
tests/session/cmd/test_parallel.py:42:    with pytest.raises(ArgumentTypeError, match="value must be a positive number"):
tests/session/cmd/test_parallel.py:47:    with pytest.raises(ArgumentTypeError, match="value must be positive"):

    [testenv]
    package = skip
    [testenv:section]
    [other:section]
    """
    project = tox_project({"tox.ini": ini})
    result = project.run()
    result.assert_success()
    assert "ROOT: Sections: tox, testenv, testenv:section, other:section" in result.out


def test_plugin_injects_invalid_python_run(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
    @impl
    def 
…[7109 chars omitted]…
figLoadArgs([], "name", None)
    with pytest.raises(exception, match=msg):
        loader.load("a", of_type=of_type, conf=None, factory=None, args=args)


def test_memory_found_keys() -> None:
    loader = MemoryLoader(a=1, c=2)
    assert loader.found_keys() == {"a", "c"}


def test_memory_loader_contains() -> None:
    loader = MemoryLoader(a=1)
    assert "a" in loader
    assert "b" not in loader

    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
…[2886 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",
]

    return self.load(item)
           ^^^^^^^^^^^^^^^
  File "/repo/src/tox/config/sets.py", line 162, in load
    return config_definition.__call__(self._conf, self.loaders, ConfigLoadArgs(chain, self.name, self.env_name))  # noqa: PLC2801
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
…[537 chars omitted]…
ne 197, in build
    return self.to(raw, of_type, factory)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  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 137, in factory
    raise TypeError(raw)
TypeError: [1]
  py: FAIL code 2 (0.12 seconds)
  evaluation failed :( (0.31 seconds)
rc:2

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,
…[932 chars omitted]…
n>", line 2, in <module>
  File "/repo/src/tox/config/source/toml_pyproject.py", line 41, in test_env
    return cls(cls.env_prefix(), name)
               ^^^^^^^^^^^^^^^^
  File "/repo/src/tox/config/source/toml_pyproject.py", line 45, in env_prefix
    return cls.SEP.join((*cls.PREFIX, cls.ENV))
                          ^^^^^^^^^^
AttributeError: type object 'TomlSection' has no attribute 'PREFIX'

tests/session/test_env_select.py:391:    outcome.assert_failed(code=-2)
tests/test_provision.py:222:    result.assert_failed(-2)
tests/test_run.py:23:    assert system_exit.value.code == -2

    to_run_list: list[str],
    results: list[ToxEnvRunResult],
    future_to_env: dict[Future[ToxEnvRunResult], ToxEnv],
    interrupt: Event,
    done: Event,
    max_workers: int | None,
    spinner: ToxSpinner,
    live: bool,  # noqa: FBT001
) -> None:
    try:  # noqa: PLR1702
        options = state._options  # noqa: SLF001
        with spinner:
            max_workers = len(to_run_list) if max_workers is None else max_workers
           
…[7895 chars omitted]…
"
    option = state.conf.options
    if option.no_capture:
        msg = "--no-capture cannot be used with parallel mode"
        raise SystemExit(msg)
    return execute(
        state,
        max_workers=auto_detect_cpus() if option.parallel == 0 else option.parallel,
        has_spinner=option.parallel_no_spinner is False and option.parallel_live is False,
        live=option.parallel_live,
    )

tests/config/source/test_toml_pyproject.py:469:    out = "[testenv:pkg]\ndeps =\n  build\n  wheel\n  setuptools>=40\n"
tests/config/source/test_toml_pyproject.py:477:        env_list = ["a", "b"]
tests/config/source/test_toml_pyproject.py:648:            id="invalid_syntax",
tests/config/source/test_toml_pyproject.py:669:    with pytest.raises(MatchError, match=error_match):

        [tool.tox]
        env = [1]
        """
    })
    outcome = project.run("l")
    outcome.assert_failed()
    outcome.assert_out_err("ROOT: HandledError| Environment key must be string, got 1\n", "")


def test_config_in_toml_bad_type_env(tox_project: ToxProjectCreator) -> None:
    project = tox_project({
        "pyproject.toml": """
        [tool.tox]
        env = {a = 1}
        """
    })
    outcome = project.run("l")
    outcome.assert_failed()
    outcome.assert_out_err("ROOT: HandledError| tool.tox.env.a
…[4564 chars omitted]…
or_match):
        project.run("c", "-e", "A", "-k", "description")


def test_config_in_toml_replace_if_factor_positive(tox_project: ToxProjectCreator) -> None:

    project = tox_project({
        "pyproject.toml": dedent("""
        [tool.tox.env."3.13-django50"]
        description = { replace = "if", condition = "factor.django50", then = "has django50", else = "no django50" }
        """),
    })

tests/config/source/test_toml_tox.py:19:    commands = [
tests/config/source/test_toml_tox.py:37:    commands = [
tests/config/source/test_toml_tox.py:54:    commands = [

      4 Path | None,
      3 of_type)
      3 float,
      2 of_type, **kwargs)
      2 list[Requirement],
      2 PythonDeps,
      2 Command,
      1 str, default=self.default_pkg_type, desc=desc)
      1 str, default=self._state.conf.options.default_runner)
      1 of_type, factory=None)
      1 of_type, conf=None, factory=None, args=args)
      1 int,
      1 int | None,
      1 entry_type, factory=None) for v in value.split(";")]
      1 dict[str, str],
      1 Version,
      1 SetEnv,
      1 PythonConstraints,
      1 EnvList, default=EnvList([]), desc=desc)
      1 EnvList,
      1 EnvConfigSet,

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
…[7839 chars omitted]…
v, *, override: bool = True) -> None:
        for key in param:
            # do not override something already set explicitly
            if override or (key not in self._raw and key not in self._materialized):
                value = param.load(key) if isinstance(param, SetEnv) else param[key]
                self._materialized[key] = value
                self.changed = True


__all__ = ("SetEnv",)

-_FACTOR_RE = re.compile(r"(?:!?[\w._][\w._-]*|^$)")
+_FACTOR_RE = re.compile(r"(?:!?[\w._*?][\w._*?-]*|^$)")
 
 
 def expand_env_with_negation(value: str) -> Iterator[str]:
diff --git a/src/tox/config/loader/toml/__init__.py b/src/tox/config/loader/toml/__init__.py
index dac45ac..bc31cfe 100644
--- a/src/tox/config/loader/toml/__init__.py
+++ b/src/tox/config/loader/toml/__init
…[1327 chars omitted]…
.config.types import Command
+from tox.report import HandledError
 
 if TYPE_CHECKING:
     from ._api import TomlTypes
@@ -71,7 +72,7 @@ def validate(val: TomlTypes, of_type: type[T]) -> T:  # noqa: C901, PLR0912
         if fail:
             msg = f"{val!r} is not of type {of_type.__name__!r}"
     if msg:
-        raise TypeError(msg)
+        raise HandledError(msg)
     return cast("T", val)

+        return f"{field} expected {expected}, got list with invalid items: {', '.join(invalid)}"
+    return f"{field} expected {expected}, got {type(raw).__name__}: {raw!r}"
+
+
 class PythonDeps(RequirementsFile):
     # these options are valid in requirements.txt, but not via pip cli and
     # thus cannot be used in the testenv `deps`
…[683 chars omitted]…
e(raw, list)
-                and (all(isinstance(i, str) for i in raw) or all(isinstance(i, Requirement) for i in raw))
+                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)

@@ -113,6 +114,14 @@ class ConfigDynamicDefinition(ConfigDefinition[T]):  # noqa: PLW1641
                     value = loader.load(primary_key, self.of_type, self.factory, conf, args, all_keys=alias_keys)
                 except KeyError:
                     continue
+                except (HandledError, TypeError) as exception:
+                    from tox.config.loader.toml import TomlLoader  # noqa: PLC0415
+
+                    if n
…[929 chars omitted]…
     except Fail as exception:
             LOGGER.error("failed with %s", exception)  # noqa: TRY400
             code = 1
+        except HandledError as exception:
+            LOGGER.error("%s", exception)  # noqa: TRY400
+            code = 1
         except Exception:  # pragma: no cover
             LOGGER.exception("internal error")  # pragma: no cover
             code = 2  # pragma: no cover

                try:
                    validate(val, arg)
                    break
                except TypeError:
                    pass
            else:
                msg = f"{val!r} is not union of {', '.join(a.__name__ for a in args)}"
        elif casting_to in {Literal, type(Literal)}:
            choice = type_args
            if val not in choice:
      
…[4766 chars omitted]…
_toml_loader.py::test_toml_loader_env_list_nok
FAILED tests/config/loader/test_toml_loader.py::test_toml_loader_list_optional_ok
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/plugin/test_plugin.py::test_plugin_injects_invalid_python_run - ...
14 failed, 95 passed in 5.81s

                    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
            validate(val, list[str])
        elif casting_to in {dict, dict}:
            key_type, value_type = type_args[0], type_args[1]
            if isinstance(va
…[1291 chars omitted]…
not of type {of_type.__name__!r}"
        if msg:
>           raise HandledError(msg)
E           tox.report.HandledError: 1 is not union of str, NoneType

src/tox/config/loader/toml/_validate.py:75: HandledError
=========================== short test summary info ============================
FAILED tests/config/loader/test_toml_loader.py::test_toml_loader_list_optional_nok
1 failed, 1 passed in 1.07s

ERROR tests/config/cli/test_argcomplete.py
!!!!!!!!!!!!!!!!!!!! Interrupted: 1 error during collection !!!!!!!!!!!!!!!!!!!!
1 error in 3.05s

                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
            validate(val, list[str])
        elif casting_to in {dict, dict}:
            key_type, value_type = type_args[0], type_args[1]
            if isinstance(val, dict):
                for va in val:
                    vali
…[8096 chars omitted]…
ml_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...
FAILED tests/plugin/test_plugin.py::test_plugin_injects_invalid_python_run - ...
14 failed, 6511 passed, 2 skipped in 135.03s (0:02:15)

      3.1x
      3.12-x
   3.12-x
rc:0
=== 3.1? ===
Execution order: 3.12, 3.13, 3.14, 3.1x, lint, cov, 3.12-x
ALL
   3.12
   3.13
   3.14
   3.1x
   lint
   cov
      3.12
      3.13
      3.14
      3.1x
   3.12-x
rc:0
=== py* ===
Execution order: 3.12, 3.13, 3.14, 3.1x, lint, cov, 3.12-x
ALL
   3.12
   3.13
   3.14
   3.1x
   lint
   cov
   3.12-x
rc:0
=== * ===
Execution order: 3.12, 3.13, 3.14, 3.1x, lint, 3.12-x, cov
ALL
   3.12
   3.13
   3.14
   3.1x
   lint
   cov
      3.12
      3.13
      3.14
      3.1x
      lint
      3.12-x
   3.12-x
rc:0
=== lint,3.* ===
Execution order: 3.12, 3.13, 3.14, 3.1x, lint, 3.12-x, cov
ALL
   3.12
   3.13
   3.14
   3.1x
   lint
   cov
      3.12
      3.13
      3.14
      3.1x
      lint
      3.12-x
   3.12-x
rc:0
=== {3.12,3.13} ===
Execution order: 3.12, 3.13, 3.14, 3.1x, lint, cov, 3.12-x
ALL
   3.12
   3.13
   3.14
   3.1x
   lint
   cov
      3.12
      3.13
   3.12-x
rc:0
=== 3.*-x ===
Execution order: 3.12, 3.13, 3.14, 3.1x, lint, 3.12-x, cov
ALL
   3.12
   3.13
   3.14
   3.1x
   lint
   cov
      3.12-x
   3.12-x
rc:0

optional c rc 
…[702 chars omitted]…
list r rc 1 | py: failed to load py.deps: deps expected str, list[str], or list[Requirement], got list with invalid items: [0] int
constraints c rc 254 | ROOT: HandledError| failed to load py.constraints: constraints expected str, list[str], or list[Requirement], got dict: {}
constraints r rc 1 | py: failed to load py.constraints: constraints expected str, list[str], or list[Requirement], got dict: {}

    assert "A" not in set_env


def test_set_env_circular_use_os_environ(tox_project: ToxProjectCreator) -> None:
    prj = tox_project({"tox.ini": "[testenv]\npackage=skip\nset_env=a={env:b}\n b={env:a}"})
    result = prj.run("c", "-e", "py", raise_on_config
…[249 chars omitted]…
val_set_env: EvalSetEnv) -> None:
    with pytest.raises(ValueError, match="a"):
        eval_set_env("[testenv]\npackage=skip\nset_env=a\n b")


def test_set_env_replacer(eval_set_env: EvalSetEnv, monkeypatch: MonkeyPatch) -> None:
    monkeypatch.setenv("MAGIC", "\nb=2\n")
    set_env = eval_set_env("[testenv]\npackage=skip\nset_env=a=1\n {env:MAGIC}")
    env = {k: set_env.load(k) for k in set_env}

121-        if of := value.get("of"):
122-            validated_of = validate(of, list[str])
123-            loaded = self.loader
…[3245 chars omitted]…
ndition: {node.value.id} (expected 'env' or 'factor')"
189-            raise MatchError(msg)
190-        if isinstance(node, ast.Constant) and isinstance(node.value, str):
191-            return node.value
192-        msg = f"Unsupported expression in condition: {ast.dump(node)}"
193-        raise MatchError(msg)
194-
195-    return bool(_eval(tree.body))
196-
197-
198-_REFERENCE_PATTERN = re.compile(

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
src/tox/config/loader/toml/__init__.py:120:            return Command(args=validate(value, list[str]))

_=/usr/bin/env
---
For variant 'global', will try loading '/etc/xdg/pip/pip.conf'
For variant 'global', will try loading '/etc/pip.conf'
For variant 'user', will try loading '/root/.pip/pip.conf'
For variant 'user', will try loading '/root/.config/pip/pip.conf'
For variant 'site', will try loading '/usr/local/pip.conf'
---
127.0.0.1	localhost
::1	localhost ip6-localhost ip6-loopback
fe00::	ip6-localnet
ff00::	ip6-mcastprefix
ff02::1	ip6-allnodes
ff02::2	ip6-allrouters
---
# Generated by Docker Engine.
# This file can be edited; Docker Engine will not make further changes once it
# has been modified.

nameserver 192.168.65.7

# Based on host file: '/etc/resolv.conf' (legacy)
# Overrides: []

readme.content-type = "text/markdown"
readme.file = "README.md"
keywords = [
  "environments",
  "isolated",
  "testing",
  "virtual",
]
license = "MIT"
maintainers = [
  { name = "Anthony Sottile", email = "asottile@umich.edu" },
  { name = "Bernát Gábor", email = "gaborjbernat@gmail.com" },
  { name = "Jürgen Gmach", email = "juergen.gmach@googlemail.com" },
  { name = "Oliver Bestwalter", email = "oliver@bestwalter.de" },
]
authors = [
  { name = "Bernát Gábor", email = "gaborjbernat@gmail.com" },
]
requires-python = ">=3.10"
classifiers = [
  "Development Status :: 5 - Production/Stable",
  "Framework :: tox"
…[1946 chars omitted]…
up = "release" },
  { include-group = "test" },
]
docs = [
  "furo>=2025.12.19",
  "sphinx>=9.1",
  "sphinx-argparse-cli>=1.20.1",
  "sphinx-autodoc-typehints>=3.6.3",
  "sphinx-copybutton>=0.5.2",
  "sphinx-inline-tabs>=2025.12.21.14",
  "sphinx-issues>=5.0.1",
  "sphinx-reredirects>=1.1",
  "sphinxcontrib-mermaid>=2",
  "sphinxcontrib-towncrier>=0.2.1a0",
  "towncrier>=25.8",
  "truststore>=0.10.4",

            if not isinstance(item, (str, Requirement))
        ]
        return f"{field} expected {expected}, got list with invalid items: {', '.join(invalid)}"
    return f"{field} expected {expected}, got {type(raw).__name__}: {raw!r}"


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

        self.add_config(
            keys=["k"],
            of_type=list[str],
            default=[],
            desc="desc",
            factory=factory,
        )
54:description = "format the code base to adhere to our styles, and complain about what we cannot do automatically"
65:commands = [ [ "pre-commit", "run", "--all-files", "--show-diff-on-failure", { replace = "posargs", extend = true } ] ]
72:commands = [ [ "ty", "check", "--python-platform", "all", "--output-format", "concise", "--error-on-warning", "." ] ]
79:commands = [ [ "ty", "check", "--python-version", "3.10", "--python-platform", "all", "--output-format", "concise", "--error-on-warning", "src", "tests" ] ]
143:commands = [ [ "python", "-m", "pip", "list", "--format=columns" ], [ "python", "-c", 'print(r"{env_python}")' ] ]

tests/test_run.py:7:from tox.report import HandledError
tests/test_run.py:18:@pytest.mark.parametrize("exception", [HandledError, KeyboardInterrupt])

220-  "ignore:unclosed database in <sqlite3.Connection object at:ResourceWarning",
221-  "ignore:unclosed file <_io.TextIOWrapper:ResourceWarning",
222-  "ignore:subprocess .* is still running:ResourceWarning",
223-  "ignore:os.path.commonprefix\\(\\) is deprecated:DeprecationWarning",          # https://github.com/pygments/pygments/issues/3039 https://github.com/pypa/pyproject-hooks/issues/223
224-]
225-ini_options.tmp_path_retention_policy = "f
…[4611 chars omitted]…
to its cache, when running with xdist this may throw off test timings
    if worker_id != "master":  # pragma: no branch
        temp_app_data = str(tmp_path_factory.mktemp(f"virtualenv-app-{worker_id}"))  # pragma: no cover
        os.environ["VIRTUALENV_APP_DATA"] = temp_app_data  # pragma: no cover
        seed_env_folder = str(tmp_path_factory.mktemp(f"seed-cache-{worker_id}"))  # pragma: no cover

         yield result
 
 
-_FACTOR_RE = re.compile(r"(?:!?[\w._][\w._-]*|^$)")
+_FACTOR_RE = re.compile(r"(?:!?[\w._*?][\w._*?-]*|^$)")
 
 
 def expand_env_with_negation(value: str) -> Iterator[str]:
diff --git a/src/tox/confi
…[6144 chars omitted]…
e(raw, list)
-                and (all(isinstance(i, str) for i in raw) or all(isinstance(i, Requirement) for i in raw))
+                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)

        ),
        pytest.param("", Command, ValueError, r"attempting to parse '' into a command failed", id="fail_empty_command"),
    ],
)
def test_str_convert_nok(raw: str, of_type: type[Any], msg: str, exc_type: type[Exception]) -> None:
    with pytest.raises(exc_type, match=msg):
        StrConvert().to(raw, of_type, None)


@pytest.mark.parametrize(

            keys=["commands_retry"],
            of_type=int,
            default=0,
            desc="number of times to retry a failed command (0 means no retries)",
        )
        self.conf.add_config(
            keys=["ignore_outcome"],
            of_type=bool,
            default=False,
            desc="if set to true a failing result of this testenv will not make tox fail (instead just warn)",
        )
        self.conf.add_confi
…[2022 chars omitted]…
   dest="hash_seed",
        )
        sub_parser.add_argument(
            "--discover",
            dest="discover",
            nargs="+",
            metavar="path",
            of_type=list[str],
            help="for Python discovery first try these Python executables",
            default=[],
        )
        list_deps = sub_parser.add_mutually_exclusive_group()
        list_deps.add_argument(

hashseed",
src/tox/config/cli/parser.py:287:            default=hashseed_default,
src/tox/config/cli/parser.py:288:            dest="hash_seed",
src/tox/tox_env/python/api.py:127:        hash_seed: int | None = getattr(self.options, "hash_seed", None)
src/tox/tox_env/python/api.py:128:        if hash_seed is not None:
src/tox/tox_env/python/api.py:129:            env["PYTHONHASHSEED"] = str(hash_seed)

from tox.config.loader.api import ConfigLoadArgs, Loader, Override
from tox.config.loader.replacer import replace
from tox.config.set_env import SetEnv
from tox.config.types import Command, EnvList
from tox.report import HandledError

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

if TYPE_CHECKING:
    from collections.abc import Iterator, Mapping

    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]):

                    fail = False
                except Exception:  # noqa: BLE001
                    fail = True
            if fail:
                msg = f"{val!r} is not of type {of_type.__name__!r}"
        if msg:
>           raise HandledError(msg)
E           tox.report.HandledError: 'c' is not one of literal 'a','b'

s
…[3400 chars omitted]…
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
FAILED tests/config/source/test_toml_pyproject.py::test_config_requires - Ass...
13 failed, 115 passed in 6.65s

        envlist = base, flake8
        [testenv]
        package = sdist
        [testenv:base]
        [testenv:flake8]
        """
        })
        outcome = project.run(f"--installpkg={pkg_with_sdist}")
>       outcome.assert_success()

tests/tox_env/python/virtual_env/package/test_package_cmd_builder.py:223: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = code: 1
cmd: /usr/local/bin/python -m 
…[8629 chars omitted]…
ires_file_lock - Assertion...
FAILED tests/tox_env/python/virtual_env/package/test_package_cmd_builder.py::test_build_wheel_external_runs_once
FAILED tests/tox_env/python/virtual_env/package/test_package_cmd_builder.py::test_build_wheel_external
FAILED tests/tox_env/python/virtual_env/package/test_package_cmd_builder.py::test_run_installpkg_targz
19 failed, 7427 passed, 17 skipped in 251.06s (0:04:11)

-rw-r--r-- 1 root root 1551 Nov  3 18:04 README.md
-rw-r--r-- 1 root root 1059 Nov  3 18:04 SECURITY.md
drwxr-xr-x 1 root root 4096 Nov  3 18:04 docs
-rw-r--r-- 1 root root   14 Nov  3 18:04 ignore-words.txt
-rw-r--r-- 1 root root 7908 Nov  3 18:04 pyproject.toml
drwxr-xr-x 1 root root 4096 Nov  3 18:04 src
drwxr-xr-x 1 root root 4096 Nov  3 18:04 tasks
drwx
…[438 chars omitted]…
md
./docs/changelog.rst
./docs/conf.py
./docs/development.rst
./docs/explanation.rst
./docs/index.rst
./docs/onboarding.rst
./docs/tox_conf.py
./ignore-words.txt
./LICENSE
./pyproject.toml
./README.md
./SECURITY.md
./tasks/release.py
./tests/conftest.py
./tests/test_call_modes.py
./tests/test_provision.py
./tests/test_report.py
./tests/test_run.py
./tests/test_version.py
./tests/__init__.py
./tox.toml

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 threading import Event, Thread
from typing import TYPE_CHECKING, Any, cast
from urllib.parse import unquote, urlparse
from urllib.request import url2pathname

from colorama import Fore

from tox.execute import Outcome
from tox.journal import write_journal
from tox.session.cmd.run.single import ToxEnvRunResult, run_one
from tox.util.graph import stable_topological_sort
from tox.util.spinner import MISS_DURATION, Spinner

if TYPE_CHECKING:
    from collections.abc import Iterator, Sequence

 
…[8629 chars omitted]…
 self.conf:
            yield self.conf.get_env(env)


@cache
def _replace_ref(env: str | None) -> Pattern[str]:
    return re.compile(
        rf"""
    (\[(?P<full_env>{re.escape(env or ".*")}(:(?P<env>[^]]+))?|(?P<section>[-\w]+))])? # env/section
    (?P<key>[-a-zA-Z0-9_]+) # key
    (:(?P<default>.*))? # default value
    $
""",
        re.VERBOSE,
    )


__all__ = [
    "ReplaceReferenceIni",
]

 exit_code)
src/tox/tox_env/runner.py:203:            of_type=bool,
src/tox/tox_env/runner.py:212:            of_type=bool,
src/tox/tox_env/runner.py:233:                of_type = "file" if pkg.is_file() else ("dir" if pkg.is_dir() else "N/A")
src/tox/tox_env/runner.py:234:                meta = {"basename": pkg.name, "type": of_type}
src/tox/tox_env/runner.py:235:                if of_type == "file":

from tox.config.types import Command, EnvList

if TYPE_CHECKING:
    from collections.abc import Iterator
    from io import StringIO
    from typing import Final


class StrConvert(Convert[str]):
    """A class converting string values to tox types."""

    @staticmethod
    def to_str(value: str) -> str:
        return str(value).strip()

    @staticmethod
    def to_path(value: str) -> Path:
        return Path(value)

    @staticmethod
    def to_list(value: str, of_type: type[Any]) -> Iterator[str]:
        splitter = "\n" if (isclass(of_type) and issubclass(of_type, Comman
…[7946 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",
]

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
…[7402 chars omitted]…
, False)
src/tox/config/loader/toml/_replace.py:137:        return matches if extending else " ".join(matches)
src/tox/config/loader/toml/_replace.py:140:        return [] if extending else ""
src/tox/config/loader/toml/_replace.py:141:    return validate(default, list) if extending else validate(default, str)
src/tox/config/loader/toml/__init__.py:135:                envs.extend(expand_product(item))

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
…[7728 chars omitted]…
{
        "tox.toml": textwrap.dedent("""\
            env_list = [
                "lint",
                { product = [["py312", "py313"], ["django42"]] },
                "docs",
            ]

            [env_run_base]
            package = "skip"
            commands = [["python", "-c", "print('ok')"]]
        """),
sed: can't read tests/tox_env/python/test_req_file.py: No such file or directory

    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
   
…[2237 chars omitted]…
lueError(msg)
src/tox/tox_env/python/pip/req_file.py:137:            raise TypeError(raw)
src/tox/tox_env/python/pip/req_file.py:184:            raise ValueError(msg)
src/tox/tox_env/python/pip/req_file.py:221:                raise ValueError(msg)
src/tox/tox_env/python/pip/req_file.py:229:                raise ValueError(msg)
src/tox/tox_env/python/pip/req_file.py:244:            raise TypeError(raw)

keywords = [
  "environments",
  "isolated",
  "testing",
  "virtual",
]
license = "MIT"
maintainers = [
  { name = "Anthony Sottile", email = "asottile@umich.edu" },
  { name = "Bernát Gábor", email = "gaborjbernat@gmail.com" },
  { name = "Jürgen Gmach", email = "juergen.gmach@googlemail.com" },
  { name = "Oliver Bestwalter", email = "oliver@bestwalter.de" },
]
authors = [
  { name = "Bernát Gábor", email = "gaborjbernat@gmail.com" },
]
requires-python = ">=3.10"
classifiers = [
  "Development Status :: 5 - Production/Stable",
  "Framework :: tox",
  "Intended Audience :: Developers",
  "License :: OSI Approved 
…[8285 chars omitted]…
ne:
    filename = str(uuid4())
    session_mocker.patch("tox.config.cli.ini.DEFAULT_CONFIG_FILE", Path(filename))
from __future__ import annotations

from typing import TYPE_CHECKING

import pytest

if TYPE_CHECKING:
    from tests.conftest import ToxIniCreator
    from tox.config.main import Config


@pytest.fixture
def empty_config(tox_ini_conf: ToxIniCreator) -> Config:
    return tox_ini_conf("")

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]…
ode.value.id} (expected 'env' or 'factor')"
            raise MatchError(msg)
        if isinstance(node, ast.Constant) and isinstance(node.value, str):
            return node.value
        msg = f"Unsupported expression in condition: {ast.dump(node)}"
        raise MatchError(msg)

    return bool(_eval(tree.body))


_REFERENCE_PATTERN = re.compile(
    r"""
    (\[(?P<section>.*)])? # default value

  File "/repo/src/tox/session/cmd/depends.py", line 29, in depends
    order, todo = run_order(state, to_run_list)
                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/tox/session/cmd/run/common.py", line 441, in run_order
    depends = set(cast("EnvList", run_env.conf["depends"]).envs)
                                  ~~~~~~~~~~~~^^^^^^^^^^^
  File "/repo/src/tox/config/sets.py", line 150, in __getitem__

…[1507 chars omitted]…
factor_groups(value):
                 ^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/tox/config/loader/ini/factor.py", line 87, in find_factor_groups
    for env in expand_env_with_negation(value):
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/tox/config/loader/ini/factor.py", line 105, in expand_env_with_negation
    raise ValueError(variant_str)
ValueError: py3.*
/tmp/tmp.KLM68AdzBQ

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

    from .cli.parser import Parsed
    from .loader.memory import MemoryLoader
    from .loader.section import Section
    from .source import Source


T = TypeVar("T", bound=ConfigSet)


class Config:
    """Main configuration object for tox."""

    def __init__(  # noqa: PLR0913  # <- no way around many args
        self,
        config_source: Source,
        options: Parsed,
        root: Path,
        pos_args: Sequence[str] | None,
        work_dir: Path,
        extra_envs: Iterab
…[8133 chars omitted]…
ef primary_key(self, key: str) -> str:
        """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 self._env_name

labels = 
env_dir = /tmp/tmp.sCmaINXd6d/.tox/py
env_tmp_dir = /tmp/tmp.sCmaINXd6d/.tox/py/tmp
env_log_dir = /tmp/tmp.sCmaINXd6d/.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 
…[765 chars omitted]…
nv_bin_dir = /tmp/tmp.sCmaINXd6d/.tox/py/bin
env_python = /tmp/tmp.sCmaINXd6d/.tox/py/bin/python
py_dot_ver = 3.12
py_impl = cpython
py_free_threaded = False
deps = 
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

from tox.plugin import impl
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",
        d
…[8628 chars omitted]…
s:
                    if exit_code == Outcome.OK:
                        exit_code = cast("int", exception.code)
                    break
                return cast("int", exception.code)
            else:
                break
    return exit_code


__all__ = (
    "ToxEnvRunResult",
src/tox/config/cli/parse.py:65:    except HandledError:
src/tox/session/env_select.py:187:    except HandledError:

src/tox/tox_env/python/package.py:81:                of_type=list[Requirement],
src/tox/tox_env/python/pip/pip_install.py:74:            of_type=PythonConstraints,
src/tox/tox_env/p
…[433 chars omitted]…
ommand],
src/tox/tox_env/runner.py:69:            of_type=list[Command],
src/tox/tox_env/runner.py:88:            of_type=int,
src/tox/config/cli/parser.py:286:            of_type=int | None,
src/tox/execute/api.py:38:            of_type=float,
src/tox/execute/api.py:44:            of_type=float,
src/tox/execute/api.py:50:            of_type=float,
src/tox/tox_env/runner.py:88:            of_type=int,

        :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

        overrides = [o for alias in (key, *all_keys) for o in self.overrides.get(alias, [])]
        converted = None
        for alias in (key, *
…[8686 chars omitted]…
value was supplied in if replacement"
        raise MatchError(msg)
    return unroll(
        value["then"] if _evaluate_condition(condition, factors) else value.get("else", ""), depth, skip_str=skip_str
    )


def _evaluate_condition(expr: str, factors: set[str]) -> bool:  # noqa: C901
    """Evaluate a condition expression supporting env.VAR, factor.NAME lookups, comparisons, and boolean logic."""

            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]…
"
    option = state.conf.options
    if option.no_capture:
        msg = "--no-capture cannot be used with parallel mode"
        raise SystemExit(msg)
    return execute(
        state,
        max_workers=auto_detect_cpus() if option.parallel == 0 else option.parallel,
        has_spinner=option.parallel_no_spinner is False and option.parallel_live is False,
        live=option.parallel_live,
    )

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
…[4587 chars omitted]…
st_config_in_toml_replace_if_factor_platform(tox_project: ToxProjectCreator) -> None:
    condition_val = f"factor.{sys.platform}"
    toml_str = f"""
from __future__ import annotations

from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from typing import TypeAlias

TomlTypes: TypeAlias = dict[str, "TomlTypes"] | list["TomlTypes"] | str | int | float | bool | None

__all__ = [
    "TomlTypes",
]

if TYPE_CHECKING:
    from collections.abc import Callable
    from configparser import ConfigParser

    from tests.conftest import ToxIniCreator
    from tox.config.main import Config


def test_factor_env_discover_empty() -> None:
    result = list(find_envs("\n\n"))
    assert result == []


@pytest.fixture(scope="session")
def complex_example() -> str:
    return dedent(
        """
    default
    lines
    p
…[6961 chars omitted]…
m(
            "py3{-11}",
            [f"py3{v}" for v in range(LATEST_PYTHON_MINOR_MIN, 12)],
            id="Expand left-open numerical range",
        ),
        pytest.param("foo{a-}", ["fooa-"], id="Don't expand right-open range"),
        pytest.param("foo{-a}", ["foo-a"], id="Don't expand left-open range"),
        pytest.param("foo{a-11}", ["fooa-11"], id="Don't expand alpha-umerical range"),

                        tox_env_done = future_to_env.pop(future)
                        try:
                            result = future.result()
                        except Cancelle
…[6897 chars omitted]…
ler is not None  # noqa: S101 # trigger installer creation to allow config registration

    def _recreate_default(self, conf: Config, value: str | None) -> bool:  # noqa: ARG002
        return cast("bool", self.options.recreate)

    @property
    def env_dir(self) -> Path:
        """:returns: the tox environments environment folder"""
        return cast("Path", self.conf["env_dir"])

    @property

        # do not include local version specifier (because it's not allowed in version spec per PEP-440)
        default=None,  # Optional[Version] translates to object
        desc="Define the minimal tox version required to run",
    )
    state.conf.core.add_config(
        keys="provision_tox_env",
        of_type=str,
        default=".tox",
        desc="Name of the virtual environment used to provision a tox.",
    )

    def add_tox_requires_min_version(reqs: list[Requirement]) -> list[Requirement]:
        min_version: Version = state.
…[6561 chars omitted]…
age/pyproject.py:455:        target: Literal["editable", "wheel"] = "editable" if for_env["package"] == "editable" else "wheel"
src/tox/tox_env/python/virtual_env/package/util.py:102:    _marker: MarkerList | tuple[Variable | Value, Op, Variable | Value] | Sequence[MarkerAtom] | Literal["and", "or"],
grep: src/tox/tox_env/python/virtual_env/package/__pycache__/util.cpython-312.pyc: binary file matches

        with self._local.with_name(name):
            yield

    @property
    def name(self) -> str:
        """:returns: the current tox environment name"""
        return self._local.name  # pragma: no cover

    @property
    def stdout(self) -> TextIOWrapper:
        """:returns: the current standard output"""
        return self._local.out_err[0]

    @property
    def stderr(self) -> TextIOWrapper:
   
…[8337 chars omitted]…
command>\n"
tests/session/cmd/test_exec_.py:25:    msg = "ROOT: HandledError| exactly one target environment allowed in exec mode but found py39, py38\n"
tests/session/cmd/test_list_envs.py:119:    assert outcome.out.splitlines() == ["ROOT: HandledError| pkg cannot self-package"]
tests/session/test_env_select.py:395:        "ROOT: HandledError| provided environments not found in configuration file:\n"

                if replace_type == "env":
                    env_result: TomlTypes = replace_env(
                        self.conf,
                        [
  
…[3843 chars omitted]…
t):
            return not bool(_eval(node.operand))
        if isinstance(node, ast.Compare) and len(node.ops) == 1 and len(node.comparators) == 1:
            left = _eval(node.left)
            right = _eval(node.comparators[0])
            if isinstance(node.ops[0], ast.Eq):
                return left == right
            if isinstance(node.ops[0], ast.NotEq):
                return left != right

    """Configuration sourced from a pyproject.toml files."""

    FILENAME = "tox.toml"
    _Section = TomlToxSection


__all__ = [
    "TomlTox",
]
                msg = f"Environment key must be string, got {env_name!r}"
                raise HandledError(msg)
            yield self._Section.test_env(env_name)

    def get_base_sections(self, base: list[str], in_section: Section) -> Iterator[Section]:
        core_prefix = self._Section.core_prefix()
        strip = f"{core_prefix}{self._Section.SEP}" if core_prefix else ""
        env_base_pfx = self._Section.env_base_prefix()
        env_base_dot = f"{env_base_pfx}{self._Section.SEP}"
        for entry in base:
            i
…[1735 chars omitted]…
bo) 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",
]
from __future__ import annotations

from .api import Source
from .discover import discover_source

__all__ = (
    "Source",
    "discover_source",
)

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
…[4969 chars omitted]…
tern)
    extending = value.get("extend", False)
    if matches := sorted(glob.glob(pattern, recursive=True)):  # noqa: PTH207
        return matches if extending else " ".join(matches)
    default = value.get("default")
    if default is None:
        return [] if extending else ""
102:    def load_raw(self, key: str, conf: Config | None, env_name: str | None) -> T:
123:    def load(  # noqa: PLR0913

from .api import Source
from .ini_section import CORE, PKG_ENV_PREFIX, TEST_ENV_PREFIX, IniSection

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

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


class IniSource(Source):
    """Configuration sourced from a ini file (such as tox.ini)."""

    CORE_SECTION = CORE

    def __init__(self, path: Path, content: str | None = None) -> None:
        super().__init__(path)
        self._parser = ConfigParser(inter
…[3725 chars omitted]…
s: set[str]) -> Iterator[str]:
        for value in self._parser[section.key].values():
            for env in find_envs(value):
                if set(env.split("-")) - known_factors:
                    yield env


__all__ = [
    "IniSource",
]
src/tox/config/loader/ini/factor.py:49:def find_envs(value: str) -> Iterator[str]:
src/tox/config/source/ini.py:115:            for env in find_envs(value):

        parser.add_argument(
            "--skip-env-install",
            dest="skip_env_install",
            help="skip dependency and package installation, reuse existing environment",
            action="store_true",
        )


def report(start: float, runs: list[ToxEnvRunResult], is_colored: bool, verbosity: int) -> int:  # noqa: FBT001
    def _print(color_: int, message: str) -> None:
        if verbosity:
            print(f"{color_ 
…[3124 chars omitted]…
ath)
25:    python_deps = PythonDeps(
38:    python_deps = PythonDeps(raw="-r requirements.txt", root=tmp_path)
48:    python_deps = PythonDeps(raw="-rr.txt\n--no-deps", root=tmp_path)
60:    python_deps = PythonDeps(raw="-rr.txt", root=tmp_path)
67:    python_deps = PythonDeps(raw="-rr.txt", root=tmp_path)
73:    a = PythonDeps(raw="foo", root=tmp_path)
74:    b = PythonDeps(raw="bar", root=tmp_path)

@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",
    
…[1577 chars omitted]…
.txt").write_text("--use-feature fast-deps")
    python_deps = PythonDeps(raw="-rr.txt", root=tmp_path)
    assert not python_deps.requirements
    assert python_deps.options == Namespace(features_enabled=["fast-deps"])


def test_req_iadd(tmp_path: Path) -> None:
    a = PythonDeps(raw="foo", root=tmp_path)
    b = PythonDeps(raw="bar", root=tmp_path)
    a += b
    assert a.lines() == ["foo", "bar"]

    """Transform a value into a string representation.

    :param value: the value in question

    :returns: a tuple, first the value as str, second a flag if the value if a multi-line one

    """
    if isinstance(value, str):
        return value, False
    if isinstance(value, (Path, float, int, bool)):
        return str(value), False
    if isinstance(value, Mapping):
        return "\n".join(f"{stringify(k)[0]}={stringify(v)[0]}" for k, v in value.items()), True
    if isinstance(value, Sequence):
        return "\n".join(stringify(i)[0] for i in
…[8071 chars omitted]…
(value: T, of_type: type[Any]) -> Iterator[T]:
        """Convert to list.

        :param value: the value to convert
        :param of_type: the type of elements in the list

        :returns: a list representation of the value

        """
        raise NotImplementedError

    @staticmethod
    @abstractmethod
    def to_set(value: T, of_type: type[Any]) -> Iterator[T]:
        """Convert to set.

tests/config/test_sets.py:186:    with pytest.raises(TypeError, match="1"):
tests/plugin/test_plugin.py:192:        with pytest.raises(TypeError, match="1"):
tests/plugin/test_plugin.py:199:    assert "raise TypeError(raw)" in result.out

                if not first:
                    msg += "\n"
                first = False
                msg += env
                if suggestion:
                    msg += f" - did you mean {suggestion}?"
            raise HandledError(msg)

    def _env_name_to_active(self) -> dict[str, bool]:
        env_name_to_active_map = {}
        fo
…[8629 chars omitted]…
     for factor_set in factors:
                        if factor_set.issubset(set(name.split("-"))):
                            env_info.is_active = True
                            break

    def __getitem__(self, item: str) -> RunToxEnv | PackageToxEnv:
        """:param item: the name of the environment

        :returns: the tox environment

        """
        env = self._defined_envs[item].env

=================

- Allow ``skip_missing_interpreters`` to be set per environment, overriding the global setting. This enables marking
  specific environments as optional while keeping others required. (:issue:`435`)
- Add ``--fail-fast`` CLI flag and ``fail_fast`` per-environment config option to stop executing remaining environments
  when the first failure occurs - b
…[5079 chars omitted]…
mmands = coverage run -p -m pytest tests

         [testenv:coverage]
         skip_install = true
         deps = coverage[toml]
         depends = 3.*
         commands =
             coverage combine
             coverage report --fail-under=80

The ``-p`` flag (parallel mode) creates separate ``.coverage.<hash>`` files per environment. ``coverage combine`` merges
them before generating the report.

    def is_test_env(self) -> bool:
        return self.prefix == TEST_ENV_PREFIX

    @property
    def names(self) -> list[str]:
        return list(extend_factors(self.name))


TEST_ENV_PREFIX = "testenv"
PKG_ENV_PREFIX = "pkgenv"
CORE = IniSection(None, "tox")

__all__ = [
    "CORE",
    "PKG_ENV_PREFIX",
    "TEST_ENV_PREFIX",
    "IniSection",
]
py3.* []
depends = py3.* []
3.1? []

    )
    optional_none = config_set["optional_none"]
    assert optional_none is None


def test_config_dict(conf_builder: ConfBuilder) -> None:
    config_set = conf_builder("dict = a=1\n  b=2\n  c=3")
    config_set.add_config(keys="dict", of_type=dict[str, int], default={}, desc="dict")
    dict_val = config_set["dict"]
    assert dict_val == OrderedDict([("a", 1), ("b", 2), ("c", 3)])


def test_config_bad_type(conf_builder: ConfBuilder) -> None:
    config_set = conf_builder("crazy = 
…[5613 chars omitted]…
ext:
tests/config/test_sets.py:87:    with pytest.raises(TypeError) as context:
tests/config/test_sets.py:95:    with pytest.raises(TypeError) as context:
tests/config/test_sets.py:179:    with pytest.raises(TypeError, match="Can't instantiate"):
tests/config/test_sets.py:186:    with pytest.raises(TypeError, match="1"):
tests/plugin/test_plugin.py:192:        with pytest.raises(TypeError, match="1"):

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
…[7760 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",
]

        args = ToxEnvCreateArgs(env_conf, self._state.conf.core, self._state.conf.options, journal, self._log_handler)
        run_env = runner(args)
        run_env.register_config()
        self._manager.tox_add_env_config(env_conf, self._state)
     
…[6099 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",
]

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


class RunnerUnavailable(Exception):  # noqa: N818
    """Runner for this environment is not available."""
src/tox/config/set_env.py:109:            raise Fail(msg)

    toml = """\
    [tool.tox.env.A]
    commands = [["echo", { replace = "if", condition = "env.V", then = ["-v"], else = ["-q"], extend = true }]]
    """
    project = tox_project({"pyproject.toml": toml})
    outcome = project.run("c", "-e", "A", "-k", "commands")
    outcome.assert_success()
    assert "-v" in outcome.out


@pytest.mark.parametrize(
    ("condition_toml", "error_match"),
    [
        pytest.param
…[3297 chars omitted]…
 = f"factor.{sys.platform}"
703:        description.condition = "{condition_val}"
717:        description = { replace = "if", condition = "not factor.win32", then = "not windows", else = "windows" }
731:        description.condition = "factor.django50 and factor.py313"
746:        description.condition = "factor.django50 or factor.py313"
764:        description.condition = "factor.django50 and env.CI"

                with self._log_handler.with_context(name):
                    try:
                        run_e
…[5064 chars omitted]…
            raise HandledError(msg) from exc
            raise RunnerUnavailable(runner_name) from exc
        journal = self._journal.get_env_journal(name)
        args = ToxEnvCreateArgs(env_conf, self._state.conf.core, self._state.conf.options, journal, self._log_handler)
        run_env = runner(args)
        run_env.register_config()
        self._manager.tox_add_env_config(env_conf, self._state)

            env.extend(
                [
                    "TEMP",  # temporary file location
                    "TMP",  # temporary file location
                    "USERPROFILE",  # needed for `os.path.expanduser()`
                    "PATHEXT",  # needed for discovering executa
…[8629 chars omitted]…
ts 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:
                ready_to_run.append(env)
        order = new_order
        yield ready_to_run

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
…[8133 chars omitted]…
y]
                self._materialized[key] = value
                self.changed = True


__all__ = ("SetEnv",)
src/tox/config/loader/toml/__init__.py:10:from tox.config.set_env import SetEnv
src/tox/config/loader/toml/__init__.py:72:        delay_replace = inspect.isclass(of_type) and issubclass(of_type, SetEnv)
grep: src/tox/config/loader/toml/__pycache__/__init__.cpython-312.pyc: binary file matches

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) -> ToxEnvRunResult:  # noqa: FBT001
    start_one = tim
…[559 chars omitted]…
tup()
            code, outcomes = run_commands(tox_env, no_test)
        except Skip as exception:
            LOGGER.warning("skipped because %s", exception)
            code = 0
            skipped = True
        except ToxBackendFailed as exception:
            LOGGER.error("%s", exception)  # noqa: TRY400
            raise SystemExit(exception.code)  # noqa: B904
        except Fail as exception:

    def _register_config(self) -> None:
        if self._with_list_deps:  # pragma: no branch
            self._env.conf.add_config(
                keys=["list_dependencies_command"],
                of_type=Command,
                default=Command(self.freeze_cmd()),
                desc="command used to list installed packages",
            )

    @abstractmethod
    def freeze_cmd(self) -> list[str]:
        raise No
…[1775 chars omitted]…
cpython-312.pyc: binary file matches
src/tox/tox_env/python/runner.py:45:            of_type=PythonDeps,
src/tox/tox_env/python/runner.py:46:            factory=partial(PythonDeps.factory, root),
src/tox/tox_env/python/virtual_env/package/cmd_builder.py:52:            of_type=PythonDeps,
src/tox/tox_env/python/virtual_env/package/cmd_builder.py:53:            factory=partial(PythonDeps.factory, root),

        values = dict.fromkeys(str(i) for i in self._paths)
        values.update(dict.fromkeys((existing or os.environ.get("PATH", "")).split(os.pathsep)))
        return os.pathsep.join(values)

    def execute(  # noqa: PLR0913
        self,
        cmd: Sequence[Path | str],
        stdin: StdinSource,
        show: bool | None = None,  # noqa: F
…[1185 chars omitted]…
wd = self.core["tox_root"]
        if show is None:
            show = self.options.verbosity > 3  # noqa: PLR2004
        request = ExecuteRequest(cmd, cwd, self.environment_variables, stdin, run_id, allow=self._allow_externals)
        if request.cwd == _CWD:
            repr_cwd = ""
        else:
            try:
                repr_cwd = f" {_CWD.relative_to(cwd)}"
            except ValueError:

        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_err, None
        out_b, err_b = cast("BytesIO", out.buffer).getvalue(), cast("BytesIO", err.buffer).getvalue()
        out.close()
        err.close()
        return out_b, err_b

    @contextmanager
    def _log_context(self) -> Iterator[None]:
        with self.log_handler.with_context(self.conf.name):
            yield

    @property
    def _has_display_suspended(self) -> bool:
        return self._suspended_out_err is not None

            msg = f"{val!r} is not dictionary"
    elif casting_to in {Union, UnionType}:  # handle Optional values
        args: list[type[Any]] = list(type_args)
        for arg in args:
            try:
                validate(val, arg)
                break
            except TypeError:
                pass
        else:
            msg = f"{val!r} is not union of {', '.jo
…[332 chars omitted]…
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_type.__name__!r}"
    if msg:
        raise TypeError(msg)
    return cast("T", val)


__all__ = [
    "validate",
]

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__(
  
…[8629 chars omitted]…
 type[Any]]) -> Iterator[tuple[str, str]]:  # noqa: ARG004
        for row in value.split("\n"):
            if row.strip():
                key, sep, value = row.partition("=")
                if sep:
                    yield key.strip(), value.strip()
                else:
                    msg = f"dictionary lines must be of form key=value, found {row!r}"
                    raise TypeError(msg)

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)*(?<!\\)#.*")


class IniLoader(StrConvert, Loader[str]):
    """Load configuration from an ini section 
…[6659 chars omitted]…
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_type.__name__!r}"
    if msg:
        raise TypeError(msg)
    return cast("T", val)


__all__ = [
    "validate",
]

        return cls(cast("str | list[str] | list[Requirement]", raw), root)


class PythonConstraints(RequirementsFile):
    def __init__(self, raw: str | list[str] | list[Requirement], root: Path) -> None:
        super().__init__(root / "tox.ini", constraint=True)
        got = raw if isinstance(raw, str) else "\n".join(str(i) for i in raw)
        self._raw = self._normalize_raw(got)
        self._unroll: tuple[list[str], li
…[7083 chars omitted]…
tor import filter_for_env
from tox.config.loader.ini.replace import ReplaceReferenceIni
from tox.config.loader.replacer import replace
from tox.config.loader.str_convert import StrConvert
from tox.config.set_env import SetEnv
from tox.report import HandledError
from tox.tox_env.errors import Skip

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

                    validate(va, entry_type)
                except TypeError as exc:
                    raise TypeError(f"item [{index}]: {exc}") from exc
        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
        validate(val, list[str])
        if isinstance(val, list) and not val:
            msg = "command must contain at least one argument"
    elif castin
…[8629 chars omitted]…
t, bool):
        msg = f"range 'start' must be an integer, got {type(start).__name__}"
        raise TypeError(msg)
    if not isinstance(stop, int) or isinstance(stop, bool):
        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",

        root = self._conf.core["tox_root"]
        self.add_config(
            keys=["set_env", "setenv"],
            of_type=SetEnv,
            factory=set_env_factory,
            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",
)

                if isinstance(v, str):
                    return True
                if isinstance(v, dict):
                    return "value" in v and isinstance(v.get("value"), str)  # ty: ignore[invalid-argument-type] # https://github.com/astral-sh/ty/issues/2374
                return False

            if n
…[761 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",

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."""

from __future__ import annotations

import inspect
import logging
from pathlib import Path
from types import UnionType
from typing import TYPE_CHECKING, Any, Literal, TypeVar, Union, cast, get_args, get_origin

from tox.config.loader.api import ConfigLoadArgs, Loader, Override

…[4741 chars omitted]…
str]:
        return set(self._section_proxy.keys())

    def get_section(self, name: str) -> SectionProxy | None:
        # needed for non tox environment replacements
        if self._parser.has_section(name):
            return self._parser[name]
        return None

    def __repr__(self) -> str:
        return f"{self.__class__.__name__}(section={self._section.key}, overrides={self.overrides!r})"

diff --git a/src/tox/config/loader/ini/__init__.py b/src/tox/config/loader/ini/__init__.py
index 26d1b2f..dc2a439 100644
--- a/src/tox/config/loader/ini/__init__.py
++
…[8630 chars omitted]…
nt]"
+    if not isinstance(raw, list):
+        return f"{expected}, got {type(raw).__name__}: {raw!r}"
+    invalid_items = [
+        f"[{index}] {type(item).__name__}"
+        for index, item in enumerate(raw)
+        if not isinstance(item, str | Requirement)
+    ]
+    return f"{expected}, got list with invalid items: {', '.join(invalid_items)}"
+
+
 ONE_ARG = {
     "-i",
     "--index-url",

        description = { replace = "glob", pattern = "dist/*.whl" }
        """),
    })
    outcome = project.run("c", "-e", "A", "-k", "description")
    outcome.assert_success()
    assert "pkg-1.0.whl" in outcome.out


def test_config_in_toml_replace_glob_no_match_default(tox_project: ToxProjectCreator) -> None:
    project = tox_project({
        "pyproject.toml": d
…[942 chars omitted]…
"env_vars", "condition", "then", "else_val", "expected"),
    [
2234:    commands = [["twine", "upload", { replace = "glob", pattern = "dist/*.whl", extend = true }]]
2244:    commands = [["twine", "upload", { replace = "glob", pattern = "dist/*.whl", default = ["fallback.whl"], extend = true }]]
2813:        commands = [["twine", "upload", { replace = "glob", pattern = "dist/*.whl", extend = true }]]

HandledError failed to load A.k: '2' is not of type 'float'

                        return value
                    return replace(conf, TomlReplaceLoader(conf, loader), value, args_)

                result.use_replacer(_toml_replacer, args=args)
        except (TypeError, ValueError) as exception:
            location = args.env_name or self.section.name or "tox"
            message = f"failed to load {location}.{key}: {exception}"
        
…[2585 chars omitted]…
:
                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__} at [{index}]"
                raise TypeError(msg)
        return EnvList(envs=envs)


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

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 = "."
    
…[2066 chars omitted]…
      f"env_base.{base_name}.factors items must be strings or product groups, "
                        f"got {type(factor).__name__} at [{index}]"
                    )
                    raise HandledError(msg)
                names.append(factor)
        for factor_suffix in names:
            result[f"{base_name}-{factor_suffix}"] = base_name
    return result


__all__ = [
    "TomlPyProject",
]

179-    for base_name, config in env_base_content.items():
180-        if not isinstance(config, Mapping):
181-            msg = f"env_base.{base_name} must be a table"

  File "/repo/src/tox/config/loader/toml/__init__.py", line 114, in to_bool
    return validate(value, bool)
           ^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/tox/config/loader/toml/_validate.py", line 89, in validate
    raise TypeError(msg)
TypeError: 'no' is not of type 'bool'

The above exception was the direct cause of the following exception:

Tracebac
…[8629 chars omitted]…
 converted = self.build(alias, of_type, factory, conf, raw, args)
                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/tox/config/loader/toml/__init__.py", line 96, in build
    raise HandledError(message) from exception
tox.report.HandledError: failed to load py.ignore_outcome: 'no' is not of type 'bool'
  py: SKIP (0.01 seconds)
  evaluation failed :( (0.20 seconds)

                        tox_env_done = future_to_env.pop(future)
                        try:
                            result = future.result()
                        except Cancelle
…[3212 chars omitted]…
         skipped=False,
                    code=1,
                    outcomes=[],
                    duration=MISS_DURATION,
                )
            )
    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()

   397	            previous = results[-1]
   398	            results[-1] = ToxEnvRunResult(
   399	                name=previous.name,
   400	                skipped=False,
   401	                code=1,
   402	                outcomes=previous.outcomes,
   403	                duration=previous.duration,
   404	                ignore_outcome=False,
   405	                fail_fa
…[1980 chars omitted]…
lections.abc import Iterator, Sequence

    from tox.config.types import EnvList
    from tox.session.state import State
    from tox.tox_env.api import ToxEnv
    from tox.tox_env.runner import RunToxEnv


class SkipMissingInterpreterAction(Action):
    def __call__(
        self,
        parser: ArgumentParser,  # noqa: ARG002
        namespace: Namespace,
        values: str | Sequence[Any] | None,

./.dockerignore
./.git/COMMIT_EDITMSG
./.git/config
./.git/description
./.git/HEAD
./.git/index
./.github/CODEOWNERS
./.github/config.yml
./.github/CONTRIBUTING.md
./.github/dependabot.yml
./.github/FUNDING.yml
./.github/PULL_REQUEST_TEMPLATE.md
./.github/release.yml
./.gitignore
./.pre-commit-config.yaml
./.readthedocs.yaml
./CODE_OF_CONDUCT.md
./docs/changelog.rst
./docs/conf.py
./docs/development.rst
./docs/explanation.rst
./docs/index.rst
./docs/onboarding.rst
./docs/tox_conf.py
./ignore-words.txt
./LICENSE
./pyproject.toml
./README.md
./SECURITY.md
./tasks/release.py
./tests/conftest.py
./tests/test_call_modes.py
./tests/test_provision.py
./tests/test_report.py
./tests/test_run.py
./tests/test_version.py
./tests/__init__.py
./tox.toml

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/
…[2278 chars omitted]…
ackage/cmd_builder.py
src/tox/tox_env/python/virtual_env/package/pyproject.py
----
src/tox/tox_env/python/pip/pip_install.py:75:            factory=partial(PythonConstraints.factory, root),
src/tox/tox_env/python/pip/req_file.py:129:    def factory(cls, root: Path, raw: object) -> PythonDeps:
src/tox/tox_env/python/pip/req_file.py:236:    def factory(cls, root: Path, raw: object) -> PythonConstraints:

    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 "\n".join(str(i) for i in raw)
        self._raw = self._normalize_raw(got)
        self._unroll: tuple[list[str], list[str]] | None = None
        self
…[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",
)

113:    def unroll(self) -> tuple[list[str], list[str]]:
124:    def __iadd__(self, other: PythonDeps) 
…[1883 chars omitted]…
)]

        if any(line.startswith("-") for line in lines):
            msg = "only constraints files or URLs can be provided"
            raise ValueError(msg)

        adjusted = "\n".join([f"-c {line}" for line in lines])
        return f"{adjusted}\n" if raw.endswith("\\\n") else adjusted  # preserve trailing newline if input has it

    @classmethod
    def _normalize_line(cls, line: str) -> str:

        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, Requir
…[8629 chars omitted]…
extmanager
    def patch_thread() -> Iterator[None]:
        with _LogThreadLocal.patch_thread():
            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)

…[1837 chars omitted]…
ror(msg) from exc
src/tox/session/env_select.py:443:                raise HandledError(msg)
src/tox/session/env_select.py:471:                    raise HandledError(msg)  # pragma: no cover
src/tox/session/env_select.py:564:            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 ._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,

…[4070 chars omitted]…
ype(item).__name__}"
                raise TypeError(msg)
        return EnvList(envs=envs)


__all__ = [
    "HandledError",
    "TomlLoader",
]
====
from __future__ import annotations

from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from typing import TypeAlias

TomlTypes: TypeAlias = dict[str, "TomlTypes"] | list["TomlTypes"] | str | int | float | bool | None

__all__ = [
    "TomlTypes",
]

src/tox/config/loader/toml/__init__.py:137:                msg = f"env_list items must be strings or product dicts, got {type(item).__name__}"
src/tox/session/cmd/run/single.py:64:            LOGGER.exception("internal error")  # pragma: no cover

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

from pathlib import Path
from typing import Any, Literal, NoReturn, TypeVar

import pytest

from tox.config.loader.api import ConfigLoadArgs
from tox.config.loader.toml import TomlLoader
from tox.config.source.toml_pyproject import TomlPyProjectSection
from tox.config.types import Command, EnvList


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"
…[3516 chars omitted]…
h="1 is not union of str, NoneType"):
        perform_load(["a", None, 1], list[str | None])


def test_toml_loader_list_literal_ok() -> None:
    assert perform_load(["a", "b"], list[Literal["a", "b"]]) == ["a", "b"]


def test_toml_loader_list_literal_nok() -> None:
    with pytest.raises(TypeError, match="'c' is not one of literal 'a','b'"):
        perform_load(["a", "c"], list[Literal["a", "b"]])

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]…
urns: command representation of the value

        """
        raise NotImplementedError

    @staticmethod
    @abstractmethod
    def to_env_list(value: T) -> EnvList:
        """Convert to a tox EnvList.

        :param value: the value to convert

        :returns: a list of tox environments from the value

        """
        raise NotImplementedError


__all__ = [
    "Convert",
    "Factory",
]

            converted = self.build(alias, of_type, factory, conf, raw, args)
            break
        else:
            if not overrides:
                raise KeyError(key)

        for override in overrides:
            converted_override = _STR_CONVERT.to(override.value, of_type, factory)
            if override.append and converted is not None:
                if isinstance(converted, list) and isinstance(converted_override, list):
                    converted += converted_overri
…[6749 chars omitted]…
 """
        raise NotImplementedError

    @staticmethod
    @abstractmethod
    def to_set(value: T, of_type: type[Any]) -> Iterator[T]:
        """Convert to set.

        :param value: the value to convert
        :param of_type: the type of elements in the set

        :returns: a set representation of the value

        """
        raise NotImplementedError

    @staticmethod
    @abstractmethod

src/tox/session/cmd/run/common.py:121:    if mode not in {"devenv", "depends"}:
src/tox/session/cmd/run/common.py:128:    if mode != "depends":
src/tox/session/cmd/run/common.py:135:    if mode not in {"devenv", "config", "depends"}:
src/tox/session/cmd/run/common.py:441:        depends = set(cast("EnvList", run_env.conf["depends"]).envs)
src/tox/session/cmd/run/common.py:442:        todo[env] = {name for dep in depends for name in to_run_set if fnmatchcase(name, dep)} - {env}
src/tox/config/loader/ini/replace.py:59:                    #   depends = {py39,py38}-{,b}

            if pkg_out_err is not None:  # pragma: no branch
                pkg_out_err_list.append(pkg_out_err)
        if not success or tox_env.conf["parallel_show_output"] or state.conf.options.list_dependencies:
            for pkg_out_err in pkg_out_err_list:
                state._option
…[3005 chars omitted]…
 !c: c
tests/session/cmd/test_parallel.py:137:    depends=py
tests/session/cmd/test_sequential.py:683:        depends = ["env1"]
tests/session/cmd/test_sequential.py:686:        depends = ["env2"]
tests/session/cmd/test_sequential.py:689:        depends = ["env3"]
tests/tox_env/python/virtual_env/package/test_package_pyproject.py:603:    assert build_env  # has a value (name depends on Python version)

def test_depends_wheel(tox_project: ToxProjectCreator, patch_prev_py: Callable[[bool], tuple[str, str]]) -> None:
    prev_ver, impl = patch_prev_py(True)  # has previous python
    ver = sys.version_info[0:2]
    py = f"py{''.join(str(i) for i in ver)}"
    prev_py = f"py{prev_ver}"
    ini = f"""
    [tox]
    env_list = py,{py},{prev_py},py31,cov2,cov
    [testenv]
    package = wheel
    [testenv:cov]
    depends = py,{py},{prev_py},py31
    skip_install = true
    [testenv:cov2]
    depends = cov
    skip_install = true
    """
    project = tox_project({"tox.ini": ini, "pyproject.toml": ""})
    outcome = project.run("de")
    outcome.assert_success()

    expected =
…[3941 chars omitted]…
project({"tox.toml": toml})
    outcome = project.run("de")
    outcome.assert_success()
    expected = dedent("""\
    Execution order: a, b, cov
    ALL
       a
       b
       cov
          a
          b
    """)
    assert outcome.out == expected


def test_depends_help(tox_project: ToxProjectCreator) -> None:
    outcome = tox_project({"tox.ini": ""}).run("de", "-h")
    outcome.assert_success()

    order, todo = run_order(state, to_run_list)
                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/tox/session/cmd/run/common.py", line 441, in run_order
    depends = set(cast("EnvList", run_env.conf["depends"]).envs)
                                  ~~~~~~~~~~~~^^^^^^^^^^^
  File "/repo/src/tox/config/sets.py", line 150, in __getitem__
    r
…[1505 chars omitted]…
tor_groups(value):
                 ^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/tox/config/loader/ini/factor.py", line 87, in find_factor_groups
    for env in expand_env_with_negation(value):
               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/tox/config/loader/ini/factor.py", line 105, in expand_env_with_negation
    raise ValueError(variant_str)
ValueError: 3.*
RC=1
/tmp/tmp.uZi8cf5eJ2

str]:
        return set(self._section_proxy.keys())

    def get_section(self, name: str) -> SectionProxy | None:
        # needed for non tox environment replacements
        if self._parser.has_section(name):
            return self._parser[name]
        return None

    def __repr__(self) -> str:
        return f"{self.__class__.__name__}(section={self._section.key}, overrides={self.overrides!r})"

    for env in expand_env_with_negation(value):
        result = [name_with_negate(f) for f in env.split("-")]
        yield result


_FACTOR_RE = re.compile(r"(?:!?[\w._][\w._-]*|^$)")


def expand_env_with_negation(value: str) -> Iterator[str]:
    """Transform '{py,!pi}-{a,b},c' to ['py-a', 'py-b', '!pi-a', '!pi-b', 'c']."""
    for key, group in groupby(re.split(r"((?:{[^}]+})+
…[3123 chars omitted]…
            of_type=list[Command],
            default=[],
grep: src/tox/tox_env/__pycache__/runner.cpython-312.pyc: binary file matches
src/tox/tox_env/runner.py:43:            "depends",
src/tox/tox_env/runner.py:45:            desc="tox environments that this environment depends on (must be run after those)",
src/tox/config/loader/ini/replace.py:59:                    #   depends = {py39,py38}-{,b}

tests/test_run.py:18:@pytest.mark.parametrize("exception", [HandledError, KeyboardInterrupt])

recreate_commands = 
change_dir = /tmp/tmp.v23KKgBzyY
args_are_paths = True
ignore_errors = False
commands_retry = 0
ignore_outcome = False
fail_fast = False
default_base_python = /usr/local/bin/python
base_python = /usr/local/bin/python
env_site_packages_dir = /tmp/tmp.v23KKgBzyY/.tox/py/lib/python3.12/site-packages
env_site_packages_dir_plat = /tmp/tmp.v23KKgBzyY/.tox/py/lib/python3.12/site-packages
env_bin_dir = /tmp/tmp.v23KKgBzyY/.tox/py/bin
env_python = /tmp/tmp.v23KKgBzyY/.tox/py/bin/python
py_dot_ver = 3.12
py_impl = cpython
py_free_threaded = False
deps = #
…[1720 chars omitted]…
 in build
    result = self.to(exploded, of_type, factory)
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  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 137, in factory
    raise TypeError(raw)
TypeError: 1
  py: FAIL code 2 (0.33 seconds)
  evaluation failed :( (0.46 seconds)

    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]…
d at start)",
        )
        self.add_constant("host_python", "the host python executable path", sys.executable)

    def _on_duplicate_conf(self, key: str, definition: ConfigDefinition[V]) -> None:
        pass  # core definitions may be defined multiple times as long as all their options match, first defined wins


class EnvConfigSet(ConfigSet):
    """Configuration set for a tox environment."""

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
…[8628 chars omitted]…
e:
    """Setup the state object of this run."""
    start = time.monotonic()
    # parse CLI arguments
    options = get_options(*args)
    options.parsed.start = start
    if options.parsed.exit_and_dump_after:
        faulthandler.dump_traceback_later(timeout=options.parsed.exit_and_dump_after, exit=True)  # pragma: no cover
    # build tox environment config objects
    return State(options, args)

    """
    project = tox_project({"tox.ini": ini})
    result = project.run()
    assert "ROOT: All envs: explicit, section, implicit" in result.out
    assert "ROOT: Default envs: explicit" in result.out


def test_plugin_can_read_sections(tox_project: ToxProjectCreator, mocker: MockerFixture) -> None:
    @impl
    def tox_add_core_config(core_conf: CoreConfigSet, state: State) -> None:  # noqa: ARG001
        logging.warning("Sections: %s", ", ".join(i.key for i in state.conf.sections()))

    register_inline_plugi
…[1854 chars omitted]…
   def tox_add_env_config(env_conf: EnvConfigSet, state: State) -> None:  # noqa: ARG001
        env_conf["set_env"].update({"MAGI_CAL": "magi_cal"})

    register_inline_plugin(mocker, tox_add_env_config)
100:        "a: tox_on_install PythonRun deps",
107:        "b: tox_on_install PythonRun deps",
191:        env_conf.loaders.insert(0, MemoryLoader(deps=[1]))
193:            assert env_conf["deps"]

    def _register_config(self) -> None:
        super(
…[2184 chars omitted]…
:                deps = package_env.load_deps_for_env(self.conf)
141:        if deps and not self.options.package_only:
142:            self._install(deps, PythonRun.__name__, "package_deps")
152:            self._install_deps()
155:    def _install_deps(self) -> None:
156:        requirements_file: PythonDeps = self.conf["deps"]
157:        self._install(requirements_file, PythonRun.__name__, "deps")

src/tox/config/loader/toml/_replace.py:140:        return [] if extending else ""
src/tox/config/loader/toml/_replace.py:141:    return validate(default, list) if extending else validate(default, str)
src/tox/config/loader/toml/__init__.py:135:                envs.extend(expand_product(item))

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]…
in if replacement",
tests/config/source/test_toml_pyproject.py:642:            "No 'then' value was supplied in if replacement",
tests/config/source/test_toml_pyproject.py:662:def test_config_in_toml_replace_if_error(tox_project: ToxProjectCreator, condition_toml: str, error_match: str) -> None:
tests/config/source/test_toml_pyproject.py:666:        description = {{ replace = "if", {condition_toml} }}

    outcome.assert_success()
    outcome.assert_out_err("[testenv:A]\ncommands = python\n", "")


def test_config_in_toml_replace_posargs_set(tox_project: ToxProjectCreator) -> None:
    project = tox_project({
        "pyproject.toml": """
        [tool.tox.env.A]
        commands = [["python", { replace = "posargs", default = ["a", "b"], extend = true } ]]
        """
    })
    outcome = project.run("c", "-e", "A", "-k", "commands", "--", "c", "d")

…[8629 chars omitted]…
t):
            return not bool(_eval(node.operand))
        if isinstance(node, ast.Compare) and len(node.ops) == 1 and len(node.comparators) == 1:
            left = _eval(node.left)
            right = _eval(node.comparators[0])
            if isinstance(node.ops[0], ast.Eq):
                return left == right
            if isinstance(node.ops[0], ast.NotEq):
                return left != right

141:    return validate(default, list) if extending else validate(default, str)
209:class TomlReplaceLoader(ReplaceReference):
214:    def __call__(self,
…[3312 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",
]

if TYPE_CHECKING:
    from collections.abc import Callable
    from configparser import ConfigParser

    from tests.conftest import ToxIniCreator
    from tox.config.main import Config


def test_factor_env_discover_empty() -> None:
    result = list(find_envs("\n\n"))
    assert result == []


@pytest.fixture(scope="session")
def complex_example() -> str:
    return dedent(
        """
    default
    lines
    py: py only
    !py: not py
    {py,!pi}-{a,b}{,-dev},c: complex
    py, d: space
    extra: extra
    more-default
    no:space
    trailing
…[3513 chars omitted]…
within the core env-list then that's also an environment"""
    config = tox_ini_conf(
        """
        [tox]
        env_list = py37-{django15,django16}
        [testenv]
        deps =
            pytest
            django15: Django>=1.5,<1.6
            django16: Django>=1.6,<1.7
            py36: unittest2
        """,
    )

    assert list(config) == ["py37-django15", "py37-django16", "py36"]

    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
…[848 chars omitted]…
env_list(value: Any) -> EnvList:
        if isinstance(value, EnvList):
            return value
        if isinstance(value, str):
            return StrConvert.to_env_list(value)
        raise TypeError(value)
from __future__ import annotations

import os
from functools import partial
from pathlib import Path
from typing import TYPE_CHECKING

import pytest

from tox.config.loader.api import Override

    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: 
…[4061 chars omitted]…
ader.py:63:    loaded = loader.load("a", of_type=of_type, conf=None, factory=None, args=args)
tests/config/loader/test_memory_loader.py:84:        loader.load("a", of_type=of_type, conf=None, factory=None, args=args)
tests/config/loader/test_toml_loader.py:29:def factory_na(obj: object) -> NoReturn:
tests/config/loader/test_toml_loader.py:40:    return loader.load(key, of_type, factory_na, None, args)

tests/config/test_sets.py:95:    with pytest.raises(TypeError) as context:
tests/config/test_sets.py:179:    with pytest.raises(TypeError, match="Can't instantiate"):
tests/config/test_sets.py:186:    with pytest.raises(TypeError, match="1"):
tests/plugin/test_plugin.py:192:        with pytest.raises(TypeError, match="1"):

    :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 groups, joined with ``-``

    """
    raw_groups = value["product"]
    if not isinstance(raw_groups, list):
        msg = f"product value must be a list of factor groups, got {type(raw_groups).__name__}"
        raise TypeError(msg)
    if not raw_groups:
        return []
    expanded = [expand_factor_group(g) for g in raw_g
…[929 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",
]

src/tox/session/env_select.py:384:                        except Exception:  # noqa: BLE001
src/tox/tox_env/runner.py:147:            except Exception:

Required-by: 
* master

        "description": {
          "type": "string",
          "description": "description attached to the tox environment"
        },
        "depends": {
          "type": "array",
          "items": {
            "oneOf": [
              {
                "$ref": "#/definitions/subs"
              },
              {
                "type": "object",
                "required": ["product"],
                "properties": {
                  "product": {
                    "type": "array",
                    "items": {
                      "o
…[2621 chars omitted]…
ce/config.rst:1078:    ``depends = *`` will depend on all other environments without creating a cycle.
docs/reference/config.rst:1082:       ``depends`` does not pull in dependencies into the run target, for example if you select ``3.13,3.12,coverage``
docs/reference/config.rst:1083:       via the ``-e`` tox will only run those three (even if ``coverage`` may specify as ``depends`` other targets too -

Features - 4.46.0
=================

- Add architecture (ISA) awareness to Python discovery. tox now propagates the ``machine`` field (e.g. ``arm64``,
  ``x86_64``) from :pypi:`virtualenv`'s interpreter info — derived from :func:`python:sysconfig.get_platform` — through
  the Python specification, validation, and journal. This allows selecting a Python interpreter by CPU architecture via
  :ref:`base_python` (e.g. ``cpython3.12-64-arm64``) and ensures tox validates the running interpreter's architecture
  matches the requested one. Requires ``virtualenv >= 20.39`` - by :user:`rahuldevikar`. (:issue:`3069`)
- Add ``env_base`` TOML sections for named environment templates that generate multiple environm
…[6522 chars omitted]…
un target, for example if you select ``3.13,3.12,coverage``
       via the ``-e`` tox will only run those three (even if ``coverage`` may specify as ``depends`` other targets too -
       such as ``3.13, 3.12, 3.11``). This is solely meant to specify dependencies and order in between a target run
       set.

.. conf::
    :keys: extra_setup_commands
    :default: <empty list>
    :version_added: 4.37

                with self._log_handler.with_context(name):
                    try:
                        run_e
…[6541 chars omitted]…
)  # noqa: PERF401
            except Exception as exception:  # noqa: BLE001
                packager_list.append(f"... ({exception})")
            names = " | ".join(packager_list)
            if names:
                print(f" ~ {names}", end="")  # noqa: T201
        print()  # noqa: T201
        at += 1
        for dep in deps[env]:
            _handle(at, dep)

    _handle(0, "ALL")
    return 0

     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))
-            )
-        ):
-            rai
…[1142 chars omitted]…
ment]"
+    if isinstance(raw, list):
+        invalid = [
+            f"[{at}] {type(item).__name__}" for at, item in enumerate(raw) if not isinstance(item, (str, Requirement))
+        ]
+        if invalid:
+            return f"{expected}, got list with invalid items: {', '.join(invalid)}"
+    return f"{expected}, got {type(raw).__name__}: {raw!r}"
+
+
 ONE_ARG = {
     "-i",
     "--index-url",

=== c int
env_site_packages_dir = /tmp/tmp.wi0NdKeMoM/.tox/py/lib/python3.12/site-packages
env_site_packages_dir_plat = /tmp/tmp.wi0NdKeMoM/.tox/py/lib/python3.12/site-packages
env_bin_dir = /tmp/tmp.wi0NdKeMoM/.tox/py/bin
env_python = /tmp/tmp.wi0NdKeMoM/.tox/py/bin/python
py_dot_ver = 3.12
py_impl = cpython
py_free_threaded = False
deps = # Exception: HandledError('failed to load py.deps: deps expected str, list[str], or list[Requirement], got int: 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
=== r int
  File "/repo/src/tox/tox_env/python/runner.py", lin
…[3015 chars omitted]…
 conf, raw, args)
                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/tox/config/loader/toml/__init__.py", line 80, in build
    raise HandledError(msg) from exception
tox.report.HandledError: failed to load py.deps: deps expected str, list[str], or list[Requirement], got list with invalid items: [1] int
  py: SKIP (0.01 seconds)
  evaluation failed :( (0.24 seconds)

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "/repo/src/tox/session/cmd/run/common.py", line 344, in _queue_and_wait
    result = future.result()
             ^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/concurrent/futures/_base.py", line 449, in result
    return self.__get_resul
…[5149 chars omitted]…
as, of_type, factory, conf, raw, args)
                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/tox/config/loader/toml/__init__.py", line 80, in build
    raise HandledError(msg) from exception
tox.report.HandledError: failed to load py.deps: deps expected str, list[str], or list[Requirement], got int: 1
  py: SKIP (0.01 seconds)
  evaluation failed :( (0.24 seconds)
RC=1

            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
…[3621 chars omitted]…
 result.fail_fast)
grep: src/tox/session/cmd/run/__pycache__/common.cpython-312.pyc: binary file matches
grep: src/tox/session/cmd/run/__pycache__/single.cpython-312.pyc: binary file matches
src/tox/session/cmd/run/common.py:379:                logging.exception("Internal Error")  # pragma: no cover
src/tox/session/cmd/run/single.py:67:            LOGGER.exception("internal error")  # pragma: no cover

                        spinner.print_report = False
                    if result is not None:
                        _handle_one_run_done(result, spinner, state, live)
                    if final_run:
                        br
…[2181 chars omitted]…
llPackageAction(Action):
    def __call__(
        self,
        parser: ArgumentParser,  # noqa: ARG002
        namespace: Namespace,
        values: str | Sequence[Any] | None,
        option_string: str | None = None,  # noqa: ARG002
    ) -> None:
        if not values:
            raise ArgumentError(self, "cannot be empty")
        raw = cast("str", values)
        path = self._resolve_path(raw)

The above exception was the direct cause of the following exception:

Traceback (most recent call last):
  File "/usr/local/lib/python3.12/threading.py", line 1075, in _bootstrap_inner
    self.run()
  File "/usr/local/lib/python3.12/threading.py", line 1012, in run
    self._target(*self._args, **self._kwargs)
  File "/repo/src/tox/sess
…[2069 chars omitted]…
as, of_type, factory, conf, raw, args)
                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/tox/config/loader/toml/__init__.py", line 80, in build
    raise HandledError(msg) from exception
tox.report.HandledError: failed to load py.deps: deps expected str, list[str], or list[Requirement], got int: 1
  py: SKIP (0.01 seconds)
  evaluation failed :( (0.21 seconds)
RC=1

        # warn about unused config keys
        _warn_unused_config(state)
        # report the outcome
        exit_code = report(
            state.conf.options.start,
            ordered_results,
            state.conf.options.is_colored,
            state.conf.options.verbosity,

E         ERROR: Could not find a version that satisfies the requirement tox (from versions: none)
E         ERROR: No matching distribution found for t
…[4845 chars omitted]…
_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...
FAILED tests/plugin/test_plugin.py::test_plugin_injects_invalid_python_run - ...
14 failed, 107 passed in 7.54s

ERROR tests/config/cli/test_argcomplete.py
!!!!!!!!!!!!!!!!!!!! Interrupted: 1 error during collection !!!!!!!!!!!!!!!!!!!!
1 error in 2.93s

            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
            validate(val, list[str])
        elif casting_to in {di
…[6922 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, 6535 passed, 4 skipped in 136.98s (0:02:16)

=== extend true r
test: install_deps> python -I -m pip install extra-pkg
WARNING: Retrying (Retry(total=4, connect=None, read=None, redirect=None, status=None)) after connection broken by 'NameResolutionError("HTTPSConnection(host='pypi.org', port=443): Failed to resolve 'pypi.org' ([Errno -3] Temporary failure in name resolution)")': /simple/extra-pkg/
WARNING: Retrying (Retry(total=3, connect=None, read=None, redirect
…[978 chars omitted]…
ve 'pypi.org' ([Errno -3] Temporary failure in name resolution)")': /simple/extra-pkg/
ERROR: Could not find a version that satisfies the requirement extra-pkg (from versions: none)
ERROR: No matching distribution found for extra-pkg
test: exit 1 (8.12 seconds) /tmp/tmp.5xqZynB98o> python -I -m pip install extra-pkg pid=2050
  test: FAIL code 1 (8.20 seconds)
  evaluation failed :( (8.28 seconds)


    """Transform a value into a string representation.

    :param value: the value in question

    :returns: a tuple, first the value as str, second a flag if the value if a multi-line one

    """
    if isinstance(value, str):
        return value, False
    if isinstance(value, (Path, float, int, bool)):
        return str(value), False
    if isinstance(value, Mapping):
        return "\n".join(f"{stringify(k)[0]}={stringify(v)[0]}" for k, v in value.items()), True
    if isinstance(value, Sequence):
        return "\n".join(stringify(i)[0] for i in
…[306 chars omitted]…
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",)
['extra-pkg'] -> ('extra-pkg', True)
['a', 'b'] -> ('a\nb', True)
{'a': 1} -> ('a=1', True)
['extra-pkg', 'x'] -> ('extra-pkg\nx', True)

Execution order: 3.12, 3.13, a1, al2, lint, cov
ALL
   3.12
   3.13
   a1
   al2
   lint
   cov
      3.12
      3.13
      a1
      al2
      lint
=== 3.*,lint
Execution order: 3.12, 3.13, a1, al2, lint, cov
ALL
   3.12
   3.13
   a1
   al2
   lint
   cov
      3.12
      3.13
      lint
=== [al]*
Execution order: 3.12, 3.13, a1, al2, lint, cov
ALL
   3.12
   3.13
   a1
   al2
   lint
   cov
      a1
      al2
      lint

            raise TypeError(_factory_type_error("constraints", raw))$
        return cls(cast("str | list[str] | list[Requirement]", raw), root)$
$
$
$
def _factory_deps_valid(raw: object) -> bool:$
    return isinstance(raw, str) or ($
        isinstance(raw, list) and all(isinstance(item, (str, Requirement)) for item in raw)$
    )$
$
$
def _fac
…[269 chars omitted]…
tem, (str, Requirement))$
        ]$
        if invalid:$
            return f"{expected}, got list with invalid items: {', '.join(invalid)}"$
    return f"{expected}, got {type(raw).__name__}: {raw!r}"$
$
$
ONE_ARG = {$
    "-i",$
    "--index-url",$
    "--extra-index-url",$
    "-e",$
    "--editable",$
    "-c",$
    "--constraint",$
    "-r",$
    "--requirement",$
    "-f",$
    "--find-links",$

  congratulations :) (0.15 seconds)
RC=0
=== depends = 1
  py: SKIP (0.01 seconds)
  evaluation failed :( (0.08 seconds)
ROOT: HandledError| failed to load py.depends: env_list must be a list, got int
RC=0

 def expand_env_with_negation(value: str) -> Iterator[str]:
diff --git a/src/tox/config/loader/toml/__init__.py b/src/tox/config/loader/toml/__init__.py
index dac45ac..2ecc66d 100644
--- a/src/tox/config/loader/toml/__init__.py
+++ b/src/tox/config/loader/toml/__init__.py
@@ -62,7 +62,7 @@ class TomlLoader(Loader[TomlTypes]):
 
     def build(  # noqa: PLR0913
         self,
-        key: str,  # noqa: ARG002
+        key: str,
         of_type: type[_T
…[5790 chars omitted]…
ment]"
+    if isinstance(raw, list):
+        invalid = [
+            f"[{at}] {type(item).__name__}" for at, item in enumerate(raw) if not isinstance(item, (str, Requirement))
+        ]
+        if invalid:
+            return f"{expected}, got list with invalid items: {', '.join(invalid)}"
+    return f"{expected}, got {type(raw).__name__}: {raw!r}"
+
+
 ONE_ARG = {
     "-i",
     "--index-url",

drwxr-xr-x 1 root root  4096 Nov  1 18:46 ..
-rw-r--r-- 1 root root     0 Nov  1 18:47 install.log
drwx------ 4 root root  4096 Nov  1 18:51 pytest-of-root
drwx------ 3 root root  4096 Nov  1 18:54 tmp.1aFRaAvVle
drwx------ 2 root root  4096 Nov  1 18:54 tmp.5Akv4YkqQw
drwx------ 3 root root  4096 Nov  1 18:54 tmp.5xqZynB98o
drwx------ 2 root root  4096 Nov  1 18:55 tmp.CllTgNBLQ1
drwx------ 3 root root  4096 Nov  1 18:48 tmp.DQShgof1vb
drwx------ 2 root root  4096 Nov  1 18:55 tmp.Dija5cIcmA
drwx------ 3 root root  4096 Nov  1 
…[2451 chars omitted]…
ject.toml
/tmp/tmp.5xqZynB98o/.tox/.gitignore
/tmp/tmp.5xqZynB98o/.tox/CACHEDIR.TAG
/tmp/tmp.YPGKlQSU3h/tox.toml
/tmp/tmp.hibsW59Ov2/tox.toml
/tmp/tmp.Dija5cIcmA/tox.toml
/tmp/tmp.uZi8cf5eJ2/tox.ini
/tmp/tmp.MJK6Mv5PM2/tox.toml
/tmp/tmp.MJK6Mv5PM2/.tox/.gitignore
/tmp/tmp.MJK6Mv5PM2/.tox/CACHEDIR.TAG
/tmp/tmp.emo54kvx2t/tox.toml
/tmp/tmp.emo54kvx2t/.tox/.gitignore
/tmp/tmp.emo54kvx2t/.tox/CACHEDIR.TAG

    return self.load(item)
           ^^^^^^^^^^^^^^^
  File "/repo/src/tox/config/sets.py", line 162, in load
    return config_definition.__call__(self._conf, self.loaders, ConfigLoadArgs(chain, self.name, self.env_name))  # noqa: PLC2801
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
…[667 chars omitted]…
loader/convert.py", line 56, in to
    return factory(raw)
           ^^^^^^^^^^^^
  File "/repo/src/tox/tox_env/python/pip/req_file.py", line 131, in factory
    raise TypeError(_factory_type_error("deps", raw))
TypeError: deps expected str, list[str], or list[Requirement], got list with invalid items: [0] int
  py: FAIL code 2 (0.06 seconds)
  evaluation failed :( (0.13 seconds)

.
1 passed in 0.79s