Codebase list python-pynvim / 0010ca2
Import python-neovim_0.1.11.orig.tar.gz Víctor Cuadrado Juan 7 years ago
20 changed file(s) with 179 addition(s) and 140 deletion(s). Raw diff Collapse all Expand all
+1
-1
PKG-INFO less more
00 Metadata-Version: 1.1
11 Name: neovim
2 Version: 0.1.10
2 Version: 0.1.11
33 Summary: Python client to neovim
44 Home-page: http://github.com/neovim/python-client
55 Author: Thiago de Arruda
+2
-0
README.md less more
77 connecting to and scripting Nvim processes through its msgpack-rpc API.
88
99 #### Installation
10
11 Supports python 2.7, and 3.3 or later.
1012
1113 ```sh
1214 pip2 install neovim
+14
-3
neovim/__init__.py less more
1111 stdio_session, tcp_session)
1212 from .plugin import (Host, autocmd, command, decode, encoding, function,
1313 plugin, rpc_export, shutdown_hook)
14 from .util import Version
1415
1516
1617 __all__ = ('tcp_session', 'socket_session', 'stdio_session', 'child_session',
1718 'start_host', 'autocmd', 'command', 'encoding', 'decode',
18 'function', 'plugin', 'rpc_export', 'Host', 'Nvim',
19 'function', 'plugin', 'rpc_export', 'Host', 'Nvim', 'VERSION',
1920 'shutdown_hook', 'attach', 'setup_logging', 'ErrorResponse')
21
22
23 VERSION = Version(major=0, minor=1, patch=11, prerelease="dev")
2024
2125
2226 def start_host(session=None):
6367
6468 if not session:
6569 session = stdio_session()
66 host = Host(Nvim.from_session(session))
70 nvim = Nvim.from_session(session)
71
72 if nvim.version.api_level < 1:
73 sys.stderr.write("This version of the neovim python package "
74 "requires nvim 0.1.6 or later")
75 sys.exit(1)
76
77 host = Host(nvim)
6778 host.start(plugins)
6879
6980
106117 if 'NVIM_PYTHON_LOG_FILE' in os.environ:
107118 prefix = os.environ['NVIM_PYTHON_LOG_FILE'].strip()
108119 major_version = sys.version_info[0]
109 logfile = '{0}_py{1}_{2}'.format(prefix, major_version, name)
120 logfile = '{}_py{}_{}'.format(prefix, major_version, name)
110121 handler = logging.FileHandler(logfile, 'w')
111122 handler.formatter = logging.Formatter(
112123 '%(asctime)s [%(levelname)s @ '
+33
-52
neovim/api/buffer.py less more
99 basestring = str
1010
1111
12 def adjust_index(idx, default=None):
13 """Convert from python indexing convention to nvim indexing convention."""
14 if idx is None:
15 return default
16 elif idx < 0:
17 return idx - 1
18 else:
19 return idx
20
21
1222 class Buffer(Remote):
1323
1424 """A remote Nvim buffer."""
1525
16 _api_prefix = "buffer_"
26 _api_prefix = "nvim_buf_"
1727
1828 def __len__(self):
1929 """Return the number of lines contained in a Buffer."""
3040 the whole buffer.
3141 """
3242 if not isinstance(idx, slice):
33 return self._session.request('buffer_get_line', self, idx)
34 include_end = False
35 start = idx.start
36 end = idx.stop
37 if start is None:
38 start = 0
39 if end is None:
40 end = -1
41 include_end = True
42 return self._session.request('buffer_get_line_slice', self, start, end,
43 True, include_end)
43 i = adjust_index(idx)
44 return self.request('nvim_buf_get_lines', i, i + 1, True)[0]
45 start = adjust_index(idx.start, 0)
46 end = adjust_index(idx.stop, -1)
47 return self.request('nvim_buf_get_lines', start, end, False)
4448
45 def __setitem__(self, idx, lines):
49 def __setitem__(self, idx, item):
4650 """Replace a buffer line or slice by integer index.
4751
4852 Like with `__getitem__`, indexes may be negative.
5155 the whole buffer.
5256 """
5357 if not isinstance(idx, slice):
54 if lines is None:
55 return self._session.request('buffer_del_line', self, idx)
56 else:
57 return self._session.request('buffer_set_line', self, idx,
58 lines)
59 if lines is None:
60 lines = []
61 include_end = False
62 start = idx.start
63 end = idx.stop
64 if start is None:
65 start = 0
66 if end is None:
67 end = -1
68 include_end = True
69 return self._session.request('buffer_set_line_slice', self, start, end,
70 True, include_end, lines)
58 i = adjust_index(idx)
59 lines = [item] if item is not None else []
60 return self.request('nvim_buf_set_lines', i, i + 1, True, lines)
61 lines = item if item is not None else []
62 start = adjust_index(idx.start, 0)
63 end = adjust_index(idx.stop, -1)
64 return self.request('buffer_set_lines', start, end, False, lines)
7165
7266 def __iter__(self):
7367 """Iterate lines of a buffer.
8680
8781 This is the same as __setitem__(idx, [])
8882 """
89 if not isinstance(idx, slice):
90 self.__setitem__(idx, None)
91 else:
92 self.__setitem__(idx, [])
93
94 def get_line_slice(self, start, stop, start_incl, end_incl):
95 """More flexible wrapper for retrieving slices."""
96 return self._session.request('buffer_get_line_slice', self, start,
97 stop, start_incl, end_incl)
98
99 def set_line_slice(self, start, stop, start_incl, end_incl, lines):
100 """More flexible wrapper for replacing slices."""
101 return self._session.request('buffer_set_line_slice', self, start,
102 stop, start_incl, end_incl, lines)
83 self.__setitem__(idx, None)
10384
10485 def append(self, lines, index=-1):
10586 """Append a string or list of lines to the buffer."""
10687 if isinstance(lines, (basestring, bytes)):
10788 lines = [lines]
108 return self._session.request('buffer_insert', self, index, lines)
89 return self.request('nvim_buf_set_lines', index, index, True, lines)
10990
11091 def mark(self, name):
11192 """Return (row, col) tuple for a named mark."""
112 return self.request('buffer_get_mark', name)
93 return self.request('nvim_buf_get_mark', name)
11394
11495 def range(self, start, end):
11596 """Return a `Range` object, which represents part of the Buffer."""
120101 """Add a highlight to the buffer."""
121102 if async is None:
122103 async = (src_id != 0)
123 return self.request('buffer_add_highlight', src_id, hl_group,
104 return self.request('nvim_buf_add_highlight', src_id, hl_group,
124105 line, col_start, col_end, async=async)
125106
126107 def clear_highlight(self, src_id, line_start=0, line_end=-1, async=True):
127108 """Clear highlights from the buffer."""
128 self.request('buffer_clear_highlight', src_id,
109 self.request('nvim_buf_clear_highlight', src_id,
129110 line_start, line_end, async=async)
130111
131112 @property
132113 def name(self):
133114 """Get the buffer name."""
134 return self.request('buffer_get_name')
115 return self.request('nvim_buf_get_name')
135116
136117 @name.setter
137118 def name(self, value):
138119 """Set the buffer name. BufFilePre/BufFilePost are triggered."""
139 return self.request('buffer_set_name', value)
120 return self.request('nvim_buf_set_name', value)
140121
141122 @property
142123 def valid(self):
143124 """Return True if the buffer still exists."""
144 return self.request('buffer_is_valid')
125 return self.request('nvim_buf_is_valid')
145126
146127 @property
147128 def number(self):
148129 """Get the buffer number."""
149 return self.request('buffer_get_number')
130 return self.request('nvim_buf_get_number')
150131
151132
152133 class Range(object):
+37
-35
neovim/api/nvim.py less more
1212 from .tabpage import Tabpage
1313 from .window import Window
1414 from ..compat import IS_PYTHON3
15 from ..util import format_exc_skip
15 from ..util import Version, format_exc_skip
1616
1717 __all__ = ('Nvim')
1818
7373 self._session = session
7474 self.channel_id = channel_id
7575 self.metadata = metadata
76 version = metadata.get("version", {"api_level": 0})
77 self.version = Version(**version)
7678 self.types = types
77 self.api = RemoteApi(self, 'vim_')
78 self.vars = RemoteMap(self, 'vim_get_var', 'vim_set_var')
79 self.api = RemoteApi(self, 'nvim_')
80 self.vars = RemoteMap(self, 'nvim_get_var', 'nvim_set_var')
7981 self.vvars = RemoteMap(self, 'vim_get_vvar', None)
80 self.options = RemoteMap(self, 'vim_get_option', 'vim_set_option')
82 self.options = RemoteMap(self, 'nvim_get_option', 'nvim_set_option')
8183 self.buffers = Buffers(self)
82 self.windows = RemoteSequence(self, 'vim_get_windows')
83 self.tabpages = RemoteSequence(self, 'vim_get_tabpages')
84 self.windows = RemoteSequence(self, 'nvim_list_wins')
85 self.tabpages = RemoteSequence(self, 'nvim_list_tabpages')
8486 self.current = Current(self)
8587 self.session = CompatibilitySession(self)
8688 self.funcs = Funcs(self)
115117
116118 is equivalent to
117119
118 vim.request('vim_err_write', 'ERROR\n', async=True)
119 vim.request('buffer_get_mark', vim.current.buffer, '.')
120 vim.request('nvim_err_write', 'ERROR\n', async=True)
121 vim.request('nvim_buf_get_mark', vim.current.buffer, '.')
120122
121123
122124 Normally a blocking request will be sent. If the `async` flag is
156158 result = request_cb(name, args)
157159 except Exception:
158160 msg = ("error caught in request handler '{} {}'\n{}\n\n"
159 .format(name, args, format_exc_skip(1, 5)))
161 .format(name, args, format_exc_skip(1)))
160162 self._err_cb(msg)
161163 raise
162164 return walk(self._to_nvim, result)
168170 notification_cb(name, args)
169171 except Exception:
170172 msg = ("error caught in notification handler '{} {}'\n{}\n\n"
171 .format(name, args, format_exc_skip(1, 5)))
173 .format(name, args, format_exc_skip(1)))
172174 self._err_cb(msg)
173175 raise
174176
204206
205207 def subscribe(self, event):
206208 """Subscribe to a Nvim event."""
207 return self.request('vim_subscribe', event)
209 return self.request('nvim_subscribe', event)
208210
209211 def unsubscribe(self, event):
210212 """Unsubscribe to a Nvim event."""
211 return self.request('vim_unsubscribe', event)
213 return self.request('nvim_unsubscribe', event)
212214
213215 def command(self, string, **kwargs):
214216 """Execute a single ex command."""
215 return self.request('vim_command', string, **kwargs)
217 return self.request('nvim_command', string, **kwargs)
216218
217219 def command_output(self, string):
218220 """Execute a single ex command and return the output."""
219 return self.request('vim_command_output', string)
221 return self.request('nvim_command_output', string)
220222
221223 def eval(self, string, **kwargs):
222224 """Evaluate a vimscript expression."""
223 return self.request('vim_eval', string, **kwargs)
225 return self.request('nvim_eval', string, **kwargs)
224226
225227 def call(self, name, *args, **kwargs):
226228 """Call a vimscript function."""
227 return self.request('vim_call_function', name, args, **kwargs)
229 return self.request('nvim_call_function', name, args, **kwargs)
228230
229231 def strwidth(self, string):
230232 """Return the number of display cells `string` occupies.
231233
232234 Tab is counted as one cell.
233235 """
234 return self.request('vim_strwidth', string)
236 return self.request('nvim_strwidth', string)
235237
236238 def list_runtime_paths(self):
237239 """Return a list of paths contained in the 'runtimepath' option."""
238 return self.request('vim_list_runtime_paths')
240 return self.request('nvim_list_runtime_paths')
239241
240242 def foreach_rtp(self, cb):
241243 """Invoke `cb` for each path in 'runtimepath'.
245247 are no longer paths. If stopped in case callable returned non-None,
246248 vim.foreach_rtp function returns the value returned by callable.
247249 """
248 for path in self.request('vim_list_runtime_paths'):
250 for path in self.request('nvim_list_runtime_paths'):
249251 try:
250252 if cb(path) is not None:
251253 break
255257 def chdir(self, dir_path):
256258 """Run os.chdir, then all appropriate vim stuff."""
257259 os_chdir(dir_path)
258 return self.request('vim_change_directory', dir_path)
260 return self.request('nvim_set_current_dir', dir_path)
259261
260262 def feedkeys(self, keys, options='', escape_csi=True):
261263 """Push `keys` to Nvim user input buffer.
266268 - 't': Handle keys as if typed; otherwise they are handled as if coming
267269 from a mapping. This matters for undo, opening folds, etc.
268270 """
269 return self.request('vim_feedkeys', keys, options, escape_csi)
271 return self.request('nvim_feedkeys', keys, options, escape_csi)
270272
271273 def input(self, bytes):
272274 """Push `bytes` to Nvim low level input buffer.
276278 written(which can be less than what was requested if the buffer is
277279 full).
278280 """
279 return self.request('vim_input', bytes)
281 return self.request('nvim_input', bytes)
280282
281283 def replace_termcodes(self, string, from_part=False, do_lt=True,
282284 special=True):
297299
298300 def out_write(self, msg):
299301 """Print `msg` as a normal message."""
300 return self.request('vim_out_write', msg)
302 return self.request('nvim_out_write', msg)
301303
302304 def err_write(self, msg, **kwargs):
303305 """Print `msg` as an error message."""
304 return self.request('vim_err_write', msg, **kwargs)
306 return self.request('nvim_err_write', msg, **kwargs)
305307
306308 def quit(self, quit_command='qa!'):
307309 """Send a quit command to Nvim.
338340 fn(*args, **kwargs)
339341 except Exception as err:
340342 msg = ("error caught while executing async callback:\n"
341 "{0!r}\n{1}\n \nthe call was requested at\n{2}"
342 .format(err, format_exc_skip(1, 5), call_point))
343 "{!r}\n{}\n \nthe call was requested at\n{}"
344 .format(err, format_exc_skip(1), call_point))
343345 self._err_cb(msg)
344346 raise
345347 self._session.threadsafe_call(handler)
358360
359361 def __init__(self, nvim):
360362 """Initialize a Buffers object with Nvim object `nvim`."""
361 self._fetch_buffers = nvim.api.get_buffers
363 self._fetch_buffers = nvim.api.list_bufs
362364
363365 def __len__(self):
364366 """Return the count of buffers."""
398400
399401 @property
400402 def line(self):
401 return self._session.request('vim_get_current_line')
403 return self._session.request('nvim_get_current_line')
402404
403405 @line.setter
404406 def line(self, line):
405 return self._session.request('vim_set_current_line', line)
407 return self._session.request('nvim_set_current_line', line)
406408
407409 @property
408410 def buffer(self):
409 return self._session.request('vim_get_current_buffer')
411 return self._session.request('nvim_get_current_buf')
410412
411413 @buffer.setter
412414 def buffer(self, buffer):
413 return self._session.request('vim_set_current_buffer', buffer)
415 return self._session.request('nvim_set_current_buf', buffer)
414416
415417 @property
416418 def window(self):
417 return self._session.request('vim_get_current_window')
419 return self._session.request('nvim_get_current_win')
418420
419421 @window.setter
420422 def window(self, window):
421 return self._session.request('vim_set_current_window', window)
423 return self._session.request('nvim_set_current_win', window)
422424
423425 @property
424426 def tabpage(self):
425 return self._session.request('vim_get_current_tabpage')
427 return self._session.request('nvim_get_current_tabpage')
426428
427429 @tabpage.setter
428430 def tabpage(self, tabpage):
429 return self._session.request('vim_set_current_tabpage', tabpage)
431 return self._session.request('nvim_set_current_tabpage', tabpage)
430432
431433
432434 class Funcs(object):
+9
-4
neovim/api/tabpage.py less more
77 class Tabpage(Remote):
88 """A remote Nvim tabpage."""
99
10 _api_prefix = "tabpage_"
10 _api_prefix = "nvim_tabpage_"
1111
1212 def __init__(self, *args):
1313 """Initialize from session and code_data immutable object.
1616 msgpack-rpc calls. It must be immutable for Buffer equality to work.
1717 """
1818 super(Tabpage, self).__init__(*args)
19 self.windows = RemoteSequence(self, 'tabpage_get_windows')
19 self.windows = RemoteSequence(self, 'nvim_tabpage_list_wins')
2020
2121 @property
2222 def window(self):
2323 """Get the `Window` currently focused on the tabpage."""
24 return self.request('tabpage_get_window')
24 return self.request('nvim_tabpage_get_win')
2525
2626 @property
2727 def valid(self):
2828 """Return True if the tabpage still exists."""
29 return self.request('tabpage_is_valid')
29 return self.request('nvim_tabpage_is_valid')
30
31 @property
32 def number(self):
33 """Get the tabpage number."""
34 return self.request('nvim_tabpage_get_number')
+17
-12
neovim/api/window.py less more
88
99 """A remote Nvim window."""
1010
11 _api_prefix = "window_"
11 _api_prefix = "nvim_win_"
1212
1313 @property
1414 def buffer(self):
1515 """Get the `Buffer` currently being displayed by the window."""
16 return self.request('window_get_buffer')
16 return self.request('nvim_win_get_buf')
1717
1818 @property
1919 def cursor(self):
2020 """Get the (row, col) tuple with the current cursor position."""
21 return self.request('window_get_cursor')
21 return self.request('nvim_win_get_cursor')
2222
2323 @cursor.setter
2424 def cursor(self, pos):
2525 """Set the (row, col) tuple as the new cursor position."""
26 return self.request('window_set_cursor', pos)
26 return self.request('nvim_win_set_cursor', pos)
2727
2828 @property
2929 def height(self):
3030 """Get the window height in rows."""
31 return self.request('window_get_height')
31 return self.request('nvim_win_get_height')
3232
3333 @height.setter
3434 def height(self, height):
3535 """Set the window height in rows."""
36 return self.request('window_set_height', height)
36 return self.request('nvim_win_set_height', height)
3737
3838 @property
3939 def width(self):
4040 """Get the window width in rows."""
41 return self.request('window_get_width')
41 return self.request('nvim_win_get_width')
4242
4343 @width.setter
4444 def width(self, width):
4545 """Set the window height in rows."""
46 return self.request('window_set_width', width)
46 return self.request('nvim_win_set_width', width)
4747
4848 @property
4949 def row(self):
5050 """0-indexed, on-screen window position(row) in display cells."""
51 return self.request('window_get_position')[0]
51 return self.request('nvim_win_get_position')[0]
5252
5353 @property
5454 def col(self):
5555 """0-indexed, on-screen window position(col) in display cells."""
56 return self.request('window_get_position')[1]
56 return self.request('nvim_win_get_position')[1]
5757
5858 @property
5959 def tabpage(self):
6060 """Get the `Tabpage` that contains the window."""
61 return self.request('window_get_tabpage')
61 return self.request('nvim_win_get_tabpage')
6262
6363 @property
6464 def valid(self):
6565 """Return True if the window still exists."""
66 return self.request('window_is_valid')
66 return self.request('nvim_win_is_valid')
67
68 @property
69 def number(self):
70 """Get the window number."""
71 return self.request('nvim_win_get_number')
+2
-2
neovim/msgpack_rpc/event_loop/base.py less more
8484 self._on_data = None
8585 self._error = None
8686 self._init()
87 getattr(self, '_connect_{0}'.format(transport_type))(*args)
87 getattr(self, '_connect_{}'.format(transport_type))(*args)
8888 self._start_reading()
8989
9090 def connect_tcp(self, address, port):
148148 debug('Stopped event loop')
149149
150150 def _on_signal(self, signum):
151 msg = 'Received {0}'.format(self._signames[signum])
151 msg = 'Received {}'.format(self._signames[signum])
152152 debug(msg)
153153 if signum == signal.SIGINT and self._transport_type == 'stdio':
154154 # When the transport is stdio, we are probably running as a Nvim
+2
-2
neovim/msgpack_rpc/event_loop/uv.py less more
2020 def _on_connect(self, stream, error):
2121 self.stop()
2222 if error:
23 msg = 'Cannot connect to {0}: {1}'.format(
23 msg = 'Cannot connect to {}: {}'.format(
2424 self._connect_address, pyuv.errno.strerror(error))
2525 self._connection_error = IOError(msg)
2626 return
4848
4949 def _connect_tcp(self, address, port):
5050 stream = pyuv.TCP(self._loop)
51 self._connect_address = '{0}:{1}'.format(address, port)
51 self._connect_address = '{}:{}'.format(address, port)
5252 stream.connect((address, port), self._on_connect)
5353
5454 def _connect_socket(self, path):
+3
-3
neovim/msgpack_rpc/session.py less more
8181 return
8282
8383 if kwargs:
84 raise ValueError("request got unsupported keyword argument(s): {0}"
84 raise ValueError("request got unsupported keyword argument(s): {}"
8585 .format(', '.join(kwargs.keys())))
8686
8787 if self._is_running:
121121 gr.switch()
122122
123123 if self._setup_exception:
124 error('Setup error: {0}'.format(self._setup_exception))
124 error('Setup error: {}'.format(self._setup_exception))
125125 raise self._setup_exception
126126
127127 # Process all pending requests and notifications
128128 while self._pending_messages:
129129 msg = self._pending_messages.popleft()
130 getattr(self, '_on_{0}'.format(msg[0]))(*msg[1:])
130 getattr(self, '_on_{}'.format(msg[0]))(*msg[1:])
131131 self._async_session.run(self._on_request, self._on_notification)
132132 self._is_running = False
133133 self._request_cb = None
+3
-3
neovim/plugin/decorators.py less more
4545 register=False, sync=False, eval=None):
4646 """Tag a function or plugin method as a Nvim command handler."""
4747 def dec(f):
48 f._nvim_rpc_method_name = 'command:{0}'.format(name)
48 f._nvim_rpc_method_name = 'command:{}'.format(name)
4949 f._nvim_rpc_sync = sync
5050 f._nvim_bind = True
5151 f._nvim_prefix_plugin_path = True
8585 def autocmd(name, pattern='*', sync=False, eval=None):
8686 """Tag a function or plugin method as a Nvim autocommand handler."""
8787 def dec(f):
88 f._nvim_rpc_method_name = 'autocmd:{0}:{1}'.format(name, pattern)
88 f._nvim_rpc_method_name = 'autocmd:{}:{}'.format(name, pattern)
8989 f._nvim_rpc_sync = sync
9090 f._nvim_bind = True
9191 f._nvim_prefix_plugin_path = True
110110 def function(name, range=False, sync=False, eval=None):
111111 """Tag a function or plugin method as a Nvim function handler."""
112112 def dec(f):
113 f._nvim_rpc_method_name = 'function:{0}'.format(name)
113 f._nvim_rpc_method_name = 'function:{}'.format(name)
114114 f._nvim_rpc_sync = sync
115115 f._nvim_bind = True
116116 f._nvim_prefix_plugin_path = True
+7
-7
neovim/plugin/host.py less more
7070 except Exception:
7171 if sync:
7272 msg = ("error caught in request handler '{} {}':\n{}"
73 .format(name, args, format_exc_skip(1, 5)))
73 .format(name, args, format_exc_skip(1)))
7474 raise ErrorResponse(msg)
7575 else:
7676 msg = ("error caught in async handler '{} {}'\n{}\n"
77 .format(name, args, format_exc_skip(1, 5)))
77 .format(name, args, format_exc_skip(1)))
7878 self._on_async_err(msg + "\n")
7979
8080 def _on_request(self, name, args):
119119 for path in plugins:
120120 err = None
121121 if path in self._loaded:
122 error('{0} is already loaded'.format(path))
122 error('{} is already loaded'.format(path))
123123 continue
124124 try:
125125 if path == "script_host.py":
132132 self._discover_classes(module, handlers, path)
133133 self._discover_functions(module, handlers, path)
134134 if not handlers:
135 error('{0} exports no handlers'.format(path))
135 error('{} exports no handlers'.format(path))
136136 continue
137137 self._loaded[path] = {'handlers': handlers, 'module': module}
138138 except Exception as e:
178178
179179 method = fn._nvim_rpc_method_name
180180 if fn._nvim_prefix_plugin_path:
181 method = '{0}:{1}'.format(plugin_path, method)
181 method = '{}:{}'.format(plugin_path, method)
182182
183183 fn_wrapped = functools.partial(self._wrap_function, fn,
184184 sync, decode, nvim_bind, method)
186186 # register in the rpc handler dict
187187 if sync:
188188 if method in self._request_handlers:
189 raise Exception(('Request handler for "{0}" is ' +
189 raise Exception(('Request handler for "{}" is ' +
190190 'already registered').format(method))
191191 self._request_handlers[method] = fn_wrapped
192192 else:
193193 if method in self._notification_handlers:
194 raise Exception(('Notification handler for "{0}" is ' +
194 raise Exception(('Notification handler for "{}" is ' +
195195 'already registered').format(method))
196196 self._notification_handlers[method] = fn_wrapped
197197 if hasattr(fn, '_nvim_rpc_spec'):
+7
-11
neovim/plugin/script_host.py less more
9595 self._set_current_range(start, stop)
9696 nvim = self.nvim
9797 start -= 1
98 stop -= 1
9998 fname = '_vim_pydo'
10099
101100 # define the function
103102 exec(function_def, self.module.__dict__)
104103 # get the function
105104 function = self.module.__dict__[fname]
106 while start <= stop:
105 while start < stop:
107106 # Process batches of 5000 to avoid the overhead of making multiple
108107 # API calls for every line. Assuming an average line length of 100
109108 # bytes, approximately 488 kilobytes will be transferred per batch,
110109 # which can be done very quickly in a single API call.
111110 sstart = start
112111 sstop = min(start + 5000, stop)
113 lines = nvim.current.buffer.get_line_slice(sstart, sstop, True,
114 True)
112 lines = nvim.current.buffer.api.get_lines(sstart, sstop, True)
115113
116114 exception = None
117115 newlines = []
122120 # Update earlier lines, and skip to the next
123121 if newlines:
124122 end = sstart + len(newlines) - 1
125 nvim.current.buffer.set_line_slice(sstart, end,
126 True, True,
127 newlines)
123 nvim.current.buffer.api.set_lines(sstart, end,
124 True, newlines)
128125 sstart += len(newlines) + 1
129126 newlines = []
130127 pass
137134 break
138135 linenr += 1
139136
140 start = sstop + 1
137 start = sstop
141138 if newlines:
142 end = sstart + len(newlines) - 1
143 nvim.current.buffer.set_line_slice(sstart, end, True, True,
144 newlines)
139 end = sstart + len(newlines)
140 nvim.current.buffer.api.set_lines(sstart, end, True, newlines)
145141 if exception:
146142 raise exception
147143 # delete the function
+20
-0
neovim/util.py less more
99 for i in range(skip):
1010 tb = tb.tb_next
1111 return ('\n'.join(format_exception(type, val, tb, limit))).rstrip()
12
13
14 # Taken from SimpleNamespace in python 3
15 class Version:
16
17 """Helper class for version info."""
18
19 def __init__(self, **kwargs):
20 """Create the Version object."""
21 self.__dict__.update(kwargs)
22
23 def __repr__(self):
24 """Return str representation of the Version."""
25 keys = sorted(self.__dict__)
26 items = ("{}={!r}".format(k, self.__dict__[k]) for k in keys)
27 return "{}({})".format(type(self).__name__, ", ".join(items))
28
29 def __eq__(self, other):
30 """Check if version is same as other."""
31 return self.__dict__ == other.__dict__
+1
-1
neovim.egg-info/PKG-INFO less more
00 Metadata-Version: 1.1
11 Name: neovim
2 Version: 0.1.10
2 Version: 0.1.11
33 Summary: Python client to neovim
44 Home-page: http://github.com/neovim/python-client
55 Author: Thiago de Arruda
+0
-1
neovim.egg-info/requires.txt less more
00 msgpack-python>=0.4.0
1 trollius
21 greenlet
+1
-1
setup.py less more
1818 install_requires.append('greenlet')
1919
2020 setup(name='neovim',
21 version='0.1.10',
21 version='0.1.11',
2222 description='Python client to neovim',
2323 url='http://github.com/neovim/python-client',
2424 download_url='https://github.com/neovim/python-client/archive/0.1.10.tar.gz',
+2
-2
test/test_buffer.py less more
8282 vim.current.buffer.api.set_var('myvar', 'thetext')
8383 eq(vim.current.buffer.api.get_var('myvar'), 'thetext')
8484 eq(vim.eval('b:myvar'), 'thetext')
85 vim.current.buffer.api.set_line_slice(0,-1,True,True,['alpha', 'beta'])
86 eq(vim.current.buffer.api.get_line_slice(0,-1,True,True), ['alpha', 'beta'])
85 vim.current.buffer.api.set_lines(0,-1,True,['alpha', 'beta'])
86 eq(vim.current.buffer.api.get_lines(0,-1,True), ['alpha', 'beta'])
8787 eq(vim.current.buffer[:], ['alpha', 'beta'])
8888
8989
+9
-0
test/test_tabpage.py less more
2727 ok(tabpage.valid)
2828 vim.command('tabclose')
2929 ok(not tabpage.valid)
30
31
32 @with_setup(setup=cleanup)
33 def test_number():
34 curnum = vim.current.tabpage.number
35 vim.command('tabnew')
36 eq(vim.current.tabpage.number, curnum + 1)
37 vim.command('tabnew')
38 eq(vim.current.tabpage.number, curnum + 2)
+9
-0
test/test_window.py less more
9393 ok(window.valid)
9494 vim.command('q')
9595 ok(not window.valid)
96
97
98 @with_setup(setup=cleanup)
99 def test_number():
100 curnum = vim.current.window.number
101 vim.command('bot split')
102 eq(vim.current.window.number, curnum + 1)
103 vim.command('bot split')
104 eq(vim.current.window.number, curnum + 2)