pytest-dev-pytest-14540-14567

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
…[8629 chars omitted]…
dIn10Warning(
    "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_ispytest(ispytest: bool) -> None:
    if not ispytest:
        warn(PRIVATE, stacklevel=3)

    """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
…[3415 chars omitted]…
tureDef's such that later at test
src/_pytest/python.py:1363:        # For scopes higher than function, a DirectParamFixtureDef might have
src/_pytest/python.py:1365:        # DirectParamFixtureDef on the node related to the scope.
src/_pytest/python.py:1384:            default: dict[str, DirectParamFixtureDef[object]] = {}
src/_pytest/python.py:1397:                fixturedef = DirectParamFixtureDef(

    def __repr__(self) -> str:
        return f"<FixtureDef argname={self.argname!r} scope={self.scope!r} baseid={self.baseid!r}>"


class RequestFixtureDef(FixtureDef[FixtureRequest]):
    """A custom FixtureDef for the special "request" fixture.

    A new one is generated on-demand whenever "request" is requested.
    """

    def __init__(self, request: FixtureRequest) -> None:
        super().__init__(
            config=request.config,
            baseid=None,
     
…[8629 chars omitted]…
ror for a bad path). These conftests' fixtures aren't
        needed since their directories' tests weren't collected either.
        """
        self._pending_conftests.clear()

    def _getautousenames(self, node: nodes.Node) -> Iterator[str]:
1710:        self._holderobjseen: Final[set[object]] = set()
2073:        if holderobj in self._holderobjseen:
2082:        self._holderobjseen.add(holderobj)

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_p
…[5415 chars omitted]…
pe.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)],

                # If used package scope and there is no package, use session
                # (for now).
                elif scope_ is Scope.Package:
                    node = collector.session
                else:
                    assert False, f"Unhandled missing scope: {scope}"
         
…[1691 chars omitted]…
s item,
        # return it.
        fixturedef = self._fixture_defs.get(argname)
        if fixturedef is not None:
            self._check_scope(fixturedef, fixturedef._scope)
            return fixturedef

        # Find the appropriate fixturedef.
        fixturedefs = self._arg2fixturedefs.get(argname, None)
        if fixturedefs is None:
            # We arrive here because of a dynamic call 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 tup
