Repository: liampauling/flumine
Pull request #357 (2020-12-28 07:57:30)

test improvements (version)
bflw upgrade


Patch:
diff --git a/HISTORY.rst b/HISTORY.rst
index 7581203..333a472 100644
--- a/HISTORY.rst
+++ b/HISTORY.rst
@@ -3,6 +3,21 @@
 Release History
 ---------------
 
+1.15.1 (2020-12-28)
++++++++++++++++++++
+
+**Improvements**
+
+- #356 Jupyter logging control added (POC) with info improvements
+- #344 lookup cache added and info optimisations
+- #327 correctly return orderStatus
+- Middleware optimisation by only processing updated runners
+- Minor test improvements
+
+**Libraries**
+
+- betfairlightweight upgraded to 2.11.1
+
 1.15.0 (2020-12-07)
 +++++++++++++++++++
 
diff --git a/examples/controls/analysis.ipynb b/examples/controls/analysis.ipynb
new file mode 100644
index 0000000..4bbb656
--- /dev/null
+++ b/examples/controls/analysis.ipynb
@@ -0,0 +1,131 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# flumine backtest analysis notebook\n",
+    "\n",
+    "Simple notebook that injests the json format from the JsonLoggingControl example to allow analysis of results.\n",
+    "\n",
+    "First step is to import required libraries and create three dataframes \n",
+    "\n",
+    "```python\n",
+    "df_strategies\n",
+    "df_markets\n",
+    "df_orders\n",
+    "```"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "sns.set_theme(style=\"darkgrid\")\n",
+    "\n",
+    "filename = \"/tmp/orders.json\"\n",
+    "\n",
+    "with open(filename, \"r\") as f:\n",
+    "    data = json.load(f)\n",
+    "    df_strategies = pd.DataFrame(data[\"strategies\"])\n",
+    "    df_markets = pd.DataFrame(data[\"markets\"])\n",
+    "    df_orders = pd.DataFrame(data[\"orders\"])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Join data into single dataframe `df`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.merge(df_orders, df_markets, left_on=\"market_id\", right_on=\"market_id\", how=\"left\")\n",
+    "df = pd.merge(df, df_strategies, left_on=\"trade__strategy\", right_on=\"name\", how=\"left\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 56,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1152x504 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "group_by = \"race_type\"\n",
+    "x_axis = \"info__average_price_matched\"\n",
+    "xlim = None\n",
+    "ylim = None\n",
+    "palette = \"ch:r=-.5,l=.75\"\n",
+    "\n",
+    "df = df.sort_values(x_axis)\n",
+    "df['cum_profit'] = df.simulated__profit.groupby(df[group_by]).cumsum()\n",
+    "df['cum_roi'] = df.simulated__profit.groupby(df[group_by]).cumsum() / df.info__size_matched.groupby(df[group_by]).cumsum()\n",
+    "\n",
+    "f, ax = plt.subplots(figsize=(16, 7), nrows=2, gridspec_kw={'height_ratios':[3, 1]})\n",
+    "\n",
+    "# Profit\n",
+    "sns.lineplot(\n",
+    "    ax=ax[0], x=x_axis, y=\"cum_profit\", hue=group_by, data=df, palette=palette, legend=False\n",
+    ")\n",
+    "ax[0].set(xlabel=None, ylabel=\"Profit (£)\")\n",
+    "\n",
+    "# ROI\n",
+    "sns.lineplot(\n",
+    "    ax=ax[1], x=x_axis, y=\"cum_roi\", hue=group_by, data=df, palette=palette\n",
+    ")\n",
+    "ax[1].set(xlabel=\"Average Price Matched\", ylabel=\"ROI (%)\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.1"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/examples/controls/jupyterloggingcontrol.py b/examples/controls/jupyterloggingcontrol.py
new file mode 100644
index 0000000..99aaf24
--- /dev/null
+++ b/examples/controls/jupyterloggingcontrol.py
@@ -0,0 +1,76 @@
+import os
+import json
+import logging
+from flumine.controls.loggingcontrols import LoggingControl
+from flumine import __version__
+
+logger = logging.getLogger(__name__)
+
+"""
+Logging control that allows analysis
+of backtesting results once complete.
+
+requirements: jupyterlab, pandas, seaborn
+
+use:
+    control = JupyterLoggingControl()
+    framework.add_logging_control(control)
+    ...
+    control.launch()
+"""
+
+
+class JupyterLoggingControl(LoggingControl):
+    NAME = "JUPYTER_LOGGING_CONTROL"
+
+    def __init__(self, *args, **kwargs):
+        super(JupyterLoggingControl, self).__init__(*args, **kwargs)
+        self.filename = os.path.join("/tmp", "orders.json")
+
+    def _process_end_flumine(self, event):
+        framework = event.event
+        # order data
+        orders = []
+        for market in framework.markets:
+            for order in market.blotter:
+                info = order.info
+                # info.info
+                _info = info.pop("info")
+                for k, v in _info.items():
+                    info["info__{0}".format(k)] = v
+                # info.trade
+                trade = info.pop("trade")
+                for k, v in trade.items():
+                    info["trade__{0}".format(k)] = v
+                # info.order_type
+                order_type = info.pop("order_type")
+                for k, v in order_type.items():
+                    info["order_type__{0}".format(k)] = v
+                # info.simulated
+                simulated = info.pop("simulated")
+                for k, v in simulated.items():
+                    info["simulated__{0}".format(k)] = v
+                # info.responses
+                responses = info.pop("responses")
+                for k, v in responses.items():
+                    info["responses__{0}".format(k)] = v
+                orders.append(info)
+        # create data
+        data = {
+            "framework": {"title": "flumine", "version": __version__},
+            "strategies": [strategy.info for strategy in framework.strategies],
+            "markets": [market.info for market in framework.markets],
+            "orders": orders,
+        }
+        self._create_json(data)
+
+    def _create_json(self, data):
+        # save json to file
+        with open(self.filename, "w") as f:
+            json.dump(data, f)
+
+    def launch(self, argv=None, **kwargs):
+        from jupyterlab.labapp import LabApp
+
+        app = LabApp()
+        app.launch_instance(argv=argv, **kwargs)
diff --git a/examples/workers/terminate.py b/examples/workers/terminate.py
index 09094ad..8fe9828 100644
--- a/examples/workers/terminate.py
+++ b/examples/workers/terminate.py
@@ -45,4 +45,4 @@ def terminate(
         market_count = len(markets)
     if market_count == 0:
         logger.info("No more markets available, terminating framework")
-        flumine.handler_queue.put(TerminationEvent(None))
+        flumine.handler_queue.put(TerminationEvent(flumine))
diff --git a/flumine/__version__.py b/flumine/__version__.py
index c279353..40ca538 100644
--- a/flumine/__version__.py
+++ b/flumine/__version__.py
@@ -1,6 +1,6 @@
 __title__ = "flumine"
 __description__ = "Betfair trading framework"
 __url__ = "https://github.com/liampauling/flumine"
-__version__ = "1.15.0"
+__version__ = "1.15.1"
 __author__ = "Liam Pauling"
 __license__ = "MIT"
diff --git a/flumine/baseflumine.py b/flumine/baseflumine.py
index 0d03dcc..3c5be77 100644
--- a/flumine/baseflumine.py
+++ b/flumine/baseflumine.py
@@ -178,7 +178,7 @@ class BaseFlumine:
             logger.warning("Empty package, not executing", extra=order_package.info)
 
     def _add_market(self, market_id: str, market_book: resources.MarketBook) -> Market:
-        logger.info("Adding: {0} to markets".format(market_id), extra=self.info)
+        logger.info("Adding: {0} to markets".format(market_id))
         market = Market(self, market_id, market_book)
         self.markets.add_market(market_id, market)
         for middleware in self._market_middleware:
@@ -223,7 +223,8 @@ class BaseFlumine:
                     market.market_catalogue = market_catalogue
                     self.log_control(events.MarketEvent(market))
                     logger.info(
-                        "Updated marketCatalogue for {0}".format(market.market_id)
+                        "Updated marketCatalogue for {0}".format(market.market_id),
+                        extra=market.info,
                     )
                 else:
                     market.market_catalogue = market_catalogue
@@ -335,8 +336,6 @@ class BaseFlumine:
             "markets": {
                 "market_count": len(self.markets),
                 "open_market_count": len(self.markets.open_market_ids),
-                "live_orders": self.markets.live_orders,
-                "markets": [m.market_id for m in self.markets],
             },
             "streams": [s for s in self.streams],
             "logging_controls": self._logging_controls,
@@ -381,7 +380,7 @@ class BaseFlumine:
         for w in self._workers:
             w.shutdown()
         # shutdown logging controls
-        self.log_control(events.TerminationEvent(None))
+        self.log_control(events.TerminationEvent(self))
         for c in self._logging_controls:
             if c.is_alive():
                 c.join()
diff --git a/flumine/markets/market.py b/flumine/markets/market.py
index cf591f0..a8d5eb0 100644
--- a/flumine/markets/market.py
+++ b/flumine/markets/market.py
@@ -34,7 +34,7 @@ class Market:
         self.closed = False
         logger.info(
             "Market {0} opened".format(self.market_id),
-            extra={"market_id": self.market_id},
+            extra=self.info,
         )
 
     def close_market(self) -> None:
@@ -42,10 +42,7 @@ class Market:
         self.date_time_closed = datetime.datetime.utcnow()
         logger.info(
             "Market {0} closed".format(self.market_id),
-            extra={
-                "market_id": self.market_id,
-                "date_time_closed": self.date_time_closed,
-            },
+            extra=self.info,
         )
 
     # order
@@ -103,7 +100,7 @@ class Market:
             return self.market_book.market_definition.market_type
 
     @property
-    def seconds_to_start(self):
+    def seconds_to_start(self) -> float:
         return (self.market_start_datetime - datetime.datetime.utcnow()).total_seconds()
 
     @property
@@ -119,3 +116,45 @@ class Market:
             return self.market_book.market_definition.market_time
         else:
             return datetime.datetime.utcfromtimestamp(0)
+
+    @property
+    def event_name(self) -> Optional[str]:
+        if self.market_catalogue:
+            return self.market_catalogue.event.name
+        elif self.market_book:
+            return self.market_book.market_definition.event_name
+
+    @property
+    def country_code(self) -> Optional[str]:
+        if self.market_catalogue:
+            return self.market_catalogue.event.country_code
+        elif self.market_book:
+            return self.market_book.market_definition.country_code
+
+    @property
+    def venue(self) -> Optional[str]:
+        if self.market_catalogue:
+            return self.market_catalogue.event.venue
+        elif self.market_book:
+            return self.market_book.market_definition.venue
+
+    @property
+    def race_type(self) -> Optional[str]:
+        if self.market_catalogue:
+            return self.market_catalogue.description.race_type
+        elif self.market_book:
+            return self.market_book.market_definition.race_type
+
+    @property
+    def info(self) -> dict:
+        return {
+            "market_id": self.market_id,
+            "event_id": self.event_id,
+            "event_type_id": self.event_type_id,
+            "event_name": self.event_name,
+            "market_type": self.market_type,
+            "market_start_datetime": str(self.market_start_datetime),
+            "country_code": self.country_code,
+            "venue": self.venue,
+            "race_type": self.race_type,
+        }
diff --git a/flumine/markets/middleware.py b/flumine/markets/middleware.py
index 318fb73..bc29d51 100644
--- a/flumine/markets/middleware.py
+++ b/flumine/markets/middleware.py
@@ -37,9 +37,13 @@ class SimulatedMiddleware(Middleware):
     def __call__(self, market) -> None:
         market_analytics = self.markets[market.market_id]
         runner_removals = []  # [(selectionId, handicap, adjustmentFactor)..]
+        # optimisation to only process a runner on an update
+        runner_updates = self._process_streaming_update(market.market_book)
+
         for runner in market.market_book.runners:
+            update = bool(runner.selection_id in runner_updates)
             if runner.status == "ACTIVE":
-                self._process_runner(market_analytics, runner)
+                self._process_runner(market_analytics, runner, update)
             elif runner.status == "REMOVED":
                 _removal = (
                     runner.selection_id,
@@ -115,6 +119,15 @@ class SimulatedMiddleware(Middleware):
                             extra=order.info,
                         )
 
+    @staticmethod
+    def _process_streaming_update(market_book) -> list:
+        # return list of runners that have been updated
+        update = market_book.streaming_update
+        if update.get("img") or update.get("marketDefinition"):
+            return [runner.selection_id for runner in market_book.runners]
+        else:
+            return [runner["id"] for runner in update.get("rc", [])]
+
     @staticmethod
     def _calculate_reduction_factor(price: float, adjustment_factor: float) -> float:
         price_adjusted = round(price * (1 - (adjustment_factor / 100)), 2)
@@ -130,14 +143,16 @@ class SimulatedMiddleware(Middleware):
                 order.simulated(market.market_book, runner_analytics)
 
     @staticmethod
-    def _process_runner(market_analytics: dict, runner: RunnerBook) -> None:
+    def _process_runner(
+        market_analytics: dict, runner: RunnerBook, update: bool
+    ) -> None:
         try:
             runner_analytics = market_analytics[(runner.selection_id, runner.handicap)]
         except KeyError:
             runner_analytics = market_analytics[
                 (runner.selection_id, runner.handicap)
             ] = RunnerAnalytics(runner)
-        runner_analytics(runner)
+        runner_analytics(runner, update)
 
 
 class RunnerAnalytics:
@@ -151,12 +166,16 @@ class RunnerAnalytics:
             i["price"]: i["size"] for i in runner.ex.traded_volume
         }  # cached current volume
 
-    def __call__(self, runner: RunnerBook):
-        self.middle = self._calculate_middle(self._runner)  # use last update
-        self.matched = self._calculate_matched(runner)
-        self.traded = self._calculate_traded(runner)
-        self._traded_volume = runner.ex.traded_volume
-        self._runner = runner
+    def __call__(self, runner: RunnerBook, update: bool):
+        if update:
+            self.middle = self._calculate_middle(self._runner)  # use last update
+            self.matched = self._calculate_matched(runner)
+            self.traded = self._calculate_traded(runner)
+            self._traded_volume = runner.ex.traded_volume
+            self._runner = runner
+        else:
+            self.matched = 0
+            self.traded = {}
 
     def _calculate_traded(self, runner: RunnerBook) -> dict:
         if self._traded_volume == runner.ex.traded_volume:
diff --git a/flumine/order/order.py b/flumine/order/order.py
index 36a95f7..e64d901 100644
--- a/flumine/order/order.py
+++ b/flumine/order/order.py
@@ -1,3 +1,4 @@
+import json
 import uuid
 import logging
 import datetime
@@ -55,6 +56,7 @@ class BaseOrder:
         self.side = side
         self.order_type = order_type
         self.handicap = handicap
+        self.lookup = self.market_id, self.selection_id, self.handicap
 
         self.runner_status = None  # RunnerBook.status
         self.status = None
