Skip to main content

Python implementation of the Joint Editors Protocol.

Project description

Build Status Coveralls Status PyPI Status

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:

Backend support

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]

    # ...

Frontend support

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))

Project details


Release history Release notifications

This version
History Node

0.5.5

Download files

Download the file for your platform. If you're not sure which to choose, learn more about installing packages.

Filename, size & hash SHA256 hash help File type Python version Upload date
jep_python-0.5.5-py3-none-any.whl (113.1 kB) Copy SHA256 hash SHA256 Wheel py3
jep-python-0.5.5.zip (36.2 kB) Copy SHA256 hash SHA256 Source None

Supported by

Elastic Elastic Search Pingdom Pingdom Monitoring Google Google BigQuery Sentry Sentry Error logging AWS AWS Cloud computing DataDog DataDog Monitoring Fastly Fastly CDN SignalFx SignalFx Supporter DigiCert DigiCert EV certificate StatusPage StatusPage Status page