+SrSSKJr SSKrSSKrSSKrSSKrSSKrSSKrSSK r SSK r SSK r SSK r SSK Jr SSKJrJr SSKJr SSKJr SS KJrJr SS KJr SS KJr SS KJr SS KJ r SSK!J"r"J#r# SSK$J%r% SSK$J&r& SSK'J(r( SSK)J*r* SSK+J,r, SSK-J.r. SSK/J0r0J1r1 SSK2J3r3 SSK4J5r5 SSKJ6r6 Sr7"SS\85r9"SS\5r:"SS\85r;"S S!\85r<"S"S#\5r=g)$z2 The main `CommandLineInterface` class and logic. )unicode_literalsN)Popen) Application AbortAction)Buffer) BufferMapping) CompleteEventget_common_complete_suffix) SEARCH_BUFFER) EventLoop)EventLoopCallbacks) Condition) StdinInputInput)InputProcessor)KeyPress)Registry)ViState)Keys)Output)Renderer print_tokens) SearchState)Event) AcceptAction)rCommandLineInterfacecH\rSrSrSrS1Sjr\S5r\S5r\S5r S2Sjr S3S jr \S 5r \S 5r S rS rSr\S5r\S5rS2Sjr\S5r\S5rSr\rSrSrSrS4SjrS5Sjr\R<"\R@"S55 S7Sjr#Sr$Sr%\$r&\%r'Sr(S r)S2S!jr*S2S"jr+S#r,S8S$jr-S4S%jr.\S&5r/\S'5r0\S(5r1S)r2\S*5r3S+r4S,r5S2S-jr6S9S.jr7S/r8S0r9g!\!a S6Sjr"Ntf=f):r/a Wrapper around all the other classes, tying everything together. Typical usage:: application = Application(...) cli = CommandLineInterface(application, eventloop) result = cli.run() print(result) :param application: :class:`~prompt_toolkit.application.Application` instance. :param eventloop: The :class:`~prompt_toolkit.eventloop.base.EventLoop` to be used when `run` is called. The easiest way to create an eventloop is by calling :meth:`~prompt_toolkit.shortcuts.create_eventloop`. :param input: :class:`~prompt_toolkit.input.Input` instance. :param output: :class:`~prompt_toolkit.output.Output` instance. (Probably Vt100_Output or Win32Output.) Nc[U[5(de[U[5(dS5eUb[U[5(deUb[U[5(deSSKJn XlX lSUl U=(d U"5Ul U=(d [[R5Ul[UR[ 5(deURUlUR"UlSUl['5Ul[+URR,URUR.UR0S9UlSUlSUlSUl[;UR<[>R@"U55Ul!0Ul"SUl#URRI5HupgURKXg5 M [MXRN5Ul'[MXRP5Ul([MXRR5Ul)[MXRT5Ul*[MXRV5Ul+[MXRX5Ul,[MXRZ5Ul-[MXR\5Ul.UR_5 U=RPURRP- sl(URPRa5 g)Nz!Passing an eventloop is required.r) create_outputF)use_alternate_screen mouse_supportr)1 isinstancerr rr shortcutsr! application eventloop _is_runningoutputrsysstdininputbuffersr editing_mode quoted_insertrvi_staterstyler"r#rendererrender_countermax_render_postpone_time _invalidatedrkey_bindings_registryweakrefrefinput_processor_async_completers_sub_cliitems add_bufferron_buffer_changed on_initializeon_input_timeout on_invalidate on_renderon_reseton_starton_stopresetfire)selfr&r'r,r)r!namebs +lib/third_party/prompt_toolkit/interface.py__init__CommandLineInterface.__init__Csd+{3333)Y//T1TT/~FF!;!;;;} 5% 8 888,&" /  3j3 +--}===="** (44#  !    " " KK!,!A!A%33 5  )*%" .k.O.OQXQ\Q\]aQbc!# ||))+GD OOD $,"'t-J-J!K"4)B)BC %d,H,H I"4)B)BCt%:%:;d$8$89 d$8$89 T#6#67   d..<<< !c.URR$N)r&layoutrHs rKrQCommandLineInterface.layouts&&&rNc.URR$rP)r& clipboardrRs rKrUCommandLineInterface.clipboards)))rNc.URR$rP)r&pre_run_callablesrRs rKrX&CommandLineInterface.pre_run_callabless111rNcx^^^^[T[5(deTTRU'U(aTRRU5 TR T5mTR T5mTTR U'UUU4SjnT=RU"5- slU4SjnT=RU- slg)z Insert a new buffer. c>UUU4SjnU$)z Wrapper around the asynchronous completer and auto suggestion, that ensures that it's only called while typing if the `complete_while_typing` filter is enabled. c>TR(aTR5(aT"5 TR(aT"5 ggrP) completercomplete_while_typing auto_suggest)_auto_suggest_functionbuffercompleter_functions rKon_text_insertYCommandLineInterface.add_buffer..create_on_insert_handler..on_text_inserts6##(D(D(F(F&(&&)+'rN)rdrarbrcs rKcreate_on_insert_handlerACommandLineInterface.add_buffer..create_on_insert_handlers  ," !rNc:>TRR5 g)z When the text in a buffer changes. (A paste event is also a change, but not an insert. So we don't want to do autocompletions in this case, but we want to propagate the on_buffer_changed event.) N)r>rG)r`rHs rKbuffer_changed7CommandLineInterface.add_buffer..buffer_changeds  " " ' ' )rNN) r$rr-focus_create_auto_suggest_function_create_async_completerr:rdon_text_changed)rHrIrbrlrgrjrarcs` ` @@rKr=CommandLineInterface.add_buffers&&))))# T  LL  t $!% B B6 J!99&A'9t$ "" !9!;; * .0rNc U=(d URnURRU5nU(aU"UUU[SS9S9 gg)zz Start asynchronous autocompletion of this buffer. (This will do nothing if a previous completion was still in progress.) T)completion_requested) select_first select_lastinsert_common_partcomplete_eventN)current_buffer_namer:getr )rH buffer_namersrtrurvr]s rKstart_completion%CommandLineInterface.start_completionsK"=T%=%= **..{;  <"-);%2%M O rNc8URRU5$)z9 The name of the current :class:`.Buffer`. (Or `None`.) )r- current_namerRs rKrw(CommandLineInterface.current_buffer_names ||((..rNc8URRU5$)z The currently focussed :class:`~.Buffer`. (This returns a dummy :class:`.Buffer` when none of the actual buffers has the focus. In this case, it's really not practical to check for `None` values or catch exceptions every time.) )r-currentrRs rKcurrent_buffer#CommandLineInterface.current_buffers||##D))rNc:URRX5 g)z: Focus the buffer with the given name on the focus stack. N)r-rlrHrys rKrlCommandLineInterface.focuss 4-rNc:URRX5 g)z Push to the focus stack. N)r- push_focusrs rKrCommandLineInterface.push_focuss 2rNc:URRU5 g)z Pop from the focus stack. N)r- pop_focusrRs rKrCommandLineInterface.pop_focuss t$rNcURR5nUb![U[R5(deU$)zy Return the current title to be displayed in the terminal. When this in `None`, the terminal title remains the original. )r& get_titler$six text_type)rHresults rKterminal_title#CommandLineInterface.terminal_titles: !!++-~FCMM!B!BBB rNc(UR[:H$)z True when we are searching. )rwr rRs rK is_searching!CommandLineInterface.is_searching s ''=88rNcj^STlSTlSTlTRR 5 TR R 5 TR R 5 TRR 5 [[U4Sj5S9Tl TRR5 g)a? Reset everything, for reading the next input. :param reset_current_buffer: XXX: not used anymore. The reason for having this option in the past was when this CommandLineInterface is run multiple times, that we could reset the buffer content from the previous run. This is now handled in the AcceptAction. FNc>TR$rP)is_ignoring_caserRsrK,CommandLineInterface.reset..,s dF[F[rN) ignore_case) _exit_flag _abort_flag _return_valuer2rFr9rQr0rr search_staterCrG)rHreset_current_buffers` rKrFCommandLineInterface.resets  !  ""$  (I>[4\] rNc8URRU5$)z True when we are in paste mode. )r& paste_moderRs rK in_paste_mode"CommandLineInterface.in_paste_mode1s**400rNc8URRU5$)z&True when we currently ignore casing. )r&rrRs rKr%CommandLineInterface.is_ignoring_case6s++D11rNc2^TR(agSTlTRR5 TRbVU4SjnTR(a#[ R "5TR-nOSnTRR XS9 gg)zG Thread safe way of sending a repaint trigger to the input event loop. NTc4>STlTR5 gNF)r5_redrawrRsrKredraw/CommandLineInterface.invalidate..redrawKs$)! rN_max_postpone_until)r5rArGr'r4timecall_from_executor)rHrrs` rK invalidateCommandLineInterface.invalidate;s     $D  ! >> % ,,&*iikD4Q4Q&Q#&*# NN - - . A &rNcUR(alURc^U=RS- slURR XR UR S9 URR5 ggg)z Render the command line again. (Not thread safe!) (From other threads, or if unsure, use :meth:`.CommandLineInterface.invalidate`.) Nr)is_done) r(r;r3r2renderrQrrBrGrRs rKrCommandLineInterface._redraw^s`    5   1 $  MM {{DLL I NN   ! !6 rNcURRSSS9 URR5 UR5 g)z When the window size changes, we erase the current output and request again the cursor position. When the CPR answer arrives, the output is drawn again. F)leave_alternate_screen erase_titleN)r2erase request_absolute_cursor_positionrrRs rK _on_resizeCommandLineInterface._on_resizeks4 5eL 668 rNcURR5H)upXR;dMX RUlM+ grP)_next_buffer_indexesr<r- working_index)rHbuffindexs rK_load_next_buffer_indexes.CommandLineInterface._load_next_buffer_indexesws644::>@ ""4::t/N/N/PQ '<<"&  MM   ! LL   $D   ""+'&<<"&  MM   ! LL   $D s&AE3AE E EEA%GaQ def run_async(self, reset_current_buffer=True, pre_run=None): """ Same as `run`, but this returns a coroutine. This is only available on Python >3.3, with asyncio. """ # Inline import, because it slows down startup when asyncio is not # needed. import asyncio @asyncio.coroutine def run(): assert pre_run is None or callable(pre_run) try: self._is_running = True self.on_start.fire() self.reset() # Call pre_run. self._pre_run(pre_run) with self.input.raw_mode(): self.renderer.request_absolute_cursor_position() self._redraw() yield from self.eventloop.run_as_coroutine( self.input, self.create_eventloop_callbacks()) return self.return_value() finally: if not self.is_done: self._exit_flag = True self._redraw() self.renderer.reset() self.on_stop.fire() self._is_running = False return run() c[e)zd Same as `run`, but this returns a coroutine. This is only available on Python >3.3, with asyncio. )NotImplementedErrorrs rK run_asyncCommandLineInterface.run_asyncs & %rNc^^^^^^[T[5(deTb[T5(deTRb [ S5eT(dTR R 5 UUUUUU4Sjn[T[TU5TRTRS9mSTl TR5 TTlg)ax Run a sub :class:`~prompt_toolkit.application.Application`. This will suspend the main application and display the sub application until that one returns a value. The value is returned by calling `done_callback` with the result. The sub application will share the same I/O of the main application. That means, it uses the same input and output channels and it shares the same event loop. .. note:: Technically, it gets another Eventloop instance, but that is only a proxy to our main event loop. The reason is that calling 'stop' --which returns the result of an application when it's done-- is handled differently. Nz(Another sub application started already.cx>TR5 T(dTR(aTRR5 TRR 5 STlSTlT(d*TRR5 TR5 T(aT"TR55 ggr) rerase_when_doner2rrFr(r;rr)_from_application_generatorr& done_callbackrrHsub_clisrKdone6CommandLineInterface.run_sub_application..done s OO +"="=  &&(    " " $"'G  DM/ >>@ g2245rN)r&r'r,r)T) r$rrr; RuntimeErrorr2rr_SubApplicationEventLoopr,r)r(r)rHr&rrrrrs````` @rKrun_sub_application(CommandLineInterface.run_sub_applications&+{3333$(?(??? == $IJ J+ MM   ! 6 6,'#.tT:**;;   # rNcURRnSUlUR5 U[R :XaSnUR U5 gU[R:XaEUR5 URR5 URR5 gU[R:XaURS5 gg)z, Set exit. When Control-D has been pressed. Tc[5erP)EOFErrorrfrNrK eof_error,CommandLineInterface.exit..eof_error2s j rNN)r&on_exitrrrRAISE_EXCEPTION_set_return_callableRETRYrFr2rr RETURN_NONEset_return_value)rHrrs rKexitCommandLineInterface.exit)s""**  k11 1 !  % %i 0  )) ) JJL MM : : <    % % '  // /  ! !$ '0rNcURRnSUlUR5 U[R :XaSnUR U5 gU[R:XaEUR5 URR5 URR5 gU[R:XaURS5 gg)z- Set abort. When Control-C has been pressed. Tc[5erP)KeyboardInterruptrfrNrKkeyboard_interrupt6CommandLineInterface.abort..keyboard_interruptGs '))rNN)r&on_abortrrrrrrrFr2rrrr)rHrrs rKabortCommandLineInterface.abort>s##,,  {22 2 *  % %&8 9 ** * JJL MM : : <    % % ' 00 0  ! !$ '1rNcP^URU4Sj5 UR5 g)zY Set a return value. The eventloop can retrieve the result it by calling `return_value`. c>T$rPrf)documentsrKr7CommandLineInterface.set_return_value..\s(rNN)rr)rHrs `rKr%CommandLineInterface.set_return_valueWs !!"23 rNc[U5(deXlUR(aURR5 ggrP)rrr'stop)rHvalues rKr)CommandLineInterface._set_return_callable_s2" >> NN   ! rNcU(a2SUlUR5 URR5 OURR 5 SUlUR R 5 U"5nSSS5 URR5 URR5 UR5 W$!,(df  NT=f)a Run function on the terminal above the prompt. What this does is first hiding the prompt, then running this callable (which can safely output to the terminal), and then again rendering the prompt which causes the output of this function to scroll above the prompt. :param func: The callable to execute. :param render_cli_done: When True, render the interface in the 'Done' state first, then execute the function. If False, erase the interface first. :returns: the result of `func`. TN)rrr2rFrr, cooked_moder)rHfuncrender_cli_doners rKrun_in_terminal$CommandLineInterface.run_in_terminalfs" !%D  LLN MM   ! MM   !!ZZ # # %VF&  668  & %s 5C  Cc@^^^^U(a2STlTR5 TRR5 OTRR 5 STlU"5m[ T[ R5(deSUUUU4SjjmU4SjmT"5 g)a  EXPERIMENTAL Like `run_in_terminal`, but takes a generator that can yield Application instances. Example: def f(): yield Application1(...) print('...') yield Application2(...) cli.run_in_terminal_async(f) The values which are yielded by the given coroutine are supposed to be `Application` instances that run in the current CLI, all other code is supposed to be CPU bound, so except for yielding the applications, there should not be any user interaction or I/O in the given function. TNc >TRR5 TRU5nSSS5 [W[5(deTR UTSS9 g!,(df  N7=f![ a T"5 g T"5 e=f)z#Execute next step of the coroutine.NT)rr)r,rsendr$rr StopIteration) send_valuerrgrH step_nexts rKr ACommandLineInterface.run_application_generator..step_nexts KZZ++-VVJ/F."&+6666((yEI)K.-   s'A1A A1 A.*A11B  B c>TRR5 TRR5 TR5 grP)r2rFrrrRsrKr.dones, MM   ! MM : : < LLNrNrP)rrr2rFrr$types GeneratorType)rH coroutinerrr r s` @@@rKrun_application_generator.CommandLineInterface.run_application_generators{& !%D  LLN MM   ! MM   !! K!U001111 K K"   rNcH^^^U4SjmUUU4SjnTRU5 g)z Run system command (While hiding the prompt. When finished, all the output will scroll above the prompt.) :param command: Shell command to be executed. c>SSKJn [5nUR[R 5UR[R 5S55nU"SUS9nTRU5 g)z Create a sub application to wait for the enter key press. This has two advantages over using 'input'/'raw_input': - This will share the same input/output I/O. - This doesn't block the event loop. r)create_prompt_applicationc:URRS5 grP)clir)events rKr`JCommandLineInterface.run_system_command..wait_for_enter.._s **40rNzPress ENTER to continue...)messager6N)r%rr add_bindingrControlJControlMr)rregistryr`r&rHs rKwait_for_enter?CommandLineInterface.run_system_command..wait_for_entersi =zH  ! !$-- 0  ! !$-- 0 111 144&.0K  $ $[ 1rNcn>TRR5nTR R5n[TSXS9nUR5 T"5 g![a! [RR5nNhf=f![a! [R R5nN{f=f)NT)shellr+stdout) r,filenoAttributeErrorr*r+r)r&rwait)input_fd output_fdpcommandrHr"s rKr4CommandLineInterface.run_system_command..runs .::,,. 0 KK..0 gT$8A FFH  " .99++- ." 0JJ--/  0s"AB (BB (B43B4N)r)rHr-rr"s`` @rKrun_system_command'CommandLineInterface.run_system_commands 2* * S!rNc`^[[S5(aU4SjnURU5 gg)z (Not thread safe -- to be called from inside the key bindings.) Suspend process. :param suspend_group: When true, suspend the whole process group. (This is the default, and probably what you want.) SIGTSTPc>T(a&[R"S[R5 g[R"[R"5[R5 g)Nr)oskillsignalr2getpid) suspend_groupsrKr7CommandLineInterface.suspend_to_background..runs2 !GGAv~~.GGBIIK8rNN)hasattrr6r)rHr8rs ` rKsuspend_to_background*CommandLineInterface.suspend_to_backgrounds, 69 % % 9   % &rNcj[URX=(d URR5 g)z Print a list of (Token, text) tuples to the output. (When the UI is running, this method has to be called through `run_in_terminal`, otherwise it will destroy the UI.) :param style: Style class to use. Defaults to the active style in the CLI. N)rr)r&r1)rHtokensr1s rKr!CommandLineInterface.print_tokenss# T[[&*I43C3C3I3IJrNcUR$)z* ``True`` when the exit flag as been set. )rrRs rK is_exitingCommandLineInterface.is_exitings rNcUR$)z+ ``True`` when the abort flag as been set. )rrRs rK is_aborting CommandLineInterface.is_abortings rNcURSL$)z, ``True`` when a return value has been set. NrrRs rK is_returning!CommandLineInterface.is_returning&s !!--rNcFUR(aUR5$g)zD Get the return value. Not that this method can throw an exception. NrGrRs rKr!CommandLineInterface.return_value-s!   %%' ' rNcfUR=(d UR=(d UR$rP)rArDrHrRs rKrCommandLineInterface.is_done6s"G$"2"2Gd6G6GGrNc8^^^^^S/mSmSUUUUU4SjjmT$)zR Create function for asynchronous autocompletion. (Autocomplete in other thread.) FclURnU[U5UR-SnX1R:H$)zj Return `True` if applying this completion doesn't have any effect. (When it doesn't insert any new text. N)text_before_cursorlenstart_positiontext)r completionrP replaced_texts rKcompletion_does_nothingMCommandLineInterface._create_async_completer..completion_does_nothingAs? "*!^^^^^TRmT=(d [SS9mTS(agTR(dTR(dgSTS'UUUUU UUUUU 4 SjnT RR U5 g)NT) text_insertedrc > ^[TRRTT55mUUUUUUUU U U 4 SjnT R(aT RR U5 gg)Nc> STS'[T5S:XaT"T TS5(aTSS2 TRT R:XaTRT R:XaTR(dSnSnT (av[ T T5nU(aRTR U5 [T5S:a/TVs/sHnUR [U55PM snTSS&OSnO[T5S:XaSnU(aTRTT =(d UT S9 T R5 gTR(dT"5 ggs snf)z Set the new complete_state in a safe way. Don't replace an existing complete_state if we had one. (The user could have pressed 'Tab' in the meantime. Also don't set it if the text was changed in the meantime. FrrNT) completions go_to_first go_to_last) rQrScursor_positioncomplete_stater insert_textnew_completion_from_positionset_completionsr)rcselect_first_anyway common_partrasync_completerrbcomplete_thread_runningrVr\rrursrtrHs rKcallbackdCommandLineInterface._create_async_completer..async_completer..run..callback^s927+A.K(A-3Hk!nMM'N{{hmm3"22h6N6NN & 5 5*..3+.*DX{*[K* & 2 2; ?#&{#3a#7 2=6>1KN7$7*"22,7,8,Os3$D>)listr]get_completionsr'r) rhr\rfrbrvrgrVrrursrtrHs @rKrRCommandLineInterface._create_async_completer..async_completer..run[sK"6#3#3#C#CHn#]^ 8*8*t>>NN55h?"rN)rr r`r]r'run_in_executor) rsrtrurvrrrfrbrgrVrHs ```` @rKrfECommandLineInterface._create_async_completer..async_completerKslH+P}4/PN'q)$$F,<,<*. #A &> @> @@ NN * *3 /rN)FFFNrf)rHrbrfrgrVs``@@@rKrn,CommandLineInterface._create_async_completer:s0 $)' 4=BEIP 0P 0brNc&^^^^S/mUUUU4SjmT$)zR Create function for asynchronous auto suggestion. (AutoSuggest in other thread.) Fc>^TRmTS(agTR(dTR(dgSTS'UUUUU4SjnTRR U5 g)NrTc>^TRRTTT5mUUUUUU4SjnTR(aTRRU5 gg)Nc>STS'TRTR:Xa2TRTR:XaTTlTR5 gT"5 g)NFr)rSr_ suggestionr)async_suggestorrbrrHsuggest_thread_runningrtsrKrhjCommandLineInterface._create_auto_suggest_function..async_suggestor..run..callbacksP05*1-{{hmm3"22h6N6NN-7))()rN)r_get_suggestionr'r)rhrtrurbrrHrvs @rKrXCommandLineInterface._create_auto_suggest_function..async_suggestor..runsG#00??fhW  * *>>NN55h?"rN)rrtr_r'rm)rrrurbrHrvs @rKruKCommandLineInterface._create_auto_suggest_function..async_suggestors\H&a(  (;(;)- "1 % @ @( NN * *3 /rNrf)rHrbrurvs``@@rKrm2CommandLineInterface._create_auto_suggest_functions #(" 0" 0FrNc[XS9$)aC Create an :class:`_StdoutProxy` class which can be used as a patch for `sys.stdout`. Writing to this proxy will make sure that the text appears above the prompt, and that it doesn't destroy the output from the renderer. :param raw: (`bool`) When True, vt100 terminal escape sequences are not removed/escaped. raw) _StdoutProxy)rHr~s rK stdout_proxy!CommandLineInterface.stdout_proxysD**rNc0[URUS9X#S9$)a Return a context manager that will replace ``sys.stdout`` with a proxy that makes sure that all printed text will appear above the prompt, and that it doesn't destroy the output from the renderer. :param patch_stdout: Replace `sys.stdout`. :param patch_stderr: Replace `sys.stderr`. r}) patch_stdout patch_stderr)_PatchStdoutContextr)rHr~rrs rKpatch_stdout_context)CommandLineInterface.patch_stdout_contexts'#   #  &%B BrNc[U5$rP)_InterfaceEventLoopCallbacksrRs rKr/CommandLineInterface.create_eventloop_callbackss +D11rN)rr:rr5r(rr;r&r-r.r'r,r9r4r>r?r@rArBrCrDrEr)r/r3r2rr0)NNNF)NFFFNrP)FN)TN)NFF)T)FTT):__name__ __module__ __qualname____firstlineno____doc__rLpropertyrQrUrXr=rzrwrrlrrrrrFrrrrequest_redrawrrrrrrexec_textwrapdedent SyntaxErrorrrrrset_exit set_abortrrrrr/r;rrArDrHrrrnrmrrr__static_attributes__rfrNrKrr/s&J"X''**22-1^?D?D(,O // **. 3 %   99 >1122AB N " 9 &*#X7& (//*# * * jTY8=< |(*(,HI""H7r1"f&0K   .. (HHbH*X + B2E & &&s "D D! D!rc@\rSrSrSrSr\S5rSrSr Sr Sr g ) rizY Callbacks on the :class:`.CommandLineInterface` object, to which an eventloop can talk. c>[U[5(deXlgrP)r$rrrHrs rKrL%_InterfaceEventLoopCallbacks.__init__s#34444rNc~URnUR(aURnUR(aMU$)z+ Return the active `CommandLineInterface`. )rr;rs rK _active_cli(_InterfaceEventLoopCallbacks._active_clis1 hhll,,Clll rNc8URR5 g)z: Report terminal size change. This will trigger a redraw. N)rrrRs rKterminal_size_changed2_InterfaceEventLoopCallbacks.terminal_size_changeds ##%rNcPURnURR5 grP)rr@rGrs rK input_timeout*_InterfaceEventLoopCallbacks.input_timeouts !!#rNc[U[5(deURnUR(d6URR U5 URR 5 gg)z/ Feed a key press to the CommandLineInterface. N)r$rrrr9feed process_keys)rH key_pressrs rKfeed_key%_InterfaceEventLoopCallbacks.feed_keysV)X.... {{    $ $Y /    , , .rN)rN) rrrrrrLrrrrrrrfrNrKrrs/  & $ /rNrc*\rSrSrSSjrSrSrSrg)ric(XlX lX0lgrP) new_stdoutrr)rHrrrs rKrL_PatchStdoutContext.__init__s$((rNc[RUl[RUlUR (aUR [lUR(aUR [lggrP)r*r&original_stdoutstderroriginal_stderrrrrrRs rK __enter___PatchStdoutContext.__enter__sG"zz"zz   CJ   CJ rNcUR(aUR[lUR(aUR [lggrP)rrr*r&rrr)rHakws rK__exit___PatchStdoutContext.__exit__%s3   --CJ   --CJ rN)rrrrrN)TT)rrrrrLrrrrfrNrKrrs) ).rNrc@\rSrSrSrS SjrSrSrSrSr Sr S r g ) ri-zN Proxy for stdout, as returned by :class:`CommandLineInterface.stdout_proxy`. c6[U[5(de[U[5(de[R"5UlXlX l/Ul[RRUl [RRUl grP) r$rbool threadingRLock_lock_cli_raw_bufferr* __stdout__errorsencoding)rHrr~s rKrL_StdoutProxy.__init__2sj#34444#t$$$$__&    nn++ // rNcURR(aQ[R"URRU5nURR R U5 gU"5 grP)rr( functoolspartialrr'r)rHrrs rK_do_StdoutProxy._do>sH 99 '// 0I0I4PO II   2 2? C FrNc^^SU;aFURSS5up#TRUS/-mU/TlUU4SjnTRU5 gTRRU5 g)a Note: print()-statements cause to multiple write calls. (write('line') and write(' ')). Of course we don't want to call `run_in_terminal` for every individual call, because that's too expensive, and as long as the newline hasn't been written, the text itself is again overwritter by the rendering of the input command line. Therefor, we have a little buffer which holds the text until a newline is written to stdout.  rc>TH`nTR(a'TRRRU5 M;TRRR U5 Mb grP)rrr) write_rawwrite)srHto_writes rKr _StdoutProxy._write..runVsD!Ayy ((2215 ((..q1 "rNN)rsplitrrappend)rHdatabeforeafterrrs` @rK_write_StdoutProxy._writeEsa 4<!KKa0MF||vtn4H!7DL 2 HHSM LL   %rNcrUR URU5 SSS5 g!,(df  g=frP)rr)rHrs rKr_StdoutProxy.writeas ZZ KK ZZs( 6c4^U4SjnTRU5 g)Nc<>TRH`nTR(a'TRRR U5 M;TRRR U5 Mb /TlTRRR 5 grP)rrrr)rrflush)rrHs rKr _StdoutProxy._flush..runfsg\\99II$$..q1II$$**1- " DL II   " " $rN)r)rHrs` rK_flush_StdoutProxy._flushes %  rNcpUR UR5 SSS5 g!,(df  g=f)z Flush buffered output. N)rrrRs rKr_StdoutProxy.flushpsZZ KKMZZs' 5)rrrrrrNr) rrrrrrLrrrrrrrfrNrKrr-s% 0&8 rNrcF\rSrSrSrSrSrSrSrS Sjr S r S r S r g) rixa Eventloop used by sub applications. A sub application is an `Application` that is "spawned" by a parent application. The parent application is suspended temporarily and the sub application is displayed instead. It doesn't need it's own event loop. The `EventLoopCallbacks` from the parent application are redirected to the sub application. So if the event loop that is run by the parent application detects input, the callbacks will make sure that it's forwarded to the sub application. When the sub application has a return value set, it will terminate by calling the `stop` method of this event loop. This is used to transfer control back to the parent application. cn[U[5(de[U5(deXlX lgrP)r$rrr stop_callback)rHrrs rKrL!_SubApplicationEventLoop.__init__s2#34444 &&&&*rNc$UR5 grP)rrRs rKr_SubApplicationEventLoop.stops rNcgrPrfrRs rKclose_SubApplicationEventLoop.closes rNcNURRRU5 grP)rr'rm)rHrhs rKrm(_SubApplicationEventLoop.run_in_executors **84rNNcJURRRXS9 g)Nr)rr'r)rHrhrs rKr+_SubApplicationEventLoop.call_from_executors" --  . ?rNcNURRRX5 grP)rr' add_reader)rHfdrhs rKr#_SubApplicationEventLoop.add_readers %%b3rNcNURRRU5 grP)rr' remove_reader)rHrs rKr&_SubApplicationEventLoop.remove_readers ((,rN)rrrP) rrrrrrLrrrmrrrrrfrNrKrrxs* + 5?4-rNr)>r __future__rrr4r6rr*rrrrr7 subprocessrr&rrrbrbuffer_mappingr rTr r enumsr eventloop.baser eventloop.callbacksrfiltersrr,rrkey_binding.input_processorrrkey_binding.registryrkey_binding.vi_staterkeysrr)rr2rrrrutilsrr__all__objectrrrrrrfrNrKr s(  1)A %3$71*),%!  u26u2p,/#5,/^.&..H6HV)-y)-rN