Pusher Channels HTTP Python Library

This package lets you trigger events to your client and query the state of your channels. When used with a server, you can validate webhooks and authenticate private- or presence- channels.

In order to use this library, you need to have a free account on http://pusher.com. After registering, you will need the application credentials for your app.

Supported Platforms

• Python - supports Python versions 2.7, 3.6 and above

Features

• Adapters for various http libraries like requests, urlfetch, aiohttp (requires Python >= 3.5.3) and tornado.
• WebHook validation
• Signature generation for socket subscriptions

Table of Contents

• Installation
• Getting started
• Configuration
• Triggering Events
• Querying Application State
  • Getting Information For All Channels
  • Getting Information For A Specific Channel
  • Getting User Information For A Presence Channel
• Authenticating Channel Subscription
• Terminating User Connections
• End-to-end Encryption
• Receiving Webhooks
• Request Library Configuration
  • Google App Engine
• Feature Support
• Running the tests
• License

Installation

You can install this module using your package management method or choice, normally easy_install or pip. For example:

pip install pusher

Users on Python 2.x and older versions of pip may get a warning, due to pip compiling the optional pusher.aiohttp module, which uses Python 3 syntax. However, as pusher.aiohttp is not used by default, this does not affect the library's functionality. See our Github issue, as well as this issue from Gunicorn for more details.

On Linux, you must ensure that OpenSSL is installed, e.g. on Debian/Ubuntu:

$ sudo apt-get install build-essential libssl-dev libffi-dev

Getting started

The minimum configuration required to use the Pusher object are the three constructor arguments which identify your Pusher Channels app. You can find them by going to "API Keys" on your app at https://app.pusher.com.

import pusher
pusher_client = pusher.Pusher(app_id=u'4', key=u'key', secret=u'secret', cluster=u'cluster')

You can then trigger events to channels. Channel and event names may only contain alphanumeric characters, - and _:

pusher_client.trigger(u'a_channel', u'an_event', {u'some': u'data'})

Configuration

import pusher
pusher_client = pusher.Pusher(app_id, key, secret, cluster=u'cluster')

The constructor will throw a TypeError if it is called with parameters that don’t match the types listed above.

Example

import pusher
pusher_client = pusher.Pusher(app_id=u'4', key=u'key', secret=u'secret', ssl=True, cluster=u'cluster')

Triggering Events

To trigger an event on one or more channels, use the trigger method on the Pusher object.

Pusher::trigger

Pusher::trigger will throw a TypeError if called with parameters of the wrong type; or a ValueError if called on more than 100 channels, with an event name longer than 200 characters, or with more than 10240 characters of data (post JSON serialisation).

Example

This call will trigger to 'a_channel' and 'another_channel', and exclude the recipient with socket_id "1234.12".

pusher_client.trigger([u'a_channel', u'another_channel'], u'an_event', {u'some': u'data'}, "1234.12")

Pusher::trigger_batch

It's also possible to send distinct messages in batches to limit the overhead of HTTP headers. There is a current limit of 10 events per batch on our multi-tenant clusters.

Events are a Dict with keys:

Pusher::trigger_batch will throw a TypeError if the data parameter is not JSONable.

Example

pusher_client.trigger_batch([
  { u'channel': u'a_channel', u'name': u'an_event', u'data': {u'some': u'data'}, u'socket_id': '1234.12'},
  { u'channel': u'a_channel', u'name': u'an_event', u'data': {u'some': u'other data'}}
])

Querying Application State

Getting Information For All Channels

Pusher::channels_info

Pusher::channels_info will throw a TypeError if prefix_filter is not a String.

Example

channels = pusher_client.channels_info(u"presence-", [u'user_count'])

#=> {u'channels': {u'presence-chatroom': {u'user_count': 2}, u'presence-notifications': {u'user_count': 1}}}

Getting Information For A Specific Channel

Pusher::channel_info

Pusher::channel_info will throw a ValueError if channel is not a valid channel.

Example

channel = pusher_client.channel_info(u'presence-chatroom', [u"user_count"])
#=> {u'user_count': 42, u'occupied': True}

Getting User Information For A Presence Channel

Pusher::users_info

Pusher::users_info will throw a ValueError if channel is not a valid channel.

