Added basic logging capability to trading.py and related classes.

data/streaming.py

@@ -1,9 +1,11 @@
 from __future__ import print_function
 
 from decimal import Decimal, getcontext, ROUND_HALF_DOWN
-import requests
+import logging
 import json
 
+import requests
+
 from qsforex.event.event import TickEvent
 from qsforex.data.price import PriceHandler
 
@@ -19,6 +21,7 @@ class StreamingForexPrices(PriceHandler):
         self.events_queue = events_queue
         self.pairs = pairs
         self.prices = self._set_up_prices_dict()
+        self.logger = logging.getLogger(__name__)
 
     def invert_prices(self, pair, bid, ask):
         """
@@ -63,10 +66,12 @@ class StreamingForexPrices(PriceHandler):
                     dline = line.decode('utf-8')
                     msg = json.loads(dline)
                 except Exception as e:
-                    print("Caught exception when converting message into json\n" + str(e))
+                    self.logger.error(
+                        "Caught exception when converting message into json: %s" % str(e)
+                    )
                     return
                 if "instrument" in msg or "tick" in msg:
-                    print(msg)
+                    self.logger.debug(msg)
                     getcontext().rounding = ROUND_HALF_DOWN 
                     instrument = msg["tick"]["instrument"].replace("_", "")
                     time = msg["tick"]["time"]

event/event.py

@@ -10,15 +10,33 @@ class TickEvent(Event):
         self.bid = bid
         self.ask = ask
 
+    def __str__(self):
+        return "Type: %s, Instrument: %s, Time: %s, Bid: %s, Ask: %s" % (
+            str(self.type), str(self.instrument), 
+            str(self.time), str(self.bid), str(self.ask)
+        )
+
+    def __repr__(self):
+        return str(self)
+
 
 class SignalEvent(Event):
     def __init__(self, instrument, order_type, side, time):
         self.type = 'SIGNAL'
         self.instrument = instrument
         self.order_type = order_type
-        self.side = side        
+        self.side = side
         self.time = time  # Time of the last tick that generated the signal
 
+    def __str__(self):
+        return "Type: %s, Instrument: %s, Order Type: %s, Side: %s" % (
+            str(self.type), str(self.instrument), 
+            str(self.order_type), str(self.side)
+        )
+
+    def __repr__(self):
+        return str(self)
+
 
 class OrderEvent(Event):
     def __init__(self, instrument, units, order_type, side):
@@ -26,4 +44,13 @@ class OrderEvent(Event):
         self.instrument = instrument
         self.units = units
         self.order_type = order_type
-        self.side = side        
+        self.side = side
+
+    def __str__(self):
+        return "Type: %s, Instrument: %s, Units: %s, Order Type: %s, Side: %s" % (
+            str(self.type), str(self.instrument), str(self.units),
+            str(self.order_type), str(self.side)
+        )
+
+    def __repr__(self):
+        return str(self)

execution/execution.py

@@ -5,6 +5,7 @@ try:
     import httplib
 except ImportError:
     import http.client as httplib
+import logging
 try:
     from urllib import urlencode
 except ImportError:
@@ -47,6 +48,7 @@ class OANDAExecutionHandler(ExecutionHandler):
         self.access_token = access_token
         self.account_id = account_id
         self.conn = self.obtain_connection()
+        self.logger = logging.getLogger(__name__)
 
     def obtain_connection(self):
         return httplib.HTTPSConnection(self.domain)
@@ -68,6 +70,6 @@ class OANDAExecutionHandler(ExecutionHandler):
             "/v1/accounts/%s/orders" % str(self.account_id), 
             params, headers
         )
-        response = self.conn.getresponse().read()
+        response = self.conn.getresponse().read().decode("utf-8").replace("\n","").replace("\t","")
-        print(response)
+        self.logger.debug(response)
         

logging.conf

@@ -0,0 +1,28 @@
+[loggers]
+keys=root,qsforex.trading.trading
+
+[handlers]
+keys=consoleHandler
+
+[formatters]
+keys=simpleFormatter
+
+[logger_root]
+level=DEBUG
+handlers=consoleHandler
+
+[logger_qsforex.trading.trading]
+level=DEBUG
+handlers=consoleHandler
+qualname=qsforex.trading.trading
+propagate=0
+
+[handler_consoleHandler]
+class=StreamHandler
+level=DEBUG
+formatter=simpleFormatter
+args=(sys.stdout,)
+
+[formatter_simpleFormatter]
+format=%(asctime)s - %(name)s - %(levelname)s - %(message)s
+datefmt=

portfolio/portfolio.py

@@ -2,6 +2,7 @@ from __future__ import print_function
 
 from copy import deepcopy
 from decimal import Decimal, getcontext, ROUND_HALF_DOWN
+import logging
 import os
 
 import pandas as pd
@@ -30,6 +31,7 @@ class Portfolio(object):
         self.positions = {}
         if self.backtest:
             self.backtest_file = self.create_equity_file()
+        self.logger = logging.getLogger(__name__)
 
     def calc_risk_position_size(self):
         return self.equity * self.risk_per_trade
@@ -184,7 +186,8 @@ class Portfolio(object):
 
             order = OrderEvent(currency_pair, units, "market", side)
             self.events.put(order)
-            print("Balance: ", self.balance)
+
+            self.logger.info("Portfolio Balance: %s" % self.balance)
         else:
-            print("Unable to execute order as price data was insufficient.")
+            self.logger.info("Unable to execute order as price data was insufficient.")
         

trading/trading.py

@@ -1,5 +1,7 @@
 import copy
 from decimal import Decimal, getcontext
+import logging
+import logging.config
 try:
     import Queue as queue
 except ImportError:
@@ -30,16 +32,23 @@ def trade(events, strategy, portfolio, execution, heartbeat):
         else:
             if event is not None:
                 if event.type == 'TICK':
+                    logger.info("Received new tick event: %s", event)
                     strategy.calculate_signals(event)
                     portfolio.update_portfolio(event)
                 elif event.type == 'SIGNAL':
+                    logger.info("Received new signal event: %s", event)
                     portfolio.execute_signal(event)
                 elif event.type == 'ORDER':
+                    logger.info("Received new order event: %s", event)
                     execution.execute_order(event)
         time.sleep(heartbeat)
 
 
 if __name__ == "__main__":
+    # Set up logging
+    logging.config.fileConfig('../logging.conf')
+    logger = logging.getLogger('qsforex.trading.trading')
+
     # Set the number of decimal places to 2
     getcontext().prec = 2
 
@@ -86,5 +95,7 @@ if __name__ == "__main__":
     price_thread = threading.Thread(target=prices.stream_to_queue, args=[])
     
     # Start both threads
+    logger.info("Starting trading thread")
     trade_thread.start()
+    logger.info("Starting price streaming thread")
     price_thread.start()