@@ -241,10 +243,6 @@ class BaseOrder:
     def selection_id(self) -> int:
         return self.trade.selection_id
 
-    @property  # todo cache (slow when lots of orders)
-    def lookup(self) -> tuple:
-        return self.market_id, self.selection_id, self.handicap
-
     @property
     def customer_order_ref(self) -> str:
         return "{0}{1}{2}".format(self.trade.strategy.name_hash, self.sep, self.id)
@@ -258,6 +256,8 @@ class BaseOrder:
             "id": self.id,
             "customer_order_ref": self.customer_order_ref,
             "bet_id": self.bet_id,
+            "date_time_created": str(self.date_time_created),
+            "publish_time": str(self.publish_time) if self.publish_time else None,
             "trade": self.trade.info,
             "order_type": self.order_type.info,
             "info": {
@@ -269,10 +269,22 @@ class BaseOrder:
                 "size_voided": self.size_voided,
                 "average_price_matched": self.average_price_matched,
             },
+            "responses": {
+                "date_time_placed": str(self.responses.date_time_placed)
+                if self.responses.date_time_placed
+                else None,
+                "elapsed_seconds_executable": self.elapsed_seconds_executable,
+            },
+            "runner_status": self.runner_status,
             "status": self.status.value if self.status else None,
             "status_log": ", ".join([s.value for s in self.status_log]),
