ZgOUSrSSKJr SSKrSSKrSSKrSSKrSSKJr SSK J r SSK J r SSK JrJrJrJrJrJrJrJrJr SSKJr SS KJr SS KJrJrJrJrJ r J!r!J"r"J#r# SS K$J%r% SS K&J'r' SS K(J)r) \(aSSK*J+r+ \RXS:aSSK-J.r. OSSK J.r. S/r/\R`r1Sr2"SS5r3"SS\45r5"SS\45r6"SS\45r7"SS5r8"SS5r9g)zMain Nvim interface.) annotationsN)partial) format_stack)SimpleNamespace) AnyAnyStrCallableDictIteratorListOptional TYPE_CHECKINGUnion)ExtType)Buffer) NvimErrorRemote RemoteApi RemoteMapRemoteSequence TDecodeModedecode_if_byteswalk)Tabpage)Window)format_exc_skip)Session))LiteralNvima= local a = vim.api local function update_highlights(buf, src_id, hls, clear_first, clear_end) if clear_first ~= nil then a.nvim_buf_clear_highlight(buf, src_id, clear_first, clear_end) end for _,hl in pairs(hls) do local group, line, col_start, col_end = unpack(hl) if col_start == nil then col_start = 0 end if col_end == nil then col_end = -1 end a.nvim_buf_add_highlight(buf, src_id, group, line, col_start, col_end) end end local chid = ... local mod = {update_highlights=update_highlights} _G["_pynvim_"..chid] = mod c.\rSrSrSr\S+Sj5r\S,Sj5rS-S.Sjjr\ S/Sj5r S0S1Sjjr S2S jr S3S jr S4S jrS5S jrS6S7S jjrS8SjrS8SjrS9SjrS:SjrS;SSjrS?SjrS?SjrS@SjrSASjrSBSjrS4SjrSCSjrSDSjr SESjr!SFSjr"SGS jr#SHSIS!jjr$SJS"jr%SKSLS#jjr&SMS$jr'SMS%jr(SNS&jr)SOSPS'jjr*SQS(jr+SRS)jr,S*r-g)Sr!=aClass that represents a remote Nvim instance. This class is main entry point to Nvim remote API, it is a wrapper around Session instances. The constructor of this class must not be called directly. Instead, the `from_session` class method should be used to create the first instance from a raw `Session` instance. Subsequent instances for the same session can be created by calling the `with_decode` instance method to change the decoding behavior or `SubClass.from_nvim(nvim)` where `SubClass` is a subclass of `Nvim`, which is useful for having multiple `Nvim` objects that behave differently without one affecting the other. When this library is used on python3.4+, asyncio event loop is guaranteed to be used. It is available as the "loop" attribute of this class. Note that asyncio callbacks cannot make blocking requests, which includes accessing state-dependent attributes. They should instead schedule another callback using nvim.async_call, which will not have this restriction. cSUlURS5up#[[U5nUSSS[USSS[ USSS[ 0nU"XX45$)zCreate a new Nvim instance for a Session instance. This method must be called to create the first Nvim instance, since it queries Nvim metadata for type information and sets a SessionHook for creating specialized objects from Nvim remote handles. c0[[US55$)N)rr)es 1/usr/lib/python3/dist-packages/pynvim/api/nvim.py#Nvim.from_session..\s)OAaD4I*Jsnvim_get_api_infotypesridrr) error_wrapperrequestrrrrr)clssession channel_idmetadatar,s r( from_sessionNvim.from_sessionTs!K&/CD 2 W h ' -v W h ' -v W i ( .  788r+cU"URURURURURUR 5$)z5Create a new Nvim instance from an existing instance.)_sessionr2r3r,_decode_err_cb)r0nvims r( from_nvimNvim.from_nvimis64==$//4==::t||T\\; ;r+Nc8XlX lX0lURSSS05n[ S0UD6UlX@l[US5Ul[USSS5Ul [USS S 5Ul [US S 5Ul [U5Ul[US 5Ul[US 5Ul[%U5Ul[)U5Ul[-U5Ul[1U5Ul[4UlXPlUc SUlg X`lg )z>Initialize a new Nvim instance. This method is module-private.version api_levelrnvim_ nvim_get_var nvim_set_var nvim_del_var nvim_get_vvarNnvim_get_optionnvim_set_optionnvim_list_winsnvim_list_tabpagescgN)_s r(r)Nvim.__init__..s4r+rK)r7r2r3getrr>r,rapirvarsvvarsoptionsBuffersbuffersrwindowstabpagesCurrentcurrentCompatibilitySessionr1FuncsfuncsLuaFuncsluarerrorr8r9)selfr1r2r3r,decodeerr_cbr>s r(__init__ Nvim.__init__os $ ,,y;*:;&11  T7+dNNNS t_dDA  '8:KL t} /=dDT/U 1? &2  t} +D1 4[ D>  >1?DL!Lr+cBURRR$)z)Get the event loop (exposed to rplugins).)r7loop_loopr_s r(re Nvim.loops}}!!'''r+cUc URn[U5[La7URURnU"XRUR 45$U(a [ X5nU$rJ)r8typerr,codedatar)r_objr`r0s r( _from_nvimNvim._from_nvimsX >\\F 9 **SXX&Cthh12 2 !#.C r+cT[U[5(a[UR6$U$rJ) isinstancerr code_data)r_rms r(_to_nvim Nvim._to_nvims# c6 " "CMM* * r+c[URSS5(d1UR[UR5 SURl[UR SRUR55$)N_has_luaFTz _pynvim_{})getattrr7exec_lua lua_moduler2rvr]formatrgs r(_get_lua_privateNvim._get_lua_privatesSt}}j%88 MM*doo 6%)DMM "txx!4!4T__!EFFr+cURRb[R"5URR:waTSR SR [ SS5SS55nURURU5 [S5eURSUR5n[URU5nURR"U/UQ70UD6n[URXeS9$) aSend an API request or notification to nvim. It is rarely needed to call this function directly, as most API functions have python wrapper functions. The `api` object can be also be used to call API functions as methods: vim.api.err_write('ERROR\n', async_=True) vim.current.buffer.api.get_mark('.') is equivalent to vim.request('nvim_err_write', 'ERROR\n', async_=True) vim.request('nvim_buf_get_mark', vim.current.buffer, '.') Normally a blocking request will be sent. If the `async_` flag is present and True, a asynchronous notification is sent instead. This will never block, and the return value or error is ignored. NzrRequest from non-main thread. Requests from different threads should be wrapped with nvim.async_call(cb, ...) {}  zrequest from non-main threadr`)r`)r7 _loop_thread threadingcurrent_threadrzjoinr async_callr9rpopr8rrsr/rn)r_nameargskwargsmsgr`ress r(r/ Nvim.requests( MM & & 2,,.$--2L2LL:F499\$%:3B%?@A  OODLL# .:; ;Hdll3DMM4(mm##D:4:6:DOOS88r+crURR5nU(a[URU5$g)zBlock until a message(request or notification) is available. If any messages were previously enqueued, return the first in queue. If not, run the event loop until one is received. N)r7 next_messagerrn)r_rs r(rNvim.next_messages/ mm((* - - r+c^^^Uc[RRnUTlSUU4SjjnSUU4SjjnTRR XVU5 g)zRun the event loop to receive requests and notifications from Nvim. This should not be called from a plugin running in the host, which already runs the loop and dispatches events to plugins. Nc>TRU5n[TRU5nT"X5n[TR U5$![a. SRX[ S55nTR U5 ef=f)Nz,error caught in request handler '{} {}' {} r&)rnr Exceptionrzrr9rs)rrresultr request_cbr_s r(filter_request_cb(Nvim.run_loop..filter_request_cbs|??4(D.D #D/  v. .  Ht?1+=> S!  s A8Bc>TRU5n[TRU5nT"X5 g![a. SRX[ S55nTR U5 ef=f)Nz1error caught in notification handler '{} {}' {} r&)rnrrrzrr9)rrrnotification_cbr_s r(filter_notification_cb-Nvim.run_loop..filter_notification_cbse??4(D.D + Mt?1+=> S!  s 38A+)rstrrrreturnr)rrrrrNone)sysstderrwriter9r7run)r_rrsetup_cbrarrs``` r(run_loop Nvim.run_loopsK >ZZ%%F  / /   +XNr+c8URR5 g)z2Stop the event loop being started with `run_loop`.N)r7stoprgs r( stop_loopNvim.stop_loop s r+c8URR5 g)z1Close the nvim session and release its resources.N)r7closergs r(r Nvim.close s r+cU$)z(Enter nvim session as a context manager.rKrgs r( __enter__Nvim.__enter__s r+c$UR5 g)z@Exit nvim session as a context manager. Closes the event loop. N)r)r_exc_infos r(__exit__ Nvim.__exit__s r+c[URURURURXR 5$)zInitialize a new Nvim instance.)r!r7r2r3r,r9)r_r`s r( with_decodeNvim.with_decodes0DMM4??MM4::v||E Er+c :UnUbX5S'URSXU5$)zeRegister as a remote UI. After this method is called, the client will receive redraw notifications. rgbnvim_ui_attachr/)r_widthheightrrrRs r( ui_attachNvim.ui_attach!s) ? EN||,eWEEr+c$URS5$)zUnregister as a remote UI.nvim_ui_detachrrgs r( ui_detachNvim.ui_detach.s||,--r+c&URSX5$)ziNotify nvim that the client window has resized. If possible, nvim will send a redraw request to resize. ui_try_resizer)r_rrs r(rNvim.ui_try_resize2s ||OU;;r+c&URSU5$)zSubscribe to a Nvim event.nvim_subscriberr_events r( subscribeNvim.subscribe9s||,e44r+c&URSU5$)zUnsubscribe to a Nvim event.nvim_unsubscriberrs r( unsubscribeNvim.unsubscribe=s||.66r+c *UR"SU40UD6$)zExecute a single ex command. nvim_commandrr_stringrs r(command Nvim.commandAs||NF=f==r+c&URSU5$)z2Execute a single ex command and return the output.nvim_command_outputrr_rs r(command_outputNvim.command_outputEs||16::r+c *UR"SU40UD6$)z Evaluate a vimscript expression. nvim_evalrrs r(eval Nvim.evalIs||K:6::r+c*UR"SX40UD6$)zCall a vimscript function.nvim_call_functionr)r_rrrs r(call Nvim.callMs||0$GGGr+c*UR"SX40UD6$)aExecute lua code. Additional parameters are available as `...` inside the lua chunk. Only statements are executed. To evaluate an expression, prefix it with `return`: `return my_function(...)` There is a shorthand syntax to call lua functions with arguments: nvim.lua.func(1,2) nvim.lua.mymod.myfunction(data, async_=True) is equivalent to nvim.exec_lua("return func(...)", 1, 2) nvim.exec_lua("mymod.myfunction(...)", data, async_=True) Note that with `async_=True` there is no return value. nvim_execute_luar)r_rkrrs r(rx Nvim.exec_luaQs&||.EfEEr+c&URSU5$)zSReturn the number of display cells `string` occupies. Tab is counted as one cell. nvim_strwidthrrs r(strwidth Nvim.strwidthfs ||OV44r+c$URS5$)z=Return a list of paths contained in the 'runtimepath' option.nvim_list_runtime_pathsrrgs r(list_runtime_pathsNvim.list_runtime_pathsms||566r+clUR5HnU"U5b gM g![a  gf=f)a<Invoke `cb` for each path in 'runtimepath'. Call the given callable for each path in 'runtimepath' until either callable returns something but None, the exception is raised or there are no longer paths. If stopped in case callable returned non-None, vim.foreach_rtp function returns the value returned by callable. N)rr)r_cbpaths r( foreach_rtpNvim.foreach_rtpqsB++-D d8'(.  s % 33c<[U5 URSU5$)z-Run os.chdir, then all appropriate vim stuff.nvim_set_current_dir)os_chdirr/)r_dir_paths r(chdir Nvim.chdirs||2H==r+c(URSXU5$)z&Push `keys` to Nvim user input buffer. nvim_feedkeysr)r_keysrR escape_csis r(feedkeys Nvim.feedkeyss||OTJGGr+c&URSU5$)zPush `bytes` to Nvim low level input buffer. Unlike `feedkeys()`, this uses the lowest level input buffer and the call is not deferred. It returns the number of bytes actually written(which can be less than what was requested if the buffer is full). nvim_inputr)r_bytess r(input Nvim.inputs||L%00r+c*URSUX#U5$)aReplace any terminal code strings by byte sequences. The returned sequences are Nvim's internal representation of keys, for example: -> '\x1b' -> '\r' -> '\x0c' -> '\x80ku' The returned sequences can be used as input to `feedkeys`. nvim_replace_termcodesr)r_r from_partdo_ltspecials r(replace_termcodesNvim.replace_termcodess&||4f%g7 7r+c *UR"SU40UD6$)zaPrint `msg` as a normal message. The message is buffered (won't display) until linefeed ("\n"). nvim_out_writerr_rrs r( out_writeNvim.out_writes ||,cT"T0TD6 g![a3nSRU[S5T5nTRU5 eSnAff=f)NzSerror caught while executing async callback: {!r} {} the call was requested at {}r&)rrzrr9)errrr call_pointfnrr_s r(handler Nvim.async_call..handlersT D#F# DsOA$6 C S!  s A .AA rr)rrr7threadsafe_call)r_r&rrr'r%s```` @r(rNvim.async_calls?WW\$23B78    %%g.r+)r8r9r7rOrTr2rXr^r[r]r3rRr1rVr,rPr>rQrU)r1rrr!)r:r!rr!)TN) r1rr2intr3zDict[str, Any]r,zDict[int, Any]r`rrazOptional[Callable[[str], None]])rzasyncio.AbstractEventLooprJ)rmrr`zOptional[TDecodeMode]rr)rmrrr)rr\)rrrrrrrr)rr)NN) r)Optional[Callable[[str, List[Any]], Any]]rr-rzOptional[Callable[[], None]]razOptional[Callable[[str], Any]]rrr))rr!)rrrr)T)r`z Literal[True]rr!) rr,rr,rzOptional[bool]rrrr)rr,rr,rr)rrrr)rrrrrr)rrrr)rrrrrr)rkrrrrrrr)rrrr,)rz List[str])rzCallable[[str], Any]rr)rrrr)rT)rrrRrrboolrr)rrrr,)FTT) rrrr.rr.rr.rr)rrrrrr)rr.)zqa!)rrrrrr,)r&Callable[..., Any]rrrrrr).__name__ __module__ __qualname____firstlineno____doc__ classmethodr4r;rbpropertyrernrsr{r/rrrrrrrrrrrrrrrrrxrrrrrrrr rrrr r__static_attributes__rKr+r(r!r!=s,99(;;#26""""""! ""  ""  ""0""H(( G "9H.2615 'O='OC'O/ 'O / 'O  'ORE >B F F"% F,: FMP F  F.<57>;;HF*57 > H1  777 7  7 7,= =N B/r+cJ\rSrSrSrS SjrS SjrS SjrS SjrSSjr Sr g )rSizRemote NVim buffers. Currently the interface for interacting with remote NVim buffers is the `nvim_list_bufs` msgpack-rpc function. Most methods fetch the list of buffers from NVim. Conforms to *python-buffers*. c:URRUlg)z4Initialize a Buffers object with Nvim object `nvim`.N)rO list_bufs_fetch_buffersr_r:s r(rbBuffers.__init__s"hh00r+c4[UR55$)zReturn the count of buffers.)lenr<rgs r(__len__Buffers.__len__s4&&())r+cnUR5HnURU:XdMUs $ [U5e)z9Return the Buffer object matching buffer number `number`.)r<numberKeyError)r_rDbs r( __getitem__Buffers.__getitem__s3$$&Axx6!'vr+cH[U[5=(a UR$)z2Return whether Buffer `b` is a known valid buffer.)rqrvalid)r_rFs r( __contains__Buffers.__contains__s!V$00r+c4[UR55$)z,Return an iterator over the list of buffers.)iterr<rgs r(__iter__Buffers.__iter__ sD'')**r+)r<Nr:r!r/)rDr,rr)rFrrr.)rzIterator[Buffer]) r1r2r3r4r5rbrArGrKrOr8rKr+r(rSrSs 1*1+r+rSc"\rSrSrSrSSjrSrg)rYiz#Helper class for API compatibility.c&URUlgrJ)rr*r=s r(rbCompatibilitySession.__init__s#r+)r*NrQ)r1r2r3r4r5rbr8rKr+r(rYrYs -/r+rYc:\rSrSrSrSSjr\SSj5r\RSSj5r\RSSj5r\SSj5r \ RSSj5r \SS j5r \ RSS j5r \SS j5r \ RSS j5r S r g)rWiz7Helper class for emulating vim.current from python-vim.cXlSUlgrJr7range)r_r1s r(rbCurrent.__init__s  r+c8URRS5$)Nnvim_get_current_liner7r/rgs r(line Current.line}}$$%<==r+c:URRSU5$)Nnvim_set_current_liner\)r_r]s r(r]r^"s}}$$%s}}$$%?IIr+rWN)r1r!)rr)r]rrrr))rr)rzUnion[Buffer, int]rr)rr)rmzUnion[Window, int]rr)rr)rszUnion[Tabpage, int]rr)r1r2r3r4r5rbr7r]setterdeleterrrmrsr8rKr+r(rWrWsA>> [[DD \\>>== ]]EE== ]]EEAA ^^JJr+rWc,\rSrSrSrSSjrSSjrSrg) rZiCz0Helper class for functional vimscript interface.cXlgrJ_nvimr=s r(rbFuncs.__init__Fs r+cB[URRU5$rJ)rr|r)r_rs r( __getattr__Funcs.__getattr__Istzz--r+r{NrQ)rrrr0)r1r2r3r4r5rbrr8rKr+r(rZrZCs:.r+rZc:\rSrSrSrSS SjjrS SjrS SjrSrg) r\iMz@Wrapper to allow lua functions to be called like python methods.cXlX lgrJr|r)r_r:rs r(rbLuaFuncs.__init__Ps   r+cvUR(aURS-OSn[URX!-5$)z#Return wrapper to named api method..r)rr\r|)r_rprefixs r(rLuaFuncs.__getattr__Ts*$(IIS2 FM22r+cSU;a [S5eURSS5nU(dSOSnURUR5nURR "U/UQ70UD6$)Nasyncz6"async" argument is not allowed. Use "async_" instead.async_Fzreturn {}(...)z{}(...)) ValueErrorrNrzrr|rx)r_rrrpatternrks r(__call__LuaFuncs.__call__Ysg f 56 6He,*0"i~~dii(zz""49$9&99r+rN)r)r:r!rr)rrrr\)rrrrrr) r1r2r3r4r5rbrrr8rKr+r(r\r\MsJ3 :r+r\):r5 __future__rasyncioosrr functoolsr tracebackrr,rtypingrrr r r r r rrmsgpackrpynvim.api.bufferrpynvim.api.commonrrrrrrrrpynvim.api.tabpagerpynvim.api.windowr pynvim.utilrpynvim.msgpack_rpcr version_infotyping_extensionsr __all__rrryr!objectrSrYrWrZr\rKr+r(rs" "!***$CCC&$'*f) ( 88 0k/k/\ +f +F/6/*Jf*JZ..::r+