Eiݏ SrSSKJr SSKrSSKrSSKJr SSKJr SSKJr SSK r SSK r SSK J r SSK r SSK r SSKJr SS KJr SS KJr SS KJr SS KJr SS KJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr SSKJr \(aSSKJr SSK J!r! SSK J"r" SSK#J$r$ SSK%J&r& SSK'J(r( SSK'J)r) SSK*J+r+ SSK*J,r, SSK*J-r- SSK.J/r/ \S r0SVS!jr1SWS"jr2SWS#jr3SXS$jr4\""S%S&9SYS'j5r5"S(S)\ Rl5r7"S*S+\ Rl5r8"S,S-\85r9"S.S/\5r:"S0S1\Rv\\5r5r?"S8S9\<\5r@"S:S;\@\A5rB"S<S=\@\>5rC"S>S?\<\5rD"S@SA\D\A5rE"SBSC\D\>5rF\ RSD:d\(a\"SESF\\\55rHO""SGSF\R"SFSHSI/5\\5rH"SJSK\\5rJSZSLjrK"SMSN5rL"SOSP\\5rM\(S[SQj5rN\(S[SRj5rO\(S\SSj5rP\(S[STj5rQ\(S\SUj5rRg)]z+Per-test stdout/stderr capturing mechanism.) annotationsN) Generator)Iterable)IteratorUnsupportedOperation) TemporaryFile) TracebackType)Any)AnyStr)BinaryIO)cast)Final)final)Generic)Literal) NamedTuple)TextIO) TYPE_CHECKING)Self)Config)hookimpl)Parser)check_ispytest)fixture) SubRequest) Collector)File)Item) CollectReportfdsysnotee-sysc xURS5nURSSSS/SQSS9 URS S S S S S9 g)Ngeneralz --capturestorer"methodr!z3Per-test capturing method: one of fd|sys|no|tee-sys)actiondefaultmetavarchoiceshelpz-s store_constr$capturezShortcut for --capture=no)r*constdestr.)getgroup addoption _addoption)parsergroups L/home/mande/repo/quber/.venv/lib/python3.13/site-packages/_pytest/capture.pypytest_addoptionr91sW OOI &E OO. B     ( cx[RRS5(aSSKngg![a gf=f)zEnsure colorama is imported so that it attaches to the correct stdio handles on Windows. colorama uses the terminal on import time. So if something does the first import of colorama while I/O capture is active, colorama will fail in various ways. win32rN)r#platform startswithcolorama ImportError)r?s r8_colorama_workaroundrADs: ||w''  (   s , 99c.SSKng![a gf=f)aEnsure readline is imported early so it attaches to the correct stdio handles. This isn't a problem with the default GNU readline implementation, but in some configurations, Python uses libedit instead (on macOS, and for prebuilt binaries such as used by uv). In theory this is only needed if readline.backend == "libedit", but the workaround consists of importing readline here, so we already worked around the issue by the time we could check if we need to. rN)readliner@rCs r8_readline_workaroundrESs     s  c$^[RRS5(a[[S5(ag[TS5(dg[TRS5(aTRR O TRn[ U[R5(dgU4SjnU"[RS5[l U"[RS5[l U"[RS5[l g) aWorkaround for Windows Unicode console handling. Python 3.6 implemented Unicode console handling for Windows. This works by reading/writing to the raw console handle using ``{Read,Write}ConsoleW``. The problem is that we are going to ``dup2`` over the stdio file descriptors when doing ``FDCapture`` and this will ``CloseHandle`` the handles used by Python to write to the console. Though there is still some weirdness and the console handle seems to only be closed randomly and not on the first call to ``CloseHandle``, or maybe it gets reopened with the same handle value when we suspend capturing. The workaround in this case will reopen stdio with a different fd which also means a different handle by replicating the logic in "Py_lifecycle.c:initstdio/create_stdio". :param stream: In practice ``sys.stdout`` or ``sys.stderr``, but given here as parameter for unittesting purposes. See https://github.com/pytest-dev/py/issues/103. r<pypy_version_infoNbufferrawc2>[TRS5(d USS:XaSnOSn[R"[ [ R "UR55X5URURURUR5$)NrIrw) hasattrrHio TextIOWrapperopenosdupfilenoencodingerrorsnewlinesline_buffering)fmode bufferingstreams r8 _reopen_stdio3_windowsconsoleio_workaround.._reopen_stdiosrv}}e,,aCII  #T 5 JJ HH JJ     r:rbwb) r#r=r>rMrHrI isinstancerN_WindowsConsoleIOstdinstdoutstderr)r[ raw_stdoutr\s` r8_windowsconsoleio_workaroundrfds0 << " "7 + +ws[TU][R"5SSSS9 g)NUTF-8rT)rTnewline write_through)super__init__rNBytesIO)r __class__s r8rCaptureIO.__init__s  SWXr:c[UR[R5(deURR 5R S5$)Nr)r`rHrNrgetvaluedecoders r8rCaptureIO.getvalues;$++rzz2222{{##%,,W55r:rrNoner)rrrrrrr __classcell__rs@r8rrsY66r:rc<^\rSrSrSU4SjjrSU4SjjrSrU=r$) TeeCaptureIOc.>Xl[TU] 5 gr)_otherrr)rotherrs r8rTeeCaptureIO.__init__s  r:cX>[TU]U5 URRU5$r)rrur)rsrs r8ruTeeCaptureIO.writes$  a{{  ##r:)r)rrrr)rrrint)rrrrrrurrrs@r8rrs$$r:rc\rSrSr\SSj5rSSSjjr\rSSjrSSSjjr SSjr SSjr SSjr SS jr SS jrSS jrS S!S jjrSS jrSSjrS"S#SjjrS$SjrS%SjrSSjrS&SjrS'Sjr\S(Sj5rSrg))DontReadFromInputc\[Rce[RR$r)r# __stdin__rTrs r8rTDontReadFromInput.encodings"}}(((}}%%%r:c[S5eNzJpytest: reading from stdin while output is captured! Consider using `-s`.OSErrorrsizes r8readDontReadFromInput.read X  r:c"UR5$rrDrs r8__next__DontReadFromInput.__next__s}}r:c[S5err)rhints r8 readlinesDontReadFromInput.readlinesrr:cU$rrrs r8__iter__DontReadFromInput.__iter__ r:c[S5e)Nz/redirected stdin is pseudofile, has no fileno()rrs r8rSDontReadFromInput.filenos"#TUUr:c[S5e)Nz.redirected stdin is pseudofile, has no flush()rrs r8flushDontReadFromInput.flushs"#STTr:cgNFrrs r8isattyDontReadFromInput.isattyr:cgrrrs r8closeDontReadFromInput.close r:cgrrrs r8readableDontReadFromInput.readablerr:c[S5e)Nz0redirected stdin is pseudofile, has no seek(int)r)roffsetwhences r8seekDontReadFromInput.seeks"#UVVr:cgrrrs r8seekableDontReadFromInput.seekablerr:c[S5e)Nz-redirected stdin is pseudofile, has no tell()rrs r8tellDontReadFromInput.tell s"#RSSr:Nc[S5e)Nzcannot truncate stdinrrs r8truncateDontReadFromInput.truncate"#:;;r:c[S5e)Nzcannot write to stdinrrdatas r8ruDontReadFromInput.writerr:c[S5e)NzCannot write to stdinr)rliness r8 writelinesDontReadFromInput.writelinesrr:cgrrrs r8writableDontReadFromInput.writablerr:cU$rrrs r8 __enter__DontReadFromInput.__enter__rr:cgrr)rtypevalue tracebacks r8__exit__DontReadFromInput.__exit__s r:cU$rrrs r8rHDontReadFromInput.buffer%s  r:rr)rL)rrrr)r int | Nonerz list[str])rz Iterator[str])rrrrbool)r)rrrrrrr)rrrr)rrrr)rz Iterable[str]rr)rr)rztype[BaseException] | NonerzBaseException | NonerzTracebackType | Nonerr)rr )rrrrrrTrrCrrrrSrrrrrrrrrurrrrrHrrr:r8rrs && H VU WT<<< ( $ (    r:rc8\rSrSr%S\S'\R S Sj5r\R SSj5r\R SSj5r \R SSj5r \R SSj5r \R SS j5r \R SS j5r S rg ) CaptureBasei.r EMPTY_BUFFERc[5erNotImplementedErrorrr"s r8rCaptureBase.__init__1 !##r:c[5err rs r8startCaptureBase.start5rr:c[5err rs r8doneCaptureBase.done9rr:c[5err rs r8suspendCaptureBase.suspend=rr:c[5err rs r8resumeCaptureBase.resumeArr:c[5err rs r8writeorgCaptureBase.writeorgErr:c[5err rs r8snapCaptureBase.snapIrr:rNr"rrrr)rr rr)rr )rrrr__annotations__abcabstractmethodrrrrrrr!rrr:r8r r .s$$ $$ $$ $$ $$ $$ $$r:r rbrcrd)rc^\rSrSrSrS SjrS SjrS SjrS SjrS Sjr SSjr SS jr S r g ) NoCaptureiQrcgrrrs r8rNoCapture.__init__Trr:cgrrrs r8rNoCapture.startWrr:cgrrrs r8rNoCapture.doneZrr:cgrrrs r8rNoCapture.suspend]rr:cgrrrs r8rNoCapture.resume`rr:cgNrrrs r8r!NoCapture.snapcsr:cgrrrs r8rNoCapture.writeorgfrr:rNr#rrrrrr) rrrrr rrrrrr!rrrr:r8r*r*Qs*L      r:r*c\rSrSrSSS.SSjjjrSSjrSSjrSSjrSS jrSS jr SS jr SS jr S r g)SysCaptureBaseijNFteec[Un[[U5UlX@lUc7US:Xa [ 5nO&U(d [ 5O[UR5nX lSUl g)Nrb initialized) patchsysdictgetattrr#_oldrrrrtmpfile_state)rr"rDr>rs r8rSysCaptureBase.__init__ksUB#C.  ?w+--0)+l4996M # r:cSRUUR[US5=(a [UR5=(d SUR UR 5$Nz(<{} {} _old={} _state={!r} tmpfile={!r}>rCz)formatrrMrrCrErD)r class_names r8rSysCaptureBase.reprysI9@@  II T6 " 6tDII D9 KK LL   r:cSRURRUR[ US5=(a [ UR 5=(d SURUR5$rH) rIrrrrMrrCrErDrs r8__repr__SysCaptureBase.__repr__sS9@@ NN # # II T6 " 6tDII D9 KK LL   r:cURU;d0SRXRSRU555egNz+cannot {} in state {!r}: expected one of {}z, rErIjoinropstatess r8 _assert_stateSysCaptureBase._assert_state;{{f$ 9 @ @KK6!2  $r:cURSS5 [[URUR5 SUlg)Nrr@started)rVsetattrr#rrDrErs r8rSysCaptureBase.starts. 7$45TYY - r:cURSS5 URS:Xag[[URUR 5 U?UR R5 SUlg)Nrr@r[ suspendedr)rVrEr\r#rrCrDrrs r8rSysCaptureBase.donesR 6#RS ;;& TYY * I  r:cURSS5 [[URUR5 SUlgNrr[r`r`)rVr\r#rrCrErs r8rSysCaptureBase.suspends. 9&>?TYY *! r:cURSS5 URS:Xag[[URUR 5 SUlgNrrdr[)rVrEr\r#rrDrs r8rSysCaptureBase.resumes= 8%=> ;;) # TYY - r:)rCrErrDr)r"rrDz TextIO | Noner>rrr)rJrrrrrTrrUztuple[str, ...]rrr) rrrrrrrMrVrrrrrrr:r8r<r<jsU04 $EJ $ $ - $>B $  $    "  r:r<c,\rSrSrSrSSjrSSjrSrg) SysCaptureBinaryir:cURSS5 URRS5 URRR 5nURRS5 URR 5 U$Nr!rdrrVrDrrHrrrress r8r!SysCaptureBinary.snapd 6#;< !ll!!&&( !  r:cURSS5 URR5 URRR U5 URRR5 gNrrd)rVrCrrHrurs r8rSysCaptureBinary.writeorgsO :'?@  t$  r:rNrbytesrrwrrrrrrr r!rrrr:r8rkrksL!r:rkc,\rSrSrSrSSjrSSjrSrg) SysCaptureirc URSS5 [UR[5(deURR 5nURR S5 URR 5 U$rm)rVr`rDrrrrros r8r!SysCapture.snapsc 6#;<$,, 2222ll##% !  r:cURSS5 URRU5 URR5 grt)rVrCrurrs r8rSysCapture.writeorgs1 :'?@  r:rNrr:ryrr:r8r{r{sLr:r{cZ\rSrSrS SjrS SjrS SjrSSjrSSjrSSjr SSjr S r g ) FDCaptureBaseichXl[R"U5 SUl[R"U5Ul US:Xa.[ [R SS9Ul [U5Ul ON[[SS9SSSSS9Ul U[ ;a[XR5Ul O[#U5Ul S Ulg![a] [R "[R [R5Ul[R"URU5 GN f=f) Nrutf-8)rT)rZrrT)rTrUrrr@)targetfdrQfstattargetfd_invalidrrPdevnullO_RDWRdup2rR targetfd_saverDr{ syscapturer}r rAr*rE)rrs r8rFDCaptureBase.__init__s  ) HHX  %)D !VVH- q= W=DL0:80DDO&*  " DL<'",X||"D"+H"5# E 513 BII0ND ! GGD))8 4 5sC A#D10D1c SURRSURSURSUR<SUR <S3 $)N< z oldfd= _state=z tmpfile=>)rrrrrErDrs r8rMFDCaptureBase.__repr__sR''($--@R@R?STkk_Idll-=Q @ r:cURU;d0SRXRSRU555egrPrQrSs r8rVFDCaptureBase._assert_staterXr:cURSS5 [R"URR 5UR 5 UR R5 SUlg)z4Start capturing on targetfd using memorized tmpfile.rrZr[N) rVrQrrDrSrrrrErs r8rFDCaptureBase.startsI 7$45  ##%t}}5  r:c$URSS5 URS:Xag[R"URUR 5 [R "UR5 URbZURUR :wa [R "UR 5 [R "UR5 URR5 URR 5 SUlg)zWStop capturing, restore streams, return original capture file, seeked to position zero.rr_N) rVrErQrrrrrrrrDrs r8rFDCaptureBase.dones 6#RS ;;&  ""DMM2 ##$  ,$$ 5' HHT** +   r:cURSS5 URS:XagURR5 [R "UR UR5 SUlgrc)rVrErrrQrrrrs r8rFDCaptureBase.suspendsQ 9&>? ;;+ %  ! ""DMM2! r:cURSS5 URS:XagURR5 [R "UR R5UR5 SUlgrg) rVrErrrQrrDrSrrs r8rFDCaptureBase.resume&sX 8%=> ;;) #     ##%t}}5 r:)rErrrrrDN)rrrrrrir) rrrrrrMrVrrrrrrr:r8rrs&'$R    " r:rc0\rSrSrSrSrSSjrS SjrSrg) FDCaptureBinaryi/zOCapture IO to/from a given OS-level file descriptor. snap() produces `bytes`. r:cURSS5 URRS5 URRR 5nURRS5 URR 5 U$rmrnros r8r!FDCaptureBinary.snap7rrr:cjURSS5 [R"URU5 g)"Write to original file descriptor.rrdN)rVrQrurrs r8rFDCaptureBinary.writeorg?s' :'?@ ##T*r:rNrvrx rrrr__doc__r r!rrrr:r8rr/s L+r:rc0\rSrSrSrSrSSjrS SjrSrg) FDCaptureiEzLCapture IO to/from a given OS-level file descriptor. snap() produces text. rcURSS5 URRS5 URR5nURRS5 URR 5 U$rm)rVrDrrrros r8r!FDCapture.snapMs^ 6#;< !ll! !  r:cURSS5 [R"URUR S55 g)rrrdrN)rVrQrurencoders r8rFDCapture.writeorgUs0 :'?@ ##T[[%9:r:rNrr:rrr:r8rrEs L;r:r) c.\rSrSr%SrS\S'S\S'Srg) CaptureResultibOThe result of :method:`caplog.readouterr() `.r ryrzrN)rrrrrr$rrr:r8rrbs]   r:rc\rSrSrSrSrSrg)rikrrN)rrrrrrrrr:r8rrks  ^ r:ryrzc\rSrSrSrSrSSjrSSjrSSjrSSjr SSSjjr SS jr SS jr SS jr SS jrS rg) MultiCaptureitNFc(XlX lX0lgrin_ryrz)rrryrzs r8rMultiCapture.__init__xs 03/2/2r:c SUR<SUR<SUR<SUR<SUR<S3 $)Nzs"   ! ! * * , !r:c\UR(aURR5 ggr)r_resumers r8rCaptureManager.resume_fixtureBs"   ! ! ) ) + !r:c## UR=(a URR5nU(aUR5 UR=(a URR 5nU(aUR 5 Sv U(aUR 5 U(aUR5 gg!U(aUR 5 U(aUR5 ff=f7f)zLContext manager to temporarily disable global and current fixture capturing.N)r _is_startedrrrrrrr)r do_fixture do_globals r8global_and_fixture_disabled*CaptureManager.global_and_fixture_disabledHs**Rt/D/D/P/P/R   "**Rt/E/E/P/P/R   ' ' ) & **,##%**,##%sB C4 C0C41C11C4c## UR5 UR5 Sv UR5 URSS9 UR 5up4UR USU5 UR USU5 g!UR5 URSS9 UR 5up4UR USU5 UR USU5 f=f7f)NFrrcrd)rr rrrrtadd_report_section)rwhenitemryrzs r8 item_captureCaptureManager.item_captureYs ""$  9   # # %  ' 'E ' 2//1HC  # #D(C 8  # #D(C 8  # # %  ' 'E ' 2//1HC  # #D(C 8  # #D(C 8s!CBACACCTrgc#l# [U[5(aUR5 SvnUR5 UR 5up4U(aUR R SU45 U(aUR R SU45 U$SvnU$!UR5 f=f7f)NzCaptured stdoutzCaptured stderr)r`rrrrrtsectionsappend)r collectorrepryrzs r8pytest_make_collect_report)CaptureManager.pytest_make_collect_reportis i & &  & & ( .++-//1HC ##%6$<= ##%6$<= C ++-s&B4BA2B4B11B4c#l# URSU5 SvsSSS5 $!,(df  g=f7f)Nsetupr rrs r8pytest_runtest_setup#CaptureManager.pytest_runtest_setup|s#   w -. - -4# 4 14c#l# URSU5 SvsSSS5 $!,(df  g=f7f)Ncallr+r,s r8pytest_runtest_call"CaptureManager.pytest_runtest_calls#   vt ,- , ,r/c#l# URSU5 SvsSSS5 $!,(df  g=f7f)Nteardownr+r,s r8pytest_runtest_teardown&CaptureManager.pytest_runtest_teardowns#   z4 01 0 0r/)tryfirstc$UR5 grrprs r8pytest_keyboard_interrupt(CaptureManager.pytest_keyboard_interrupt ""$r:c$UR5 grr:rs r8pytest_internalerror#CaptureManager.pytest_internalerrorr=r:)rrrN)r)_CaptureMethodrrr)rz str | boolrrrr)rzCaptureResult[str])rzCaptureFixture[Any]rrrGenerator[None])rrrrrrC)r%rrz-Generator[None, CollectReport, CollectReport])rrrrC)"rrrrrrrMrrrqrprrrrrrtrrr rrr contextlibcontextmanagerrr rr'r-r2r6r;r?rrr:r8rmrms7$A  $1 * 6 >) 3 0%+ * -, &&  9 9d" 6$dddt%%t%%r:rmc\rSrSrSrSSS.SSjjrSSjrSSjrSS jrSS jr SS jr SS jr \ RSS j5rSrg)CaptureFixtureizxObject returned by the :fixture:`capsys`, :fixture:`capsysbinary`, :fixture:`capfd` and :fixture:`capfdbinary` fixtures.NFconfig _ispytestc[U5 XlX lU(aUO0UlSUlURR UlURR Ulgr)r captureclassr_config_capturer  _captured_out _captured_err)rrLrrIrJs r8rCaptureFixture.__init__sQ y!7C !'vR 59 %)%6%6%C%C%)%6%6%C%Cr:c URc_[SUR"S0URD6UR"S0URD6S9UlURR 5 gg)Nr)r')r()rNrrLrMrrs r8r CaptureFixture._starts\ == (%%84<<8%%84<<8DM MM ) ) + !r:cURbhURR5upU=RU- slU=RU- slURR 5 SUlggr)rNrrOrPrrs r8rCaptureFixture.closes^ == $}}779HC   # %    # %  MM ( ( * DM %r:cURURp!URb$URR5up4X- nX$- nURR UlURR Ul[ X5$)zRead and return the captured output so far, resetting the internal buffer. :returns: The captured content as a namedtuple with ``out`` and ``err`` string attributes. )rOrPrNrrLr r)r captured_out captured_errryrzs r8rCaptureFixture.readouterrsx&*%7%79K9Kl == $}}//1HC  L  L!..;;!..;;\88r:cTURbURR5 gg)z1Suspend this fixture's own capturing temporarily.N)rNrrs r8rCaptureFixture._suspends! == $ MM + + - %r:cTURbURR5 gg)z0Resume this fixture's own capturing temporarily.N)rNrrs r8rCaptureFixture._resumes! == $ MM * * , %r:cRURbURR5$g)z5Whether actively capturing -- not disabled or closed.F)rNrrs r8rCaptureFixture._is_starteds" == $==++- -r:c## URRRRS5nUR 5 Sv SSS5 g!,(df  g=f7f)z>Temporarily disable capturing while inside the ``with`` block.rjN)rrIrl getpluginr)r capmanagers r8disabledCaptureFixture.disabledsF&*\\%8%8%F%F%P%P &  3 3 5 6 5 5sAA!A A! AA!)rNrPrOrMrLr) rLztype[CaptureBase[AnyStr]]rrrIzdict[str, Any] | NonerJrrrrrrrB)rrrrrrr rrrrrrDrErcrrr:r8rGrGs=)- D/DD & D  D D ,!9". -  r:rGc## URRRS5n[[USS9nUR U5 UR 5 Uv UR5 UR5 g7f)aEnable text capturing of writes to ``sys.stdout`` and ``sys.stderr``. The captured output is made available via ``capsys.readouterr()`` method calls, which return a ``(out, err)`` namedtuple. ``out`` and ``err`` will be ``text`` objects. Returns an instance of :class:`CaptureFixture[str] `. Example: .. code-block:: python def test_output(capsys): print("hello") captured = capsys.readouterr() assert captured.out == "hello\n" rjTrJN) rIrlrarGr{rr rrrrxrs r8capsysrhsh&%^^99CCDTUF$ZDIO '  A;A=c## URRRS5n[[U[ SS9SS9nUR U5 UR5 Uv UR5 UR5 g7f)aEnable simultaneous text capturing and pass-through of writes to ``sys.stdout`` and ``sys.stderr`` as defined by ``--capture=``. The captured output is made available via ``capteesys.readouterr()`` method calls, which return a ``(out, err)`` namedtuple. ``out`` and ``err`` will be ``text`` objects. The output is also passed-through, allowing it to be "live-printed", reported, or both as defined by ``--capture=``. Returns an instance of :class:`CaptureFixture[str] `. Example: .. code-block:: python def test_output(capteesys): print("hello") captured = capteesys.readouterr() assert captured.out == "hello\n" rjTr=rHN) rIrlrarGr{dictrr rrrgs r8 capteesysrlss0%^^99CCDTUF$GDTNdO '  sBBc## URRRS5n[[USS9nUR U5 UR 5 Uv UR5 UR5 g7f)aEnable bytes capturing of writes to ``sys.stdout`` and ``sys.stderr``. The captured output is made available via ``capsysbinary.readouterr()`` method calls, which return a ``(out, err)`` namedtuple. ``out`` and ``err`` will be ``bytes`` objects. Returns an instance of :class:`CaptureFixture[bytes] `. Example: .. code-block:: python def test_output(capsysbinary): print("hello") captured = capsysbinary.readouterr() assert captured.out == b"hello\n" rjTrfN) rIrlrarGrkrr rrrgs r8 capsysbinaryrn&si&%^^99CCDTUF$%5w$OO '  ric## URRRS5n[[USS9nUR U5 UR 5 Uv UR5 UR5 g7f)aEnable text capturing of writes to file descriptors ``1`` and ``2``. The captured output is made available via ``capfd.readouterr()`` method calls, which return a ``(out, err)`` namedtuple. ``out`` and ``err`` will be ``text`` objects. Returns an instance of :class:`CaptureFixture[str] `. Example: .. code-block:: python def test_system_echo(capfd): os.system('echo "hello"') captured = capfd.readouterr() assert captured.out == "hello\n" rjTrfN) rIrlrarGrrr rrrgs r8capfdrpBsh&%^^99CCDTUF$Y4HO '  ric## URRRS5n[[USS9nUR U5 UR 5 Uv UR5 UR5 g7f)aEnable bytes capturing of writes to file descriptors ``1`` and ``2``. The captured output is made available via ``capfd.readouterr()`` method calls, which return a ``(out, err)`` namedtuple. ``out`` and ``err`` will be ``byte`` objects. Returns an instance of :class:`CaptureFixture[bytes] `. Example: .. code-block:: python def test_system_echo(capfdbinary): os.system('echo "hello"') captured = capfdbinary.readouterr() assert captured.out == b"hello\n" rjTrfN) rIrlrarGrrr rrrgs r8 capfdbinaryrr^sh(%^^99CCDTUF$_gNO '  ri)r6rrrr)r[rrr)rvrrrC)r)rArzMultiCapture[str])rrrzGenerator[CaptureFixture[str]])rrrz Generator[CaptureFixture[bytes]])Sr __future__rr% collectionscollections.abcrrrrDrNrrQr#tempfiler typesr typingr r r rrrrrrrrtyping_extensionsr_pytest.configrr_pytest.config.argparsingr_pytest.deprecatedr_pytest.fixturesrr _pytest.nodesrrr_pytest.reportsr rAr9rArErfr{rOr}rrrABCr rArr*r<rwrkr{rrr version_infor namedtuplerrrmrGrhrlrnrprrrr:r8rs1" %$$ # " &!#,-$'#)56&  "41n $<<"""<"6  6$9$JJ`$#''76?$@xH5  C  2@ [(@ F!~e,!$$"\ K'\ ~+mE*+,; c";6w-  GFO ?Q'76?Q'h >"x%x%vMWV_Mf  6  D  6  6  r: