Skip to main content

Python implementation of SPORE

Project description

Britney is a module that implements the SPORE specification. It is based on Spyre. This module requires a SPORE description of an API. Some descriptions for known services are available here. You can write your own with this guide. Code Health Python Version


Britney is working under Python 2.7 and Python >= 3.2. To install the module, you should use pip or easy_install :

$> pip install britney


$> easy_install britney

Create your client


You must create your client with the new method that reads a json file containing the API description or an URI exposing the description. This can be done like that :

import britney

# from a description file
client ='/path/to/api_desc.json')

# from an URI
client ='http://my-server/ws/api_desc.json')

The base URL

If your API description file doesn’t specify the base URL of the service, you can pass it to the new as the named argument base_url :

import britney

client ='/path/to/api_desc.json', base_url='http://my-server/ws/api/')


Sometimes, services need credentials to let you access the data or even send data. The client you created can enable middlewares at runtime and also extend his usage, by doing this :

import britney
from britney.middleware import auth

client ='http://my-server/ws/api_desc.json')
client.enable(auth.Basic, username='login', password='xxxxxx')

Sometimes, you want to enable middlewares on certain conditions. Another method called enable_if can take a callable predicate as argument that can check the environment parameters of the request :

import britney
from britney.middleware import auth

client ='http://my-server/ws/api_desc.json')
client.enable_if(lambda request: request['payload'] != '', auth.Basic, username='login', password='xxxxxx')

Use your client

Access data

Send data

A full example

Create your own middleware


Creating and enabling middlewares let you control how request are send or response are received by adding authentification or formatting data. To create your middleware, you should :

  • inherit from britney.middleware.Middleware

  • define how to instantiate your middleware

  • implement the process_request method to process the request

  • implement the process_response method to process the response

Here is a base class example to perform runtime on request :

from britney.middleware import Middleware

class Runtime(Middleware):

    def __init__(self, runtime_header):
        self.runtime_header  = runtime_header

    def process_request(self, environ):

    def process_response(self, response):

Processing request

With this method, you can access all of the keys and values of the request’s base environment. By the way, you can add keys and values, change them or even delete them. Most of time, this method doesn’t return data but if you return a requests.Response object, the process will stop and return this response. The result environment data will be used to build the request :

import datetime


def process_request(self, environ):
    self.start_time =
    environ[self.runtime_key] = 0

Processing response

With this method, you can access data from the response, change or format content or even check headers or status :


def process_response(self, reponse):
    request_time = - self.start_time
    response.environ[self.runtime_key] = self.request_time.seconds

Use it

When you create your client, you only should enable your middleware and pass appopriate named arguments to the enable method :

import britney
from your_module.middleware import Runtime

client ='http:://')
client.enable(Runtime, runtime_key='X-Spore-Runtime')

That’s all !

Test it

A mock middleware and a function to fake Requests response are available to test the middlewares you created by faking a server. To test the Runtime middleware, you can do as follow :

import datetime
import unittest
import britney
from britney.middleware import utils
from your_module.middleware import Runtime

def test_response(request):
    return utils.fake_response(request, 'OK')

class TestRuntime(unittest.TestCase):

    def setUp(self):
        self.fake_server = {'/test', test_response}
        self.client ='/path/to/api.json')
        self.runtime_key = 'X-Spore-Runtime'

    def test_runtime(self):
        self.client.enable(Runtime, runtime_header=self.runtime_header)
        self.client.enable(utils.Mock, fakes=self.fake_server, middlewares=self.client.middlewares)
        start =
        result = self.client.test()
        stop =

        self.assertIn(result.environ, self.runtime_key)
        self.assertAlmostEqual(result.environ[self.runtime_key], (stop - start).seconds)

Project details

Download files

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

Source Distribution

britney-0.5.1.tar.gz (11.4 kB view hashes)

Uploaded source

Built Distribution

britney-0.5.1-py2.py3-none-any.whl (16.7 kB view hashes)

Uploaded py2 py3

Supported by

AWS AWS Cloud computing and Security Sponsor Datadog Datadog Monitoring Fastly Fastly CDN Google Google Download Analytics Microsoft Microsoft PSF Sponsor Pingdom Pingdom Monitoring Sentry Sentry Error logging StatusPage StatusPage Status page