+            "violation_msg": self.violation_msg,
+            "simulated": self.simulated.info,
         }
 
+    def json(self) -> str:
+        return json.dumps(self.info)
+
     def __repr__(self):
         return "Order {0}: {1}".format(
             self.bet_id, self.status.value if self.status else None
diff --git a/flumine/order/trade.py b/flumine/order/trade.py
index 353b37a..2922710 100644
--- a/flumine/order/trade.py
+++ b/flumine/order/trade.py
@@ -158,12 +158,15 @@ class Trade:
     @property
     def info(self) -> dict:
         return {
-            "id": self.id,
-            "strategy": self.strategy,
-            "status": self.status,
+            "id": str(self.id),
+            "strategy": str(self.strategy),
+            "place_reset_seconds": self.place_reset_seconds,
+            "reset_seconds": self.reset_seconds,
             "orders": [o.id for o in self.orders],
             "notes": self.notes_str,
             "market_notes": self.market_notes,
+            "status": self.status.value if self.status else None,
+            "status_log": ", ".join([s.value for s in self.status_log]),
         }
 
     def __enter__(self):
diff --git a/flumine/strategy/strategy.py b/flumine/strategy/strategy.py
index 5433461..b958ccf 100644
--- a/flumine/strategy/strategy.py
+++ b/flumine/strategy/strategy.py
@@ -217,8 +217,13 @@ class BaseStrategy:
             "streaming_timeout": self.streaming_timeout,
             "conflate_ms": self.conflate_ms,
             "stream_ids": self.stream_ids,
+            "max_selection_exposure": self.max_selection_exposure,
+            "max_order_exposure": self.max_order_exposure,
+            "max_live_trade_count": self.max_live_trade_count,
+            "max_trade_count": self.max_trade_count,
             "context": self.context,
             "name_hash": self.name_hash,
+            "client": str(self.client),
         }
 
     @property
diff --git a/requirements.txt b/requirements.txt
index fd7de7e..30d0de3 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,4 +1,4 @@
-betfairlightweight==2.11.0
+betfairlightweight==2.11.1
 tenacity==5.0.3
 python-json-logger==2.0.1
 requests