…[2685 chars omitted]…


        @deprecated(
            "config.inicfg is deprecated, use config.getini() to access configuration values instead.",
        )
        @property
        def inicfg(self) -> _DeprecatedInicfgProxy:
            raise NotImplementedError()
    else:

        @property
        def inicfg(self) -> _DeprecatedInicfgProxy:
            warnings.warn(
                _pytest.deprecated.CONFIG_INICFG,

src/_pytest/python.py:1360:        # registering art
…[22 chars omitted]…
tureDef's such that later at test
src/_pytest/python.py:1363:        # For scopes higher than function, a DirectParamFixtureDef might have
src/_pytest/python.py:1365:        # DirectParamFixtureDef on the node related to the scope.
src/_pytest/python.py:1384:            default: dict[str, DirectParamFixtureDef[object]] = {}
src/_pytest/python.py:1397:                fixturedef = DirectParamFixtureDef(

        # (using `request.getfixturevalue("foo")`) are not included here.
        self._arg2fixturedefs: Final = arg2fixturedefs
        # The evaluated argnames so far, mapping to the FixtureDef they resolved
        # to.
        self._fixture_defs: Final = fixture_defs
        # Notes on the type of `param`:
        # -`request.param` is only d
…[5900 chars omitted]…
           argname=name,
            func=func,
            scope=scope,
            params=params,
            ids=ids,
            _ispytest=True,
            _autouse=autouse,
            node=node,
*** Error compiling 'src/_pytest/fixtures.py'...
  File "src/_pytest/fixtures.py", line 1066
    argname: str,
    ^^^^^^^^^^^^
SyntaxError: parameter without a default follows parameter with a default

                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/_pytest/config/__init__.py", line 358, in get_config
    pluginmanager = PytestPluginManager()
                    ^^^^^^^^^^^^^^^^^^^^^
  File "/repo/src/_pytest/config/__init__.py", line 4
…[254 chars omitted]…
from _pytest.fixtures import FixtureFunctionDefinition
  File "/repo/src/_pytest/fixtures.py", line 440, in <module>
    class FixtureRequest(abc.ABC):
  File "/repo/src/_pytest/fixtures.py", line 569, in FixtureRequest
    @abc.abstractmethod
     ^^^^^^^^^^^^^^^^^^
  File "<frozen abc>", line 24, in abstractmethod
AttributeError: attribute '__isabstractmethod__' of 'property' objects is not writable

    def keywords(self) -> MutableMapping[str, Any]:
        """Keywords/markers dictionary for the underlying node."""
        node: nodes.Node = self.node
        return node.keywords

    @property
    def session(self) -> Session:
…[1375 chars omitted]…
e 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.

eType' object has no attribute 'config'
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!
!!!!!!!!!!!!!!!!!!!! Interrupted: 1 error during collection !!!!!!!!!!!!!!!!!!!!
 src/_pytest/deprecated.py |  4 ++++
 src/_pytest/fixtures.py   | 42 +++++++++++++++++++++---------------------
 src/_pytest/python.py     |  6 +++---
 3 files changed, 28 insertions(+), 24 deletions(-)

                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
…[1843 chars omitted]…
    elif scope_ is Scope.Package:
                    node = collector.session
                else:
                    assert False, f"Unhandled missing scope: {scope}"
            default: dict[str, DirectParamFixtureDef[object]] = {}
            name2directparamfixturedef = node.stash.setdefault(
                name2directparamfixturedef_key, default
            )
        for argname in argnames:

_column_width, subtests, tmp_path, tmp_path_factory, tmpdir, tmpdir_factory, tw_mock
>       use 'pytest --fixtures [testpath]' for help on them.

/repo/testing/conftest.py:160
=========================== short test summary info ============================
ERROR ../dev::test_external_plugins_integrated[pytest_capturelog]
!!!!!!!!!!!!!!!!!!!!!!!!!! stopping after 1 failures !!!!!!!!!!!!!!!!!!!!!!!!!!!

 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 HAS_LOCATI
…[3787 chars omitted]…
ility (nodeid=None).
-            self.parsefactories(plugin, None)
+            self.parsefactories(holder=plugin, node=self.session)
 
     @hookimpl(wrapper=True)
     def pytest_make_collect_report(
@@ -1927,12 +1933,12 @@ class FixtureManager:
         *,
         name: str,
         func: _FixtureFunc[object],
-        nodeid: str | None = None,
+        nodeid: str | None | NotSetType = NOTSET,

src/_pytest/python.py:810:        self.session._fixturemanager._register_fixture(
sr
…[1813 chars omitted]…
s(node) - node has .obj attribute
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(
127:    "Passing nodeid string to parsefactories is deprecated. "
128:    "Use parsefactories(holder=obj, node=node) instead."

from warnings import warn

from _pytest.warning_types import PytestDeprecationWarning
from _pytest.warning_types import PytestRemovedIn10Warning
from _pytest.warning_types import UnformattedWarning


# set of plugins which have been integrated into the core; we use this list to ignore
# them during registration to avoid conflicts
DEPRECATED_EXTERNAL_PLUGINS = {
    "pytest_catchlog",
    "pytest_capturelog",
    "pytest_fau
…[8630 chars omitted]…
der = MockAwareDocTestFinder()
        optionflags = get_optionflags(self.config)
        runner = _get_runner(
            verbose=False,
            optionflags=optionflags,
            checker=_get_checker(),
            continue_on_failure=_get_continue_on_failure(self.config),
        )

        for test in finder.find(module, module.__name__):
            if test.examples:  # skip empty doctests

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
…[8630 chars omitted]…
_names
from _pytest.compat import get_real_func
from _pytest.compat import getimfunc
from _pytest.compat import is_async_function
from _pytest.compat import NOTSET
from _pytest.compat import safe_getattr
from _pytest.compat import safe_isclass
src/_pytest/python.py:1158:class DirectParamFixtureDef(FixtureDef[FixtureValue]):
src/_pytest/python.py:1397:                fixturedef = DirectParamFixtureDef(

        # Used for node-based matching which is more robust than string matching.
        self.node: Final = 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 o
…[8629 chars omitted]…
  self.parsefactories(holder=plugin, node=session)

    def pytest_collection_finish(self) -> None:
        """Clean up any conftests that were never collected by a Directory.

        After __init__ flushes above-rootdir conftests and collection pops
        under-rootdir ones, remaining entries mean collection was interrupted
        (e.g. UsageError for a bad path). These conftests' fixtures aren't

    try:
        next(it)
    except StopIteration:
        pass
    else:
        fs, lineno = getfslineno(fixturefunc)
        fail(
            f"fixture function has more than one 'yield':\n\n"
            f"{Source(fixturefunc).indent()}\n"
            f"{fs}:{lineno + 1}",
            pytrace=False,
        )


def _eval_scope_callable(
    scope_callable: 
…[8629 chars omitted]…
Def[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(
1710:        self._holderobjseen: Final[set[object]] = set()
2073:        if holderobj in self._holderobjseen:
2082:        self._holderobjseen.add(holderobj)

        ids: tuple[object | None, ...] | Callable[[Any], object | None] | None = None,
        autouse: bool = False,
        node: nodes.Node | None = None,
    ) -> None:
        """Register a fixture

        :param name:
            The fixture's name.
        :param func:
            The fixture's implementation function.
        :param nodeid:
            The visibility of the fixture (deprecated, use node instead).
            The fixture will be avail
…[4544 chars omitted]…
tureDef's such that later at test
src/_pytest/python.py:1363:        # For scopes higher than function, a DirectParamFixtureDef might have
src/_pytest/python.py:1365:        # DirectParamFixtureDef on the node related to the scope.
src/_pytest/python.py:1384:            default: dict[str, DirectParamFixtureDef[object]] = {}
src/_pytest/python.py:1397:                fixturedef = DirectParamFixtureDef(

        # (using function parameters, autouse, etc).

        fixturedef = self._get_active_fixturedef(argname)
        assert fixturedef.cached_result is not None, (
            f'The fixture value for "{argname}" is not available.  '
            "This can happen when the fixture has already been torn down."
        )
        return fixturedef.cached
…[787 chars omitted]…
te fixturedef.
        fixturedefs = self._arg2fixturedefs.get(argname, None)
        if fixturedefs is None:
            # We arrive here because of a dynamic call to
./src/_pytest/fixtures.py:1710:        self._holderobjseen: Final[set[object]] = set()
./src/_pytest/fixtures.py:2073:        if holderobj in self._holderobjseen:
./src/_pytest/fixtures.py:2082:        self._holderobjseen.add(holderobj)

    """

    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_
…[2037 chars omitted]…
ding conftest modules waiting to be parsed when their Directory is collected.
        # Maps directory path -> conftest plugin module.
./src/_pytest/deprecated.py:117:FIXTURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(
./src/_pytest/fixtures.py:60:from _pytest.deprecated import FIXTURE_BASEID_DEPRECATED
./src/_pytest/fixtures.py:1075:            warnings.warn(FIXTURE_BASEID_DEPRECATED, stacklevel=2)

    def pytest_collection_finish(self) -> None:
2134:    def _matchfactories(
2135-        self, fixturedefs: Iterable[FixtureDef[Any]], node: nodes.Node
2136-    ) -> Iterator[FixtureDef[Any]]:
2137-        # Collect parent nodes and their IDs for matching
2138-        parent_nodes = 
…[399 chars omitted]…
aseid in parentnodeids:
2147-                # Fallback to string-based matching for legacy/plugins
2148-                yield fixturedef
2149-
2150-
2151-def show_fixtures_per_test(config: Config) -> int | ExitCode:
2152-    from _pytest.main import wrap_session
2153-
2154-    return wrap_session(config, _show_fixtures_per_test)
2155-
2156-
2157-_PYTEST_DIR = Path(_pytest.__file__).parent
2158-
2159-

    return fixture_marker


@deprecated(
    "@pytest.yield_fixture is deprecated. Use @pytest.fixture instead; they are the same.",
    category=None,  # We have our own runtime warning logic
)
def yield_fixture(
    fixture_function=None,
    *args,
    scope="function",
    params=None,
    autouse=False,
    ids=None,
    name=None,
):
    """(Return a) decorator to mark a yield-fixture factory function.

        self.hook = self.pluginmanager.hook
        self._inicache: dict[str, Any] = {}
        self._inicfg
…[1338 chars omitted]…
/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(

        if setup_module is None and teardown_module is None:
            return

        def xunit_setup_module_fixture(request) -> Generator[None]:
            module = request.module
            if setup_module is not None:
                _call_with_optional_argument(setup_module, module)
            yield
            if teardown_module is not N
…[7862 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

    """

    def __init__(
        self,
        config: Config,
        baseid: str | None | NotSetType = NOTSET,
        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,
132:                if parent.nodeid == fixturedef.baseid:
148:        if candidate.baseid == other.baseid:
1065: 
…[210 chars omitted]…
6-    scope="function",
1537-    params=None,
--
2037:    @deprecated(
2038-        "Passing nodeid to parsefactories is deprecated. Use parsefactories(holder=obj, node=node) instead.",
2039-        category=None,
2040-    )
2041-    def parsefactories(
2042-        self,
2043-        node_or_obj: nodes.Node | object | None = None,
2044-        nodeid: str | NotSetType | None = NOTSET,
2045-        *,

        *,
        _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)
        if node is NOTSET:
            warnings.warn(FIXTURE_BASEID_DEPRECATED, stacklevel=2)

 from _pytest.deprecated import FIXTURE_NODEID_DEPRECATED
 from _pytest.deprecated import PARSEFACTORIES_NODEID_DEPRECATED
@@ -482,6 +483,11 @@ class FixtureRequest(abc.ABC):
     def _scope(self) -> Scope:
         raise NotImplementedError()
 
+    @property
+    def has_location(self) -
…[4130 chars omitted]…
s) is fine.
-        if nodeid and node is None:
+        if nodeid is not NOTSET or node is NOTSET:
             warnings.warn(FIXTURE_NODEID_DEPRECATED, stacklevel=2)
+        if node is NOTSET:
+            node = None
         fixture_def = FixtureDef(
             config=self.config,
             baseid=nodeid if node is None else None,
@@ -2027,6 +2034,10 @@ class FixtureManager:
     ) -> None:

-            baseid="",
+            config=node.config,
+            baseid=NOTSET,
             argname=argname,
             func=get_direct_param_fixture_func,
             scope=scope,
             params=None,
             ids=None,
             _ispytest=True,
+            node=node,
         )
 
 
@@ -1359,7 +1360,7 @@ class Metafunc:
         # Add direct parametrizations as fixturedef
…[4795 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.

--- a/src/_pytest/deprecated.py
+++ b/src/_pytest/deprecated.py
@@ -114,6 +114,10 @@ PASTEBIN = PytestRemovedIn10Warning(
 # the warning (possibly error in the future).
 
 
+FIXTURE_HAS_LOCATION = PytestRemovedIn10Warning(
+    "FixtureDef.has_location is deprecated and will be removed in pytest 10."
+)
+
 FIXTURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing baseid to FixtureDef is deprecated. Pass node instead for fixture scoping."
 )

        if nodeid is NOTSET:
            nodeid = None
        fixture_def = FixtureDef(
            config=self.config,
            baseid=nodeid if node is None else None,
            argname=name,

s.py:2110
src/_pytest/fixtures.py:2110
  /repo/src/_pytest/fixtures.py:2110: PytestRemovedIn10Warning: Passing nodeid to _register_fixture is deprecated. Pass node instead for fixture scoping.
    self._register_fixture(

-- Docs: https://docs.pytest.org/en/stable/how-to/capture-warnings.html
2 passed, 2 warnings in 0.02s
 M src/_pytest/deprecated.py
 M src/_pytest/fixtures.py
 M src/_pytest/python.py

2075-            # Legacy: parsefactories(obj, nodeid) - string-based scoping only
2076-            warnings.warn(PARSEFACTORIES_NODEID_DEPRECATED, stacklevel=2)
2077-            holderobj = node_or_obj
 src/_pytest/deprecated.py |  4 ++++
 src/_pytest/fixtures.py   | 51 +++++++++++++++++++++++++++--------------------
 src/_pytest/python.py     | 11 +++++-----
 3 files changed, 39 insertions(+), 27 deletions(-)

src/_pytest/fixtures.py:2180:    from _pytest.python import DirectPa
…[7881 chars omitted]…
dIn10Warning(
    "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_ispytest(ispytest: bool) -> None:
    if not ispytest:
        warn(PRIVATE, stacklevel=3)

    Note: At this time, only explicitly documented fields and methods are
    considered public stable API.
    """

    def __init__(
        self,
        config: Config,
        baseid: str | None,
        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 deprecationwarnin
…[8630 chars omitted]…
tureDef's such that later at test
src/_pytest/python.py:1363:        # For scopes higher than function, a DirectParamFixtureDef might have
src/_pytest/python.py:1365:        # DirectParamFixtureDef on the node related to the scope.
src/_pytest/python.py:1384:            default: dict[str, DirectParamFixtureDef[object]] = {}
src/_pytest/python.py:1397:                fixturedef = DirectParamFixtureDef(

        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: obj
…[6797 chars omitted]…
 None:
        pass


def resolve_fixture_function(
    fixturedef: FixtureDef[FixtureValue], request: FixtureRequest
src/_pytest/fixtures.py:1521:@deprecated(
src/_pytest/compat.py:325:        def deprecated(msg, /, *, category=None, stacklevel=1):
src/_pytest/config/__init__.py:1164:        @deprecated(
src/_pytest/fixtures.py:1521:@deprecated(
src/_pytest/mark/structures.py:554:        @deprecated(

    return fixture_marker


@deprecated(
    "@pytest.yield_fixture is deprecated. Use @pytest.fixture instead; they are the same.",
    category=None,  # We have our own runtime warning logic
)
def yield_fixture(
    fixture_function=None,
    *args,
    scope="function",
    params=None,
    autouse=False,
    ids=None,
    name=None,
):
    """(Return a) decorator to mark a yield-fixture factory function.

48:from _pytest.compat import NOTSET
700:            param = NOTSET
835:        if param is not NOTSET:
2033
…[2179 chars omitted]…
est_make_collect_report(
        self, collector: nodes.Collector
    ) -> Generator[None, CollectReport, CollectReport]:
        result = yield
        if isinstance(collector, nodes.Directory):
            plugin = self._pending_conftests.pop(collector.path, None)
            if plugin is not None:
src/_pytest/fixtures.py:1097:        self.has_location: Final = node is not None or baseid is not None

    # 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
        self.hook = self.plug
…[1302 chars omitted]…
g2fixturedefs: Final[dict[str, list[FixtureDef[Any]]]] = {}
        self._holderobjseen: Final[set[object]] = set()
        # A mapping from a node to a list of autouse fixture names it defines.
        # The Session entry holds global usefixtures from config.
        self._node_autousenames: Final[dict[nodes.Node, list[str]]] = {
            session: list(self.config.getini("usefixtures")),
        }

    """

    def __init__(
        self,
        config: Config,
        baseid: str | NotSetType | None = NOTSET,
        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 pyt
…[3700 chars omitted]…
use:
            Whether this is an autouse fixture.
        """
        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 else None,
            argname=name,
            func=func,
            scope=scope,
            params=params,

1253-            config=request.config,
1254-            baseid=None,
1255-            argname="request",
1256-            func=lambda: request,
1257-            scope=Scope.Function,
1258-            params=None,
1259-            _ispytest=True,
1260-            node=request.node,
1261-        )
1262-        self.cached_result = (request, [0], None)
1263-
487:    def has_location(self) -> bool:
1260:            node=request.node,

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

--
2013-        node_or_obj: nodes.Node,
2014-    ) -> None:
2015-        raise NotImplementedError()
2016-
2017-    @overload
2018:    def parsefactories(
--
2021-        nodeid: str | None,
2022-    ) -> None:
2023-        raise NotImplementedError()
2024-
2025-    @overload
2026:    def parsefactories(
--
2035-
2036-    @deprecated(
2037-        "Passing nodeid to parsefactories is deprecated.",
2038-        category=None,
2039-    )
2040:    def parsefactories(

…[3107 chars omitted]…
FixtureFunc[FixtureValue]', scope: 'Scope | ScopeName | Callable[[str, Config], ScopeName] | None', params: 'Sequence[object] | None', baseid: 'str | NotSetType | None' = <NotSetType.token: 0>, ids: 'tuple[object | None, ...] | Callable[[Any], object | None] | None' = None, *, _ispytest: 'bool' = False, _autouse: 'bool' = False, node: 'nodes.Node | NotSetType | None' = <NotSetType.token: 0>) -> 'None'

--- 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
@@ -482,6 +483,11 @@ class FixtureRequest(abc.ABC):
     def _scope(self) -> Scope:
         raise NotImplementedError()
 
+    @pr
…[3465 chars omitted]…
 _FixtureFunc[object],
-        nodeid: str | None = None,
+        nodeid: str | NotSetType | None = 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 = None,

 src/_pytest/python.py     |  9 +++++----
 3 files changed, 36 insertions(+), 27 deletions(-)

+)
+
 FIXTURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing baseid to FixtureDef is deprecated. Pass node instead for fixture scoping."
 )
diff --git a/src/_pytest/python.py b/src/_pytest/python.py
index ad5a2c6..a9218cc 100644
--- a/src/_pytest/python.py
+++ b/src/_pytest/python.py
@@ -1164,16 +1164,17 @@ class DirectParamFixtureDef(FixtureDef[FixtureValue]):
     usuall
…[508 chars omitted]…
         _ispytest=True,
+            node=node,
         )
 
 
@@ -1395,7 +1396,7 @@ class Metafunc:
                 fixturedef = name2directparamfixturedef[argname]
             else:
                 fixturedef = DirectParamFixtureDef(
-                    config=self.config,
+                    node=node,
                     argname=argname,
                     scope=scope_,
                 )

s
…[1798 chars omitted]…
 higher than function, a DirectParamFixtureDef might have
src/_pytest/python.py:1365:        # DirectParamFixtureDef on the node related to the scope.
src/_pytest/python.py:1384:            default: dict[str, DirectParamFixtureDef[object]] = {}
src/_pytest/python.py:1397:                fixturedef = DirectParamFixtureDef(
src/_pytest/unittest.py:106:        self.session._fixturemanager.parsefactories(

            indices=indices,
            _arg2scope=arg2scope,
            _idlist=self._idlist if id is HIDDEN_PARAM else [*self._idlist, id],
            marks=[*self.marks, *normalize_mark_list(marks)],
        )

    def getparam(self, name: str) -> object:
        try:
            return self.params[name]
        except KeyError as e:
            raise ValueError(name) from e

    @property
    def id(self) -> str:
      
…[2845 chars omitted]…
 = []
        for callspec in self._calls or [CallSpec2()]:
            for param_index, (param_id, param_set) in enumerate(
                zip(ids, parametersets, strict=True)
            ):
                newcallspec = callspec.setmulti(
                    argnames=argnames,
.
./.git
./.git/branches
./.git/hooks
./.git/info
./.git/logs
./.git/objects
./.git/refs
./.github
./.github/ISSUE_TEMPLATE

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


def check_ispytest(ispytest: bool) -> None:
    if not ispytest:
        warn(PRIVATE, stacklevel=3)
            yield from mark.args

    def getfixtureclosure(
        self,
        parentnode: nodes.Node,
        initialnames: tuple[str, ...],
        ignore_args: AbstractSet[str],
    ) -> tuple[list[str], dict[str, Sequence[FixtureDef[Any]]]]:
        
…[8628 chars omitted]…
Value,
src/_pytest/python.py:1158:class DirectParamFixtureDef(FixtureDef[FixtureValue]):
src/_pytest/python.py:1397:                fixturedef = DirectParamFixtureDef(
./src/_pytest/fixtures.py:1710:        self._holderobjseen: Final[set[object]] = set()
./src/_pytest/fixtures.py:2073:        if holderobj in self._holderobjseen:
./src/_pytest/fixtures.py:2082:        self._holderobjseen.add(holderobj)

    def _getautousenames(self, node: nodes.Node) -> Iterator[str]:
        """Return the names of autouse fixtures applicable to node."""
        for parentnode in node.listchain():
            basenames = self._node_autousenames.get(parentnode)
            if bas
…[2317 chars omitted]…
       traverse_fixture_closure(
                initialnames,
                getfixturedefs=getfixturedefs,
            ),
            key=sort_by_scope,
            reverse=True,
        )
src/_pytest/fixtures.py:648:            return RequestFixtureDef(self)
src/_pytest/fixtures.py:1963:        fixture_def = FixtureDef(
src/_pytest/python.py:1397:                fixturedef = DirectParamFixtureDef(

        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 tup
…[7851 chars omitted]…
_init__ flushes above-rootdir conftests and collection pops
        under-rootdir ones, remaining entries mean collection was interrupted
        (e.g. UsageError for a bad path). These conftests' fixtures aren't
        needed since their directories' tests weren't collected either.
        """
        self._pending_conftests.clear()

    def _getautousenames(self, node: nodes.Node) -> Iterator[str]:

src/_pytest/python.py:1320:            nodeid=self.definition.nodeid,
src/_pytest/python.py:1346:            a
…[233 chars omitted]…
t(nodeid=item.nodeid, location=item.location)
src/_pytest/runner.py:119:    ihook.pytest_runtest_logfinish(nodeid=item.nodeid, location=item.location)
src/_pytest/terminal.py:596:            fslocation=fslocation, message=message, nodeid=nodeid
src/_pytest/warnings.py:67:                            nodeid=nodeid,
[tool.pytest]
minversion = "2.0"
addopts = [ "-rfEX", "-p", "pytester" ]
python_files = [

    # 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
                    fixture_n
…[1414 chars omitted]…
/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(

1249-            scope=Scope.Function,
1250-            params=None,
1251-            _ispytest=True,
1252-        )
1253-        self.cached_result = (request, [0], None)
1254-
1255-    def addfinalizer(self, finalizer: Callable[[], object]) -> None:
1256-        pass
1257-
1258-
1259-def resolve_fixture_function(
1260-    fixturedef: FixtureDef[FixtureValue], request: FixtureRequest
1261-) -> _FixtureFunc[FixtureValue]:
1262-   
…[8627 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

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

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

    @property
    def has_location(self) -
…[5347 chars omitted]…
e)
            holderobj = cast(object, node_or_obj.obj)  # type: ignore[attr-defined]
            effective_node = node_or_obj
        # Avoid accessing `@property` (and other descriptors) when iterating fixtures.
        if not safe_isclass(holderobj) and not isinstance(holderobj, types.ModuleType):
            holderobj_tp: object = type(holderobj)
        else:
            holderobj_tp = holderobj

    Note: At this time, only explicitly documented fields and methods are
    considered public stable API.
    """

    def __init__(
        self,
        config: Config,
        baseid: str | None | NotSetType = NOTSET,
        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,
   
…[2138 chars omitted]…


    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.

        :param name:
            The fixture's name.
        :param func:
            The fixture's implementation function.
        :param nodeid:
            The visibility of the fixture (deprecated, use node instead).
            The fixture will be available to the node with this nodeid and
            its children in the collection tree. None means global visibility.
        :param node:
            The node where the fix
…[1032 chars omitted]…
===================================
__________________________ [doctest] test_x.test_doc ___________________________
006 >>> getfixture("fix")
Expected:
        'fix'
Got:
    'fix'

/tmp/tmp.WmDO7qdY2c/test_x.py:6: DocTestFailure
=========================== short test summary info ============================
FAILED ../tmp/tmp.WmDO7qdY2c/test_x.py::test_x.test_doc
1 failed, 2 passed in 0.02s
status=1

49:from _pytest.compat import safe_getattr
50:from _pytest.compat import safe_isclass

+++ b/src/_pytest/fixtures.py
@@ -58,6 +58,7 @@ from _pytest.config.argparsing import Parser
 from _pytest.deprecated import check_ispytest
 from _pytest.deprecated import CLASS_FIXTURE_INSTANCE_METHOD
 from _pytest.
…[4785 chars omitted]…
ings.warn(FIXTURE_NODEID_DEPRECATED, stacklevel=2)
         fixture_def = FixtureDef(
             config=self.config,
-            baseid=nodeid if node is None else None,
+            baseid=nodeid if node is None else NOTSET,
             argname=name,
             func=func,
             scope=scope,
@@ -2008,6 +2016,7 @@ class FixtureManager:
     ) -> None:
         raise NotImplementedError()

 3 files changed, 36 insertions(+), 28 deletions(-)

changelog
codecov.yml
doc
extra
pyproject.toml
scripts
src
testing
tox.ini
0f12b2d base
48:from _pytest.compat import NOTSET
700:            param = NOTSET
835:        if param is not NOTSET:
1097:        self.has_location: Final = node is not None or baseid is not None
1675:    During collection fm.parsefactories() is called multiple times to parse
1706:        # suite/plugins defined with this name. Populated by parsefactories().
1781:            self.parsefactories(plugin, None)
1791:                self.parsefactories(holder=plugin, node=collector)
1808:            self.parsefactories(holder=plugin, node=session)
2005:    def parsefactories(
2012:    def parsefactories(
2020:    def parsefactories(
2030:    def parsefactories(
2033: 
…[100 chars omitted]…
obj as holder, node for scope.
2048:        - ``parsefactories(obj, nodeid)``: Uses obj as holder, nodeid string for scope.
2060:            raise TypeError("parsefactories() requires holder or node_or_obj")
2061:        elif nodeid is not NOTSET:
2062:            # Legacy: parsefactories(obj, nodeid) - string-based scoping only
2069:            # Legacy: parsefactories(node) - node has .obj attribute

        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 = None,
    ) -> None:
        check_ispytest(_ispytest)
        # Emit deprecation warning if baseid string is used when node could be provided.
        # baseid=None (global plugins) and baseid="
…[8629 chars omitted]…
"""
        for parentnode in node.listchain():
            basenames = self._node_autousenames.get(parentnode)
            if basenames:
                yield from basenames
            # Legacy fallback: check string-based nodeid autouse names.
            nodeid_basenames = self._nodeid_autousenames.get(parentnode.nodeid)
            if nodeid_basenames:
                yield from nodeid_basenames

                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()


…[3685 chars omitted]…
se=marker.autouse,
                    node=effective_node,
                    nodeid=effective_nodeid,
                )

    def getfixturedefs(
        self, argname: str, node: nodes.Node
    ) -> Sequence[FixtureDef[Any]] | None:
        """Get FixtureDefs for a fixture name which are applicable
        to a given node.

        Returns None if there are no fixtures at all defined with the given

                #
                # TODO: Handle the case where the super-fixture is transitively
                # requested (see #7737 and the xfail'd test
                # test_override_parametrized_fixture_via_transitive_fixture).
                if argname not in fixturedef.argnames:
                    break

                # Try next super fixture, if any.

    def pytest_collection_modifyitems(self, items
…[3439 chars omitted]…
TURE_BASEID_DEPRECATED = PytestRemovedIn10Warning(
121:FIXTURE_NODEID_DEPRECATED = PytestRemovedIn10Warning(
126:PARSEFACTORIES_NODEID_DEPRECATED = PytestRemovedIn10Warning(
src/_pytest/fixtures.py:1710:        self._holderobjseen: Final[set[object]] = set()
src/_pytest/fixtures.py:2073:        if holderobj in self._holderobjseen:
src/_pytest/fixtures.py:2082:        self._holderobjseen.add(holderobj)

    "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_ispytest(ispytest: bool) -> None:
    if not ispytest:
        warn(PRIVATE, stacklevel=3)
src/_pytest/fixtures.py:648:            return RequestFixtureDef(self)
src/_pytest/fixtures.py:1237:class RequestFixtureDef(FixtureDef[
…[456 chars omitted]…
tureDef's such that later at test
src/_pytest/python.py:1363:        # For scopes higher than function, a DirectParamFixtureDef might have
src/_pytest/python.py:1365:        # DirectParamFixtureDef on the node related to the scope.
src/_pytest/python.py:1384:            default: dict[str, DirectParamFixtureDef[object]] = {}
src/_pytest/python.py:1397:                fixturedef = DirectParamFixtureDef(

    def __init__(self, request: FixtureRequest) -> None:
        super().__init__(
            config=request.config,
            baseid=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_funct
…[2810 chars omitted]…
         name2directparamfixturedef[argname] = fixturedef
            self._arg2fixturedefs[argname] = [fixturedef]

        # Create the new calls: if we are parametrize() multiple times (by applying the decorator
        # more than once) then we accumulate those calls generating the cartesian product
        # of all calls.
        newcalls = []
        for callspec in self._calls or [CallSpec2()]:

            if generated_ids is not None:
                ids = generated_ids

        ids = self._resolve_parameter_set_ids(
            argnames, ids, parametersets, nodeid=self.definition.nodeid
        )

        # Store used (possibly generated) ids with parametrize Marks.
        if _param_mark and _param_mark._param_ids_from and generated_ids is None:

…[1871 chars omitted]…
     continue
            if (
                name2directparamfixturedef is not None
                and argname in name2directparamfixturedef
            ):
                fixturedef = name2directparamfixturedef[argname]
            else:
                fixturedef = DirectParamFixtureDef(
                    config=self.config,
                    argname=argname,
                    scope=scope_,

testing/python/metafunc.py
testing/test_conftest.py

                return func

            return decorator
    if fixture_function:
        return fixture_marker(fixture_function)

    return fixture_marker


@deprecated(
    "@pytest.yield_fixture is deprecated. Use @pytest.fixture instead; they are the same.",
    category=None,  # We have our own runtime warning logic
)
def yield_fixture(
    fixture_function=None,
    *args,
    scope="function",
    params=None,
    autouse=False,
    ids=None,
    name=None,
):
    """(Return a) decorator to mark a yield-fixture factory function.

src/_pytest/d
…[652 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(

        Using a fixture to invoke this methods ensures we play nicely and unsurprisingly with
        other fixtures (#517).
        """
        setup_module = _get_first_non_fixture_func(
            self.obj, ("setUpModule", "setup_module")
        )
        teardown_module = _get_first_non_fixture_func(
            self.obj, ("tearDownModu
…[8419 chars omitted]…
      yield
            if teardown is not None:
                teardown(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,

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/test_conftest.py:632:    def test_parsefactories_relative_node_ids(

    - _nodeid_autousenames population and _getautousenames yield
    - _matchfactories string-based fallback (match + non-match branches)
    """

    def test_parsefactories_nodeid_deprecation(self, pytester: Pytester) -> None:
        """parsefactories(obj, "path") warns; parsefactories(obj, None) does not."""
        pytester.
…[1416 chars omitted]…
rsefactories() with no holder and no node_or_obj raises TypeError."""
        pytester.makeconftest(
            """
            import pytest

            def pytest_collection_modifyitems(session, items):
                fm = session._fixturemanager
                with pytest.raises(TypeError, match="requires holder or node_or_obj"):
                    fm.parsefactories()
            """
        )

        # getfixturevalue() is also called by pytest itself during item and fixture
        # setup to evaluate the fixtures that are requested statically
        # (using function parameters, autouse, etc).

        fixturedef = self._get_active_fixturedef(argname)
        assert fixturedef.cached_result is not None, (
            f'The fixture value f
…[703 chars omitted]…
s item,
        # return it.
        fixturedef = self._fixture_defs.get(argname)
        if fixturedef is not None:
            self._check_scope(fixturedef, fixturedef._scope)
            return fixturedef

        # Find the appropriate fixturedef.
        fixturedefs = self._arg2fixturedefs.get(argname, None)
        if fixturedefs is None:
            # We arrive here because of a dynamic call to

from _pytest.compat import signature
from _pytest.config import _PluggyPlugin
from _pytest.config import Config
from _pytest.config import ExitCode
from _pytest.config import hookimpl
from _pytest.config.argparsing import Parser
from _pytest.deprecated import check_ispytest
from _pytest.deprecated import CLASS_FIXTURE_INSTANCE_METHOD
from _pytest.deprecated import FIXTURE_BASEID_DEPRECATED
43:from _pytest.compat import assert_never
44:from _pytest.compat import get_real_func
45:from _pytest.compat import getfuncargnames
46:from _pytest.compat import getimfunc
47:from _pytest.compat import getlocation
48:from _pytest.compat import NOTSET
49:from _pytest.compat import NotSetType
50:from _pytest.compat import safe_getattr
51:from _pytest.compat import safe_isclass
52:from _pytest.compat import signature

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

    @property
    def has_location(self) -> bool:
        """Whether the fixture was found from a node or conftest in the collection tree.

        .. deprecated:: 9.0
           Will be removed in pytest 10.
        """
        warnings.warn(FIXTURE_HAS_LOCATION_DEPRECATED, stacklevel=2)
        return self._has
…[1025 chars omitted]…
ect]]] = []

        # 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)

        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 = None,
    ) -> None:
        check_ispytest(_ispytest)
        # Emit deprecation warning if baseid string is used when node could be provided.
        if baseid is not NOTSET and node is None:
            warnings.warn(FIXTURE_BASEID_DEPRECATED, stacklevel=2)

changelog
codecov.yml
doc
extra
pyproject.toml
scripts
src
testing
tox.ini
pyproject.toml:360:minversion = "2.0"

…[271 chars omitted]…
LED 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
FAILED testing/deprecated_test.py::TestFixtureNodeidDeprecations::test_parsefactories_nodeid_deprecation
14 failed, 313 passed, 1 skipped, 1 xfailed in 18.99s

>           config=node.config,
                   ^^^^^^^^^^^
            baseid=NOTSET,
            argname=argname,
     
…[80 chars omitted]…
ope=scope,
            params=None,
            ids=None,
            _ispytest=True,
        )
E       AttributeError: 'DefinitionMock' object has no attribute 'config'

src/_pytest/python.py:1169: AttributeError
=========================== short test summary info ============================
FAILED testing/python/metafunc.py::TestMetafunc::test_parametrize_single_arg_trailing_comma
1 failed in 0.79s

    def test_no_funcargs(self) -> None:
        def function():
            pass

        metafunc = self.Metafunc(function)

        definition._fixtureinfo = fixtureinfo
        definition.session = SessionMock(FixtureManagerMock({}))
        return python.Metafunc(definition, fixtureinfo, config, _ispytest=True)

            # Only consider the non-kw-only fields in the __init__ call.
            if f.init:
                if not (f.default is MISSING and f.default_factory is MISSING):
                    seen_default = True
                elif seen_default:
>                   raise TypeError(f'non-default argument {f.name!r} '
                                    'follows default argument')
E                   TypeError: non-default argument 'config' follows default argument

/usr/local/lib/python3.12/dataclasses.py:585: TypeError
=========================== short test summary info ============================
FAILED testing/python/metafunc.py::TestMetafunc::test_parametrize_twoargs - T...
1 failed in 0.88s

        .. deprecated:: 9.0
           Will be removed in pytest 10.
        """
        warnings.warn(FIXTURE_HAS_LOCATION_DEPRECATED, stacklevel=2)
        return self._has_location

    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.

    def test_has_location(request):
        fdefs = request._fixturemanager.getfixturedefs("fix", request._pyfuncitem)
        with pytest.warns(pytest.PytestRemovedIn10Warning, match="has_location"):
>         
…[191 chars omitted]…
on, another exception occurred:

request = <FixtureRequest for <Function test_has_location>>

    def test_has_location(request):
        fdefs = request._fixturemanager.getfixturedefs("fix", request._pyfuncitem)
>       with pytest.warns(pytest.PytestRemovedIn10Warning, match="has_location"):
             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
/repo/src/pytest/__init__.py

	modified:   testing/python/metafunc.py

no changes added to commit (use "git add" and/or "git commit -a")
Dropped refs/stash@{0} (4544cbb61e198401f5bc8249f1f39f422c6c8cb2)

…[14 chars omitted]…
config.py::TestParseIni::test_toxini_before_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

     "Pass node instead for fixture scoping."
 )
 
+FIXTURE_HAS_LOCATION_DEPRECATED = PytestRemovedIn10Warning(
+    "The has_location attribute of FixtureDef is deprecated and will be "
+    "removed in pytest 10."
+)
+
 PARSEFACTORIES_NODEID_DEPRECATED = PytestRemovedIn10Warning(
     "Passing nodeid string to parsefactories is
…[8044 chars omitted]…
/_pytest/python.py
index ad5a2c6..87731b8 100644
--- a/src/_pytest/python.py
+++ b/src/_pytest/python.py
@@ -1164,11 +1164,12 @@ 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:

954-        return FixtureLookupErrorRepr(fspath, lineno, tblines, msg, self.argname)
955-
956-
957-class FixtureLookupErrorRepr(TerminalRepr):
958-    def __init__(
959-        self,
960-        filename: str | os.PathLike[str],
961-        firstlineno: int,
962-        tblines: Sequence[str],

…[570 chars omitted]…
    # Collect parent nodes and their IDs for matching
2144-        parent_nodes = set(node.iter_parents())
2145-        parentnodeids = {n.nodeid for n in parent_nodes}
2146-
2147-        for fixturedef in fixturedefs:
2148-            if fixturedef.node is not None:
2149-                # Node-based matching: check if fixture's node is a parent
2150-                if fixturedef.node in parent_nodes:

            elif fixturedef.baseid in parentnodeids:
                # Fallback to string-based matching for legacy/plugins
                yield fixturedef


def show_fixtures_per_test(config: Config) -> int | ExitCode:
    from _pytest.main import wrap_session

    return wrap_session(config, _show_fixtures_per_test)


_PYTEST_DIR = Path(_pytest.__fi
…[394 chars omitted]…
 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.

    Dynamically requested fixtures are excluded because they are not known
    statically.
    """

-            baseid="",
+            config=node.config,
+            baseid=NOTSET,
             argname=argname,
+            node=node,
             func=get_direct_param_fixture_func,
             scope=scope,
             params=None,
@@ -1365,6 +1366,7 @@ class Metafunc:
         # DirectParamFixtureDef on the node related to the scope.
         if scope_ is Scope.Function:
             n
…[2149 chars omitted]…
      names = getfuncargnames(func)
         fixtureinfo: Any = FuncFixtureInfoMock(names)
         definition: Any = DefinitionMock._create(obj=func, _nodeid="mock::nodeid")
+        definition.config = config
         definition._fixtureinfo = fixtureinfo
         definition.session = SessionMock(FixtureManagerMock({}))
         return python.Metafunc(definition, fixtureinfo, config, _ispytest=True)