U 42isg@sddlmZddlZddlmZddlmZddlZddlZddlm Z ddl m Z ddl m Z ddl m Z dd l mZdd l mZdd l mZdd l mZdd l mZddl mZddl mZddlZddlZddlZddlmZddlmZddlmZddlmZddlmZddlm Z ddl!m"Z"ddl!m#Z#ddl$m%Z%ddl&m'Z'ddl(m)Z)ddl(m*Z*ddl(m+Z+ddl,m-Z-ddl.m/Z/ddl.m0Z0dd l1m2Z2dd!l3m4Z4erdd"l5m6Z6dd#l7m8Z8d$Z9e ej:j;Zed-d.d/Z?Gd0d1d1ej@ZAGd2d.d.ejBeAd3ZCd.d4d5d6d7ZDGd8d9d9eCejBZEd:d)d;d<d=d>ZFGd?d@d@eEejBZGGdAdBdBeGejBZHGdCdDdDeGejBZIGdEdFdFeCejBZJdS)G) annotationsN)cached_property) signature)Path)Any)Callable)cast)Iterable)Iterator)MutableMapping)NoReturn)overload) TYPE_CHECKING)TypeVar) getfslineno) ExceptionInfo) TerminalRepr) Traceback)TracebackStyle) LEGACY_PATH)Config)ConftestImportFailure) _check_path)NODE_CTOR_FSPATH_ARG)Mark) MarkDecorator) NodeKeywords)fail) absolutepath) commonpath)Stash) PytestWarning)Self)Session/_Tz type[Node] Path | NoneLEGACY_PATH | Noner) node_typepathfspathreturncCsV|dk r tjtj|jddd|dk r>|dk r:t|||S|dk sJtt|SdS)N)Znode_type_name) stacklevel)warningswarnrformat__name__rAssertionErrorr)r(r)r*r31/tmp/pip-unpacked-wheel-7n2p7kht/_pytest/nodes.py _imply_path<s  r5 _NodeTypeNode)boundcs6eZdZdZddddZdddfd d ZZS) NodeMetaaMetaclass used by :class:`Node` to enforce that direct construction raises :class:`Failed`. This behaviour supports the indirection introduced with :meth:`Node.from_parent`, the named constructor to be used instead of direct construction. The design decision to enforce indirection with :class:`NodeMeta` was made as a temporary aid for refactoring the collection tree, which was diagnosed to have :class:`Node` objects whose creational patterns were overly entangled. Once the refactoring is complete, this metaclass can be removed. See https://github.com/pytest-dev/pytest/projects/3 for an overview of the progress on detangling the :class:`Node` classes. r r+cOs*dj|jd|jd}t|dddS)NzDirect construction of {name} has been deprecated, please use {name}.from_parent. See https://docs.pytest.org/en/stable/deprecations.html#node-construction-changed-to-node-from-parent for more details..nameF)pytrace)r0 __module__r1r)clskkwmsgr3r3r4__call__cs zNodeMeta.__call__ztype[_T]r%r@r+c sztj||WStk rtt|dfdd|D}ddlm}t ||dt |dtj||YSXdS)N__init__cs i|]\}}|jkr||qSr3) parameters).0rAvsigr3r4 qs z$NodeMeta._create..)PytestDeprecationWarningz7 is not using a cooperative constructor and only takes z. See https://docs.pytest.org/en/stable/deprecations.html#constructors-of-custom-pytest-node-subclasses-should-take-kwargs for more details.) superrD TypeErrorrgetattritemsZ warning_typesrNr.r/set)r@rArBZknown_kwrN __class__rJr4_createls  zNodeMeta._create)r1r? __qualname____doc__rDrV __classcell__r3r3rTr4r9Ts r9c @seZdZUdZded<dZd^dddd d d d d dddZedddddZe ddddZ ddddZ dd dddZ e dddd Z d!dd"d#Zd dd$d%Zd dd&d'Zd(dd)d*Zd+dd,d-Zd_d/d0d d1d2d3Zd`d d4d5d6d7Zdad d8d5d9d:Zedd;d5dd>d?d@d=Zdbdd;d;d?dAd=ZdBddCdDZdEddFdGZdHd dIdJdKZdLdMdNdOdPZdQdRdSdTdUZdcdQdVdWdXdYdZZdddQdVd[dXd\d]ZdS)er7zBase class of :class:`Collector` and :class:`Item`, the components of the test collection tree. ``Collector``\'s are the internal nodes of the tree, and ``Item``\'s are the leaf nodes. rr*)r=parentconfigsessionr)_nodeid_store__dict__Nstr Node | None Config | NoneSession | Noner'r& str | NoneNone)r=rZr[r\r*r)nodeidr+cCs||_||_|r||_n|s$td|j|_|r8||_n|sDtd|j|_|dkrh|dkrht|dd}tt|||d|_t ||_ g|_ t |_ |dk rd|kst||_n"|jstd|jjd|j|_t|_|j|_dS)Nz!config or parent must be providedz"session or parent must be providedr)r*z::()z!nodeid or parent must be providedz::)r=rZr[rPr\rQr5typer)rkeywords own_markersrSextra_keyword_matchesr2r]rfr stashr^)selfr=rZr[r\r*r)rfr3r3r4rFs4    z Node.__init__r")rZr+cKs4d|krtdd|kr td|jfd|i|S)a:Public constructor for Nodes. This indirection got introduced in order to enable removing the fragile logic from the node constructors. Subclasses can use ``super().from_parent(...)`` when overriding the construction. :param parent: The parent node of this Node. r[z.config is not a valid argument for from_parentr\z/session is not a valid argument for from_parentrZ)rPrV)r@rZrBr3r3r4 from_parents zNode.from_parentzpluggy.HookRelayr:cCs|j|jS)z6fspath-sensitive hook proxy used to call pytest hooks.)r\Z gethookproxyr)rmr3r3r4ihooksz Node.ihookcCsd|jjt|ddS)Nz<{} {}>r=)r0rUr1rQror3r3r4__repr__sz Node.__repr__Warning)warningr+cCsNt|tstd|t|\}}|dk s0ttj|dt||dddS)awIssue a warning for this Node. Warnings will be displayed after the test session, unless explicitly suppressed. :param Warning warning: The warning instance to issue. :raises ValueError: If ``warning`` instance is not a subclass of Warning. Example usage: .. code-block:: python node.warn(PytestWarning("some message")) node.warn(UserWarning("some message")) .. versionchanged:: 6.2 Any subclass of :class:`Warning` is now accepted, rather than only :class:`PytestWarning ` subclasses. z8warning must be an instance of Warning or subclass, got NrM)categoryfilenamelineno) isinstancerr ValueErrorget_fslocation_from_itemr2r. warn_explicitr`)rmrsr)rvr3r3r4r/s   z Node.warncCs|jS)z;A ::-separated string denoting its collection tree address.)r]ror3r3r4rfsz Node.nodeidintcCs t|jSN)hashr]ror3r3r4__hash__sz Node.__hash__cCsdSr|r3ror3r3r4setup sz Node.setupcCsdSr|r3ror3r3r4teardown#sz Node.teardownzIterator[Node]ccs|}|dk r|V|j}qdS)zIterate over all parent collectors starting from and including self up to the root of the collection tree. .. versionadded:: 8.1 N)rZ)rmrZr3r3r4 iter_parents&szNode.iter_parentsz list[Node]cCs.g}|}|dk r"|||j}q||S)zxReturn a list of all parent collectors starting from the root of the collection tree down to and including self.N)appendrZreverse)rmchainitemr3r3r4 listchain1s zNode.listchainTzstr | MarkDecoratorbool)markerrr+cCsnddlm}t|tr|}nt|tr2t||}ntd||j|j<|rZ|j |j n|j d|j dS)zDynamically add a marker object to the node. :param marker: The marker. :param append: Whether to append the marker, or prepend it. r)MARK_GENz'is not a string or pytest.mark.* MarkerN) Z _pytest.markrrwrr`rQrxrir=rjrmarkinsert)rmrrrZmarker_r3r3r4 add_marker<s     zNode.add_markerzIterator[Mark])r=r+cCsdd|j|dDS)zIterate over all markers of the node. :param name: If given, filter the results by the name attribute. :returns: An iterator of the markers of the node. css|]}|dVqdS)rMNr3rHxr3r3r4 Xsz$Node.iter_markers..r<)iter_markers_with_nodermr=r3r3r4 iter_markersRszNode.iter_markerszIterator[tuple[Node, Mark]]ccs@|D]2}|jD]&}|dks.t|dd|kr||fVqqdS)zIterate over all markers of the node. :param name: If given, filter the results by the name attribute. :returns: An iterator of (node, mark) tuples. Nr=)rrjrQ)rmr=noderr3r3r4rZs  zNode.iter_markers_with_nodez Mark | NonecCsdSr|r3rr3r3r4get_closest_markergszNode.get_closest_markerr)r=defaultr+cCsdSr|r3rmr=rr3r3r4rjscCst|j|d|S)zReturn the first marker matching the name, from closest (for example function) to farther level (for example module level). :param default: Fallback return value if no marker was found. :param name: Name to filter by. r<)nextrrr3r3r4rmszset[str]cCs$t}|D]}||jq|S)z;Return a set of all extra keywords in self and any parents.)rSrupdaterk)rmZextra_keywordsrr3r3r4listextrakeywordsvs zNode.listextrakeywordsz list[str]cCsdd|DS)NcSsg|] }|jqSr3r<rr3r3r4 ~sz"Node.listnames..)rror3r3r4 listnames}szNode.listnameszCallable[[], object])finr+cCs|jj||dS)zRegister a function to be called without arguments when this node is finalized. This method can only be called when this node is active in a setup chain, for example during self.setup(). N)r\Z _setupstate addfinalizer)rmrr3r3r4rszNode.addfinalizerztype[_NodeType]z_NodeType | NonerEcCs$|D]}t||r|SqdS)zGet the closest parent node (including self) which is an instance of the given class. :param cls: The node class to search for. :returns: The node, if found. N)rrw)rmr@rr3r3r4 getparents   zNode.getparentExceptionInfo[BaseException]rexcinfor+cCs|jSr|) traceback)rmrr3r3r4_traceback_filterszNode._traceback_filterzTracebackStyle | Noner)rstyler+c Cs*ddlm}t|jtr&t|jj}t|jtj r@|jj s@d}t|j|rV|j S|j ddrnd}d}n|j}|dkrd}|dkr|j ddd krd }nd}|j d krd}nd }|j d krdnd }ztt|j jjk}Wntk rd }YnX|jd ||j d d||||dS)Nr)FixtureLookupErrorvalue fulltraceFlongautotbstyleshortrMT showlocals)Zfuncargsabspathrrtbfiltertruncate_locals truncate_args)Z_pytest.fixturesrrwrrrfrom_exceptioncauser Exceptionr>Z formatreprr[ getoptionrZ get_verbosityrosgetcwdZinvocation_paramsdirOSErrorZgetrepr)rmrrrrrrrr3r3r4_repr_failure_pysF      zNode._repr_failure_pystr | TerminalReprcCs |||S)zReturn a representation of a collection or test failure. .. seealso:: :ref:`non-python tests` :param excinfo: Exception information for the failure. )r)rmrrr3r3r4 repr_failures zNode.repr_failure)NNNNNN)T)N)N)N)N)N)r1r?rWrX__annotations__ __slots__rF classmethodrnpropertyrprqr/rfr~rrrrrrrr rrrrrrrrr3r3r3r4r7sR  =%       =) metaclassztuple[str | Path, int | None])rr+cCsLt|dd}|dk r |ddSt|dd}|dk r.zF is an Item subclass and should not be a collector, however its bases z are collectors. Please split the Collectors and the Item into separate node types. Pytest Doc example: https://docs.pytest.org/en/latest/example/nonpython.html example pull request on a plugin: https://github.com/asmeurer/pytest-flakes/pull/40/) rhrQsetattrjoin __bases__r.r/r1r!)rmr@ attr_nameproblemsr3r3r4rs   z2Item._check_item_and_collector_diamond_inheritancecCs tddS)zRun the test case for this item. Must be implemented by subclasses. .. seealso:: :ref:`non-python tests` z,runtest must be implemented by Item subclassNrror3r3r4runtestsz Item.runtestr`)whenkeycontentr+cCs|r|j|||fdS)aAdd a new report section, similar to what's done internally to add stdout and stderr captured output:: item.add_report_section("call", "stdout", "report section contents") :param str when: One of the possible capture states, ``"setup"``, ``"call"``, ``"teardown"``. :param str key: Name of the section, can be customized at will. Pytest uses ``"stdout"`` and ``"stderr"`` internally. :param str content: The full contents as a string. N)rr)rmrrrr3r3r4add_report_sectionszItem.add_report_sectionz.tuple[os.PathLike[str] | str, int | None, str]cCs |jddfS)aPGet location information for this item for test reports. Returns a tuple with three elements: - The path of the test (default ``self.path``) - The 0-based line number of the test (default ``None``) - A name of the test to be shown (default ``""``) .. seealso:: :ref:`non-python tests` Nrrror3r3r4 reportinfos zItem.reportinfoztuple[str, int | None, str]cCsF|}t|d}|j|}t|dtks4t||d|dfS)z Returns a tuple of ``(relfspath, lineno, testname)`` for this item where ``relfspath`` is file path relative to ``config.rootpath`` and lineno is a 0-based line number. rrrM)rrr\Z_node_location_to_relpathrhr`r2)rmrr)Z relfspathr3r3r4rs   z Item.location)NNNN)r1r?rWrXnextitemrFrrrrrrrrrYr3r3rTr4rs  r)K __future__rr functoolsrinspectrrpathlibrtypingrrrr r r r r rrr.ZpluggyZ _pytest._codeZ_pytestrZ_pytest._code.coderrrrZ_pytest.compatrZ_pytest.configrrZ_pytest.config.compatrZ_pytest.deprecatedrZ_pytest.mark.structuresrrrZ_pytest.outcomesrZ_pytest.pathlibrrZ _pytest.stashr Z_pytest.warning_typesr!Ztyping_extensionsr"Z _pytest.mainr#r__file__rZrr%r5r6ABCMetar9ABCr7ryrrrrrrr3r3r3r4sp                                    ,b/F