Matrix logger implementation

.env_example

@@ -4,3 +4,8 @@ KRAKEN_API_SEC =
 R_VALUE_TARGET = 
 INVESTMENT_COUNT = 
 INVESTMENT_VOLUME = 
+LOG_LEVEL = 
+MATRIX_HOMESERVER_ADDRESS = 
+MATRIX_USER_ID = 
+MATRIX_USER_PASSWORD = 
+MATRIX_ROOM_ID = 

app.py

@@ -1,30 +1,15 @@
-import logging
-import os
+from dotenv import load_dotenv
 
 from kraken_bot.KrakenBot import KrakenBot
 from kraken_bot.LinearRegression import LinearRegression
-from kraken_bot.HighLowCutoff import HighLowCutoff
-from dotenv import load_dotenv
+from kraken_bot.MyStrategy import MyStrategy
 
 load_dotenv()
 
-logger = logging.getLogger(__name__)
-
-model = LinearRegression(
-        r_value_target = float(os.getenv('R_VALUE_TARGET'))
-        )
-strategy = HighLowCutoff(
-        investment_count = int(os.getenv('INVESTMENT_COUNT')),
-        investment_volume = float(os.getenv('INVESTMENT_VOLUME')),
-        target_gain = float(os.getenv('TARGET_GAIN')),
-        max_loss = float(os.getenv('MAX_LOSS'))
-        )
 bot = KrakenBot(
-        token = os.getenv('KRAKEN_API_TOKEN'),
-        secret = os.getenv('KRAKEN_API_SEC'),
         tier = 'Pro',
-        model = model,
-        trading_strategy = strategy
+        model = LinearRegression(),
+        trading_strategy = MyStrategy()
         )
 
 if __name__ == '__main__':

kraken_bot/KrakenBot.py

@@ -1,5 +1,4 @@
 import krakenex
-import logging
 import os
 import scipy
 import sys
@@ -7,16 +6,14 @@ import time
 
 from pykrakenapi import KrakenAPI
 
+from kraken_bot.MatrixLogger import MatrixLogger
+
 class KrakenBot(KrakenAPI):
-    def __init__(self, token, secret, tier, model, trading_strategy):
+    def __init__(self, tier, model, trading_strategy):
         self.model = model
         self.trading_strategy = trading_strategy
-        self.log = logging.getLogger(__name__)
-        self.log.setLevel(
-                getattr(logging, os.getenv('LOG_LEVEL', 'INFO'), logging.INFO)
-                )
-        self.log.addHandler(logging.StreamHandler(sys.stdout))
-        super().__init__(krakenex.API(token, secret), tier=tier)
+        self.log = MatrixLogger(self.__class__.__name__)
+        super().__init__(krakenex.API(os.getenv('KRAKEN_API_TOKEN'), os.getenv('KRAKEN_API_SEC')), tier=tier)
         self.update(full=True)
 
     def _delay_factor(self):
@@ -75,7 +72,7 @@ class KrakenBot(KrakenAPI):
                 order.ordertype, order.type, order.pair, order.userref, order.volume, order.price, order.price2, order.trigger,
                 order.leverage, order.oflags, order.timeinforce, order.starttm, order.expiretm, order.close_ordertype,
                 order.close_price, order.close_price2, order.deadline, order.validate, order.otp)
-        self.log.info(order)
+        self.log.info(f"Added order to %{order.type} %{order.volume} on {order.pair}")
         self.update()
 
     def update(self, full=False):

kraken_bot/LinearRegression.py

@@ -1,17 +1,13 @@
-import logging
 import os
 import pandas
 
-from kraken_bot.Model import Model
 from scipy.stats import linregress
 
+from kraken_bot.Model import Model
+
 class LinearRegression(Model):
-    def __init__(self, r_value_target):
-        self.r_value_target = r_value_target
-        self.log = logging.getLogger(__name__)
-        self.log.setLevel(
-                getattr(logging, os.getenv('LOG_LEVEL', 'INFO'), logging.INFO)
-                )
+    def __init__(self):
+        self.r_value_target = float(os.getenv('R_VALUE_TARGET'))
         self.analysis = pandas.DataFrame({})
         super().__init__(
                 interval = 1,
@@ -54,5 +50,4 @@ class LinearRegression(Model):
                             ) for asset_pair in self._filter_asset_pairs(tradable_asset_pairs).index
                         }).transpose()
                     ))
-        self.log.info(f"Completed linear regression analysis of OHLC market data")
-        self.log.info(self.analysis)
+        self.log.debug(self.analysis)

kraken_bot/MatrixLogger.py