Example

pusher_client.users_info(u'presence-chatroom')
#=> {u'users': [{u'id': u'1035'}, {u'id': u'4821'}]}

Authenticating Channel Subscription

Pusher::authenticate

In order for users to subscribe to a private- or presence-channel, they must be authenticated by your server.

The client will make a POST request to an endpoint (either "/pusher/auth" or any which you specify) with a body consisting of the channel's name and socket_id.

Using your Pusher instance, with which you initialized Pusher, you can generate an authentication signature. Having responded to the request with this signature, the subscription will be authenticated.

Pusher::authenticate will throw a ValueError if the channel or socket_id that it’s called with are invalid.

Example

Private Channels

auth = pusher_client.authenticate(

  channel=u"private-channel",

  socket_id=u"1234.12"
)
# return `auth` as a response

Presence Channels

auth = pusher_client.authenticate(

  channel=u"presence-channel",

  socket_id=u"1234.12",

  custom_data={
    u'user_id': u'1',
    u'user_info': {
      u'twitter': '@pusher'
    }
  }
)
# return `auth` as a response

Terminating user connections

TIn order to terminate a user's connections, the user must have been authenticated. Check the Server user authentication docs for the information on how to create a user authentication endpoint.

To terminate all connections established by a given user, you can use the terminate_user_connections function:

pusher_client.terminate_user_connections(userId)

Please note, that it only terminates the user's active connections. This means, if nothing else is done, the user will be able to reconnect. For more information see: Terminating user connections docs.

End to End Encryption

This library supports end to end encryption of your private channels. This means that only you and your connected clients will be able to read your messages. Pusher cannot decrypt them. You can enable this feature by following these steps:

1. You should first set up Private channels. This involves creating an authentication endpoint on your server.

2. Next, generate a 32 byte master encryption key, base64 encode it and store it securely.

   This is secret and you should never share this with anyone. Not even Pusher.

   To generate a suitable key from a secure random source, you could use:

   openssl rand -base64 32

3. Pass your master key to the SDK constructor

   import pusher
   
   pusher_client = pusher.Pusher(
     app_id='yourappid',
     key='yourkey',
     secret='yoursecret',
     encryption_master_key_base64='<output from command above>',
     cluster='yourclustername',
     ssl=True
   )
   
   pusher_client.trigger('private-encrypted-my-channel', 'my-event', {
     'message': 'hello world'
   })

4. Channels where you wish to use end to end encryption must be prefixed with private-encrypted-.

5. Subscribe to these channels in your client, and you're done! You can verify it is working by checking out the debug console on the https://dashboard.pusher.com/ and seeing the scrambled ciphertext.

Important note: This will not encrypt messages on channels that are not prefixed by private-encrypted-.

More info on End-to-end Encrypted Channels here.

Receiving Webhooks

If you have webhooks set up to POST a payload to a specified endpoint, you may wish to validate that these are actually from Pusher. The Pusher object achieves this by checking the authentication signature in the request body using your application credentials.

Pusher::validate_webhook

Pusher::validate_webhook will raise a TypeError if it is called with any parameters of the wrong type.

Example

webhook = pusher_client.validate_webhook(

  key="key_sent_in_header",

  signature="signature_sent_in_header",

  body="{ \"time_ms\": 1327078148132  \"events\": [ { \"name\": \"event_name\", \"some\": \"data\" }  ]}"
)

print webhook["events"]

Request Library Configuration

Users can configure the library to use different backends to send calls to our API. The HTTP libraries we support are:

• Requests (pusher.requests.RequestsBackend). This is used by default.
• Tornado (pusher.tornado.TornadoBackend).
• AsyncIO (pusher.aiohttp.AsyncIOBackend).
• Google App Engine (pusher.gae.GAEBackend).

Upon initializing a Pusher instance, pass in any of these options to the backend keyword argument.

Google App Engine

GAE users are advised to use the pusher.gae.GAEBackend backend to ensure compatability.

Feature Support

Helper Functionality

These are helpers that have been implemented to to ensure interactions with the HTTP API only occur if they will not be rejected e.g. channel naming conventions.

Running the tests

To run the tests run python setup.py test

License

Copyright (c) 2015 Pusher Ltd. See LICENSE for details.