Autobahn|Python

   

Autobahn|Python is a subproject of Autobahn and provides open-source implementations of

• The WebSocket Protocol
• The Web Application Messaging Protocol (WAMP)

in Python running on Twisted and asyncio.

You can use Autobahn|Python to create clients and servers in Python speaking just plain WebSocket or WAMP.

WebSocket allows bidirectional real-time messaging on the Web and WAMP adds asynchronous Remote Procedure Calls and Publish & Subscribe on top of WebSocket.

WAMP provides asynchronous Remote Procedure Calls and Publish & Subscribe for applications in one protocol running over WebSocket (and fallback transports for old browsers).

It is ideal for distributed, multi-client and server applications, such as multi-user database-drive business applications, sensor networks (IoT), instant messaging or MMOGs (massively multi-player online games) .

WAMP enables application architectures with application code distributed freely across processes and devices according to functional aspects. Since WAMP implementations exist for multiple languages, WAMP applications can be polyglott. Application components can be implemented in a language and run on a device which best fit the particular use case.

Show me some code

A simple WebSocket echo server:

class MyServerProtocol(WebSocketServerProtocol):

   def onConnect(self, request):
      print("Client connecting: {}".format(request.peer))

   def onOpen(self):
      print("WebSocket connection open.")

   def onMessage(self, payload, isBinary):
      if isBinary:
         print("Binary message received: {} bytes".format(len(payload)))
      else:
         print("Text message received: {}".format(payload.decode('utf8')))

      ## echo back message verbatim
      self.sendMessage(payload, isBinary)

   def onClose(self, wasClean, code, reason):
      print("WebSocket connection closed: {}".format(reason))

... and a sample WAMP application component:

class MyComponent(ApplicationSession):

   def onConnect(self):
      self.join("realm1")


   @inlineCallbacks
   def onJoin(self, details):

      # 1) subscribe to a topic
      def onevent(msg):
         print("Got event: {}".format(msg))

      yield self.subscribe(onevent, 'com.myapp.hello')

      # 2) publish an event
      self.publish('com.myapp.hello', 'Hello, world!')

      # 3) register a procedure for remoting
      def add2(x, y):
         return x + y

      self.register(add2, 'com.myapp.add2');

      # 4) call a remote procedure
      res = yield self.call('com.myapp.add2', 2, 3)
      print("Got result: {}".format(res))

Features

• framework for WebSocket / WAMP clients and servers
• compatible with Python 2.6, 2.7, 3.3 and 3.4
• runs on CPython, PyPy and Jython
• runs under Twisted and asyncio
• implements WebSocket RFC6455, Draft Hybi-10+, Hixie-76
• implements WebSocket compression
• implements WAMPv1 and WAMPv2 (upcoming)
• high-performance, fully asynchronous implementation
• best-in-class standards conformance (100% strict passes with Autobahn Testsuite)
• message-, frame- and streaming-APIs for WebSocket
• supports TLS (secure WebSocket) and proxies
• Open-source (Apache 2 license)

More Information

For more information, take a look at the project documentation. This provides:

• installation instructions
• a list of all examples in this repo
• an introduction to WebSocket programming
• an introduction to WAMP programming
• a full API reference

Get in touch

Get in touch on IRC #autobahn on chat.freenode.net, follow us on Twitter or join the mailing list.