hl037
commented
2 years ago While digging in UltiSnips code, I remarked that a lot of stuff are simply hacks because vim would not respond immediately to change from python.
Came to me an idea : Why not use co-routines ?
Here are some point on it :
1) (Golden rule) ONLY 1 co-routine should be executing at once, other thing would only be event handling/dispatching (The goal is not doing async tasks, but only use they ability to be paused and resumed).
2) All function/methods of Ultisnips are marked async
3) All SnippetManager methods are wrapped by a non-async function that would handle the async part (This way, the vim part does not need changes, since it still work with non-async code).
4) An "async vim_dispatch()" function is created (see below for the implementation). This function permits to pause the python code until vim dispatches its own event queue and then resume.
Implementation
The vim_dispatch would actually be rather simple : it would simply call vim.command('call UltiSnips#Reenter()')
and await a future.
Here is a POC :
import asyncio
import nest_asyncio # needed because of some silly closed-minded people... https://bugs.python.org/issue22239#msg225883
nest_asyncio.apply()
loop = asyncio.new_event_loop()
class VimResumed():
slingleton = None
resumable = None
def __init__(self):
self.fut = loop.create_future()
async def wait(self):
# vim.command('call UltiSnips#resume()')
print('call UltiSnips#resume()')
self.resumable.fut.set_result(True)
print('WAITING FOR VIM...')
await self.fut
def resume(self):
self.fut.set_result(True)
self.resumable.resume()
@classmethod
def init(cls):
cls.singleton = cls()
VimResumed.init()
async def vim_resumed():
await VimResumed.singleton.wait()
def resume():
VimResumed.singleton.resume()
class Resumeable():
def __init__(self, fn, *args, **kwargs):
self.fn = fn
self.args = args
self.kwargs = kwargs
loop.create_task(self._exec_or_wait())
self.resume()
def resume(self):
self.fut = loop.create_future()
try:
running_loop = asyncio.get_running_loop()
except:
running_loop = None
asyncio.set_event_loop(loop)
try:
loop.run_until_complete(self._wait())
#loop.create_task(self._wait())
#loop.run_forever()
finally:
if running_loop is not None:
asyncio.set_event_loop(running_loop)
async def _wait(self):
await self.fut
async def _exec_or_wait(self):
VimResumed.resumable = self
await self.fn(*self.args, **self.kwargs)
if not self.fut.done():
self.fut.set_result(True)
VimResumed.resumable = None
def non_async_wrapper(fn):
def main(*args, **kwargs):
Resumeable(fn, *args, **kwargs)
return main
@non_async_wrapper
async def fn():
print('WAITING')
await vim_resumed()
print('RESUMED')
print('DONE')
print('START')
fn()
print('VIM DOES ITS STUFF')
resume()
print('ENDED')
...Note that next-asyncio is a single file, BSD-2 so it could be provided directly inside Ultisnips, or cloned as a git submodule
SirVer
rebelot
I would like to open a thread for some suggestions I would have for a future UltiSnips Version.
This is definitively not a roadmap nor some feature request, just some idea I would love to debate... Even if they never get implemented