Skip to main content

A trading system building blocks

Project description


Automated quantitative trading system kit, for hackers

.. figure::
:alt: Dashboard


**Intuition** is an engine, some building bricks and a set of tools
meant to let you efficiently and intuitively make your own **automated
quantitative trading system**. It is designed to let traders, developers
and scientists explore, improve and deploy market technical hacks.

While the project is still at an early stage, you can already write,
use, combine **signal detection algorithms, portfolio allocation
strategies, data sources and contexts configurators**. Just plug your
strategies and analyze **backtests** or monitor **live trading

In addition I work on facilities to build a distributed system and 21st
century application (big data, fat computations, d3.js and other html5
stuff), tools to mix languages like Python, node.js and R and a
financial library. You will find some goodies like machine learning
forecast, markowitz portfolio optimization, genetic optimization,
sentiment analysis from twitter, ...


- Highly configurable trading environment, powered by
`zipline <>`__
- From instant kickstart to full control
- Made to let you tweak algorithms, portfolio manager, data sources,
contexts and plugins
- Already includes many
- Experimental live trading on different markets (Nyse, Nasdaq, CAC40
and Forex for now)
- Experimental R integration in your algorithms
- Results analyser
- Mail and Android notifications (for now with the help of freely
available `NotifyMyAndroid <>`__ or
`PushBullet <>`__)
- Financial library, with common used trading functions, data fetchers,
... used for example to solve Coursera econometrics assignments
- Easy to use data management, powered by `rethinkdb <>`__
- `Docker <>`__ support for development workflow and
- Kind of a CI showcase as I am testing
`travis <>`__, `wercker <>`__,
`shippable <>`__, ` <>`__,
`coveralls <>`__ and `landscape <>`__


.. raw:: html

<!--[![wercker status]( "wercker status")](>

|wercker status| |Build Status| |Build Status| |Coverage Status| |Code

**Attention** Project is in an *early alpha*, and under heavy
development. The new version 0.3.0 revises a lot of code :

- Algoithms, managers and data sources have their `own
repository <>`__
- More powerful API to build custom versions of them
- The context module now handles configuration
- `Shiny <>`__ interface,
`Dashboard <>`__ and
clustering will have their intuition-plugins repository (soon)
- ZeroMQ messaging is for now removed but might be back for inter-algo
- So is MySQL, that has been removed and will be re-implemented as a
plugin <>`__
- But currently it has been replaced by `Rethinkdb <>`__
- Installation is much simpler and a docker image is available for
development and deployment
- More intuitive configuration splitted between the context mentioned,
command line argument and environment variables
- And a lot (I mean A LOT) of house keeping and code desgin stuff


You are just a few steps away from algoritmic trading. Choose one of the
following installation method

- The usual way

.. code:: console

$ pip install intuition
$ # Optionnaly, install offcial algorithms, managers, ...
$ pip install insights

- One-liner for the full installation (i.e. with packages and buit-in
`modules <>`__)

.. code:: console

$ wget -qO- | sudo -E bash
$ # ... Go grab a coffee

- From source

.. code:: console

$ git clone
$ cd intuition && sudo make

- Sexy, early-adopter style

.. code:: console

$ docker pull hivetech/intuition

Getting started

Intuition wires 4 primitives to build up the system : A data source
generates events, processed by the algorithm, that can optionnaly use a
portfolio manager to compute assets allocation. They are configured
through a Context, while third party services use environment variables
(take a look in config/local.env).

The following example trades in real time forex, with a simple buy and
hold algorithm and a portfolio manager that allocates same amount for
each asset. Their configuration below is stored in a json file.

.. code:: console

$ intuition --context file::liveForex.json --id chuck --showlog

.. code:: json

id: "liveForex",
start: "2011-05-05",
end: "2013-10-05",
frequency: "day",
universe: "forex,5",
algorithm: {
save: false
manager: {
android: 0,
buy_scale: 150,
cash: 10000,
max_weight: 0.3,
perc_sell: 1,
sell_scale: 100
modules: {
context: "file",
algorithm: "algorithms.buyandhold.BuyAndHold",
data: "",
manager: "managers.fair.Fair"

Note that in the current implementation, Nasdaq, Nyse, Cac 40 and Forex
markets are available.

Alternatively you can use docker. Here we also fire up a
`rethinkdb <>`__ database to store portfolios while
trading, and `mongodb <>`__ to store

.. code:: console

$ docker run -d -name mongodb -p 27017:27017 -p 28017:28017 waitingkuo/mongodb

$ docker run -d -name rethinkdb crosbymichael/rethinkdb --bind all

$ docker run \
-e LOG=debug \
-e LANGUAGE="fr_FR.UTF-8" \
-e LANG="fr_FR.UTF-8" \
-e LC_ALL="fr_FR.UTF-8" \
-name trade_box hivetech/intuition \
intuition --context mongodb::${host_ip}:27017/backtestNasdaq --showlog

For Hackers

You can easily work out and plug your own strategies :

- `Algorithm
API <>`__
- `Portfolio
API <>`__
- `Data
API <>`__
- `Context
API <>`__
- `Middlewares <>`__

Either clone the `insights
repository <>`__ and hack it or
start from scratch. Just make sure the modules paths you give in the
configuration are in the python path.

`provided <>`__
``intuition`` command does already a lot of things but why not improve
it or write your own. Here is a minimal implementation, assuming you
installed *insights*.

.. code:: python

from datetime import datetime
from intuition.core.engine import Simulation

engine = Simulation({
'end': datetime(2014, 1, 7),
'universe': 'cac40',
'modules': {
'algorithm': 'algorithms.movingaverage.DualMovingAverage',
'manager': 'managers.gmv.GlobalMinimumVariance',
'data': ''}})

# Use the configuration to prepare the trading environment

data = {'universe': 'cac40',
'index': pd.date_range(, datetime(2014, 1, 7))}
analyzes =, data)

# Explore the analyzes object
print analyzes.overall_metrics('one_month')
print analyzes.results.tail()


Fork, implement, add tests, pull request, get my everlasting thanks
and a respectable place here
`=) <>`__


Copyright 2014 Xavier Bruhiere Intuition is available under the `Apache
License, Version
2.0 <>`__.



- `Zipline <>`__
- `Quantopian <>`__
- `Pandas <>`__
- `R-bloggers <>`__
- `QSTK <>`__
- `Coursera <>`__
- `Udacity <>`__
- `Babypips <>`__
- `GLMF <>`__

.. |wercker status| image::
.. |Build Status| image::
.. |Build Status| image::
.. |Coverage Status| image::
.. |Code Health| image::

Project details

Release history Release notifications

History Node


History Node


History Node


History Node


History Node


History Node


This version
History Node


History Node

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
intuition-0.3.0.tar.gz (36.2 kB) Copy SHA256 hash SHA256 Source None Jan 8, 2014

Supported by

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