Test patch:
diff --git a/flumine/backtest/simulated.py b/flumine/backtest/simulated.py
index 4ce1e2b..372aadb 100644
--- a/flumine/backtest/simulated.py
+++ b/flumine/backtest/simulated.py
@@ -117,11 +117,20 @@ class Simulated:
             return self._create_place_response(bet_id)
 
     def _create_place_response(
-        self, bet_id: int, status: str = "SUCCESS", error_code: str = None
+        self,
+        bet_id: int,
+        status: str = "SUCCESS",
+        order_status: str = None,
+        error_code: str = None,
     ) -> SimulatedPlaceResponse:
+        if order_status is None:
+            if self.size_remaining == 0:
+                order_status = "EXECUTION_COMPLETE"
+            else:
+                order_status = "EXECUTABLE"
         return SimulatedPlaceResponse(
             status=status,
-            order_status="EXECUTABLE",  # todo?
+            order_status=order_status,
             bet_id=str(bet_id),
             average_price_matched=self.average_price_matched,
             size_matched=self.size_matched,
@@ -336,5 +345,13 @@ class Simulated:
         else:
             return "EXECUTABLE"
 
+    @property
+    def info(self) -> dict:
+        return {
+            "profit": self.profit,
+            "piq": self._piq,
+            "matched": self.matched,
+        }
+
     def __bool__(self):
         return config.simulated or self.order.trade.client.paper_trade
diff --git a/flumine/backtest/utils.py b/flumine/backtest/utils.py
index b5e76c2..b1bb519 100644
--- a/flumine/backtest/utils.py
+++ b/flumine/backtest/utils.py
@@ -13,8 +13,8 @@ class PendingPackages(list):
 class SimulatedPlaceResponse:
     def __init__(
         self,
-        status: str,
-        order_status: str = None,
+        status: str,  # SUCCESS, FAILURE or TIMEOUT
+        order_status: str = None,  # PENDING, EXECUTION_COMPLETE, EXECUTABLE or EXPIRED
         bet_id: str = None,
         average_price_matched: float = None,
         size_matched: float = None,
diff --git a/tests/test_integration.py b/tests/test_integration.py
index 63034a6..972919f 100644
--- a/tests/test_integration.py
+++ b/tests/test_integration.py
@@ -11,6 +11,10 @@ SKIP_INTEGRATION_TESTS = int(os.environ.get("SKIP_INTEGRATION_TESTS", 1))
 
 
 class IntegrationTest(unittest.TestCase):
+    def setUp(self) -> None:
+        # change config to raise errors
+        config.raise_errors = True
+
     def test_backtest_basic(self):
         class Ex(BaseStrategy):
             def check_market_book(self, market, market_book):
@@ -117,3 +121,4 @@ class IntegrationTest(unittest.TestCase):
 
     def tearDown(self) -> None:
         config.simulated = False
+        config.raise_errors = False
diff --git a/tests/test_markets.py b/tests/test_markets.py
index 2ecd251..148eacd 100644
--- a/tests/test_markets.py
+++ b/tests/test_markets.py
@@ -268,3 +268,73 @@ class MarketTest(unittest.TestCase):
         self.market.closed = True
         self.market.date_time_closed = datetime.datetime.utcnow()
         self.assertGreaterEqual(self.market.elapsed_seconds_closed, 0)
+
+    def test_event_name_mc(self):
+        mock_market_catalogue = mock.Mock()
+        self.market.market_catalogue = mock_market_catalogue
+        self.assertEqual(self.market.event_name, mock_market_catalogue.event.name)
+
+    def test_event_name_mb(self):
+        self.market.market_catalogue = None
+        mock_market_book = mock.Mock()
+        self.market.market_book = mock_market_book
+        self.assertEqual(
+            self.market.event_name, mock_market_book.market_definition.event_name
+        )
+
+    def test_country_code_mc(self):
+        mock_market_catalogue = mock.Mock()
+        self.market.market_catalogue = mock_market_catalogue
+        self.assertEqual(
+            self.market.country_code, mock_market_catalogue.event.country_code
+        )
+
+    def test_country_code_mb(self):
+        self.market.market_catalogue = None
+        mock_market_book = mock.Mock()
+        self.market.market_book = mock_market_book
+        self.assertEqual(
+            self.market.country_code, mock_market_book.market_definition.country_code
+        )
+
+    def test_venue_mc(self):
+        mock_market_catalogue = mock.Mock()
+        self.market.market_catalogue = mock_market_catalogue
+        self.assertEqual(self.market.venue, mock_market_catalogue.event.venue)
+
+    def test_venue_mb(self):
+        self.market.market_catalogue = None
+        mock_market_book = mock.Mock()
+        self.market.market_book = mock_market_book
+        self.assertEqual(self.market.venue, mock_market_book.market_definition.venue)
+
+    def test_race_type_mc(self):
+        mock_market_catalogue = mock.Mock()
+        self.market.market_catalogue = mock_market_catalogue
+        self.assertEqual(
+            self.market.race_type, mock_market_catalogue.description.race_type
+        )
+
+    def test_race_type_mb(self):
+        self.market.market_catalogue = None
+        mock_market_book = mock.Mock()
+        self.market.market_book = mock_market_book
+        self.assertEqual(
+            self.market.race_type, mock_market_book.market_definition.race_type
+        )
+
+    def test_info(self):
+        self.assertEqual(
+            self.market.info,
+            {
+                "market_id": self.market.market_id,
+                "event_id": self.market.event_id,
+                "event_type_id": self.market.event_type_id,
+                "event_name": self.market.event_name,
+                "market_type": self.market.market_type,
+                "market_start_datetime": str(self.market.market_start_datetime),
+                "country_code": self.market.country_code,
+                "venue": self.market.venue,
+                "race_type": self.market.race_type,
+            },
+        )
diff --git a/tests/test_middleware.py b/tests/test_middleware.py
index 4a57d5b..3e83f88 100644
--- a/tests/test_middleware.py
+++ b/tests/test_middleware.py
@@ -49,7 +49,7 @@ class SimulatedMiddlewareTest(unittest.TestCase):
         mock_market_book.runners = [mock_runner]
         mock_market.market_book = mock_market_book
         self.middleware(mock_market)
-        mock__process_runner.assert_called_with({}, mock_runner)
+        mock__process_runner.assert_called_with({}, mock_runner, True)
         self.assertEqual(mock_market.context, {"simulated": {}})
         mock__process_simulated_orders.assert_called_with(mock_market, {})
 
@@ -135,6 +135,29 @@ class SimulatedMiddlewareTest(unittest.TestCase):
         self.middleware._process_runner_removal(mock_market, 12345, 0, None)
         self.assertEqual(mock_order.simulated.matched, [[123, 8.6, 10]])
 
+    def test__process_streaming_update(self):
+        mock_market_book = mock.Mock(
+            streaming_update={"img": True, "rc": [{"id": 3}, {"id": 4}]},
+            runners=[mock.Mock(selection_id=1), mock.Mock(selection_id=2)],
+        )
+        self.assertEqual(
+            self.middleware._process_streaming_update(mock_market_book), [1, 2]
+        )
+        mock_market_book = mock.Mock(
+            streaming_update={"marketDefinition": {1: 2}, "rc": [{"id": 3}, {"id": 4}]},
+            runners=[mock.Mock(selection_id=1), mock.Mock(selection_id=2)],
+        )
+        self.assertEqual(
+            self.middleware._process_streaming_update(mock_market_book), [1, 2]
+        )
+        mock_market_book = mock.Mock(
+            streaming_update={"rc": [{"id": 3}, {"id": 4}]},
+            runners=[mock.Mock(selection_id=1), mock.Mock(selection_id=2)],
+        )
+        self.assertEqual(
+            self.middleware._process_streaming_update(mock_market_book), [3, 4]
+        )
+
     def test__calculate_reduction_factor(self):
         self.assertEqual(self.middleware._calculate_reduction_factor(10, 10), 9)
         self.assertEqual(self.middleware._calculate_reduction_factor(1000, 0), 1000)
@@ -168,11 +191,12 @@ class SimulatedMiddlewareTest(unittest.TestCase):
     def test__process_runner(self, mock_runner_analytics):
         market_analytics = {}
         mock_runner = mock.Mock()
-        self.middleware._process_runner(market_analytics, mock_runner)
+        self.middleware._process_runner(market_analytics, mock_runner, True)
         self.assertEqual(len(market_analytics), 1)
-        self.middleware._process_runner(market_analytics, mock_runner)
+        self.middleware._process_runner(market_analytics, mock_runner, False)
         self.assertEqual(len(market_analytics), 1)
         mock_runner_analytics.assert_called_with(mock_runner)
+        mock_runner_analytics().assert_called_with(mock_runner, False)
 
 
 class RunnerAnalyticsTest(unittest.TestCase):
@@ -198,7 +222,7 @@ class RunnerAnalyticsTest(unittest.TestCase):
         self, mock__calculate_traded, mock__calculate_middle, mock__calculate_matched
     ):
         mock_runner = mock.Mock()
-        self.runner_analytics(mock_runner)
+        self.runner_analytics(mock_runner, True)
         mock__calculate_traded.assert_called_with(mock_runner)
         mock__calculate_middle.assert_called_with(self.mock_runner)
         mock__calculate_matched.assert_called_with(mock_runner)
@@ -210,6 +234,20 @@ class RunnerAnalyticsTest(unittest.TestCase):
         self.assertEqual(self.runner_analytics.traded, mock__calculate_traded())
         self.assertEqual(self.runner_analytics._runner, mock_runner)
 
+    @mock.patch("flumine.markets.middleware.RunnerAnalytics._calculate_matched")
+    @mock.patch("flumine.markets.middleware.RunnerAnalytics._calculate_middle")
+    @mock.patch("flumine.markets.middleware.RunnerAnalytics._calculate_traded")
+    def test_call_no_update(
+        self, mock__calculate_traded, mock__calculate_middle, mock__calculate_matched
+    ):
+        mock_runner = mock.Mock()
+        self.runner_analytics(mock_runner, False)
+        mock__calculate_traded.assert_not_called()
+        mock__calculate_middle.assert_not_called()
+        mock__calculate_matched.assert_not_called()
+        self.assertEqual(self.runner_analytics.matched, 0)
+        self.assertEqual(self.runner_analytics.traded, {})
+
     def test__calculate_traded_dict_empty(self):
         self.runner_analytics._traded_volume = []
         mock_runner = mock.Mock()
diff --git a/tests/test_order.py b/tests/test_order.py
index 5c6b0e9..c6aa74f 100644
--- a/tests/test_order.py
+++ b/tests/test_order.py
@@ -17,8 +17,10 @@ from flumine.exceptions import OrderUpdateError
 class BaseOrderTest(unittest.TestCase):
     def setUp(self) -> None:
         mock_client = mock.Mock(paper_trade=False)
-        self.mock_trade = mock.Mock(client=mock_client)
-        self.mock_order_type = mock.Mock()
+        self.mock_trade = mock.Mock(
+            client=mock_client, market_id="1.1", selection_id=123, info={}
+        )
+        self.mock_order_type = mock.Mock(info={})
         self.order = BaseOrder(self.mock_trade, "BACK", self.mock_order_type, 1)
 
     def test_init(self):
@@ -27,6 +29,10 @@ class BaseOrderTest(unittest.TestCase):
         self.assertEqual(self.order.side, "BACK")
         self.assertEqual(self.order.order_type, self.mock_order_type)
         self.assertEqual(self.order.handicap, 1)
+        self.assertEqual(
+            self.order.lookup,
+            (self.order.market_id, self.order.selection_id, self.order.handicap),
+        )
         self.assertIsNone(self.order.runner_status)
         self.assertIsNone(self.order.status)
         self.assertEqual(self.order.status_log, [])
@@ -253,9 +259,11 @@ class BaseOrderTest(unittest.TestCase):
 class BetfairOrderTest(unittest.TestCase):
     def setUp(self) -> None:
         mock_client = mock.Mock(paper_trade=False)
-        self.mock_trade = mock.Mock(client=mock_client)
+        self.mock_trade = mock.Mock(
+            client=mock_client, market_id="1.1", selection_id=123, info={}
+        )
         self.mock_status = mock.Mock()
-        self.mock_order_type = mock.Mock()
+        self.mock_order_type = mock.Mock(info={}, size=2.0, liability=2.0)
         self.order = BetfairOrder(self.mock_trade, "BACK", self.mock_order_type)
 
     def test_init(self):
@@ -478,8 +486,10 @@ class BetfairOrderTest(unittest.TestCase):
                 "bet_id": None,
                 "handicap": self.order.handicap,
                 "id": self.order.id,
+                "date_time_created": str(self.order.date_time_created),
                 "market_id": self.mock_trade.market_id,
                 "selection_id": self.mock_trade.selection_id,
+                "publish_time": None,
                 "status": None,
                 "status_log": "Pending, Execution complete",
                 "trade": self.mock_trade.info,
@@ -494,9 +504,23 @@ class BetfairOrderTest(unittest.TestCase):
                     "average_price_matched": self.order.average_price_matched,
                 },
                 "customer_order_ref": self.order.customer_order_ref,
