Method collect

src/_pytest/main.py:899–1021

(self)

            return rep, False

    def collect(self) -> Iterator[nodes.Item | nodes.Collector]:
        class="cm"># This is a cache for the root directories of the initial paths.
        class="cm"># We can't use collection_cache for Session because of its special
        class="cm"># role as the bootstrapping collector.
        path_cache: dict[Path, Sequence[nodes.Collector]] = {}

        pm = self.config.pluginmanager

        for collection_argument in self._initial_parts:
            self.trace(class="st">"processing argument", collection_argument)
            self.trace.root.indent += 1

            argpath = collection_argument.path
            names = collection_argument.parts
            parametrization = collection_argument.parametrization
            module_name = collection_argument.module_name

            class="cm"># resolve_collection_argument() ensures this.
            if argpath.is_dir():
                assert not names, fclass="st">"invalid arg {(argpath, names)!r}"

            paths = [argpath]
            class="cm"># Add relevant parents of the path, from the root, e.g.
            class="cm">#   /a/b/c.py -> [/, /a, /a/b, /a/b/c.py]
            if module_name is None:
                class="cm"># Paths outside of the confcutdir should not be considered.
                for path in argpath.parents:
                    if not pm._is_in_confcutdir(path):
                        break
                    paths.insert(0, path)
            else:
                class="cm"># For --pyargs arguments, only consider paths matching the module
                class="cm"># name. Paths beyond the package hierarchy are not included.
                module_name_parts = module_name.split(class="st">".")
                for i, path in enumerate(argpath.parents, 2):
                    if i > len(module_name_parts) or path.stem != module_name_parts[-i]:
                        break
                    paths.insert(0, path)

            class="cm"># Start going over the parts from the root, collecting each level
            class="cm"># and discarding all nodes which donclass="st">'t match the level's part.
            any_matched_in_initial_part = False
            notfound_collectors = []
            work: list[tuple[nodes.Collector | nodes.Item, list[Path | str]]] = [
                (self, [*paths, *names])
            ]
            while work:
                matchnode, matchparts = work.pop()

                class="cm"># Pop'd all of the parts, this is a match.
                if not matchparts:
                    yield matchnode
                    any_matched_in_initial_part = True
                    continue

                class="cm"># Should have been matched by now, discard.
                if not isinstance(matchnode, nodes.Collector):
                    continue