@@ -1,15 +1,19 @@
 import asyncio
 import logging
+import os
 
-from nio import AsyncClient, MatrixRoom, RoomMessageText
+from nio import HttpClient, MatrixRoom, RoomMessageText
 
 class MatrixHandler(logging.Handler):
-    def __init__(self, url, user_id, user_password, room_id):
+    def __init__(self):
         super().__init__()
-        self.client = AsyncClient(url, user_id)
-        self.room_id = room_id
+        self.homeserver_address = os.getenv('MATRIX_HOMESERVER_ADDRESS'),
+        self.user_id = os.getenv('MATRIX_USER_ID'),
+        self.user_password = os.getenv('MATRIX_USER_PASSWORD'),
+        self.room_id = os.getenv('MATRIX_ROOM_ID')
+        self.client = HttpClient(self.address, self.user_id)
         self.client.add_event_callback(self.message_callback, RoomMessageText)
-        await self.client.login(user_password)
+        self.client.login(self.user_password)
 
     def message_callback(self, room: MatrixRoom, event: RoomMessageText) -> None:
         return
@@ -23,33 +27,32 @@ class MatrixHandler(logging.Handler):
 
 class MatrixLogger:
     def __init__(self, name):
-        self.logger = logging.getLogger(name)
-        self.logger.setLevel(logging.DEBUG)
+        self.log = logging.getLogger(name)
+        self.log.setLevel(os.getenv('LOG_LEVEL', 'INFO'))
 
         console_handler = logging.StreamHandler()
-        console_handler.setLevel(logging.DEBUG)
-        console_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %(message)s'))
+        console_handler.setLevel(os.getenv('LOG_LEVEL', 'INFO'))
+        console_handler.setFormatter(logging.Formatter('%(asctime)s - %(levelname)s - %{name}s - %(message)s'))
 
-        
-        matrix_handler = MatrixHandler(room_id)
-        matrix_handler.setLevel(logging.INFO)
-        matrix_handler.setFormatter(logging.Formatter('%(levelname)s - %(message)s'))
+        matrix_handler = MatrixHandler()
+        matrix_handler.setLevel(os.getenv('LOG_LEVEL', 'INFO'))
+        matrix_handler.setFormatter(logging.Formatter('%(levelname)s - %{name}s - %(message)s'))
 
-        self.logger.addHandler(console_handler)
-        self.logger.addHandler(matrix_handler)
+        self.log.addHandler(console_handler)
+        self.log.addHandler(matrix_handler)
 
     def debug(self, message):
-        self.logger.debug(message)
+        self.log.debug(message)
 
     def info(self, message):
-        self.logger.info(message)
+        self.log.info(message)
 
     def warning(self, message):
-        self.logger.warning(message)
+        self.log.warning(message)
 
     def error(self, message):
-        self.logger.error(message)
+        self.log.error(message)
 
     def critical(self, message):
-        self.logger.critical(message)
+        self.log.critical(message)
 

kraken_bot/Model.py

@@ -1,9 +1,12 @@
 from abc import ABC, abstractmethod
 
+from kraken_bot.MatrixLogger import MatrixLogger
+
 class Model(ABC):
     def __init__(self, interval, ascending):
         self.interval = interval
         self.ascending = ascending
+        self.log = MatrixLogger(self.__class__.__name__)
 
     @abstractmethod
     def since():

kraken_bot/MyStrategy.py

@@ -2,8 +2,8 @@ from kraken_bot.TradingStrategy import TradingStrategy
 from kraken_bot.KrakenOrder import KrakenOrder
 
 class MyStrategy(TradingStrategy):
-    def __init__(self, investment_count, investment_volume):
-        super().__init__(investment_count, investment_volume)
+    def __init__(self):
+        super().__init__()
 
     def update(self, tradable_asset_pairs, ohlc_data, market_analysis, account_balance):
         self.orders = []

kraken_bot/TradingStrategy.py

@@ -1,10 +1,14 @@
+import os
+
 from abc import ABC, abstractmethod
-from kraken_bot.KrakenOrder import KrakenOrder
+
+from kraken_bot.MatrixLogger import MatrixLogger
 
 class TradingStrategy(ABC):
-    def __init__(self, investment_count, investment_volume):
-        self.investment_count = investment_count
-        self.investment_volume = investment_volume
+    def __init__(self):
+        self.investment_count = int(os.getenv('INVESTMENT_COUNT')),
+        self.investment_volume = float(os.getenv('INVESTMENT_VOLUME')),
+        self.log = MatrixLogger(self.__class__.__name__)
         self.orders = []
 
     @abstractmethod