pytest-dev-pytest-14540-14567

01221dc base
AUTHORS
CHANGELOG.rst
CITATION
CODE_OF_CONDUCT.md
CONTRIBUTING.rst
LICENSE
OPENCOLLECTIVE.rst
README.rst
RELEASING.rst
SECURITY.md
TIDELIFT.rst

bench
changelog
codecov.yml
doc
extra
pyproject.toml
scripts
src
testing
tox.ini
__init__.py
_argcomplete.py
_code
_io
_py
_version.py
assertion
cacheprovider.py
capture.py
compat.py
config
debugging.py
deprecated.py
doctest.py
faulthandler.py
fixtures.py
freeze_support.py
helpconfig.py
hookspec.py
junitxml.py
legacypath.py
logging.py
main.py
mark
monkeypatch.py
nodes.py
outcomes.py
pastebin.py
pathlib.py
py.typed
pytester.py
pytester_assertions.py
python.py
python_api.py
raises.py
recwarn.py
reports.py
runner.py
scope.py
setuponly.py
setupplan.py
skipping.py
stash.py
stepwise.py
subtests.py
terminal.py
terminalprogress.py
threadexception.py
timing.py
tmpdir.py

48:from _pytest.compat import NOTSET
131:                if parent.nodeid == fixturedef.baseid:
144:        # with global visibility (no node). In this case compare baseids, which
146:        # This branch can be removed once baseid deprecation is done (pytest 10).
147:        if candidate.baseid == other.baseid:
149:        if other.baseid == "":
151:        # `candidate.baseid` must continue with a node separator for it to be a
153:        return candidate.baseid.startswith(other.baseid) and candidate.baseid[
154:            len(other.baseid)
648:            return RequestFixtureDef(self)
700:            param = NOTSET
835:        if param is not NOTSET:

1049:class FixtureDef(Generic[FixtureValue]):
1059:        baseid: str | None,
1072:        # Emit deprecation warning if baseid string is used when node could be provided.
1073:        # baseid=None (global plugins) and baseid="" (
…[1954 chars omitted]…
# Legacy: parsefactories(node) - node has .obj attribute
2103:                self._register_fixture(
2146:            elif fixturedef.baseid in parentnodeids:
2180:    from _pytest.python import DirectParamFixtureDef
2194:        if isinstance(fixturedef, DirectParamFixtureDef):
2278:                    len(fixturedef.baseid),
2288:    for baseid, module, prettypath, argname, fixturedef in available:

# mypy: allow-untyped-defs
from __future__ import annotations

import abc
from collections import defaultdict
from collections import deque
from collections import OrderedDict
from collections.abc import Callable
from collections.abc import Generator
from collections.abc import Iterable
from collections.abc import Iterator
from collections.abc import Mapping

from collections.abc import MutableMapping
from collections.abc import Sequence
from collections.abc import Set as AbstractSet
import dataclasses
import functools
import inspect
import os
from pathlib import Path
import sys
import types
from typing import Any
from typing import cast
from typing import Final
from typing import final
from typing import Generic
from typing import Literal
from typing import NoReturn
from typing import overload
from typing import TYPE_CHECKING
from typing import TypeVar
import warnings

from .compat im
…[6487 chars omitted]…
118:    "Passing baseid to FixtureDef is deprecated. Pass node instead for fixture scoping."
121:FIXTURE_NODEID_DEPRECATED = PytestRemovedIn10Warning(
122:    "Passing nodeid to _register_fixture is deprecated. "
126:PARSEFACTORIES_NODEID_DEPRECATED = PytestRemovedIn10Warning(
127:    "Passing nodeid string to parsefactories is deprecated. "
128:    "Use parsefactories(holder=obj, node=node) instead."

#   def my_private_function(some, args):
#       ...
#
# Do this:
#
#   def my_private_function(some, args, *, _ispytest: bool = False):
#       check_ispytest(_ispytest)
#       ...
#
# Change all internal/allowed calls to
#
#   my_private_function(some, args, _ispytest=True)

#
# All other calls will get the default _ispytest=False and trigger
# the warning (possibly error in the future).


FIXTURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(
    "Passing baseid to FixtureDef is deprecated. Pass node instead for fixture scoping."
)

FIXTURE_NODEID_DEPRECATED = PytestRemovedIn10Warning(
    "Passing nodeid to _register_fixture is deprecated. "
    "Pass node instead for fixture scoping."
)

PARSEFACTORIES_NODEID_DEPRECATED = PytestRemovedIn10Warning(
    "Passing nodeid string to parsefactories is deprecated. "
    "Use parsefactories(holder=obj, node=node) instead."
)


def check_is
…[8628 chars omitted]…
aseid=None,
            argname="request",
            func=lambda: request,
            scope=Scope.Function,
            params=None,
            _ispytest=True,
        )
        self.cached_result = (request, [0], None)

    def addfinalizer(self, finalizer: Callable[[], object]) -> None:
        pass


def resolve_fixture_function(
    fixturedef: FixtureDef[FixtureValue], request: FixtureRequest

src/_pytest/deprecated.py:122:    "Passing nodeid to _register_fixture is deprecated. "
src/_pytest/deprecated.py:127:    "Passing nodeid string to parsefactories is deprecated. "
src/_pytest/deprecated.py:128:    "Use parsefactories(holder=obj, node=node) instead."
src/_pytest/doctest.py:557:        self.session._fixturemanager.parsefactories(self)
src/_pytest/fixtures.py:648:            return RequestFixtureDef(self)
src/_pytest/fixtures.py:1073:        # baseid=None (global plugins) and baseid="" (synthetic fixtures) are fine.
src/_pytest/fixtures.py:1097:        self.has_location: Final = node is not None or baseid is not None
src/_pytest/fixtures.py:1234:        return f"<FixtureDef argname={self.argname!r} scope={self.scope!r} baseid={self.baseid!r}>"
src/_pytest/fixtures.py:1237:class RequestFixtureDef(FixtureDef[FixtureRequest]):
src/_pytest/fixtures.py:1246:            baseid
…[2748 chars omitted]…
test/python.py:1397:                fixturedef = DirectParamFixtureDef(

src/_pytest/unittest.py:106:        self.session._fixturemanager.parsefactories(
src/_pytest/unittest.py:173:        self.session._fixturemanager._register_fixture(
src/_pytest/unittest.py:190:        self.session._fixturemanager._register_fixture(
src/_pytest/unittest.py:219:        self.session._fixturemanager._register_fixture(

if directness == "direct"
        )
    return parametrize_argnames


def deduplicate_names(*seqs: Iterable[str]) -> tuple[str, ...]:
    """De-duplicate the sequence of names while keeping the original order."""
    # Ideally we would use a set, but it does not preserve insertion order.
    return tuple(dict.fromkeys(name for seq in seqs for name in seq))


class FixtureManager:

    """pytest fixture definitions and information is stored and managed
    from this class.

    During collection fm.parsefactories() is called multiple times to parse
    fixture function definitions into FixtureDef objects and internal
    data structures.

    During collection of test functions, metafunc-mechanics instantiate
    a FuncFixtureInfo object which is cached per node/func-name.
    This FuncFixtureInfo object is later retrieved by Function nodes
    which themselves offer a fixtu
…[8630 chars omitted]…
     except KeyError:
            return None
        return tuple(self._matchfactories(fixturedefs, node))

    def _matchfactories(
        self, fixturedefs: Iterable[FixtureDef[Any]], node: nodes.Node
    ) -> Iterator[FixtureDef[Any]]:
        # Collect parent nodes and their IDs for matching
        parent_nodes = set(node.iter_parents())
        parentnodeids = {n.nodeid for n in parent_nodes}

ignore_args=direct_parametrize_args,
        )

        return FuncFixtureInfo(argnames, initialnames, names_closure, arg2fixturedefs)

    def pytest_plugin_registered(self, plugin: _PluggyPlugin, plugin_name: str) -> None:
        # Fixtures defined in conftest plugins are only visible to within the
        # conftest's directory. This is unlike fixtures in non-conftest plugins
        # which have global visibility. Conftest fixtures are deferred until
        # their Directory is collected, so we can use the Directory's nodeid.
        if plugin_name and plugin_name.endswith("conftest.py"):
            # Note: we explicitly do *not* use `plugin.__file__` here -- The

            # difference is that plugin_name has the correct capitalization on
            # case-insensitive systems (Windows) and other normalization issues
            # (issue #11816).
            conft
…[6727 chars omitted]…
thout node reference.
                self._nodeid_autousenames.setdefault(nodeid, []).append(name)
            else:
                # Global plugin autouse fixtures go under Session.
                self._node_autousenames.setdefault(self.session, []).append(name)

    @overload
    def parsefactories(
        self,
        node_or_obj: nodes.Node,
    ) -> None:
        raise NotImplementedError()

"Hint: make sure your test modules/packages have valid Python names.\n"
            "Traceback:\n"
            f"{formatted_tb}"
        ) from e
    except skip.Exception as e:
        if e.allow_module_level:
            raise
        raise nodes.Collector.CollectError(
            "Using pytest.skip outside of a test will skip the entire module. "
            "If that's your intention, pass `allow_module_level=True`. "
            "If you want to skip a specific test or an entire class, "
            "use the @pytest.mark.skip or @pytest.mark.skipif decorators."

        ) from e
    config.pluginmanager.consider_module(mod)
    return mod


class Module(nodes.File, PyCollector):
    """Collector for test classes and functions in a Python module."""

    def _getobj(self):
        return importtestmodule(self.path, self.config)

    def collect(self) -> Iterable[nodes.It
…[8629 chars omitted]…
   newcallspec = callspec.setmulti(
                    argnames=argnames,
                    valset=param_set.values,
                    id=param_id,
                    marks=param_set.marks,
                    scope=scope_,
                    param_index=param_index,
                    nodeid=nodeid,
                )
                newcalls.append(newcallspec)
        self._calls = newcalls

# file generated by vcs-versioning
# don't change, don't track in version control
from __future__ import annotations

__all__ = [
    "__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

47:    "version",
51:    "exceptiongroup>=1; python_version<'3.11'",
56:    "tomli>=1; python_version<'3.11'",
85:write_to = "src/_pytest/_version.py"
88:# See https://black.readthedocs.io/en/stable/usage_and_configuration/the_basics.html#t-target-version
89:target-version = [ "py310", "py311", "py312", "py313" ]
92:target-version = "py310"
171:lint.per-file-ignores."src/_pytest/_version.py" = [
360:minversion = "2.0"
488:title_format = "pytest {version} ({project_date})"

testing/deprecated_test.py:139:    - parsefactories(obj, nodeid_string) deprecation warning
testing/deprecated_test.py:140:    - parsefactories(obj, None) does NOT warn (standard plugin pattern)
testing/deprecated_test.py:141:    - parsefactories() with no args raises TypeError
testing/deprecated_test.py:148:        """parsefactories(obj, "path") warns; parsefactories(obj, None) does not."""
testing/deprecated_test.py:173:                    fm.parsefactories(mod_with_path, "some/nodeid")
testing/deprecated_test.py:174:                    fm.parsefactories(mod_none, None)
testing/deprecated_test.py:190:        """parsefactories() with no holder and no node_or_obj raises TypeError."""
testing/deprecated_test.py:198:                    fm.parsefactories()

def test_foo(self, fix):
                pass
        """
    )
    result = pytester.runpytest("-Werror::pytest.PytestRemovedIn10Warning")
    result.assert_outcomes(errors=1)
    result.stdout.fnmatch_lines(
        ["*PytestRemovedIn10Warning: Class-scoped fixture defined as instance method*"]
    )


def test_class_scope_classmethod_fixture_not_deprecated(pytester: Pytester) -> None:

    """A class-scoped fixture defined as @classmethod does NOT warn."""
    pytester.makepyfile(
        """
        import pytest

        class TestClass:
            @pytest.fixture(scope="class")
            @classmethod
            def fix(cls):
                cls.attr = True

            def test_foo(self, fix):
                assert type(self).attr is True
        """
    )
    result = pytester.runpytest("-Werror::pytest.PytestRemovedIn10Warning")
    result.assert_outcomes(passe
…[8628 chars omitted]…
ine_genitems(p, "--doctest-modules")
testing/test_doctest.py:141:        reprec = pytester.inline_run("--doctest-modules", "--import-mode=importlib")
testing/test_doctest.py:215:        result = pytester.runpytest("--doctest-modules")
testing/test_doctest.py:262:        result = pytester.runpytest("--doctest-modules")
testing/test_doctest.py:301:        result = pytester.runpytest("--doctest-modules")

553:    def test_txtfile_with_fixtures(self, pytester: Pytester):
556:            >>> p = getfixture('tmp_path')
564:    def test_txtfile_with_usefixtures_in_ini(self, pytester: Pytester):
568:            usefixtures = myfixture
574:            @pytest.fixture
575:            def myfixture(monkeypatch):
590:    def test_doctestmodule_with_fixtures(self, pytester: Pytester):
594:                >>> p = getfixture('tmp_path')
607:            >>> p = getfixture('tmp_path')
1155:    @pytest.fixture(params=["text", "module"])
1270:    def test_doctest_module_session_fixture(self, pytester: Pytester):
1271:        """Test that session fixtures are initialized for doctest modules (#768)."""

1272:        # session fixture which changes some global data, which will
1279:            @pytest.fixture(autouse=True, scope='session')
1280:            def myfixture():
1307:    def test_fixture_scopes
…[2716 chars omitted]…
t global_legacy == "ok"

            def test_scoped_invisible(request):
                defs = request.session._fixturemanager.getfixturedefs(
                    "scoped_legacy", request._pyfuncitem
                )
                assert defs == ()
            """
        )
        result = pytester.runpytest("-W", "ignore::pytest.PytestRemovedIn10Warning")
        result.assert_outcomes(passed=2)

result = pytester.runpytest(p, "-s")
        result.stdout.fnmatch_lines(
            [
                "001 >>> i = 0",
                "002 >>> i + 1",
                "Expected:",
                "    2",
                "Got:",
                "    1",
                "*test_txtfile_failing.txt:2: DocTestFailure",
            ]
        )

    def test_txtfile_with_fixtures(self, pytester: Pytester):
        p = pytester.maketxtfile(
            """
            >>> p = getfixture('tmp_path')
            >>> p.is_dir()
            True
        """
        )
        reprec = pytester.inline_run(p)
        reprec.assertoutcome(passed=1)

    def test_txtfile_with_usefixtures_in_ini(self, pytester: Pytester):
        pytester.makeini(
            """
            [pytest]
            usefixtures = myfixture
        """
        )
        pytester.makeconftest(
            """
   
…[8271 chars omitted]…
tcome(passed=1)


class TestDoctestReportingOption:
    def _run_doctest_report(self, pytester, format):
        pytester.makepyfile(
            """
            def foo():
                '''
                >>> foo()
                   a  b
                0  1  4
                1  2  4
                2  3  6
                '''
                print('   a  b\\n'
                      '0  1  4\\n'

14342.improvement.rst
14371.feature.rst
14373.improvement.rst
14377.bugfix.rst
14381.bugfix.rst
14389.bugfix.rst
14392.bugfix.rst
14430.improvement.rst
14434.deprecation.rst
14441.improvement.rst
14442.bugfix.rst
14456.bugfix.rst

14461.improvement.rst
14465.doc.rst
14474.bugfix.rst
14483.bugfix.rst
14492.bugfix.rst
14513.improvement.rst
14524.improvement.rst
1764.deprecation.rst
1764.improvement.rst
3697.bugfix.rst
3850.bugfix.rst
5848.bugfix.rst
6757.feature.rst
719.bugfix.rst
8265.improvement.rst
8395.feature.rst
README.rst
_template.rst
changelog/14004.deprecation.rst:1:Passing ``baseid`` to :class:`~pytest.FixtureDef` or ``nodeid`` strings to fixture registration APIs is now deprecated. These are internal pytest APIs that are used by some plugins.
doc/en/deprecations.rst:20:Passing ``baseid``/``nodeid`` strings to fixture registration APIs
doc/en/deprecations.rst:25:Passing ``base
…[60 chars omitted]…

doc/en/deprecations.rst:26:``FixtureManager._register_fixture`` and ``FixtureManager.parsefactories``
doc/en/deprecations.rst:35:    fixture_manager.parsefactories(plugin_obj, nodeid="tests/sub")
doc/en/deprecations.rst:39:    fixture_manager.parsefactories(holder=plugin_obj, node=directory_node)
doc/en/deprecations.rst:42:In pytest 10, the ``baseid`` and ``nodeid`` string parameters will be removed.

* master
.. _deprecations:

Deprecations and Removals
=========================

This page lists all pytest features that are currently deprecated or have been removed in past major releases.
The objective is to give users a clear rationale why a certain feature has been removed, and what alternatives
should be used instead.


Deprecated Features

-------------------

Below is a complete list of all pytest features which are considered deprecated. Using those features will issue
:class:`~pytest.PytestWarning` or subclasses, which can be filtered using :ref:`standard warning filters <warnings>`.


.. _fixture-nodeid-deprecated:

Passing ``baseid``/``nodeid`` strings to fixture registration APIs
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

.. deprecated:: 9.2

Passing ``baseid`` to :class:`~pytest.FixtureDef` or ``nodeid`` strings to
``FixtureManager._register_fixt
…[1373 chars omitted]…
t_code = pytest.main()


.. _pastebin-deprecated:
Passing ``baseid`` to :class:`~pytest.FixtureDef` or ``nodeid`` strings to fixture registration APIs is now deprecated. These are internal pytest APIs that are used by some plugins.

Use the ``node`` parameter instead for fixture scoping. This enables more robust node-based
matching instead of string prefix matching.

This will be removed in pytest 10.

src/_pytest/compat.py:325:        def deprecated(msg, /, *, category=None, stacklevel=1):
    * Aren't replaced with mocks.

    The cls arguments indicate that the function should be treated as a bound
    method even though it's not unless the function is a static method.

    The name parameter should be the original name in which the function was collected.
    """
    # TODO(RonnyPfannschmidt): This function should be refactored when we
    # revisit fixtures. The fixture mechanism should ask the node for
    # the fixture names, and not try to obtain directly from the
    # function object well after collection has occurred.

    # The parameters attribute of a Signature object contains an
    # ordered mapping of parameter names to Parameter instances.  This
    # creates a tuple of the names of the parameters that don't have
    # defaults.
    try:
        parameters = signat
…[1527 chars omitted]…
ch were excluded from its result
    # because they had default values.
    return tuple(
        p.name
        for p in signature(function).parameters.values()
        if p.kind in (Parameter.POSITIONAL_OR_KEYWORD, Parameter.KEYWORD_ONLY)
        and p.default is not Parameter.empty
    )


_non_printable_ascii_translate_table = {
    i: f"\\x{i:02x}" for i in range(128) if i not in range(32, 127)
}

class CallableBool:
    """
    A bool-like object that can also be called, returning its true/false value.

    Used for backwards compatibility in cases where something was supposed to be a method
    but was implemented as a simple attribute by mistake (see `TerminalReporter.isatty`).

    Do not use in new code.
    """

    def __init__(self, value: bool) -> None:
        self._value = value

    def __bool__(self) -> bool:
        return self._value

    def __call__(self) -> bool:
        return self._value


def running_on_ci() -> bool:
    """Check if we're currently running on a CI system."""
    # Only enable CI mode if one of these env variables is defined and non-empty.
    # Note: review `regendoc` tox env in case this list is changed.
    env_vars = ["CI", "BUILD_NUMBER"]
    return any(os.environ.get(var) for var in env_vars)


if sys.version_info >= (3, 13):
    from 
…[120 chars omitted]…
 deprecated
    else:

        def deprecated(msg, /, *, category=None, stacklevel=1):
            def decorator(func):
                return func

            return decorator
src/_pytest/config/__init__.py:61:from _pytest.compat import deprecated
src/_pytest/config/__init__.py:1164:        @deprecated(
src/_pytest/fixtures.py:1521:@deprecated(
src/_pytest/mark/structures.py:554:        @deprecated(

automatically from the params.

    :param name:
        The name of the fixture. This defaults to the name of the decorated
        function. If a fixture is used in the same module in which it is
        defined, the function name of the fixture will be shadowed by the
        function arg that requests the fixture; one way to resolve this is to
        name the decorated function ``fixture_<fixturename>`` and then use
        ``@pytest.fixture(name='<fixturename>')``.
    """
    fixture_marker = FixtureFunctionMarker(
        scope=scope,

        params=tuple(params) if params is not None else None,
        autouse=autouse,
        ids=None if ids is None else ids if callable(ids) else tuple(ids),
        name=name,
        _ispytest=True,
    )

    # Direct decoration.
    if fixture_function:
        return fixture_marker(fixture_function)

    return fixture_marker


@
…[2328 chars omitted]…
 deprecated. "
            "Convert argvalues to a list or tuple.",
        )
        def __call__(
            self,
            argnames: str | Sequence[str],
            argvalues: Iterable[ParameterSet | Sequence[object] | object],
            *,
            indirect: bool | Sequence[str] = ...,
            ids: Iterable[None | str | float | int | bool]
            | Callable[[Any], object | None]

def test_register_fixture_nodeid_and_autouse_legacy(
        self, pytester: Pytester
    ) -> None:
        """_register_fixture(nodeid=string) warns and autouse populates/yields.

        Covers end-to-end:
        - Deprecation warning on _register_fixture(nodeid=...)
        - _nodeid_autousenames populated for autouse + non-empty nodeid
        - _getautousenames yields from nodeid_basenames at lookup time
        """
        pytester.makeconftest(
            """

            import pytest
            import warnings

            _done = False

            def pytest_collectstart(collector):
                global _done
                if _done or not hasattr(collector.session, "_fixturemanager"):
                    return
                if collector.nodeid == "":
                    return
                _done = True
                fm = collector.session._fixturemanager

…[2605 chars omitted]…
dule_fix=[DummyFixtureDef(Scope.Module)],
testing/python/metafunc.py:206:                class_fix=[DummyFixtureDef(Scope.Class)],
testing/python/metafunc.py:207:                func_fix=[DummyFixtureDef(Scope.Function)],
testing/python/metafunc.py:208:                mixed_fix=[DummyFixtureDef(Scope.Module), DummyFixtureDef(Scope.Class)],
src/_pytest/fixtures.py:1963:        fixture_def = FixtureDef(

fatal: unable to access 'https://github.com/pytest-dev/pytest.git/': Could not resolve host: github.com

# access below can raise. safe_getattr() ignores such exceptions.
            obj_ub = safe_getattr(holderobj_tp, name, None)
            if type(obj_ub) is FixtureFunctionDefinition:
                marker = obj_ub._fixture_function_marker
                if marker.name:
                    fixture_name = marker.name
                else:
                    fixture_name = name

                # OK we know it is a fixture -- now safe to look up on the _instance_.
                try:
                    obj = getattr(holderobj, name)

                # if the fixture is named in the decorator we cannot find it in the module
                except AttributeError:
                    obj = obj_ub

                func = obj._get_wrapped_function()

                self._register_fixture(
                    name=fixture_name,
                    func=func,
                 
…[8629 chars omitted]…
rdown(self, request.function)

        self.session._fixturemanager._register_fixture(
            # Use a unique name to speed up lookup.
            name=f"_unittest_setup_method_fixture_{cls.__qualname__}",
            func=unittest_setup_method_fixture,
            node=self,
            scope="function",
            autouse=True,
        )


class TestCaseFunction(Function):
    nofuncargs = True

class DoctestModule(Module):
    def collect(self) -> Iterable[DoctestItem]:
        import doctest

        class MockAwareDocTestFinder(doctest.DocTestFinder):
            py_ver_info_minor = sys.version_info[:2]
            is_find_lineno_broken = (
                py_ver_info_minor < (3, 11)
                or (py_ver_info_minor == (3, 11) and sys.version_info.micro < 9)
                or (py_ver_info_minor == (3, 12) and sys.version_info.micro < 3)
            )
            if is_find_lineno_broken:

                def _find_lineno(self, obj, source_lines):
                    """On older Pythons, doctest code does not take into account
                    `@property`. https://github.com/python/cpython/issues/61648

                    Moreover, wrapped Doctests need to be unwrapped so the correct
                    line number is returned. #8796
                    """
      
…[4354 chars omitted]…
s",
            autouse=True,
        )

    def _register_setup_method_fixture(self) -> None:
        """Register an autouse, function scoped fixture into the collected class object
        that invokes setup_method/teardown_method if either or both are available.

        Using a fixture to invoke these methods ensures we play nicely and unsurprisingly with
        other fixtures (#517).
        """

Refused: `find /` walks the whole container FS. Scope under /repo.

3.12.13 (main, Aug  5 2026, 01:10:24) [GCC 14.2.0]
/usr/local/lib/python3.12/site-packages/pytest-0.1.dev1+g01221dc5e.dist-info
/repo/src/_pytest/fixtures.py
/repo/src/pytest
/repo/src/pytest.egg-info

faclist.insert(i, fixture_def)
                break
        else:
            faclist.append(fixture_def)
        if autouse:
            if node is not None:
                self._node_autousenames.setdefault(node, []).append(name)
            elif nodeid:
                # Legacy: plugin passed nodeid string without node reference.
                self._nodeid_autousenames.setdefault(nodeid, []).append(name)
            else:
                # Global plugin autouse fixtures go under Session.

                self._node_autousenames.setdefault(self.session, []).append(name)

    @overload
    def parsefactories(
        self,
        node_or_obj: nodes.Node,
    ) -> None:
        raise NotImplementedError()

    @overload
    def parsefactories(
        self,
        node_or_obj: object,
        nodeid: str | None,
    ) -> None:
        raise NotImplementedError()


…[1823 chars omitted]…
2)
            holderobj = node_or_obj
            effective_nodeid = nodeid
        else:
            # Legacy: parsefactories(node) - node has .obj attribute
            assert isinstance(node_or_obj, nodes.Node)
            holderobj = cast(object, node_or_obj.obj)  # type: ignore[attr-defined]
            effective_node = node_or_obj
        if holderobj in self._holderobjseen:
            return

01221dc refs/heads/master@{0}: commit (initial): base
01221dc HEAD@{0}: commit (initial): base

testing/python/metafunc.py:203:                session_fix=[DummyFixtureDef(Scope.Session)],
testing/python/metafunc.py:204:                package_fix=[DummyFixtureDef(Scope.Package)],
testing/python/metafunc.py:205:                module_fix=[DummyFixtureDef(Scope.Module)],
testing/python/metafunc.py:206:                class_fix=[DummyFixtureDef(Scope.Class)],
testing/python/metafunc.py:207:                func_fix=[DummyFixtureDef(Scope.Function)],
testing/python/metafunc.py:208:                mixed_fix=[DummyFixtureDef(Scope.Module), DummyFixtureDef(Scope.Class)],
src/_pytest/fixtures.py:648:            return RequestFixtureDef(self)
src/_pytest/fixtures.py:1049:class FixtureDef(Generic[FixtureValue]):
src/_pytest/fixtures.py:1237:class RequestFixtureDef(FixtureDef[FixtureRequest]):
src/_pytest/fixtures.py:1963:        fixture_def = FixtureDef(
src/_pytest/python.py:1158:class DirectParamFixtureDef(FixtureDef[FixtureValue]):
src/_pytest/python.py:1397:                fixturedef = DirectParamFixtureDef(

doc/en/reference/reference.rst:999:.. autoclass:: pytest.FixtureDef()

--- changelog/10819.deprecation.rst
Added a deprecation warning for class-scoped fixtures defined as instance methods (without ``@classmethod``). Such fixtures set attributes on a different instance than the test methods use, leading to unexpected behavior. Use ``@classmethod`` decorator instead -- by :user:`yastcher`.

See :issue:`10819` and :issue:`14011`.
--- changelog/11022.doc.rst
Document safer alternatives and scope guidance for monkeypatching standard library functions.
--- changelog/11225.improvement.rst
:func:`pytest.warns` now shows "Regex pattern did not match" instead of "DID NOT WARN" when warnings were emitted but the ``match`` pattern did not match.
--- changelog/11295.improvement.rst
Improved output of ``--fixtures-per-test`` by excluding internal-implementation fixtures generated by ``@pytest.mark.parametrize`` and similar.
--- changelog/11307.doc.rst
Document that `

…[8629 chars omitted]…
tead of describing internal changes which are only relevant to the developers.

Make sure to use full sentences in the **past or present tense** and use punctuation, examples::

    Improved verbose diff output with sequences.

    Terminal summary statistics now use multiple colors.

Each file should be named like ``<ISSUE>.<TYPE>.rst``, where
``<ISSUE>`` is an issue number, and ``<TYPE>`` is one of:

14513.improvement.rst
14524.improvement.rst
./doc/en/changelog.rst:1687:- `#11929 <https://github.com/pytest-dev/pytest/issues/11929>`_: Fix a regression in pytest 8.0.0 whereby autouse fixtures defined in a module get ignored by the doctests in the module.
./testing/test_doctest.py:1409:        Regression test for #11929.

439:class FixtureRequest(abc.ABC):
458:        self._pyfuncitem: Final = pyfuncitem
478:        return self._pyfuncitem.session._fixturemanager
501:        result = list(self._pyfuncitem.fixturenames)
507:    def node(self):
514:        return self._pyfuncitem.config
523:        return self._pyfuncitem.obj
530:        clscol = self._pyfuncitem.getparent(_pytest.python.Class)
539:        return getattr(self._pyfuncitem, "instance", None)
546:        mod = self._pyfuncitem.getparent(_pytest.python.Module)
555:        return self._pyfuncitem.path
566:        return self._pyfuncitem.session

663:            fixturedefs = self._fixturemanager.getfixturedefs(argname, self._pyfuncitem)
691:            callspec = self._pyfuncitem.callspec
733:        funcitem = self._pyfuncitem
770:class TopRequest(FixtureRequest):
795:    def node(self):
796:        return self._pyfuncitem
802:        item = 
…[4904 chars omitted]…
param, param_index, fixturedef, _ispytest=True
        )

        if not self.session._setupstate.is_node_active(self.node):
            # TODO(pytest10.1): Remove the `warn` and `if` and call
            # _raise_teardown_lookup_error unconditionally.
            warnings.warn(
                FIXTURE_GETFIXTUREVALUE_DURING_TEARDOWN.format(argname=argname),
                stacklevel=3,
            )

closure = set(
            traverse_fixture_closure(
                self.initialnames,
                getfixturedefs=self.name2fixturedefs.get,
            )
        )
        self.names_closure[:] = (name for name in self.names_closure if name in closure)


class FixtureRequest(abc.ABC):
    """The type of the ``request`` fixture.

    A request object gives access to the requesting test context and has a
    ``param`` attribute in case the fixture is parametrized.
    """

    def __init__(
        self,
        pyfuncitem: Function,
        fixturename: str | None,
        arg2fixturedefs: Mapping[str, Sequence[FixtureDef[Any]]],
        fixture_defs: dict[str, FixtureDef[Any]],
        *,
        _ispytest: bool = False,
    ) -> None:
        check_ispytest(_ispytest)
        #: Fixture for which this request is being performed.
        self.fixturename: Final = fixture
…[5040 chars omitted]…
       self,
        requested_fixturedef: FixtureDef[object],
        requested_scope: Scope,
    ) -> None:
        if self._scope > requested_scope:
            # Try to report something helpful.
            argname = requested_fixturedef.argname
            fixture_stack = "\n".join(
                self._format_fixturedef_line(fixturedef)
                for fixturedef in self._get_fixturestack()

388:        for option in self.config.getini(option_name):
466:            config=self.config,
561:        return importtestmodule(self.path, self.config)
678:        init_mod = importtestmodule(self.path / "__init__.py", self.config)
700:        config = self.config
967:        if self.config is None:
969:        strict_parametrization_ids = self.config.getini("strict_parametrization_ids")
971:            strict_parametrization_ids = self.config.getini("strict")
982:                    yield _ascii_escaped_by_config(parameterset.id, self.config)
1030:        if self.config:
1031:            id: str | None = self.config.hook.pytest_make_parametrize_id(
1032:                config=self.config, val=val, argname=argname

1041:            return _ascii_escaped_by_config(val, self.config)
1185:class Metafunc:
1206:        self.definition = definition
1209:        self.config = config
1313: 
…[7687 chars omitted]…
e
        # For scopes higher than function, a DirectParamFixtureDef might have
        # already been created for the scope. We thus store and cache the
        # DirectParamFixtureDef on the node related to the scope.
        if scope_ is Scope.Function:
            name2directparamfixturedef = None
        else:
            collector = self.definition.parent
            assert collector is not None

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
.E                                                                       [100%]
==================================== ERRORS ====================================
__________________________ ERROR at setup of test_fix __________________________
file /tmp/repro/test_mod.py, line 7
  def test_fix(fix):

E       fixture 'fix' not found
>       available fixtures: cache, capfd, capfdbinary, caplog, capsys, capsysbinary, capteesys, doctest_na
…[3 chars omitted]…
pace, monkeypatch, pytestconfig, record_property, record_testsuite_property, record_xml_attribute, recwarn, subtests, tmp_path, tmp_path_factory, tmpdir, tmpdir_factory
>       use 'pytest --fixtures [testpath]' for help on them.

/tmp/repro/test_mod.py:7
=========================== short test summary info ============================
ERROR ../tmp/repro/test_mod.py::test_fix
1 passed, 1 error in 0.02s

42:# Singleton type for NOTSET, as described in:
44:class NotSetType(enum.Enum):
46:NOTSET: Final = NotSetType.token
# mypy: allow-untyped-defs
"""Python version compatibility code and random general utilities."""

from __future__ import annotations

from collections.abc import Callable
import enum
import functools
import inspect

from inspect import Parameter
from inspect import Signature
import os
from pathlib import Path
import sys
from typing import Any
from typing import Final
from typing import NoReturn
from typing import TYPE_CHECKING

import py


if sys.version_info >= (3, 14):
    from annotationlib import Format


#: constant to prepare valuing pylib path replacements/lazy proxies later on
#  intended for removal in pytest 8.0 or 9.0

# fmt: off
# intentional space to create a fake difference for the verification
LEGACY_PATH = py.path. local
# fmt: on


def legacy_path(path: 
…[493 chars omitted]…
with async
    def syntax, and doesn't contain yield), or a function decorated with
    @asyncio.coroutine.

    Note: copied and modified from Python 3.5's builtin coroutines.py to avoid
    importing asyncio directly, which in turns also initializes the "logging"
    module as a side-effect (see issue #8).
    """
    return inspect.iscoroutinefunction(func) or getattr(func, "_is_coroutine", False)

total 12
drwxr-xr-x 3 root root 4096 Nov  5 11:31 .
drwx------ 1 root root 4096 Nov  5 11:31 ..
drwxr-xr-x 4 root root 4096 Nov  5 11:32 pip
total 16
drwxr-xr-x  4 root root 4096 Nov  5 11:32 .
drwxr-xr-x  3 root root 4096 Nov  5 11:31 ..
drwxr-xr-x 18 root root 4096 Nov  5 11:32 http-v2
drwxr-xr-x  2 root root 4096 Nov  5 11:32 selfcheck
total 12
drwxrwxrwt 1 root root 4096 Nov  5 11:34 .
drwxr-xr-x 1 root root 4096 Nov  5 11:29 ..

-rw-r--r-- 1 root root    0 Nov  5 11:32 install.log
drwxr-xr-x 4 root root 4096 Nov  5 11:34 repro
total 8
drwxr-xr-x 2 root root 4096 Aug  3 00:00 .
drwxr-xr-x 1 root root 4096 Nov  5 11:29 ..

No locally built wheels cached.

GPG_KEY=7169605F62C751356D054A26A821E680E5FA6305
HOME=/root
HOSTNAME=6193bad260aa
LANG=C.UTF-8
OLDPWD=/repo
PATH=/usr/local/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin
PS1=
PWD=/repo
PYTHON_SHA256=c08bc65a81971c1dd5783182826503369466c7e67374d1646519adf05207b684
PYTHON_VERSION=3.12.13
SHLVL=1
TERM=dumb

_=/usr/bin/env
total 68
drwxr-xr-x   1 root root 4096 Nov  5 11:29 .
drwxr-xr-x   1 root root 4096 Nov  5 11:29 ..
-rwxr-xr-x   1 root root    0 Nov  5 11:29 .dockerenv
lrwxrwxrwx   1 root root    7 Jul  4 09:05 bin -> usr/bin
drwxr-xr-x   2 root root 4096 Jul  4 09:05 boot
drwxr-xr-x   5 root root  340 Nov  5 11:29 dev
drwxr-xr-x   1 root root 4096 Nov  5 11:31 etc
drwxr-xr-x   2 root root 4096 Jul  4 09:05 home
lrwxrwxrwx   1 root root    7 Jul  4 09:05 lib -> usr/lib
lrwxrwxrwx   1 root root    9 Jul  4 09:05 lib64 -> usr/lib64
drwxr-xr-x   2 root root 4096 Aug  3
…[640 chars omitted]…
:32 .
drwxr-xr-x 1 root root  4096 Nov  5 11:29 ..
-rw-r--r-- 1 root root     5 Nov  5 11:29 COMMIT_EDITMSG
-rw-r--r-- 1 root root    23 Nov  5 11:29 HEAD
drwxr-xr-x 1 root root  4096 Nov  5 11:29 branches
-rw-r--r-- 1 root root   111 Nov  5 11:29 config
-rw-r--r-- 1 root root    73 Nov  5 11:29 description
drwxr-xr-x 1 root root  4096 Nov  5 11:29 hooks
-rw-r--r-- 1 root root 72598 Nov  5 11:29 index

testing/python/metafunc.py:804:        # Since `y` is a direct parameter, its DirectParamFixtureDef would
testing/python/metafunc.py:1702:    def test_reordering_with_scopeless_and_just_indirect_parametrization(
testing/python/show_fixtures_per_test.py:259:def test_should_not_show_direct_param_fixtures(pytester: Pytester) -> None:
628:        # A fixture from a plugin has no baseid set, which screwed up
1906:    def test_register_fixture_ordered_by_visibility(self, pytester: Pytester) -> None:
1919:                fm._register_fixture(name="fix", func=lambda: "session1", node=session)
1921:                fm._register_fixture(name="fix", func=lambda: "session-legacy", nodeid="")
1922:                fm._register_fixture(name="fix", func=lambda: "broken-legacy", nodeid="broken")
1923:                fm._register_fixture(name="fix", func=lambda fix: f"item1-{fix}", node=item)
1924:                fm._register_fixture(name="fix", func=lambda fix: f"item2-{fix}", node=item)
1925:                fm._register_fixture(name="fix", func=lambda: "session2", node=session)

Regression test for #7737.
        """
        pytester.makepyfile(
            """
            import pytest

            @pytest.fixture(params=[1, 2])
            def foo(request):
                return request.param

            @pytest.fixture
            def bar(foo):

                return foo

            class TestIt:
                @pytest.fixture
                def foo(self, bar):
                    return bar * 2

                def test_it(self, foo):
                    pass
            """
        )
        result = pytester.runpytest()
        assert result.ret == ExitCode.OK
        result.assert_outcomes(passed=2)

    def test_autouse_fixture_plugin(self, pytester: Pytester) -> None:
        # A fixture from a plugin has no baseid set, which screwed up
        # the autouse fixture handling.
        pytester.makepyfile(
            testplugin="""
      
…[4368 chars omitted]…
_parametrize_indirect_list_empty(self) -> None:
        """#714"""

        def func(x, y):
            pass

        metafunc = self.Metafunc(func)
        metafunc.parametrize("x, y", [("a", "b")], indirect=[])
        assert metafunc._calls[0].params == dict(x="a", y="b")
        assert list(metafunc._arg2fixturedefs.keys()) == ["x", "y"]

    def test_parametrize_indirect_wrong_type(self) -> None:

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
test_mod2.py::test_mod2.use_fix
test_mod2.py::test_fix

2 tests collected in 0.01s

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
ITEM test_mod2.py::test_mod2.use_fix DoctestItem
    DoctestItem test_mod2.py::test_mod2.use_fix 130855144423024
    DoctestModule test_mod2.py 130855144418320
    Dir . 130855144416976
    Session  130855144185696

ITEM test_mod2.py::test_fix Function
    Function test_mod2.py::test_fix 130855144421344
    Module test_mod2.py 130855144418096
    Dir . 130855144416976
    Session  130855144185696
SETUP FIX
..TEARDOWN FIX

2 passed in 0.01s

36:from _pytest import nodes
43:from _pytest.compat import ascii_escaped
44:from _pytest.compat import get_default_arg_names
45:from _pytest.compat import get_real_func
46:from _pytest.compat import getimfunc
47:from _pytest.compat import is_async_function
48:from _pytest.compat import NOTSET
49:from _pytest.compat import safe_getattr
50:from _pytest.compat import safe_isclass

deprecated updated

FixtureDef updated

RequestFixtureDef updated

manager init/plugin/register updated

def parsefactories(
        self,
        node_or_obj: nodes.Node,
    ) -> None:
        raise NotImplementedError()

    @overload
    def parsefactories(
        self,
        node_or_obj: object,
        nodeid: str | None,
    ) -> None:

        raise NotImplementedError()

    @overload
    def parsefactories(
        self,
        node_or_obj: None = ...,
        nodeid: None = ...,
        *,
        holder: object,
        node: nodes.Node,
    ) -> None:
        raise NotImplementedError()

    def parsefactories(
        self,
        node_or_obj: nodes.Node | object | None = None,
        nodeid: str | NotSetType | None = NOTSET,
        *,
        holder: object | None = None,
        node: nodes.Node | None = None,
    ) -> None:
        """Collect fixtures from a collection node or object.

        Found fixtures are parsed into `FixtureDef`s and saved.

        The
…[2524 chars omitted]…
ance_.
                try:
                    obj = getattr(holderobj, name)
                # if the fixture is named in the decorator we cannot find it in the module
                except AttributeError:
                    obj = obj_ub

                func = obj._get_wrapped_function()

                self._register_fixture(
                    name=fixture_name,
                    func=func,

parsefactories updated

python.py updated

src/_pytest/deprecated.py:121:FIXTURE_HAS_LOCATION_DEPRECATED = PytestRemovedIn10Warning(
src/_pytest/deprecated.py:122:    "FixtureDef.has_location is deprecated. Use FixtureDef.node instead."
src/_pytest/fixtures.py:62:from _pytest.deprecated import FIXTURE_HAS_LOCATION_DEPRECATED
src/_pytest/fixtures.py:487:    def has_location(self) -> bool:
src/_pytest/fixtures.py:488:        warnings.warn(FIXTURE_HAS_LOCATION_DEPRECATED, stacklevel=2)
src/_pytest/fixtures.py:489:        return self._has_location
src/_pytest/fixtures.py:1116:        self._has_location: Final = node is not None or baseid is not None
src/_pytest/python.py:1158:class DirectParamFixtureDef(FixtureDef[FixtureValue]):
src/_pytest/python.py:1398:                fixturedef = DirectParamFixtureDef(
grep: src/_pytest/__pycache__/fixtures.cpython-312.pyc: binary file matches

#   this cannot be reflected in the type.
        # - Technically `param` is only (possibly) defined on SubRequest, not
        #   FixtureRequest, but the typing of that is still in flux so this cheats.
        # - In the future we might consider using a generic for the param type, but
        #   for now just using Any.
        self.param: Any

    @property
    def _fixturemanager(self) -> FixtureManager:
        return self._pyfuncitem.session._fixturemanager

    @property

    @abc.abstractmethod
    def _scope(self) -> Scope:
        raise NotImplementedError()

    @property
    def has_location(self) -> bool:
        warnings.warn(FIXTURE_HAS_LOCATION_DEPRECATED, stacklevel=2)
        return self._has_location

    @property
    def scope(self) -> ScopeName:
        """Scope string, one of "function", "class", "module", "package", "session"."""
        return self._sco
…[1584 chars omitted]…
me)
        # If the fixture was executed, the current value of the fixture.
        # Can change if the fixture is executed with different parameters.
        self.cached_result: _FixtureCachedResult[FixtureValue] | None = None
        self._finalizers: Final[list[Callable[[], object]]] = []

        # only used to emit a deprecationwarning, can be removed in pytest9
        self._autouse = _autouse

492:    def scope(self) -> ScopeName:
1055:class FixtureDef(Generic[FixtureValue]):
1147:    def scope(self) -> ScopeName:
        self.cached_result: _FixtureCachedResult[FixtureValue] | None = None
        self._finalizers: Final[list[Callable[[], object]]] = []

        # only used to emit a deprecationwarning, can be removed in pytest9
        self._autouse = _autouse

    @property
    def scope(self) -> ScopeName:
        """Scope string, one of "function", "class", "module", "package", "session"."""

        return self._scope.value

    def addfinalizer(self, finalizer: Callable[[], object]) -> None:
        self._finalizers.append(finalizer)

    def finish(self, request: SubRequest) -> None:
        if self.cached_result is None:
            # Already finished. It is assumed that finalizers cannot be added in
            # this state.
            return

        exceptions: list[BaseException] = []
        while self._finalizers:
            fin = self._finalizers.pop()
            try:
                fin()
            except BaseException as e:

property moved
1111:        self._has_location: Final = node is not None or baseid is not None
1142:    def has_location(self) -> bool:
1144:        return self._has_location

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
ITEM test_mod.py::test_mod.use_fix DoctestItem
    DoctestItem test_mod.py::test_mod.use_fix 130613359181648
    DoctestModule test_mod.py 130613359176608
    Dir . 130613359175600
    Session  130613358927936

ITEM test_mod.py::test_fix Function
    Function test_mod.py::test_fix 130613359179968
    Module test_mod.py 130613359176384
    Dir . 130613359175600
    Session  130613358927936
..                                                                       [100%]
2 passed in 0.01s

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
..                                                                       [100%]
2 passed in 0.01s
4

Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
..                                                                       [100%]
2 passed in 0.01s
2 /tmp/repro2/base/calls.txt
call
call

ERROR: /repo/pyproject.toml: 'minversion' requires pytest-2.0, actual pytest-0.1.dev1+g01221dc5e'

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
........................................................................ [ 51%]
.....x...............................................................    [100%]
140 passed, 1 xfailed in 6.32s

INTERNALERROR>   File "/usr/local/lib/python3.12/site-packages/pluggy/_manager.py", line 183, in _hookexec
INTERNALERROR>     return self._inner_hookexec(hook_name, methods, kwargs, firstresult)
INTERNALERROR>            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
INTERNALERROR>   File "/usr/local/lib/python3.12/site-packages/pluggy/_manager.py", line 598, in traced_hookexec
INTERNALERROR>     return outcome.get_result()
INTERNALERROR>            ^^^^^^^^^^^^^^^^^^^^
INTERNALERROR>   File "/usr/local/lib/python3.12/site-packages/pluggy/_result.py", line 103, in get_result
INTERNALERROR>     raise exc.with_traceback(tb)
INTERNALERROR>   File "/usr/local/lib/python3.12/site-packages/pluggy/_result.py", line 62, in from_call
INTERNALERROR>     result = func()
INTERNALERROR>              ^^^^^^
INTERNALERROR>   File "/usr/local/lib/python3.12/site-packages/pluggy/_manage

…[4589 chars omitted]…
n([<warnings.WarningMessage object at 0x7a4d6a84c530>, <warnings.WarningMessage object at 0x7a4d6a84c500>])

============================ no tests ran in 0.03s =============================
=========================== short test summary info ============================
FAILED testing/deprecated_test.py::TestFixtureNodeidDeprecations::test_parsefactories_nodeid_deprecation
1 failed, 13 passed in 1.28s

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
...............................x........................................ [ 32%]
....................x................................................... [ 64%]
........................................................s............... [ 97%]
......                                                                   [100%]
219 passed, 1 skipped, 2 xfailed in 13.14s

def test_parametrize_iterator_deprecation(self) -> None:
        """Test that using iterators for argvalues raises a deprecation warning."""
    
        def func(x: int) -> None:
            raise NotImplementedError()
    
        def data_generator() -> Iterator[int]:
            yield 1
            yield 2
    
        metafunc = self.Metafunc(func)
    

        with pytest.warns(
            pytest.PytestRemovedIn10Warning,
            match=r"Passing a non-Collection iterable to parametrize is deprecated",
        ):
>           metafunc.parametrize("x", data_generator())

testing/python/metafunc.py:1165: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
src/_pytest/python.py:1398: in parametrize
    fixturedef = DirectParamFixtureDef(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <[AttributeError("'
…[1670 chars omitted]…
afunc::test_parametrize_indirect_list
FAILED testing/python/metafunc.py::TestMetafunc::test_parametrize_indirect_list_empty
FAILED testing/python/metafunc.py::TestMetafunc::test_parametrize_onearg - At...
FAILED testing/python/metafunc.py::TestMetafunc::test_parametrize_twoargs - A...
FAILED testing/python/metafunc.py::TestMetafunc::test_parametrize_iterator_deprecation
13 failed, 115 passed in 11.08s

50:        class DefinitionMock(python.FunctionDefinition):
        - "arg" (string, no comma): argvalues is a list of values
        - "arg," (string, trailing comma): argvalues is a list of tuples (like tuple form)
        - ("arg",) (tuple): argvalues is a list of tuples
        """

        def func(arg):
            pass  # pragma: no cover

        scenarios = [("a",), ("b",)]

        # Tuple form: argvalues are tuples, unpacked to get the value

        metafunc = self.Metafunc(func)
        metafunc.parametrize(("arg",), scenarios)
        assert metafunc._calls[0].params == {"arg": "a"}
        assert metafunc._calls[1].params == {"arg": "b"}

        # String with trailing comma: should behave like tuple form
        metafunc = self.Metafunc(func)
        metafunc.parametrize("arg,", scenarios)
        assert metafunc._calls[0].params == {"arg": "a"}
        assert metafunc.
…[1222 chars omitted]…
e("y", [5, 6])

        with pytest.raises(TypeError, match=r"^ids must be a callable or an iterable$"):
            metafunc.parametrize("y", [5, 6], ids=42)  # type: ignore[arg-type]

    def test_parametrize_error_iterator(self) -> None:
        def func(x):
            raise NotImplementedError()

        class Exc(Exception):
            def __repr__(self):
                return "Exc(from_gen)"

class FuncFixtureInfoMock:
            name2fixturedefs: dict[str, list[fixtures.FixtureDef[object]]] = {}

            def __init__(self, names):
                self.names_closure = names

        @dataclasses.dataclass
        class FixtureManagerMock:
            config: Any

        @dataclasses.dataclass
        class SessionMock:

            _fixturemanager: FixtureManagerMock

        @dataclasses.dataclass
        class DefinitionMock(python.FunctionDefinition):
            _nodeid: str
            obj: object

        names = getfuncargnames(func)
        fixtureinfo: Any = FuncFixtureInfoMock(names)
        definition: Any = DefinitionMock._create(obj=func, _nodeid="mock::nodeid")
        definition._fixtureinfo = fixtureinfo
        definition.session = SessionMock(FixtureManagerMock({}))
        return python.Metafunc(definition, fixtureinfo, config, _ispytest=Tru
…[254 chars omitted]…
f func(arg1, arg2="qwe"):
            pass

        metafunc = self.Metafunc(func)
        assert len(metafunc.fixturenames) == 1
        assert "arg1" in metafunc.fixturenames
        assert metafunc.function is func
        assert metafunc.cls is None

    def test_parametrize_single_arg_trailing_comma(self) -> None:
        """Test that trailing comma in string argnames behaves like tuple argnames.

fallback added
/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
........................................................................ [ 56%]
........................................................                 [100%]
128 passed in 7.36s

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
..                                                                       [100%]
2 passed in 0.01s

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
..F.                                                                     [100%]
=================================== FAILURES ===================================
_____________________ test_register_explicit_none_no_warn ______________________

request = <FixtureRequest for <Function test_register_explicit_none_no_warn>>

    def test_register_explicit_none_no_warn(request):
        fm = request._fixturemanager
        with warnings.ca
…[253 chars omitted]…
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
E       TypeError: test_register_explicit_none_no_warn.<locals>.<lambda>() takes 0 positional arguments but 1 was given

/tmp/check/test_fd.py:28: TypeError
=========================== short test summary info ============================
FAILED ../tmp/check/test_fd.py::test_register_explicit_none_no_warn - TypeErr...
1 failed, 3 passed in 0.35s

src/_pytest/fixtures.py-1946-        *,
src/_pytest/fixtures.py-1947-        name: str,
src/_pytest/fixtures.py-1948-        func: _FixtureFunc[object],
src/_pytest/fixtures.py-1949-        nodeid: str | None | NotSetType = NOTSET,
src/_pytest/fixtures.py-1950-        scope: Scope | ScopeName | Callable[[str, Config], ScopeName] = "function",
src/_pytest/fixtures.py-1951-        params: Sequence[object] | None = None,
src/_pytest/fixtures.py-1952-        ids: tuple[object | None, ...] | Callable[[Any], object | None] | None = None,
src/_pytest/fixtures.py-1953-        autouse: bool = False,
src/_pytest/fixtures.py-1954-        node: nodes.Node | None | NotSetType = NOTSET,
src/_pytest/fixtures.py-1955-    ) -> None:
src/_pytest/fixtures.py-1956-        """Register a fixture
--

--
src/_pytest/fixtures.py-2127-                    params=marker.params,
src/_pytest/fixtures.py-2128-      
…[5405 chars omitted]…
ttest.py-223-            node=self,
src/_pytest/unittest.py-224-            scope="function",
src/_pytest/unittest.py-225-            autouse=True,
src/_pytest/unittest.py-226-        )
src/_pytest/unittest.py-227-
src/_pytest/unittest.py-228-
src/_pytest/unittest.py-229-class TestCaseFunction(Function):
src/_pytest/unittest.py-230-    nofuncargs = True
src/_pytest/unittest.py-231-    failfast = False

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
.                                                                        [100%]
1 passed in 0.00s

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
ITEM test_mod.py::test_mod.use_fix DoctestItem
    DoctestItem test_mod.py::test_mod.use_fix 126723861067184
    DoctestModule test_mod.py 126723861067968
    Dir . 126723861066960
    Session  126723863146048

ITEM test_mod.py::test_fix Function
    Function test_mod.py::test_fix 126723861431920
    Module test_mod.py 126723861067744
    Dir . 126723861066960
    Session  126723863146048
..                                                                       [100%]
2 passed in 0.01s

testing/example_scripts/fixtures
testing/example_scripts/unittest
testing/logging/test_fixture.py
testing/python/fixtures.py
testing/python/show_fixtures_per_test.py
testing/test_unittest.py

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
..........................................sssssss....................... [ 66%]
............s.....................s.                                     [100%]
99 passed, 9 skipped in 5.33s

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
.......................................................s...x............ [ 76%]
.............s........                                                   [100%]
91 passed, 2 skipped, 1 xfailed in 15.94s

f"{self.inipath}: 'minversion' requires pytest-{minver}, actual pytest-{pytest.__version__}'"
                )
E               pytest.UsageError: /tmp/pytest-of-root/pytest-8/test_invalid_config_options3/tox.ini: 'minversion' requires pytest-5.0.0, actual pytest-0.1.dev1+g01221dc5e'

/repo/src/_pytest/config/__init__.py:1458: UsageError
_________________ TestInicfgDeprecation.test_inicfg_deprecated _________________

self = <test_config.TestInicfgDeprecation object at 0x7bcd03004e00>
pytester = <Pytester PosixPath('/tmp/pytest-of-root/pytest-8/test_inicfg_deprecated0')>

    def test_inicfg_deprecated(self, pytester: Pytester) -> None:
        """Test that accessing config.inicfg issues a deprecation warning."""

        pytester.makeini(
            """
            [pytest]
            minversion = 3.0
            """
        )
>       config = pytester.parseconfi
…[3246 chars omitted]…
tParseIni::test_invalid_config_options[unknown-in-other-header]
FAILED testing/test_config.py::TestParseIni::test_invalid_config_options[no-unknowns]
FAILED testing/test_config.py::TestInicfgDeprecation::test_inicfg_deprecated
XPASS testing/_py/test_local.py::TestLocalPath::test_make_numbered_dir_multiprocess_safe - #11603
17 failed, 4072 passed, 123 skipped, 12 xfailed, 1 xpassed in 421.19s (0:07:01)

diff --git a/src/_pytest/deprecated.py b/src/_pytest/deprecated.py
index 70640f7..a049ef1 100644
--- a/src/_pytest/deprecated.py
+++ b/src/_pytest/deprecated.py
@@ -118,6 +118,10 @@ FIXTURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing baseid to FixtureDef is deprecated. Pass node instead for fixture scoping."
 )
 
+FIXTURE_HAS_LOCATION_DEPRECATED = PytestRemovedIn10Warning(
+    "FixtureDef.has_location is deprecated. Use FixtureDef.node instead."
+)
+

 FIXTURE_NODEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing nodeid to _register_fixture is deprecated. "
     "Pass node instead for fixture scoping."
diff --git a/src/_pytest/fixtures.py b/src/_pytest/fixtures.py
index cbff945..ce4f68d 100644
--- a/src/_pytest/fixtures.py
+++ b/src/_pytest/fixtures.py
@@ -59,6 +59,7 @@ from _pytest.deprecated import check_ispytest
 from _pytest.deprecated import CLASS_FIXTURE_IN
…[8629 chars omitted]…
          # directly; fall back to the session's config.
+            config = node.session._fixturemanager.config
         super().__init__(
             config=config,
-            baseid="",
+            baseid=NOTSET,
             argname=argname,
             func=get_direct_param_fixture_func,
             scope=scope,
             params=None,
             ids=None,
             _ispytest=True,

src/_pytest/config/argparsing.py:189:        default: Any = NOTSET,
src/_pytest/config/__init__.py:1923:    def getoption(self, name: str, default: Any = NOTSET, skip: bool = False):
src/_pytest/fixtures.py:701:            param = NOTSET
src/_pytest/fixtures.py:1060:        baseid: str | None | NotSetType = NOTSET,
src/_pytest/fixtures.py:1061:        argname: str | NotSetType = NOTSET,
src/_pytest/fixtures.py:1062:        func: _FixtureFunc[FixtureValue] | NotSetType = NOTSET,
src/_pytest/fixtures.py:1067:        | NotSetType = NOTSET,
src/_pytest/fixtures.py:1068:        params: Sequence[object] | None | NotSetType = NOTSET,
src/_pytest/fixtures.py:1074:        node: nodes.Node | None | NotSetType = NOTSET,
src/_pytest/fixtures.py:1949:        nodeid: str | None | NotSetType = NOTSET,
src/_pytest/fixtures.py:1954:        node: nodes.Node | None | NotSetType = NOTSET,
src/_pytest/fix

…[119 chars omitted]…
 None | NotSetType = NOTSET,
src/_pytest/fixtures.py:2077:        effective_node: nodes.Node | None | NotSetType = NOTSET
src/_pytest/fixtures.py:2078:        effective_nodeid: str | None | NotSetType = NOTSET
src/_pytest/monkeypatch.py:182:        value: object = NOTSET,
src/_pytest/monkeypatch.py:253:        name: str | NotSetType = NOTSET,
src/_pytest/pytester.py:664:    CLOSE_STDIN: Final = NOTSET

M src/_pytest/deprecated.py
 M src/_pytest/fixtures.py
 M src/_pytest/python.py

Returns None if there are no fixtures at all defined with the given
        name. (This is different from the case in which there are fixtures
        with the given name, but none applicable to the node. In this case,
        an empty result is returned).

        :param argname: Name of the fixture to search for.
        :param node: The requesting Node.
        """
        try:
            fixturedefs = self._arg2fixturedefs[argname]
        except KeyError:
            return None

        return tuple(self._matchfactories(fixturedefs, node))

    def _matchfactories(
        self, fixturedefs: Iterable[FixtureDef[Any]], node: nodes.Node
    ) -> Iterator[FixtureDef[Any]]:
        # Collect parent nodes and their IDs for matching
        parent_nodes = set(node.iter_parents())
        parentnodeids = {n.nodeid for n in parent_nodes}

        for fixturedef in fixturedefs:
 
…[1428 chars omitted]…
tems may not have _fixtureinfo attribute.
    fixture_info: FuncFixtureInfo | None = getattr(test, "_fixtureinfo", None)
    if fixture_info is None:
        return  # pragma: no cover

    # dict key not used in loop but needed for sorting.
    for argname, fixturedefs in sorted(fixture_info.name2fixturedefs.items()):
        if not fixturedefs:
            # Not supposed to be empty, but for safety.

def pytest_sessionstart(session: Session) -> None:
    session._fixturemanager = FixtureManager(session)


def get_scope_package(
    node: nodes.Item,
    fixturedef: FixtureDef[object],
) -> nodes.Node | None:
    from _pytest.python import Package

    for parent in node.iter_parents():
        if isinstance(parent, Package):

            if fixturedef.node is not None:
                if parent == fixturedef.node:
                    return parent
            else:
                if parent.nodeid == fixturedef.baseid:
                    return parent
    return node.session


def is_visibility_more_specific(
    candidate: FixtureDef[Any], other: FixtureDef[Any]
) -> bool:
    """Return whether the visibility of ``candidate`` is strictly more specific
    than that of ``other``, i.e. ``candidate`` is defined on a strict descendant
    in the collection tree of where ``other`` is
…[570 chars omitted]…

        return candidate.baseid.startswith(other.baseid) and candidate.baseid[
            len(other.baseid)
        ] in ("/", ":")

    return (
        candidate.node is not other.node and other.node in candidate.node.iter_parents()
    )


def get_scope_node(node: nodes.Node, scope: Scope) -> nodes.Node | None:
    """Get the closest parent node (including self) which matches the given
    scope.

# mypy: allow-untyped-defs
from __future__ import annotations

from collections.abc import Iterator
from collections.abc import Sequence
import dataclasses
import itertools
import re
import sys
import textwrap
from typing import Any
from typing import cast

import hypothesis
from hypothesis import strategies

from _pytest import fixtures
from _pytest import python
from _pytest.compat import getfuncargnames
from _pytest.compat import NOTSET
from _pytest.outcomes import fail
from _pytest.outcomes import Failed
from _pytest.pytester import Pytester
from _pytest.python import Function
from _pytest.python import IdMaker
from _pytest.scope import Scope
import pytest


class TestMetafunc:
    def Metafunc(self, func, config=None) -> python.Metafunc:
        # The unit tests of this class check if things work correctly
        # on the funcarg level, so we don't need a full blown
        # in
…[1165 chars omitted]…
f func(arg1, arg2="qwe"):
            pass

        metafunc = self.Metafunc(func)
        assert len(metafunc.fixturenames) == 1
        assert "arg1" in metafunc.fixturenames
        assert metafunc.function is func
        assert metafunc.cls is None

    def test_parametrize_single_arg_trailing_comma(self) -> None:
        """Test that trailing comma in string argnames behaves like tuple argnames.

arg_directness = _resolve_args_directness(
            argnames, indirect, self.definition.nodeid
        )
        self._params_directness.update(arg_directness)

        # Add direct parametrizations as fixturedefs to arg2fixturedefs by
        # registering artificial DirectParamFixtureDef's such that later at test
        # setup time we can rely on FixtureDefs to exist for all argnames.
        node: nodes.Node = self.definition
        # For scopes higher than function, a DirectParamFixtureDef might have
        # already been created for the scope. We thus store and cache the
        # DirectParamFixtureDef on the node related to the scope.

        if scope_ is Scope.Function:
            name2directparamfixturedef = None
        else:
            collector = self.definition.parent
            assert collector is not None
            node = get_scope_node(collector, sco
…[3702 chars omitted]…
             filename=str(filename),
                lineno=lineno + 1,
            )
        elif getattr(obj, "__test__", True):
            if inspect.isgeneratorfunction(obj):
                fail(
                    f"'yield' keyword is allowed in fixtures, but not in tests ({name})",
                    pytrace=False,
                )
            return list(collector._genfunctions(name, obj))

class DirectParamFixtureDef(FixtureDef[FixtureValue]):
    """A custom FixtureDef for direct parametrization fixtures.

    Each parameter in direct parametrization is desugared to a parametrized
    fixture which returns the direct parameterization value as its param.
    We use this custom type as a "marker" for this type of FixtureDef, but
    usually behaves like any other FixtureDef.
    """

    def __init__(self, *, config: Config, argname: str, scope: Scope) -> None:
        super().__init__(
            config=config,

            baseid="",
            argname=argname,
            func=get_direct_param_fixture_func,
            scope=scope,
            params=None,
            ids=None,
            _ispytest=True,
        )


# Used for storing fixturedefs for direct parametrization.
        for argname in argnames:
            if arg_directness[argname] == "indirect":
      
…[82 chars omitted]…
not None
                and argname in name2directparamfixturedef
            ):
                fixturedef = name2directparamfixturedef[argname]
            else:
                fixturedef = DirectParamFixtureDef(
                    config=self.config,
                    argname=argname,
                    scope=scope_,
                )
                if name2directparamfixturedef is not None:

diff --git a/src/_pytest/python.py b/src/_pytest/python.py
index ad5a2c6..940de03 100644
--- a/src/_pytest/python.py
+++ b/src/_pytest/python.py
@@ -1164,16 +1164,22 @@ class DirectParamFixtureDef(FixtureDef[FixtureValue]):
     usually behaves like any other FixtureDef.
     """
 
-    def __init__(self, *, config: Config, argname: str, scope: Scope) -> None:
+    def __init__(self, *, node: nodes.Node, argname: str, scope: Scope) -> None:
+        config = getattr(node, "config", None)
+        if config is None:

+            # Some custom items used in tests/mocks do not expose a config
+            # directly; fall back to the session's config.
+            config = node.session._fixturemanager.config
         super().__init__(
             config=config,
-            baseid="",
+            baseid=NOTSET,
             argname=argname,
             func=get_direct_param_fixture_fu
…[641 chars omitted]…
      # DirectParamFixtureDef on the node related to the scope.
@@ -1395,7 +1401,7 @@ class Metafunc:
                 fixturedef = name2directparamfixturedef[argname]
             else:
                 fixturedef = DirectParamFixtureDef(
-                    config=self.config,
+                    node=node,
                     argname=argname,
                     scope=scope_,
                 )

23:DEPRECATED_EXTERNAL_PLUGINS = {
32:YIELD_FIXTURE = PytestDeprecationWarning(
37:CLASS_FIXTURE_INSTANCE_METHOD = PytestRemovedIn10Warning(
46:PRIVATE = PytestDeprecationWarning("A private pytest class or function was used.")
49:HOOK_LEGACY_MARKING = UnformattedWarning(
58:MONKEYPATCH_LEGACY_NAMESPACE_PACKAGES = PytestRemovedIn10Warning(
65:PARAMETRIZE_NON_COLLECTION_ITERABLE = UnformattedWarning(
73:CONSOLE_MAIN = PytestRemovedIn10Warning(
79:CONFIG_INICFG = PytestRemovedIn10Warning(
84:FIXTURE_GETFIXTUREVALUE_DURING_TEARDOWN = UnformattedWarning(
92:PASTEBIN = PytestRemovedIn10Warning(
117:FIXTURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(

121:FIXTURE_HAS_LOCATION_DEPRECATED = PytestRemovedIn10Warning(
125:FIXTURE_NODEID_DEPRECATED = PytestRemovedIn10Warning(
130:PARSEFACTORIES_NODEID_DEPRECATED = PytestRemovedIn10Warning(

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
...............................x........................................ [ 32%]
....................x................................................... [ 64%]
........................................................s............... [ 97%]
......                                                                   [100%]
219 passed, 1 skipped, 2 xfailed in 13.21s

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
........................................................................ [ 32%]
.....x.................................................................. [ 65%]
....................sssssss...................................s......... [ 97%]
...s.                                                                    [100%]
211 passed, 9 skipped, 1 xfailed in 10.59s

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
..                                                                       [100%]
2 passed in 0.01s

)

        return FuncFixtureInfo(argnames, initialnames, names_closure, arg2fixturedefs)

    def pytest_plugin_registered(self, plugin: _PluggyPlugin, plugin_name: str) -> None:
        # Fixtures defined in conftest plugins are only visible to within the
        # conftest's directory. This is unlike fixtures in non-conftest plugins
        # which have global visibility. Conftest fixtures are deferred until
        # their Directory is collected, so we can use the Directory's nodeid.
        if plugin_name and plugin_name.endswith("conftest.py"):
            # Note: we explicitly do *not* use `plugin.__file__` here -- The
            # difference is that plugin_name has the correct capitalization on

            # case-insensitive systems (Windows) and other normalization issues
            # (issue #11816).
            conftestpath = absolutepath(plugin_name)
            c
…[72 chars omitted]…
red parsing when its Directory is collected.
            self._pending_conftests[conftest_dir] = plugin
        else:
            # Non-conftest plugins have global visibility.
            self.parsefactories(holder=plugin, node=self.session)

    @hookimpl(wrapper=True)
    def pytest_make_collect_report(
        self, collector: nodes.Collector
    ) -> Generator[None, CollectReport, CollectReport]:

return self._inner_hookexec(hook_name, methods, kwargs, firstresult)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
/repo/src/_pytest/helpconfig.py:124: in pytest_cmdline_parse
    config = yield
             ^^^^^
/repo/src/_pytest/config/__init__.py:1232: in pytest_cmdline_parse
    self.parse(args)
/repo/src/_pytest/config/__init__.py:1573: in parse
    self._checkversion()
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <_pytest.config.Config object at 0x712baeb733b0>

    def _checkversion(self) -> None:
        import pytest
    
        minver = self.getini("minversion")
        if minver:
            # Imported lazily to improve start-up time.
            from packaging.version import Version
    
            if Version(minver) > Version(pytest.__version__):
>               raise pytest.UsageError(
        
…[1718 chars omitted]…
_lower_pytestini
FAILED testing/test_config.py::TestParseIni::test_invalid_config_options[1-unknown]
FAILED testing/test_config.py::TestParseIni::test_invalid_config_options[unknown-in-other-header]
FAILED testing/test_config.py::TestParseIni::test_invalid_config_options[no-unknowns]
FAILED testing/test_config.py::TestInicfgDeprecation::test_inicfg_deprecated
20 failed, 234 passed, 1 xfailed in 11.96s

testing/deprecated_test.py::TestFixtureNodeidDeprecations::test_parsefactories_nodeid_deprecation
testing/test_config.py::TestParseIni::test_ini_names[tool:pytest-setup.cfg]
testing/test_config.py::TestParseIni::test_ini_names[pytest-tox.ini]
testing/test_config.py::TestParseIni::test_ini_names[pytest-pytest.ini]
testing/test_config.py::TestParseIni::test_ini_names[pytest-.pytest.ini]
testing/test_config.py::TestParseIni::test_toml_config_names[pytest.toml]
testing/test_config.py::TestParseIni::test_toml_config_names[.pytest.toml]
testing/test_config.py::TestParseIni::test_pyproject_toml
testing/test_config.py::TestParseIni::test_pytest_toml
testing/test_config.py::TestParseIni::test_pytest_toml_trumps_pyproject_toml
testing/test_config.py::TestParseIni::test_pytest_toml_trumps_pytest_ini
testing/test_config.py::TestParseIni::test_dot_pytest_toml_trumps_pytest_ini

testing/test_config.
…[268 chars omitted]…
lid_config_options[no-unknowns]
testing/test_config.py::TestInicfgDeprecation::test_inicfg_deprecated
testing/test_config.py::TestConfigFromdictargs::test_basic_behavior
testing/test_config.py::TestConfigFromdictargs::test_invocation_params_args
testing/test_config.py::TestOverrideIniArgs::test_addopts_before_initini
testing/test_config.py::TestOverrideIniArgs::test_override_ini_does_not_contain_paths

165:            self.config: Config = config
169:            self.config = parent.config
416:        if self.config.getoption("fulltrace", False):
425:            if self.config.getoption("tbstyle", "auto") == "short":
430:        if self.config.get_verbosity() > 1:
435:        truncate_args = False if self.config.get_verbosity() > 2 else True
444:            abspath = Path(os.getcwd()) != self.config.invocation_params.dir
451:            showlocals=self.config.getoption("showlocals", False),
514:        if isinstance(excinfo.value, self.CollectError) and not self.config.getoption(
522:        tbstyle = self.config.getoption("tbstyle", "auto")

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
.                                                                        [100%]
1 passed in 0.01s

src/_pytest/fixtures.py:49:from _pytest.compat import NotSetType
src/_pytest/fixtures.py:1060:        baseid: str | None | NotSetType = NOTSET,
src/_pytest/fixtures.py:1061:        argname: str | NotSetType = NOTSET,
src/_pytest/fixtures.py:1062:        func: _FixtureFunc[FixtureValue] | NotSetType = NOTSET,
src/_pytest/fixtures.py:1067:        | NotSetType = NOTSET,
src/_pytest/fixtures.py:1068:        params: Sequence[object] | None | NotSetType = NOTSET,
src/_pytest/fixtures.py:1074:        node: nodes.Node | None | NotSetType = NOTSET,
src/_pytest/fixtures.py:1949:        nodeid: str | None | NotSetType = NOTSET,
src/_pytest/fixtures.py:1954:        node: nodes.Node | None | NotSetType = NOTSET,
src/_pytest/fixtures.py:2048:        nodeid: None | NotSetType = ...,
src/_pytest/fixtures.py:2051:        node: nodes.Node | None | NotSetType = ...,
src/_pytest/fixtures.py:2058:        nodeid: str | NotSetType | None = NOTSET,

src/_pytest/fixtures.py:2061:        node: nodes.Node | None | NotSetType = NOTSET,
src/_pytest/fixtures.py:2077:        effective_node: nodes.Node | None | NotSetType = NOTSET
src/_pytest/fixtures.py:2078:        effective_nodeid: str | None | NotSetType = NOTSET

1387:                    node = collector.session
1391:            name2directparamfixturedef = node.stash.setdefault(
1404:                    node=node,
1427:                    nodeid=nodeid,
1437:        nodeid: str,
1448:        :param nodeid str:
1449:            The nodeid of the definition item that generated this
1469:            nodeid=nodeid,
1489:            nodeid = self.definition.nodeid
1491:                f"In {nodeid}: {len(parametersets)} parameter sets specified, with different number of ids: {num_ids}",
1509:        nodeid = self.definition.nodeid
1514:                        f"In {nodeid}: function already takes an argument '{arg}' with a default value",

1523:                        f"In {nodeid}: function uses no {name} '{arg}'",
1579:class Function(PyobjMixin, nodes.Item):
1600:        Fixture information already resolved at this fixture node..
1759:    definition nodes and manage to get rid of ``metafunc``."""

diff --git a/src/_pytest/fixtures.py b/src/_pytest/fixtures.py
index cbff945..ce4f68d 100644
--- a/src/_pytest/fixtures.py
+++ b/src/_pytest/fixtures.py
@@ -59,6 +59,7 @@ from _pytest.deprecated import check_ispytest
 from _pytest.deprecated import CLASS_FIXTURE_INSTANCE_METHOD
 from _pytest.deprecated import FIXTURE_BASEID_DEPRECATED
 from _pytest.deprecated import FIXTURE_GETFIXTUREVALUE_DURING_TEARDOWN
+from _pytest.deprecated import FIXTURE_HAS_LOCATION_DEPRECATED
 from _pytest.deprecated import FIXTURE_NODEID_DEPRECATED
 from _pytest.deprecated import PARSEFACTORIES_NODEID_DEPRECATED
 from _pytest.deprecated import YIELD_FIXTURE

@@ -1056,23 +1057,36 @@ class FixtureDef(Generic[FixtureValue]):
     def __init__(
         self,
         config: Config,
-        baseid: str | None,
-        argname: str,
-        func: _FixtureFunc[FixtureValue],
-        scope: Scope | ScopeName | 
…[8239 chars omitted]…
isclass(holderobj) and not isinstance(holderobj, types.ModuleType):
@@ -2079,7 +2100,6 @@ class FixtureManager:
         else:
             holderobj_tp = holderobj
 
-        self._holderobjseen.add(holderobj)
         for name in dir(holderobj):
             # The attribute can be an arbitrary descriptor, so the attribute
             # access below can raise. safe_getattr() ignores such exceptions.

src/_pytest/deprecated.py |  4 +++
 src/_pytest/fixtures.py   | 82 +++++++++++++++++++++++++++++------------------
 src/_pytest/python.py     | 14 +++++---
 3 files changed, 65 insertions(+), 35 deletions(-)
 M src/_pytest/deprecated.py
 M src/_pytest/fixtures.py
 M src/_pytest/python.py
INTERNALERROR>     return outcome.get_result()
INTERNALERROR>            ^^^^^^^^^^^^^^^^^^^^
INTERNALERROR>   File "/usr/local/lib/python3.12/site-packages/pluggy/_result.py", line 103, in get_result
INTERNALERROR>     raise exc.with_traceback(tb)
INTERNALERROR>   File "/usr/local/lib/python3.12/site-packages/pluggy/_result.py", line 62, in from_call

INTERNALERROR>     result = func()
INTERNALERROR>              ^^^^^^
INTERNALERROR>   File "/usr/local/lib/python3.12/site-packages/pluggy/_manager.py", line 595, in <lambda>
INTERNALERROR>     lambda: oldcall(hook_name, hook_impls, caller_kwargs, firs
…[1647 chars omitted]…
en([<warnings.WarningMessage object at 0x7e2b907c1df0>, <warnings.WarningMessage object at 0x7e2b907c1eb0>])

============================ no tests ran in 0.03s =============================
=========================== short test summary info ============================
FAILED testing/deprecated_test.py::TestFixtureNodeidDeprecations::test_parsefactories_nodeid_deprecation
1 failed, 3 passed in 0.75s

You are using pytest version 0.1.dev1+g01221dc5e. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
..                                                                       [100%]
2 passed in 0.01s
bash: line 1018: /tmp/repro3/calls.txt: No such file or directory
LINES:

warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
..                                                                       [100%]
2 passed in 0.01s
LINES: 2
call
call

/repo
AUTHORS
CHANGELOG.rst
CITATION
CODE_OF_CONDUCT.md
CONTRIBUTING.rst
LICENSE
OPENCOLLECTIVE.rst
README.rst
RELEASING.rst
SECURITY.md
TIDELIFT.rst

bench
changelog
codecov.yml
doc
extra
pyproject.toml
scripts
src
testing
tox.ini

src/_pytest/fixtures.py:1049:class FixtureDef(Generic[FixtureValue]):
src/_pytest/fixtures.py:1097:        self.has_location: Final = node is not None or baseid is not None
src/_pytest/fixtures.py:1237:class RequestFixtureDef(FixtureDef[FixtureRequest]):
src/_pytest/fixtures.py:1925:    def _register_fixture(
src/_pytest/fixtures.py:2103:                self._register_fixture(
src/_pytest/fixtures.py:2180:    from _pytest.python import DirectParamFixtureDef
src/_pytest/fixtures.py:2194:        if isinstance(fixturedef, DirectParamFixtureDef):
src/_pytest/deprecated.py:122:    "Passing nodeid to _register_fixture is deprecated. "

testing/deprecated_test.py:139:    - parsefactories(obj, nodeid_string) deprecation warning
testing/deprecated_test.py:140:    - parsefactories(obj, None) does NOT warn (standard plugin pattern)
testing/deprecated_test.py:141:    - parsefactories() with no args raises TypeError
testing/deprecated_test.py:142:    - _register_fixture(nodeid=string) deprecation warning
testing/deprecated_test.py:147:    def test_parsefactories_nodeid_deprecation(self, pytester: Pytester) -> None:
testing/deprecated_test.py:148:        """parsefactories(obj, "path") warns; parsefactories(obj, None) does not."""
testing/deprecated_test.py:173:                    fm.parsefactories(mod_with_path, "some/nodeid")
testing/deprecated_test.py:174:                    fm.parsefactories(mod_none, None)
testing/deprecated_test.py:176:                nodeid_warns = [x for x in w if "parsefactories" in str(x.message)]

…[2056 chars omitted]…
 func=lambda: "session2", node=session)

testing/python/fixtures.py:1938:    def test_parsefactories_relative_node_ids(
testing/python/fixtures.py:2127:    def test_parsefactories_conftest(self, pytester: Pytester) -> None:
testing/python/metafunc.py:804:        # Since `y` is a direct parameter, its DirectParamFixtureDef would
testing/test_conftest.py:632:    def test_parsefactories_relative_node_ids(

src/_pytest/fixtures.py:648:            return RequestFixtureDef(self)
src/_pytest/fixtures.py:1049:class FixtureDef(Generic[FixtureValue]):
src/_pytest/fixtures.py:1237:class RequestFixtureDef(FixtureDef[FixtureRequest]):
src/_pytest/fixtures.py:1963:        fixture_def = FixtureDef(
src/_pytest/python.py:1158:class DirectParamFixtureDef(FixtureDef[FixtureValue]):
src/_pytest/python.py:1397:                fixturedef = DirectParamFixtureDef(
src/_pytest/python.py:1158:class DirectParamFixtureDef(FixtureDef[FixtureValue]):
src/_pytest/python.py:1397:                fixturedef = DirectParamFixtureDef(

def fix(cls):
                cls.attr = True

            def test_foo(self, fix):
                assert type(self).attr is True
        """
    )
    result = pytester.runpytest("-Werror::pytest.PytestRemovedIn10Warning")
    result.assert_outcomes(passed=1)


class TestFixtureNodeidDeprecations:

    """Tests for deprecated baseid/nodeid string APIs in fixture registration.

    AI-generated coverage tests for legacy paths that will be removed in
    pytest 10. These exist solely to maintain patch coverage until the
    deprecated code is deleted.

    Legacy paths covered:
    - parsefactories(obj, nodeid_string) deprecation warning
    - parsefactories(obj, None) does NOT warn (standard plugin pattern)
    - parsefactories() with no args raises TypeError
    - _register_fixture(nodeid=string) deprecation warning
    - _nodeid_autousenames population and _getautousenam
…[5393 chars omitted]…
er.runpytest("-W", "ignore::pytest.PytestRemovedIn10Warning")
        result.assert_outcomes(passed=2)
testing/deprecated_test.py:255:        - baseid="" matches all nodes (global fixture)
testing/deprecated_test.py:256:        - baseid="nonexistent/path" matches nothing (scoped fixture invisible)
testing/python/metafunc.py:804:        # Since `y` is a direct parameter, its DirectParamFixtureDef would

src/_pytest/python.py:594:        self.session._fixturemanager._register_fixture(
src/_pytest/python.py:630:        self.session._fixturemanager._register_fixture(
src/_pytest/python.py:810:        self.session._fixturemanager._register_fixture(
src/_pytest/python.py:844:        self.session._fixturemanager._register_fixture(
src/_pytest/unittest.py:173:        self.session._fixturemanager._register_fixture(
src/_pytest/unittest.py:190:        self.session._fixturemanager._register_fixture(
src/_pytest/unittest.py:219:        self.session._fixturemanager._register_fixture(
testing/deprecated_test.py:142:    - _register_fixture(nodeid=string) deprecation warning
testing/deprecated_test.py:208:        """_register_fixture(nodeid=string) warns and autouse populates/yields.
testing/deprecated_test.py:211:        - Deprecation warning on _register_fixture(nodeid=...)
testing/deprecated_tes
…[859 chars omitted]…

g
testing/deprecated_test.py:140:    - parsefactories(obj, None) does NOT warn (standard plugin pattern)
testing/deprecated_test.py:148:        """parsefactories(obj, "path") warns; parsefactories(obj, None) does not."""
testing/deprecated_test.py:173:                    fm.parsefactories(mod_with_path, "some/nodeid")
testing/deprecated_test.py:174:                    fm.parsefactories(mod_none, None)

if config.get_verbosity() < 2:
            exc_info.traceback = exc_info.traceback.filter(filter_traceback)
        exc_repr = (
            exc_info.getrepr(style="short")
            if exc_info.traceback
            else exc_info.exconly()
        )
        formatted_tb = str(exc_repr)
        raise nodes.Collector.CollectError(
            f"ImportError while importing test module '{path}'.\n"
            "Hint: make sure your test modules/packages have valid Python names.\n"
            "Traceback:\n"

            f"{formatted_tb}"
        ) from e
    except skip.Exception as e:
        if e.allow_module_level:
            raise
        raise nodes.Collector.CollectError(
            "Using pytest.skip outside of a test will skip the entire module. "
            "If that's your intention, pass `allow_module_level=True`. "
            "If you want to skip a specific test o
…[8629 chars omitted]…
xturedefs: Mapping[str, Sequence[fixtures.FixtureDef[object]]],
src/_pytest/setuponly.py:33:    fixturedef: FixtureDef[object], request: SubRequest
src/_pytest/setuponly.py:54:    fixturedef: FixtureDef[object], request: SubRequest
src/_pytest/setuponly.py:65:    fixturedef: FixtureDef[object], config: Config, msg: str
src/_pytest/setupplan.py:24:    fixturedef: FixtureDef[object], request: SubRequest

325:        def deprecated(msg, /, *, category=None, stacklevel=1):
326-            def decorator(func):
327-                return func
328-
329-            return decorator
doc/en/deprecations.rst:26:``FixtureManager._register_fixture`` and ``FixtureManager.parsefactories``
doc/en/deprecations.rst:35:    fixture_manager.parsefactories(plugin_obj, nodeid="tests/sub")
doc/en/deprecations.rst:39:    fixture_manager.parsefactories(holder=plugin_obj, node=directory_node)
./src/_pytest/fixtures.py:1097:        self.has_location: Final = node is not None or baseid is not None

def __init__(self, value: bool) -> None:
        self._value = value

    def __bool__(self) -> bool:
        return self._value

    def __call__(self) -> bool:
        return self._value


def running_on_ci() -> bool:
    """Check if we're currently running on a CI system."""

    # Only enable CI mode if one of these env variables is defined and non-empty.
    # Note: review `regendoc` tox env in case this list is changed.
    env_vars = ["CI", "BUILD_NUMBER"]
    return any(os.environ.get(var) for var in env_vars)


if sys.version_info >= (3, 13):
    from warnings import deprecated as deprecated
else:
    if TYPE_CHECKING:
        from typing_extensions import deprecated as deprecated
    else:

        def deprecated(msg, /, *, category=None, stacklevel=1):
            def decorator(func):
                return func

            return decorator
src/_pytest/config/__init__.p
…[1945 chars omitted]…
nally by the ``pytest`` console script
and ``python -m pytest``. It was never intended for programmatic use, and exposing it
in the public API led to confusion with :func:`pytest.main`, which is the correct way
to invoke pytest from Python code.

If you are calling ``pytest.console_main()`` in your code, replace it with :func:`pytest.main`:

53:class PytestRemovedIn10Warning(PytestDeprecationWarning):

src/_pytest/config/__init__.py:1164:        @deprecated(
src/_pytest/fixtures.py:1422:@overload
src/_pytest/fixtures.py:1434:@overload
src/_pytest/fixtures.py:1521:@deprecated(
src/_pytest/fixtures.py:2004:    @overload
src/_pytest/fixtures.py:2011:    @overload
src/_pytest/fixtures.py:2019:    @overload
src/_pytest/main.py:779:    @overload
src/_pytest/main.py:784:    @overload
src/_pytest/mark/expression.py:132:    @overload
src/_pytest/mark/expression.py:135:    @overload
src/_pytest/mark/structures.py:397:    @overload

src/_pytest/mark/structures.py:401:    @overload
src/_pytest/mark/structures.py:507:        @overload  # type: ignore[override,no-overload-impl]
src/_pytest/mark/structures.py:510:        @overload
src/_pytest/mark/structures.py:522:        @overload  # type: ignore[override,no-overload-impl]
src/_pytest/mark/structures.py:525:        @overload
src/_pytest/mark/stru
…[1432 chars omitted]…
c/_pytest/recwarn.py:48:@overload
src/_pytest/recwarn.py:54:@overload
src/_pytest/recwarn.py:92:@overload
src/_pytest/recwarn.py:100:@overload
src/_pytest/_code/code.py:414:    @overload
src/_pytest/_code/code.py:417:    @overload
src/_pytest/_code/source.py:52:    @overload
src/_pytest/_code/source.py:55:    @overload
src/_pytest/_py/path.py:961:    @overload
src/_pytest/_py/path.py:964:    @overload

argnames, parametersets = ParameterSet._for_parametrize(
            argnames,
            argvalues,
            self.function,
            self.config,
            nodeid=self.definition.nodeid,
        )
        del argvalues

        if "request" in argnames:
            fail(
                f"{nodeid}: 'request' is a reserved name and cannot be used in @pytest.mark.parametrize",

                pytrace=False,
            )

        if scope is not None:
            scope_ = Scope.from_user(
                scope, descr=f"parametrize() call in {self.function.__name__}"
            )
        else:
            scope_ = _find_parametrized_scope(argnames, self._arg2fixturedefs, indirect)

        self._validate_if_using_arg_names(argnames, indirect)

        # Use any already (possibly) generated ids with parametrize Marks.
        if _param_mark and _param_mark._param_ids_fr
…[6788 chars omitted]…
raise FixtureLookupError(argname, self)
        # The are no fixtures with this name applicable for the function.
        if not fixturedefs:
            raise FixtureLookupError(argname, self)

testing/python/fixtures.py:787:            from _pytest.fixtures import RequestFixtureDef
testing/python/fixtures.py:800:                    leaked = [x for _ in gc.garbage if isinstance(_, RequestFixtureDef)]

261-        self.dtest = dtest
262-
263-        # Stuff needed for fixture support.
264-        self.obj = None
265-        fm = self.session._fixturemanager
266:        fixtureinfo = fm.getfixtureinfo(node=self, func=None, cls=None)
267-        self._fixtureinfo = fixtureinfo
268-        self.fixturenames = fixtureinfo.names_closure
269-        self._initrequest()
270-
271-    @classmethod
--

285-        self.funcargs: dict[str, object] = {}
286-        self._request = TopRequest(self, _ispytest=True)  # type: ignore[arg-type]
287-
288-    def setup(self) -> None:
289-        self._request._fillfixtures()
290:        globs = dict(getfixture=self._request.getfixturevalue)
291:        for name, value in self._request.getfixturevalue("doctest_namespace").items():
292-            globs[name] = value
293-        self.dtest.globs.update(globs)
294-
295-    def runtest(self) -> None:
296-  
…[833 chars omitted]…
ure:
727-
728-    .. code-block:: python
729-
730-        @pytest.fixture(autouse=True)
731:        def add_np(doctest_namespace):
732:            doctest_namespace["np"] = numpy
733-
734:    For more details: :ref:`doctest_namespace`.
735-    """
736-    return dict()
pyproject.toml:375:testpaths = [
_py
acceptance_test.py
code
conftest.py
deprecated_test.py
example_scripts
examples
freeze
io
logging

src/_pytest/deprecated.py:117:FIXTURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(
src/_pytest/deprecated.py:121:FIXTURE_NODEID_DEPRECATED = PytestRemovedIn10Warning(
src/_pytest/deprecated.py:126:PARSEFACTORIES_NODEID_DEPRECATED = PytestRemovedIn10Warning(
src/_pytest/fixtures.py:60:from _pytest.deprecated import FIXTURE_BASEID_DEPRECATED
src/_pytest/fixtures.py:62:from _pytest.deprecated import FIXTURE_NODEID_DEPRECATED
src/_pytest/fixtures.py:63:from _pytest.deprecated import PARSEFACTORIES_NODEID_DEPRECATED
src/_pytest/fixtures.py:1075:            warnings.warn(FIXTURE_BASEID_DEPRECATED, stacklevel=2)
src/_pytest/fixtures.py:1962:            warnings.warn(FIXTURE_NODEID_DEPRECATED, stacklevel=2)
src/_pytest/fixtures.py:2065:                warnings.warn(PARSEFACTORIES_NODEID_DEPRECATED, stacklevel=2)

grep: src/pytest.py: No such file or directory
doc/en/changelog.rst:1226:  * ``FixtureDef.cached_result[2]`` is now a tuple ``(exc, tb)``
doc/en/changelog.rst:2043:- `#7469 <https://github.com/pytest-dev/pytest/issues/7469>`_: :class:`~pytest.FixtureDef` is now exported as ``pytest.FixtureDef`` for typing purposes.
doc/en/changelog.rst:2091:- `#11208 <https://github.com/pytest-dev/pytest/issues/11208>`_: The (internal) ``FixtureDef.cached_result`` type has changed.
doc/en/changelog.rst:4408:- :issue:`6737`: The ``cached_result`` attribute of ``FixtureDef`` is now set to ``None`` when
doc/en/changelog.rst:4635:- :issue:`6436`: :class:`~pytest.FixtureDef` objects now properly register their finalizers with autouse and
doc/en/deprecations.rst:25:Passing ``baseid`` to :class:`~pytest.FixtureDef` or ``nodeid`` strings to
doc/en/reference/reference.rst:996:FixtureDef
doc/en/reference/refere
…[232 chars omitted]…

testing/python/metafunc.py:205:                module_fix=[DummyFixtureDef(Scope.Module)],

testing/python/metafunc.py:206:                class_fix=[DummyFixtureDef(Scope.Class)],
testing/python/metafunc.py:207:                func_fix=[DummyFixtureDef(Scope.Function)],
testing/python/metafunc.py:208:                mixed_fix=[DummyFixtureDef(Scope.Module), DummyFixtureDef(Scope.Class)],
4d354d7 base

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g4d354d7d4. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
.E.                                                                      [100%]
==================================== ERRORS ====================================
________________________ ERROR at setup of test_regular ________________________
file /tmp/tmp.4yiKEl8VC0/test_issue.py, line 7
  def test_regular(fix):

E       fixture 'fix' not found
>       available fixtures: cache, capfd, capfdbinary, caplog, capsys, capsysbinary, captee
…[55 chars omitted]…
rd_property, record_testsuite_property, record_xml_attribute, recwarn, subtests, tmp_path, tmp_path_factory, tmpdir, tmpdir_factory
>       use 'pytest --fixtures [testpath]' for help on them.

/tmp/tmp.4yiKEl8VC0/test_issue.py:7
=========================== short test summary info ============================
ERROR test_issue.py::test_regular
2 passed, 1 error in 0.02s
status=1 tmp=/tmp/tmp.4yiKEl8VC0

sed: can't read src/_pytest/unittest.py: No such file or directory

/tmp/tmp.4yiKEl8VC0
        teardown = getattr(cls, "tearDownClass", None)
        if setup is None and teardown is None:
            return None
        cleanup = getattr(cls, "doClassCleanups", lambda: None)

        def process_teardown_exceptions() -> None:
            # tearDown_exceptions is a list set in the class containing exc_infos for errors during
            # teardown for the class.
            exc_infos = getattr(cls, "tearDown_exceptions", None)
            if not exc_infos:
                return

            exceptions = [exc for (_, exc, _) in exc_infos]
            # If a single exception, raise it directly as this provides a more readable
            # error (hopefully this will improve in #12255).
            if len(exceptions) == 1:
                raise exceptions[0]
            else:
                raise ExceptionGroup("Unittest class cleanup errors", exceptio
…[7442 chars omitted]…
egister_fixture(
src/_pytest/unittest.py:219:        self.session._fixturemanager._register_fixture(
grep: src/_pytest/__pycache__/deprecated.cpython-312.pyc: binary file matches
grep: src/_pytest/__pycache__/fixtures.cpython-312.pyc: binary file matches
grep: src/_pytest/__pycache__/python.cpython-312.pyc: binary file matches
grep: src/_pytest/__pycache__/unittest.cpython-312.pyc: binary file matches

src/_pytest/fixtures.py:119:def get_scope_package(
src/_pytest/fixtures.py:162:def get_scope_node(node: nodes.Node, scope: Scope) -> nodes.Node | None:
        "python_classes",
        type="args",
        default=["Test"],
        help="Prefixes or glob names for Python test class discovery",
    )
    parser.addini(
        "python_functions",
        type="args",
        default=["test"],
        help="Prefixes or glob names for Python test function and method discovery",

    )
    parser.addini(
        "disable_test_id_escaping_and_forfeit_all_rights_to_community_support",
        type="bool",
        default=False,
        help="Disable string escape non-ASCII characters, might cause unwanted "
        "side effects(use at your own risk)",
    )
    parser.addini(
        "strict_parametrization_ids",
        type="bool",
        # None => fallback to `strict`.
        default=
…[8629 chars omitted]…
} for {self._pyfuncitem!r}>"
856-
857-    @property
858-    def _scope(self) -> Scope:
859-        return self._scope_field
860-
861-    @property
862-    def node(self):
863-        return self._node
864-
865-    def _check_scope(
866-        self,
867-        requested_fixturedef: FixtureDef[object],
868-        requested_scope: Scope,
869-    ) -> None:
870-        if self._scope > requested_scope:

# mypy: allow-untyped-defs
"""Python test discovery, setup and run of test functions."""

from __future__ import annotations

import abc
from collections import Counter
from collections import defaultdict
from collections.abc import Callable
from collections.abc import Generator
from collections.abc import Iterable
from collections.abc import Iterator

from collections.abc import Mapping
from collections.abc import Sequence
import dataclasses
import enum
import fnmatch
from functools import partial
import inspect
import itertools
import os
from pathlib import Path
import re
import textwrap
import types
from typing import Any
from typing import cast
from typing import final
from typing import Literal
from typing import NoReturn
from typing import TYPE_CHECKING
import warnings

import _pytest
from _pytest import fixtures
from _pytest import nodes
from _pytest._code import filter_tracebac
…[8433 chars omitted]…
blicly exposing NodeKeywords.
186-        #: Keywords/markers collected from all scopes.
187-        self.keywords: MutableMapping[str, Any] = NodeKeywords(self)
188-
189-        #: The marker objects belonging to this node.
190-        self.own_markers: list[Mark] = []
191-
192-        #: Allow adding of extra keywords to use for matching.
193-        self.extra_keyword_matches: set[str] = set()
194-

Returns None if there are no fixtures at all defined with the given
        name. (This is different from the case in which there are fixtures
        with the given name, but none applicable to the node. In this case,
        an empty result is returned).

        :param argname: Name of the fixture to search for.
        :param node: The requesting Node.
        """
        try:
            fixturedefs = self._arg2fixturedefs[argname]
        except KeyError:
            return None

        return tuple(self._matchfactories(fixturedefs, node))

    def _matchfactories(
        self, fixturedefs: Iterable[FixtureDef[Any]], node: nodes.Node
    ) -> Iterator[FixtureDef[Any]]:
        # Collect parent nodes and their IDs for matching
        parent_nodes = set(node.iter_parents())
        parentnodeids = {n.nodeid for n in parent_nodes}

        for fixturedef in fixturedefs:
 
…[855 chars omitted]…
 loc)


def _get_fixtures_per_test(test: nodes.Item) -> Iterator[FixtureDef[object]]:
    """Returns all fixtures used by the test item except for those created by
    direct parametrization and those requested dynamically with
    ``request.getfixturevalue``.

    The justification for excluding fixtures created by direct parametrization
    is that for users, they are internal implementation detail.

117:FIXTURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(
121:FIXTUREDEF_HAS_LOCATION_DEPRECATED = PytestRemovedIn10Warning(
125:FIXTURE_NODEID_DEPRECATED = PytestRemovedIn10Warning(
130:PARSEFACTORIES_NODEID_DEPRECATED = PytestRemovedIn10Warning(
117:FIXTURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(
121:FIXTUREDEF_HAS_LOCATION_DEPRECATED = PytestRemovedIn10Warning(
125:FIXTURE_NODEID_DEPRECATED = PytestRemovedIn10Warning(
130:PARSEFACTORIES_NODEID_DEPRECATED = PytestRemovedIn10Warning(

451:    def _genfunctions(self, name: str, funcobj) -> Iterator[Function]:
458:        definition = FunctionDefinition.from_parent(self, name=name, callobj=funcobj)
463:        metafunc = Metafunc(

    def _genfunctions(self, name: str, funcobj) -> Iterator[Function]:
        modulecol = self.getparent(Module)
        assert modulecol is not None
        module = modulecol.obj
        clscol = self.getparent(Class)
        cls = (clscol and clscol.obj) or None

        definition = FunctionDefinition.from_parent(self, name=name, callobj=funcobj)

        fixtureinfo = definition._fixtureinfo

        # pytest_generate_tests impls call metafunc.parametrize() which fills
        # metafunc._calls, the outcome of the hook.
        metafunc = Metafunc(
            definition=definition,
            fixtureinfo=fixtureinfo,
            config=self.config,
            cls=cls,
            m
…[5444 chars omitted]…
 dataclasses.field(default_factory=list)

    def setmulti(
        self,
        *,
        argnames: Iterable[str],
        valset: Iterable[object],
        id: str | _HiddenParam,
        marks: Iterable[Mark | MarkDecorator],
        scope: Scope,
1181:name2directparamfixturedef_key = StashKey[dict[str, DirectParamFixtureDef[object]]]()
1386:                name2directparamfixturedef_key, default

diff --git a/src/_pytest/deprecated.py b/src/_pytest/deprecated.py
index 70640f7..c1c5d0c 100644
--- a/src/_pytest/deprecated.py
+++ b/src/_pytest/deprecated.py
@@ -118,6 +118,10 @@ FIXTURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing baseid to FixtureDef is deprecated. Pass node instead for fixture scoping."
 )
 
+FIXTUREDEF_HAS_LOCATION_DEPRECATED = PytestRemovedIn10Warning(
+    "FixtureDef.has_location is deprecated."
+)
+

 FIXTURE_NODEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing nodeid to _register_fixture is deprecated. "
     "Pass node instead for fixture scoping."
diff --git a/src/_pytest/fixtures.py b/src/_pytest/fixtures.py
index cbff945..3421c9b 100644
--- a/src/_pytest/fixtures.py
+++ b/src/_pytest/fixtures.py
@@ -58,6 +58,7 @@ from _pytest.config.argparsing import Parser
 from _pytest.deprecated import check_ispytest
 from _pytest.deprecated imp
…[8628 chars omitted]…
holderobj) and not isinstance(holderobj, types.ModuleType):
             holderobj_tp: object = type(holderobj)
         else:
             holderobj_tp = holderobj
 
-        self._holderobjseen.add(holderobj)
         for name in dir(holderobj):
             # The attribute can be an arbitrary descriptor, so the attribute
             # access below can raise. safe_getattr() ignores such exceptions.

diff --git a/src/_pytest/deprecated.py b/src/_pytest/deprecated.py
index 70640f7..c1c5d0c 100644
--- a/src/_pytest/deprecated.py
+++ b/src/_pytest/deprecated.py
@@ -118,6 +118,10 @@ FIXTURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing baseid to FixtureDef is deprecated. Pass node instead for fixture scoping."
 )
 
+FIXTUREDEF_HAS_LOCATION_DEPRECATED = PytestRemovedIn10Warning(
+    "FixtureDef.has_location is deprecated."
+)
+

 FIXTURE_NODEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing nodeid to _register_fixture is deprecated. "
     "Pass node instead for fixture scoping."
diff --git a/src/_pytest/fixtures.py b/src/_pytest/fixtures.py
index cbff945..3421c9b 100644
--- a/src/_pytest/fixtures.py
+++ b/src/_pytest/fixtures.py
@@ -58,6 +58,7 @@ from _pytest.config.argparsing import Parser
 from _pytest.deprecated import check_ispytest
 from _pytest.deprecated imp
…[8630 chars omitted]…
 module
                except AttributeError:
                    obj = obj_ub

                func = obj._get_wrapped_function()

                self._register_fixture(
                    name=fixture_name,
                    func=func,
                    scope=marker.scope,
                    params=marker.params,
                    ids=marker.ids,
                    autouse=marker.autouse,

len(other.baseid)
        ] in ("/", ":")

    return (
        candidate.node is not other.node and other.node in candidate.node.iter_parents()
    )


def get_scope_node(node: nodes.Node, scope: Scope) -> nodes.Node | None:
    """Get the closest parent node (including self) which matches the given
    scope.

    If there is no parent node for the scope (e.g. asking for class scope on a
    Module, or on a Function when not defined in a class), returns None.
    """
    import _pytest.python

    if scope is Scope.Function:
        # Type ignored because this is actually safe, see:
        # https://github.com/python/mypy/issues/4717
        return node.getparent(nodes.Item)  # type: ignore[type-abstract]
    elif scope is Scope.Class:
        return node.getparent(_pytest.python.Class)
    elif scope is Scope.Module:
        return node.getparent(_pytest.python.Module)
…[5035 chars omitted]…
84:            default: dict[str, DirectParamFixtureDef[object]] = {}
src/_pytest/python.py:1397:                fixturedef = DirectParamFixtureDef(
grep: src/_pytest/__pycache__/fixtures.cpython-312.pyc: binary file matches
grep: src/_pytest/__pycache__/python.cpython-312.pyc: binary file matches
testing/python/metafunc.py:804:        # Since `y` is a direct parameter, its DirectParamFixtureDef would

src/_pytest/deprecated.py |  4 +++
 src/_pytest/fixtures.py   | 75 +++++++++++++++++++++++++++--------------------
 src/_pytest/python.py     | 11 ++++---
 3 files changed, 54 insertions(+), 36 deletions(-)
diff --git a/src/_pytest/deprecated.py b/src/_pytest/deprecated.py
index 70640f7..c1c5d0c 100644
--- a/src/_pytest/deprecated.py
+++ b/src/_pytest/deprecated.py
@@ -118,6 +118,10 @@ FIXTURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing baseid to FixtureDef is deprecated. Pass node instead for fixture scoping."
 )
 

+FIXTUREDEF_HAS_LOCATION_DEPRECATED = PytestRemovedIn10Warning(
+    "FixtureDef.has_location is deprecated."
+)
+
 FIXTURE_NODEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing nodeid to _register_fixture is deprecated. "
     "Pass node instead for fixture scoping."
diff --git a/src/_pytest/fixtures.py b/src/_pytest/fixtures.py
index cbff945..fe780
…[8629 chars omitted]…
parent
@@ -1394,8 +1396,9 @@ class Metafunc:
             ):
                 fixturedef = name2directparamfixturedef[argname]
             else:
+                assert node is not None
                 fixturedef = DirectParamFixtureDef(
-                    config=self.config,
+                    node=node,
                     argname=argname,
                     scope=scope_,
                 )

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g4d354d7d4. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
...                                                                      [100%]
3 passed in 0.01s
status=0 tmp=/tmp/tmp.LZFddwCl9c

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g4d354d7d4. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
ERROR: file or directory not found: testing/python/fixtures.py


no tests ran in 0.00s

ERROR: /repo/pyproject.toml: 'minversion' requires pytest-2.0, actual pytest-0.1.dev1+g4d354d7d4'

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g4d354d7d4. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
.............FFF
=================================== FAILURES ===================================
___________ TestMetafunc.test_parametrize_single_arg_trailing_comma ____________

self = <metafunc.TestMetafunc object at 0x7342a3035b80>

    def test_parametrize_single_arg_trailing_comma(self) -> None:
        """Test that trailing comma in string argnames behaves like tuple argnames.
    
        Regression test for https://github.co
…[5156 chars omitted]…
mmary info ============================
FAILED ../dev::TestMetafunc::test_parametrize_single_arg_trailing_comma - Att...
FAILED ../dev::TestMetafunc::test_parametrize_error - AttributeError: 'Defini...
FAILED ../dev::TestMetafunc::test_parametrize_error_iterator - AttributeError...
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 3 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
3 failed, 13 passed, 2 warnings in 1.41s

# mypy: allow-untyped-defs
from __future__ import annotations

from collections.abc import Iterator
from collections.abc import Sequence
import dataclasses
import itertools
import re
import sys
import textwrap
from typing import Any
from typing import cast

import hypothesis
from hypothesis import strategies

from _pytest import fixtures
from _pytest import python
from _pytest.compat import getfuncargnames
from _pytest.compat import NOTSET
from _pytest.outcomes import fail
from _pytest.outcomes import Failed
from _pytest.pytester import Pytester
from _pytest.python import Function
from _pytest.python import IdMaker
from _pytest.scope import Scope
import pytest


class TestMetafunc:
    def Metafunc(self, func, config=None) -> python.Metafunc:
        # The unit tests of this class check if things work correctly
        # on the funcarg level, so we don't need a full blown
        # in
…[4208 chars omitted]…
ect=True) == Scope.Function
        assert find_scope(["func_fix", "session_fix"], indirect=True) == Scope.Function
        assert find_scope(["session_fix", "class_fix"], indirect=True) == Scope.Class
        assert (
            find_scope(["package_fix", "session_fix"], indirect=True) == Scope.Package
        )
        assert find_scope(["module_fix", "session_fix"], indirect=True) == Scope.Module

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g4d354d7d4. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
..............................................EEE
==================================== ERRORS ====================================
_________ ERROR at setup of TestMetafunc.test_parametrize_request_name _________
file /repo/testing/python/metafunc.py, line 179
      def test_parametrize_request_name(self, pytester: Pytester) -> None:

file /repo/testing/conftest.py, line 160
  @pytest.fixture
  def pytester(pytester: Pytester, monkeypa
…[2375 chars omitted]…
g/conftest.py:160
=========================== short test summary info ============================
ERROR ../dev::TestMetafunc::test_parametrize_request_name
ERROR ../dev::TestMetafunc::test_parametrize_ids_exception
ERROR ../dev::TestMetafunc::test_parametrize_ids_returns_non_string
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 3 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
46 passed, 1 warning, 3 errors in 3.25s

src/_pytest/fixtures.py:128:            if fixturedef.node is not None:
src/_pytest/fixtures.py:129:                if parent == fixturedef.node:
src/_pytest/fixtures.py:132:                if parent.nodeid == fixturedef.baseid:
src/_pytest/fixtures.py:1096:            self.node.nodeid if self.node is not None else (baseid_value or "")
src/_pytest/fixtures.py:1102:            self.node is not None or baseid_value is not None
src/_pytest/fixtures.py:2153:            if fixturedef.node is not None:
src/_pytest/fixtures.py:2155:                if fixturedef.node in parent_nodes:
src/_pytest/fixtures.py:2157:            elif fixturedef.baseid in parentnodeids:
src/_pytest/fixtures.py:2289:                    len(fixturedef.baseid),
src/_pytest/fixtures.py:463:        self._arg2fixturedefs: Final = arg2fixturedefs
src/_pytest/fixtures.py:659:        fixturedefs = self._arg2fixturedefs.get(
…[545 chars omitted]…

_arg2fixturedefs[argname]
src/_pytest/fixtures.py:2278:    for argname, fixturedefs in fm._arg2fixturedefs.items():
src/_pytest/python.py:1230:        self._arg2fixturedefs = fixtureinfo.name2fixturedefs
src/_pytest/python.py:1342:            scope_ = _find_parametrized_scope(argnames, self._arg2fixturedefs, indirect)
src/_pytest/python.py:1413:            self._arg2fixturedefs[argname] = [fixturedef]

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g4d354d7d4. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
...                                                                      [100%]
3 passed in 0.01s
status=0 lines=2
run
run

ERROR: /repo/pyproject.toml: 'minversion' requires pytest-2.0, actual pytest-0.1.dev1+g4d354d7d4'

[tox]
requires =
    tox >= 4
envlist =
    linting
    py310
    py311
    py312
    py313
    py314
    py315
    pypy3

    py310-{pexpect,xdist,twisted24,twisted25,asynctest,numpy,pluggymain,pylib}
    doctesting
    doctesting-coverage
    plugins
    py310-freeze
    docs
    docs-checklinks

    # checks that 3.11 native ExceptionGroup works with exceptiongroup
    # not included in CI.
    py311-exceptiongroup



[pkgenv]
# NOTE: This section tweaks how Tox manages the PEP 517 build
# NOTE: environment where it assembles wheels (editable and regular)
# NOTE: for further installing them into regular testenvs.
#
# NOTE: `[testenv:.pkg]` does not work due to a regression in tox v4.14.1
# NOTE: so `[pkgenv]` is being used in place of it.
# Refs:
# * https://github.com/tox-dev/tox/pull/3237
# * https://github.com/tox-dev/tox/issues/3238
# * https://github.com/tox-dev/tox/issues/3292
…[6083 chars omitted]…
turenames
        except AttributeError:
            # doctest at least
            # (https://github.com/pytest-dev/pytest/issues/5070)
            neutral_items.append(item)
        else:
            if "pytester" in fixtures:
                co_names = item.function.__code__.co_names
                if spawn_names.intersection(co_names):
                    item.add_marker(pytest.mark.uses_pexpect)

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g4d354d7d4. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
..                                                                       [100%]
2 passed in 0.01s
status=0 tmp=/tmp/tmp.xADqwu4e80

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g4d354d7d4. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
........................................................................ [ 20%]
.........x............................................................x. [ 40%]
........................................................................ [ 61%]
..................................s..................................... [ 81%]
............................................................F.....       [100%]

=================================== F
…[8677 chars omitted]…
age object at 0x74fa54aef530>, <warnings.WarningMessage object at 0x74fa54aecce0>])

============================ no tests ran in 0.02s =============================
=========================== short test summary info ============================
FAILED testing/deprecated_test.py::TestFixtureNodeidDeprecations::test_parsefactories_nodeid_deprecation
1 failed, 350 passed, 1 skipped, 2 xfailed in 16.27s

M src/_pytest/deprecated.py
 M src/_pytest/fixtures.py
 M src/_pytest/python.py
            pytrace=False,
        )
    return result


class FixtureDef(Generic[FixtureValue]):
    """A container for a fixture definition.

    Note: At this time, only explicitly documented fields and methods are

    considered public stable API.
    """

    def __init__(
        self,
        config: Config,
        baseid: str | None | NotSetType,
        argname: str,
        func: _FixtureFunc[FixtureValue],
        scope: Scope | ScopeName | Callable[[str, Config], ScopeName] | None,
        params: Sequence[object] | None,
        ids: tuple[object | None, ...] | Callable[[Any], object | None] | None = None,
        *,
        _ispytest: bool = False,
        # only used in a deprecationwarning msg, can be removed in pytest9
        _autouse: bool = False,
        node: nodes.Node | None | Not
…[8630 chars omitted]…
                    node=node,
                    argname=argname,
                    scope=scope_,
                )
                if name2directparamfixturedef is not None:
                    name2directparamfixturedef[argname] = fixturedef
            self._arg2fixturedefs[argname] = [fixturedef]

        # Create the new calls: if we are parametrize() multiple times (by applying the decorator

Can't list 'src/_pytest'

Traceback (most recent call last):
  File "<stdin>", line 3, in <module>
  File "/usr/local/lib/python3.12/pathlib.py", line 1027, in read_text
    with self.open(mode='r', encoding=encoding, errors=errors) as f:
         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/usr/local/lib/python3.12/pathlib.py", line 1013, in open
    return io.open(self, mode, buffering, encoding, errors, newline)
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
FileNotFoundError: [Errno 2] No such file or directory: 'src/_pytest/fixtures.py'
grep: src/_pytest/fixtures.py: No such file or directory
sed: can't read src/_pytest/fixtures.py: No such file or directory

2017:    def parsefactories(
2018-        self,
2019-        node_or_obj: nodes.Node,
2020-    ) -> None:
2021-        raise NotImplementedError()
2022-
2023-    @overload
2024-    @deprecated(
2025-        "Passing nodeid string to parsefactories is deprecated. "
2026-        "Use parsefactories(holder=obj, node=node) instead.",
2027-        category=None,
2028-    )

2029:    def parsefactories(
2030-        self,
2031-        node_or_obj: object,
2032-        nodeid: str | None,
2033-    ) -> None:
2034-        raise NotImplementedError()
2035-
2036-    @overload
2037:    def parsefactories(
2038-        self,
2039-        node_or_obj: None = ...,
2040-        nodeid: None = ...,
2041-        *,
2042-        holder: object,
2043-        node: nodes.Node | None,
2044-    ) -> None:
2045-        raise NotImplementedError()
2046-
2047:    def parsefactories(
2048-        self,
2049-   
…[2098 chars omitted]…
fined, if available.
        # Used for node-based matching which is more robust than string matching.
        self.node: Final = None if node is NOTSET else node
        # The "base" node ID for the fixture.
        #
        # This is a node ID prefix. A fixture is only available to a node (e.g.
        # a `Function` item) if the fixture's baseid is a nodeid of a parent of
        # node.
        #

diff --git a/src/_pytest/deprecated.py b/src/_pytest/deprecated.py
index 70640f7..c1c5d0c 100644
--- a/src/_pytest/deprecated.py
+++ b/src/_pytest/deprecated.py
@@ -118,6 +118,10 @@ FIXTURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing baseid to FixtureDef is deprecated. Pass node instead for fixture scoping."
 )
 
+FIXTUREDEF_HAS_LOCATION_DEPRECATED = PytestRemovedIn10Warning(
+    "FixtureDef.has_location is deprecated."
+)
+

 FIXTURE_NODEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing nodeid to _register_fixture is deprecated. "
     "Pass node instead for fixture scoping."
diff --git a/src/_pytest/fixtures.py b/src/_pytest/fixtures.py
index cbff945..a80a45b 100644
--- a/src/_pytest/fixtures.py
+++ b/src/_pytest/fixtures.py
@@ -58,6 +58,7 @@ from _pytest.config.argparsing import Parser
 from _pytest.deprecated import check_ispytest
 from _pytest.deprecated imp
…[8629 chars omitted]…
parent
@@ -1394,8 +1402,9 @@ class Metafunc:
             ):
                 fixturedef = name2directparamfixturedef[argname]
             else:
+                assert node is not None
                 fixturedef = DirectParamFixtureDef(
-                    config=self.config,
+                    node=node,
                     argname=argname,
                     scope=scope_,
                 )

/usr/local/bin/python: No module named ruff
/usr/local/bin/python: No module named ruff

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g4d354d7d4. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
........................................................................ [ 21%]
.....x............................................................x..... [ 42%]
........................................................................ [ 63%]
..............................s......................................... [ 84%]
....................................................                     [100%]

337 passed, 1 skipped, 2 xfailed in 14.41s

# mypy: allow-untyped-defs
"""Discover and run std-library "unittest" style tests."""

from __future__ import annotations

from collections.abc import Callable
from collections.abc import Generator
from collections.abc import Iterable
from collections.abc import Iterator
from enum import auto
from enum import Enum
import inspect

import sys
import traceback
import types
from typing import Any
from typing import TYPE_CHECKING
from unittest import TestCase

import _pytest._code
from _pytest._code import ExceptionInfo
from _pytest.compat import assert_never
from _pytest.compat import is_async_function
from _pytest.config import hookimpl
from _pytest.fixtures import FixtureRequest
from _pytest.monkeypatch import MonkeyPatch
from _pytest.nodes import Collector
from _pytest.nodes import Item
from _pytest.outcomes import exit
from _pytest.outcomes import fail
from _pytest.outcomes import skip
…[7039 chars omitted]…
ribute
src/_pytest/python.py:566:        self.session._fixturemanager.parsefactories(self)
src/_pytest/python.py:782:        self.session._fixturemanager.parsefactories(
src/_pytest/unittest.py:106:        self.session._fixturemanager.parsefactories(
grep: src/_pytest/__pycache__/deprecated.cpython-312.pyc: binary file matches
grep: src/_pytest/__pycache__/fixtures.cpython-312.pyc: binary file matches

- config-defined usefixtures
    - autouse-marked fixtures along the collection chain up from the function
    - usefixtures markers at module/class/function level
    - test function funcargs

    Subsequently the funcfixtureinfo.fixturenames attribute is computed
    as the closure of the fixtures needed to setup the initial fixtures,
    i.e. fixtures needed by fixture functions themselves are appended
    to the fixturenames list.

    Upon the test-setup phases all fixturenames are instantiated, retrieved
    by a lookup of their FuncFixtureInfo.

    """

    def __init__(self, session: Session) -> None:
        self.session = session
        self.config: Config = session.config
        # Maps a fixture name (argname) to all of the FixtureDefs in the test
        # suite/plugins defined with this name. Populated by parsefactories().
        # TODO: The order of the FixtureDef
…[8629 chars omitted]…
     config = node.config
        except AttributeError:
            config = node.session._fixturemanager.config
        super().__init__(
            config=config,
            baseid=NOTSET,
            argname=argname,
            func=get_direct_param_fixture_func,
            scope=scope,
            params=None,
            ids=None,
            _ispytest=True,
            node=node,
        )

.. autoclass:: pytest.ExceptionInfo()
    :members:


ExitCode
~~~~~~~~

.. autoclass:: pytest.ExitCode
    :members:


FixtureDef

~~~~~~~~~~

.. autoclass:: pytest.FixtureDef()
    :members:
    :show-inheritance:

MarkDecorator
~~~~~~~~~~~~~

.. autoclass:: pytest.MarkDecorator()
    :members:


MarkGenerator
~~~~~~~~~~~~~

.. autoclass:: pytest.MarkGenerator()
    :members:


Mark
~~~~

.. autoclass:: pytest.Mark()
    :members:


Metafunc
~~~~~~~~

.. autoclass:: pytest.Metafunc()
    :members:

Parser
~~~~~~

.. autoclass:: pytest.Parser()
    :members:

grep: testing: Is a directory
HEAD:testing/python/metafunc.py:                session_fix=[DummyFixtureDef(Scope.Session)],
HEAD:testing/python/metafunc.py:                package_fix=[DummyFixtureDef(Scope.Package)],
HEAD:testing/python/metafunc.py:                module_fix=[DummyFixtureDef(Scope.Module)],
HEAD:testing/python/metafunc.py:                class_fix=[DummyFixtureDef(Scope.Class)],
HEAD:testing/python/metafunc.py:                func_fix=[DummyFixtureDef(Scope.Function)],
HEAD:testing/python/metafunc.py:                mixed_fix=[DummyFixtureDef(Scope.Module), DummyFixtureDef(Scope.Class)],

src/_pytest/fixtures.py:836:        if param is not NOTSET:
src/_pytest/fixtures.py:1973:        if nodeid is not NOTSET or node is NOTSET:
src/_pytest/fixtures.py:2007:            if node is not NOTSET and node is not None:
src/_pytest/fixtures.py:2009:            elif nodeid is not NOTSET and nodeid:
src/_pytest/fixtures.py:2078:        elif nodeid is not NOTSET:
src/_pytest/python.py:1628:        if callobj is not NOTSET:

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g4d354d7d4. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
..                                                                       [100%]
2 passed in 0.01s
exit=0 lines=2
tmp=/tmp/tmp.4Tdq3prPpa

@pytest.fixture
                def hello(self, request):
                    return "class"
                def test_hello(self, item, fm):
                    faclist = fm.getfixturedefs("hello", item)
                    print(faclist)
                    assert len(faclist) == 3

                    assert faclist[0].func(item._request) == "conftest"
                    assert faclist[1].func(item._request) == "module"
                    assert faclist[2].func(item._request) == "class"
            """

        )
        reprec = pytester.inline_run("-s")
        reprec.assertoutcome(passed=1)

    def test_register_fixture_ordered_by_visibility(self, pytester: Pytester) -> None:
        """A fixturedef registered for a more specific node takes precedence
        over one registered for a more general (ancestor) node, regardless of
        the order in which they we
…[5553 chars omitted]…
npytest("-W", "ignore::pytest.PytestRemovedIn10Warning")
        result.assert_outcomes(passed=2)
testing/deprecated_test.py:142:    - _register_fixture(nodeid=string) deprecation warning
testing/deprecated_test.py:208:        """_register_fixture(nodeid=string) warns and autouse populates/yields.
grep: testing/__pycache__/deprecated_test.cpython-312-pytest-0.1.dev1+g4d354d7d4.pyc: binary file matches

src/_pytest/fixtures.py:2065:        - ``parsefactories(obj, nodeid)``: Uses obj as holder, nodeid string for scope.
src/_pytest/fixtures.py:2079:            # Legacy: parsefactories(obj, nodeid) - string-based scoping only.
grep: src/_pytest/__pycache__/fixtures.cpython-312.pyc: binary file matches
grep: testing/__pycache__/deprecated_test.cpython-312-pytest-0.1.dev1+g4d354d7d4.pyc: binary file matches

testing/logging/test_fixture.py
testing/python/fixtures.py
testing/python/show_fixtures_per_test.py
testing/test_doctest.py
 src/_pytest/deprecated.py |  4 +++
 src/_pytest/fixtures.py   | 77 +++++++++++++++++++++++++++--------------------
 src/_pytest/python.py     | 15 +++++++--
 3 files changed, 60 insertions(+), 36 deletions(-)
 M src/_pytest/deprecated.py
 M src/_pytest/fixtures.py
 M src/_pytest/python.py

src/_pytest/deprecated.py:121:FIXTUREDEF_HAS_LOCATION_DEPRECATED = PytestRemovedIn10Warning(
src/_pytest/deprecated.py:122:    "FixtureDef.has_location is deprecated."
src/_pytest/fixtures.py:61:from _pytest.deprecated import FIXTUREDEF_HAS_LOCATION_DEPRECATED
src/_pytest/fixtures.py:1101:        self._has_location: Final = (
src/_pytest/fixtures.py:1134:    def has_location(self) -> bool:
src/_pytest/fixtures.py:1135:        warnings.warn(FIXTUREDEF_HAS_LOCATION_DEPRECATED, stacklevel=2)
src/_pytest/fixtures.py:1136:        return self._has_location
grep: src/_pytest/__pycache__/deprecated.cpython-312.pyc: binary file matches
grep: src/_pytest/__pycache__/fixtures.cpython-312.pyc: binary file matches

ids: tuple[object | None, ...] | Callable[[Any], object | None] | None = None,
        *,
        _ispytest: bool = False,
        # only used in a deprecationwarning msg, can be removed in pytest9
        _autouse: bool = False,
        node: nodes.Node | None | NotSetType = NOTSET,
    ) -> None:
        check_ispytest(_ispytest)
        # Emit a deprecation warning whenever no node is provided.
        if node is NOTSET:
            warnings.warn(FIXTURE_BASEID_DEPRECATED, stacklevel=2)
        # The node where this fixture was defined, if available.

        # Used for node-based matching which is more robust than string matching.
        self.node: Final = None if node is NOTSET else node
        # The "base" node ID for the fixture.
        #
        # This is a node ID prefix. A fixture is only available to a node (e.g.
        # a `Function` item) if the fixture's basei
…[1392 chars omitted]…
er a more general one, so that it takes precedence in the
        # override chain (the last applicable fixturedef in the list is used
        # first, see getfixturedefs).
        # fixturedefs with the same visibility keep registration order, i.e. the
        # last registered wins.
        # The order between non-comparable fixturedefs doesn't matter since they
        # cannot be visible together.

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g4d354d7d4. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
PytestRemovedIn10Warning: Passing nodeid string to parsefactories is deprecated. Use parsefactories(holder=obj, node=node) instead.
PytestRemovedIn10Warning: Passing nodeid to _register_fixture is deprecated. Pass node instead for fixture scoping.
PytestRemovedIn10Warning: Passing nodeid string to parsefactories is deprecated. Use parsefactories(holder=obj, node=node) instead.
PytestRemovedIn10Warning: Passing nodeid to _register_fixture is deprecated. Pass node instead for fixture scoping.
.

1 passed in 0.00s

:param ids:
            The fixture's IDs.
        :param autouse:
            Whether this is an autouse fixture.
        """
        # Emit a deprecation warning when the legacy nodeid argument is used or
        # when no node is provided.
        if nodeid is not NOTSET or node is NOTSET:
            warnings.warn(FIXTURE_NODEID_DEPRECATED, stacklevel=2)
        fixture_def = FixtureDef(
            config=self.config,
            baseid=nodeid if node is NOTSET or node is None else NOTSET,

            argname=name,
            func=func,
            scope=scope,
            params=params,
            ids=ids,
            _ispytest=True,
            _autouse=autouse,
            node=None if node is NOTSET else node,
        )

        faclist = self._arg2fixturedefs.setdefault(name, [])
        # Insert the fixturedef into the list while maintaining a partial order
        # based on visibility: a fixturedef whose visibility is more specific
        # sorts after a more general one, so that it takes precedence in the
        # override chain (the last applicable fixturedef in the list is used
        # first, see getfixturedefs).

(command exceeded 600s)

/repo
91:[tool.ruff]
93:line-length = 88
113:    "RUF",     # ruff
163:    # ruff ignore
199:# In order to be able to format for 88 char in ruff format
200:lint.pycodestyle.max-line-length = 120
206:max-line-length = 120
219:    "cell-var-from-loop",                     # B023 from ruff / flake8-bugbear
220:    "comparison-of-constants",                # disabled in ruff (PLR0133)
222:    "comparison-with-itself",                 # PLR0124 from ruff
229:    "consider-using-from-import",             # not activated by default, PLR0402 disabled in ruff

244:    "else-if-used",                           # not activated by default, PLR5501 disabled in ruff
245:    "empty-comment",                          # not activated by default, PLR2044 disabled in ruff
246:    "eq-without-hash",                        # PLW1641 disabled in ruff
251:    "global-statement",                       # PLW06
…[799 chars omitted]…
in ruff
335:    "useless-else-on-loop",                   # PLC0414 disabled in ruff
341:    "wrong-import-order",                     # handled by isort / ruff
342:    "wrong-import-position",                  # handled by isort / ruff
4	0	src/_pytest/deprecated.py
44	34	src/_pytest/fixtures.py
12	3	src/_pytest/python.py
 M src/_pytest/deprecated.py
 M src/_pytest/fixtures.py
 M src/_pytest/python.py

# Try next super fixture, if any.

    def pytest_collection_modifyitems(self, items: list[nodes.Item]) -> None:
        # Separate parametrized setups.
        items[:] = reorder_items(items)

    def _register_fixture(
        self,
        *,
        name: str,
        func: _FixtureFunc[object],
        nodeid: str | None | NotSetType = NOTSET,

        scope: Scope | ScopeName | Callable[[str, Config], ScopeName] = "function",
        params: Sequence[object] | None = None,
        ids: tuple[object | None, ...] | Callable[[Any], object | None] | None = None,
        autouse: bool = False,
        node: nodes.Node | None | NotSetType = NOTSET,
    ) -> None:
        """Register a fixture

        :param name:
            The fixture's name.
        :param func:
            The fixture's implementation function.
        :param nodeid:
            The visibility of t
…[7816 chars omitted]…
 parsefactories is deprecated. "
    "Use parsefactories(holder=obj, node=node) instead."
)


def check_ispytest(ispytest: bool) -> None:
    if not ispytest:
        warn(PRIVATE, stacklevel=3)
 src/_pytest/deprecated.py |  4 +++
 src/_pytest/fixtures.py   | 78 ++++++++++++++++++++++++++---------------------
 src/_pytest/python.py     | 15 +++++++--
 3 files changed, 60 insertions(+), 37 deletions(-)

1244:99:        return f"<FixtureDef argname={self.argname!r} scope={self.scope!r} baseid={self.baseid!r}>"
1291:92:        # Handle the case where fixture is defined not in a test class, but some other class
1320:99:            f"{request.node.name!r} requested an async fixture {request.fixturename!r}{auto_str}, "
1321:113:            "with no plugin or hook that handled it. This is an error, as pytest does not natively support it.\n"
1322:108:            "See: https://docs.pytest.org/en/stable/deprecations.html#sync-test-depending-on-async-fixture",
1360:109:                f"@pytest.fixture is being applied more than once to the same function {function.__name__!r}"
1366:117:                "See docs: https://docs.pytest.org/en/stable/deprecations.html#applying-a-mark-to-a-fixture-function"
1377:94:                f"'request' is a reserved word for fixtures, use another name:\n  {lo
…[557 chars omitted]…
es are: str, bytes, int, float, complex, bool, enum, regex or anything with a __name__."
1333:105:                f"{nodeid}: 'request' is a reserved name and cannot be used in @pytest.mark.parametrize",
60:89:    "Legacy namespace packages (using pkg_resources.declare_namespace) are deprecated.\n"

62:98:    "See https://docs.pytest.org/en/stable/deprecations.html#monkeypatch-fixup-namespace-packages"

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g4d354d7d4. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
........................................................................ [ 20%]
.........x............................................................x. [ 40%]
........................................................................ [ 61%]
..................................s..................................... [ 81%]
.................................................................        [100%]

350 passed, 1 skipped, 1 deselected, 2 xfailed in 15.64s

diff --git a/src/_pytest/deprecated.py b/src/_pytest/deprecated.py
index 70640f7..c1c5d0c 100644
--- a/src/_pytest/deprecated.py
+++ b/src/_pytest/deprecated.py
@@ -118,6 +118,10 @@ FIXTURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing baseid to FixtureDef is deprecated. Pass node instead for fixture scoping."
 )
 
+FIXTUREDEF_HAS_LOCATION_DEPRECATED = PytestRemovedIn10Warning(
+    "FixtureDef.has_location is deprecated."
+)
+

 FIXTURE_NODEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing nodeid to _register_fixture is deprecated. "
     "Pass node instead for fixture scoping."
diff --git a/src/_pytest/fixtures.py b/src/_pytest/fixtures.py
index cbff945..ba7da50 100644
--- a/src/_pytest/fixtures.py
+++ b/src/_pytest/fixtures.py
@@ -58,6 +58,7 @@ from _pytest.config.argparsing import Parser
 from _pytest.deprecated import check_ispytest
 from _pytest.deprecated imp
…[8629 chars omitted]…
parent
@@ -1394,8 +1402,9 @@ class Metafunc:
             ):
                 fixturedef = name2directparamfixturedef[argname]
             else:
+                assert node is not None
                 fixturedef = DirectParamFixtureDef(
-                    config=self.config,
+                    node=node,
                     argname=argname,
                     scope=scope_,
                 )

# Emit a deprecation warning when the legacy nodeid argument is used or
        # when no node is provided.
        if nodeid is not NOTSET or node is NOTSET:
            warnings.warn(FIXTURE_NODEID_DEPRECATED, stacklevel=2)
        fixture_def = FixtureDef(
            config=self.config,
            baseid=nodeid if node is NOTSET or node is None else NOTSET,
            argname=name,
            func=func,
            scope=scope,
            params=params,
            ids=ids,

            _ispytest=True,
            _autouse=autouse,
            node=node,
        )

        faclist = self._arg2fixturedefs.setdefault(name, [])
        # Insert the fixturedef into the list while maintaining a partial order
        # based on visibility: a fixturedef whose visibility is more specific
        # sorts after a more general one, so that it takes precedence in the
        # override chain (the last applicable fixturedef in the list is used
        # first, see getfixturedefs).
        # fixturedefs with the same visibility keep registration order, i.e. the
        # last registered wins.
        # The order between non-comparable fixturedefs doesn't matter since they

/usr/local/lib/python3.12/site-packages/_hypothesis_pytestplugin.py:85: UserWarning: 
        You are using pytest version 0.1.dev1+g4d354d7d4. Hypothesis tests work with any test
        runner, but our pytest plugin requires pytest 4.6 or newer.
        Note that the pytest developers no longer support your version either!
        Disabling the Hypothesis pytest plugin...
    
  warnings.warn(PYTEST_TOO_OLD_MESSAGE % (pytest.__version__,), stacklevel=1)
...                                                                      [100%]
3 passed in 0.01s

M src/_pytest/deprecated.py
 M src/_pytest/fixtures.py
 M src/_pytest/python.py
 src/_pytest/deprecated.py |  4 +++
 src/_pytest/fixtures.py   | 76 +++++++++++++++++++++++++++--------------------
 src/_pytest/python.py     | 15 ++++++++--
 3 files changed, 59 insertions(+), 36 deletions(-)
1976:            baseid=nodeid if node is NOTSET or node is None else NOTSET,
1977-            argname=name,
1978-            func=func,
1979-            scope=scope,
1980-            params=params,

1981-            ids=ids,
1982-            _ispytest=True,
1983-            _autouse=autouse,
1984-            node=node,
1985-        )
1986-
1987-        faclist = self._arg2fixturedefs.setdefault(name, [])
1988-        # Insert the fixturedef into the list while maintaining a partial order

1729:90:        # Pending conftest modules waiting to be parsed when their Directory is collected.
2107:90:                # if the fixture is named in the decorator we cannot find it in the module
1415:97:        # Create the new calls: if we are parametrize() multiple times (by applying the decorator
1416:89:        # more than once) then we accumulate those calls generating the cartesian product

diff --git a/src/_pytest/deprecated.py b/src/_pytest/deprecated.py
index 70640f7..c1c5d0c 100644
--- a/src/_pytest/deprecated.py
+++ b/src/_pytest/deprecated.py
@@ -118,6 +118,10 @@ FIXTURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing baseid to FixtureDef is deprecated. Pass node instead for fixture scoping."
 )
 
+FIXTUREDEF_HAS_LOCATION_DEPRECATED = PytestRemovedIn10Warning(
+    "FixtureDef.has_location is deprecated."
+)
+

 FIXTURE_NODEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing nodeid to _register_fixture is deprecated. "
     "Pass node instead for fixture scoping."
diff --git a/src/_pytest/fixtures.py b/src/_pytest/fixtures.py
index cbff945..7e879a3 100644
--- a/src/_pytest/fixtures.py
+++ b/src/_pytest/fixtures.py
@@ -58,6 +58,7 @@ from _pytest.config.argparsing import Parser
 from _pytest.deprecated import check_ispytest
 from _pytest.deprecated imp
…[8629 chars omitted]…
parent
@@ -1394,8 +1402,9 @@ class Metafunc:
             ):
                 fixturedef = name2directparamfixturedef[argname]
             else:
+                assert node is not None
                 fixturedef = DirectParamFixtureDef(
-                    config=self.config,
+                    node=node,
                     argname=argname,
                     scope=scope_,
                 )

submitted.