This is the Python implementation of the Joint Editors Protocol (JEP), see http://joint-editors.org/ for more information. jep-python is providing language authors with a frontend library for IDE/editor integration and a backend library for language support.
This implementation is currently compatible with Python 3.3+.
Look at these associated projects for examples of productive use of the library:
- Frontend used in Sublime editor: https://github.com/jep-project/jep-sublime
- Backend used for improved CMake language support: https://github.com/jep-project/jep-cmake
Implementing JEP based support for a custom language is easy. Simply derive one or more listener classes to respond to frontend messages and then run the backend with those listeners.
from jep_py.backend import Backend, FrontendListener
class Listener(FrontendListener):
def on_completion_request(self, completion_request, context):
# process completion request and send back response:
completion_response = f(completion_request)
context.send_message(completion_response)
# instantiate and start backend service with our listeners:
listener = Listener()
backend = Backend([listener])
backend.start()
Callbacks that are not needed by a certain listener do not need to be overridden in the derived class.
While the user is editing a file in a connected IDE the frontend will
repeatedly send ContentSync
objects to the backend. The backend
implementation already processes these messages internally and provides
an accumulated file view to client code. Since backend-internal message
processing is done before messages are passed to subscribed listeners,
you can process the latest view of a file directly inside your
listener's handler of ContentSync
by accessing the context's
content_monitor
filepath dictionary:
def on_content_sync(self, content_sync, context):
# get the content monitor's view of the file that was just updated:
file_content = context.content_monitor[content_sync.file]
# ...
Similarly in an IDE frontend you again derive listener classes, this time listening to backend messages. Since the frontend initiates the connection you additionally have to create such a connection for a certain language. JEP service lookup is then used to determine the supporting backend and the frontend will start it in its own subprocess.
Here is an example shutting down the backend service upon reception of its first alive message:
import datetime
from jep_py.frontend import Frontend, BackendListener, State
from jep_py.schema import Shutdown
class MyListener(BackendListener):
def on_backend_alive(self, context):
context.send_message(Shutdown())
frontend = Frontend([MyListener()])
connection = frontend.get_connection('localfile.mydsl')
while connection.state is not State.Disconnected:
connection.run(datetime.timedelta(seconds=0.1))