+                "simulated": {
+                    "profit": 0.0,
+                    "piq": 0.0,
+                    "matched": [],
+                },
+                "violation_msg": self.order.violation_msg,
+                "responses": {
+                    "date_time_placed": None,
+                    "elapsed_seconds_executable": None,
+                },
+                "runner_status": self.order.runner_status,
             },
         )
 
+    def test_json(self):
+        self.assertTrue(isinstance(self.order.json(), str))
+
     def test_set_invalid_sep(self):
         with self.assertRaises(ValueError):
             self.order.sep = "@"
diff --git a/tests/test_release.py b/tests/test_release.py
new file mode 100644
index 0000000..4726bfa
--- /dev/null
+++ b/tests/test_release.py
@@ -0,0 +1,11 @@
+import re
+import unittest
+
+from flumine import __version__
+
+
+class ReleaseTests(unittest.TestCase):
+    def test_version(self):
+        with open("HISTORY.rst", "r") as f:
+            version = re.findall(r"(?:(\d+\.(?:\d+\.)*\d+))", f.read())[0]
+        self.assertEqual(__version__, version)
diff --git a/tests/test_simulated.py b/tests/test_simulated.py
index d9f32a1..44b7614 100644
--- a/tests/test_simulated.py
+++ b/tests/test_simulated.py
@@ -192,21 +192,35 @@ class SimulatedTest(unittest.TestCase):
         self.assertEqual(resp.error_code, "RUNNER_REMOVED")
         self.assertEqual(self.simulated.matched, [])
 
