skip to navigation
skip to content

Not Logged In

intuition 0.3.0

A trading system building blocks

Latest Version: 0.4.0


    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

    $ export FULL_INTUITION=1
    $ 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 DB_HOST=$DB_HOST \
      -e DB_PORT=$DB_PORT \
      -e DB_NAME=$DB_NAME \
      -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::
File Type Py Version Uploaded on Size
intuition-0.3.0.tar.gz (md5) Source 2014-01-08 35KB
  • Downloads (All Versions):
  • 12 downloads in the last day
  • 835 downloads in the last week
  • 1483 downloads in the last month