This is a pre-production deployment of Warehouse, however changes made here WILL affect the production instance of PyPI.
Latest Version Dependencies status unknown Test status unknown Test coverage unknown
Project Description

This is the Python implementation of the Joint Editors Protocol (JEP), see 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)

# instantiate and start backend service with our listeners:
listener = Listener()
backend = Backend([listener])

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

frontend = Frontend([MyListener()])
connection = frontend.get_connection('localfile.mydsl')

while connection.state is not State.Disconnected:
Release History

Release History


This version

History Node

TODO: Figure out how to actually get changelog content.

Changelog content for this version goes here.

Donec et mollis dolor. Praesent et diam eget libero egestas mattis sit amet vitae augue. Nam tincidunt congue enim, ut porta lorem lacinia consectetur. Donec ut libero sed arcu vehicula ultricies a non tortor. Lorem ipsum dolor sit amet, consectetur adipiscing elit.

Show More

Download Files

Download Files

TODO: Brief introduction on what you do with files - including link to relevant help section.

File Name & Checksum SHA256 Checksum Help Version File Type Upload Date
jep_python-0.5.5-py3-none-any.whl (113.1 kB) Copy SHA256 Checksum SHA256 py3 Wheel Jan 5, 2016 (36.2 kB) Copy SHA256 Checksum SHA256 Source Jan 5, 2016

Supported By

WebFaction WebFaction Technical Writing Elastic Elastic Search Pingdom Pingdom Monitoring Dyn Dyn DNS HPE HPE Development Sentry Sentry Error Logging CloudAMQP CloudAMQP RabbitMQ Heroku Heroku PaaS Kabu Creative Kabu Creative UX & Design Fastly Fastly CDN DigiCert DigiCert EV Certificate Rackspace Rackspace Cloud Servers DreamHost DreamHost Log Hosting