-    def test_place_else(self):
+    @mock.patch("flumine.backtest.simulated.Simulated._create_place_response")
+    def test_place_else(self, mock__create_place_response):
         mock_client = mock.Mock(best_price_execution=True)
         self.simulated.order.order_type.ORDER_TYPE = OrderTypes.MARKET_ON_CLOSE
         mock_market_book = mock.Mock()
         self.simulated.place(mock_client, mock_market_book, {}, 1)
         self.assertEqual(self.simulated.matched, [])
+        mock__create_place_response.assert_called_with(1)
 
     def test__create_place_response(self):
         resp = self.simulated._create_place_response(
-            1234, "FAILURE", "dubs of the mad skint and british"
+            1234, "FAILURE", error_code="dubs of the mad skint and british"
         )
         self.assertEqual(resp.bet_id, "1234")
         self.assertEqual(resp.status, "FAILURE")
+        self.assertEqual(resp.order_status, "EXECUTABLE")
         self.assertEqual(resp.error_code, "dubs of the mad skint and british")
 
+    @mock.patch(
+        "flumine.backtest.simulated.Simulated.size_remaining",
+        new_callable=mock.PropertyMock,
+        return_value=0,
+    )
+    def test__create_place_response_complete(self, mock_size_remaining):
+        resp = self.simulated._create_place_response(1234)
+        self.assertEqual(resp.bet_id, "1234")
+        self.assertEqual(resp.status, "SUCCESS")
+        self.assertEqual(resp.order_status, "EXECUTION_COMPLETE")
+
     def test_cancel(self):
         self.simulated.order.update_data = {}
         resp = self.simulated.cancel()
@@ -551,6 +565,16 @@ class SimulatedTest(unittest.TestCase):
         self.mock_order.status.value = "PENDING"
         self.assertEqual(self.simulated.status, "EXECUTABLE")
 
+    def test_info(self):
+        self.assertEqual(
+            self.simulated.info,
+            {
+                "profit": 0,
+                "piq": 0,
+                "matched": [],
+            },
+        )
+
     def test_bool(self):
         self.assertFalse(self.simulated)
         from flumine import config
diff --git a/tests/test_strategy.py b/tests/test_strategy.py
index fe0bf10..aaa321a 100644
--- a/tests/test_strategy.py
+++ b/tests/test_strategy.py
@@ -246,6 +246,11 @@ class BaseStrategyTest(unittest.TestCase):
                 "stream_ids": [],
                 "streaming_timeout": self.streaming_timeout,
                 "context": {"trigger": 0.123},
+                "max_live_trade_count": 4,
+                "max_order_exposure": 2,
+                "max_selection_exposure": 1,
+                "max_trade_count": 3,
+                "client": str(self.strategy.client),
             },
         )
 
diff --git a/tests/test_trade.py b/tests/test_trade.py
index 95eb0eb..939ca85 100644
--- a/tests/test_trade.py
+++ b/tests/test_trade.py
@@ -154,15 +154,19 @@ class TradeTest(unittest.TestCase):
         self.assertEqual(self.trade.notes_str, "")
 
     def test_info(self):
+        self.trade.status_log = [TradeStatus.PENDING, TradeStatus.COMPLETE]
         self.assertEqual(
             self.trade.info,
             {
-                "id": self.trade.id,
+                "id": str(self.trade.id),
                 "orders": [],
-                "status": TradeStatus.LIVE,
-                "strategy": self.mock_strategy,
+                "place_reset_seconds": 12,
+                "reset_seconds": 34,
+                "strategy": str(self.mock_strategy),
                 "notes": "123",
                 "market_notes": None,
+                "status": "Live",
+                "status_log": "Pending, Complete",
             },
         )