Add load config to avoid settings data file at each launch

Author: Skinok

DataFile.py

@@ -0,0 +1,24 @@
+
+class DataFile():
+
+    def __init__(self):
+
+        # File location
+        self.filePath = ""
+        self.fileName = ""
+
+        # File import parameters
+        self.timeFrame = ""
+        self.separator = ""
+        self.timeFormat = ""
+
+        # Panda data frame
+        self.dataFrame = None
+
+        pass
+
+
+
+
+
+

SkinokBacktraderUI.py

@@ -23,6 +23,7 @@
 from CerebroEnhanced import *
 
 import sys, os
+from DataFile import DataFile
 
 from dataManager import DataManager
 sys.path.append(os.path.dirname(os.path.realpath(__file__)) + '/observers')
@@ -38,6 +39,8 @@
 from wallet import Wallet
 from userConfig import UserConfig
 
+from PyQt6 import QtCore
+
 class SkinokBacktraderUI:
 
     def __init__(self):
@@ -48,7 +51,7 @@ def __init__(self):
 
         # Init attributes
         self.strategyParameters = {}
-        self.dataframes = {}
+        self.dataFiles = {}
 
         # Global is here to update the Ui in observers easily, if you find a better way, don't hesistate to tell me (Skinok)
         global interface
@@ -82,23 +85,32 @@ def loadConfig(self):
         isEmpty = True
 
         # Load previous data files
-        for timeframe in self.timeFrameIndex.keys():
+        #for timeframe in self.timeFrameIndex.keys():
 
-            if timeframe in userConfig.data.keys():
-                
-                filePath = userConfig.data[timeframe]['filePath']
-                timeFormat = userConfig.data[timeframe]['timeFormat']
-                separator = userConfig.data[timeframe]['separator']
+        for timeframe in userConfig.data.keys():
+
+            dataFile = DataFile()
+            
+            dataFile.filePath = userConfig.data[timeframe]['filePath']
+            dataFile.fileName = userConfig.data[timeframe]['fileName']
+            dataFile.timeFormat = userConfig.data[timeframe]['timeFormat']
+            dataFile.separator = userConfig.data[timeframe]['separator']
+            dataFile.timeFrame = timeframe
 
-                fileName = os.path.basename(filePath)
+            if not dataFile.timeFormat in self.dataFiles:
+                dataFile.dataFrame, errorMessage = self.dataManager.loadDataFrame(dataFile)
 
-                df, errorMessage = self.dataManager.loadDataFile(filePath,timeFormat, separator)
+                if dataFile.dataFrame is not None:
 
-                if df is not None:
-                    self.dataframes[fileName] = df
                     isEmpty = False
-                else:
-                    print(f" Error loading user data file : {errorMessage}")
+
+                    # REALLY UGLY : it should be a function of user interface
+                    items = self.interface.strategyTesterUI.loadDataFileUI.dataFilesListWidget.findItems(dataFile.fileName, QtCore.Qt.MatchFixedString)
+
+                    if len(items) == 0:
+                        self.interface.strategyTesterUI.loadDataFileUI.dataFilesListWidget.addItem(os.path.basename(dataFile.filePath))
+                    
+                    self.dataFiles[dataFile.timeFrame] = dataFile;
 
         if not isEmpty:
             self.importData()
@@ -140,17 +152,17 @@ def resetCerebro(self):
     def importData(self):
 
         try:
-
-            fileNames = list(self.dataframes.keys())
+            
+            timeFrames = list(self.dataFiles.keys())
 
             # Sort data by timeframe
             # For cerebro, we need to add lower timeframes first
-            fileNames.sort( key=lambda x: self.timeFrameIndex[self.dataManager.findTimeFrame(self.dataframes[x])] )
+            timeFrames.sort( key=lambda x: self.timeFrameIndex[x] )
 
             # Files should be loaded in the good order
-            for fileName in fileNames:
+            for timeFrame in timeFrames:
 
-                df = self.dataframes[fileName]
+                df = self.dataFiles[timeFrame].dataFrame
 
                 # Datetime first column : 2012-12-28 17:45:00
                 #self.dataframe['TimeInt'] = pd.to_datetime(self.dataframe.index).astype('int64') # use finplot's internal representation, which is ns
@@ -161,24 +173,21 @@ def importData(self):
                 # Add data to cerebro : only add data when all files have been selected for multi-timeframes
                 self.cerebro.adddata(self.data)  # Add the data feed
 
-                # Find timeframe
-                timeframe = self.dataManager.findTimeFrame(df)
-
                 # Create the chart window for the good timeframe (if it does not already exists?)
-                self.interface.createChartDock(timeframe)
+                self.interface.createChartDock(timeFrame)
 
                 # Draw charts based on input data
-                self.interface.drawChart(df, timeframe)
+                self.interface.drawChart(df, timeFrame)
 
             # Enable run button
             self.interface.strategyTesterUI.runBacktestBtn.setEnabled(True)
 
             return True
 
         except AttributeError as e:
-            print("AttributeError error:" + str(e))
+            print("AttributeError error:" + str(e) + " " + str(sys.exc_info()[0]))
         except KeyError as e:
-            print("KeyError error:" + str(e))
+            print("KeyError error:" + str(e) + " " + str(sys.exc_info()[0]))
         except:
             print("Unexpected error:" + str(sys.exc_info()[0]))
             return False
@@ -262,12 +271,11 @@ def displayStrategyResults(self):
         #self.interface.createTransactionsUI(self.portfolio_transactions)
         self.interface.fillSummaryUI(self.strat_results.stats.broker.cash[0], self.strat_results.stats.broker.value[0], self.strat_results.analyzers.ta.get_analysis())
         self.interface.fillTradesUI(self.strat_results._trades.items())        
-        
+        self.interface.dock_strategyResultsUI.show()
         #self.interface.drawTrades(self.strat_results._trades.items())
         #Orders filters
         self.myOrders = []
         for order in self.strat_results._orders:
-
             if order.status in [order.Completed]:
                 self.myOrders.append(order)
 
@@ -281,7 +289,7 @@ def displayStrategyResults(self):
         pnl_data['cash'] = self.wallet.cash_list
 
         # really uggly
-        pnl_data['time'] = list(self.dataframes.values())[0].index
+        pnl_data['time'] = list(self.dataFiles.values())[0].dataFrame.index
 
         # draw charts
         df = pd.DataFrame(pnl_data) 

dataManager.py

@@ -32,27 +32,27 @@ def DatetimeFormat(self, dataFilePath):
 
     # Return True if loading is successfull & the error string if False
     # dataPath is the full file path
-    def loadDataFile(self, dataPath, datetimeFormat, separator):
+    def loadDataFrame(self, loadDataFile):
 
         # Try importing data file
         # We should code a widget that ask for options as : separators, date format, and so on...
         try:
 
             # Python contains
             if pd.__version__<'2.0.0':
-                df = pd.read_csv(dataPath, 
-                                    sep=separator, 
+                df = pd.read_csv(loadDataFile.filePath, 
+                                    sep=loadDataFile.separator, 
                                     parse_dates=[0], 
-                                    date_parser=lambda x: pd.to_datetime(x, format=datetimeFormat), 
+                                    date_parser=lambda x: pd.to_datetime(x, format=loadDataFile.timeFormat), 
                                     skiprows=0, 
                                     header=0, 
                                     names=["Time", "Open", "High", "Low", "Close", "Volume"],
                                     index_col=0)
             else:
-                df = pd.read_csv(dataPath,
-                                    sep=separator, 
+                df = pd.read_csv(loadDataFile.filePath,
+                                    sep=loadDataFile.separator, 
                                     parse_dates=[0], 
-                                    date_format=datetimeFormat, 
+                                    date_format=loadDataFile.timeFormat, 
                                     skiprows=0, 
                                     header=0, 
                                     names=["Time", "Open", "High", "Low", "Close", "Volume"],

finplotWindow.py

@@ -129,8 +129,6 @@ def drawOrders(self, orders = None):
                 ##############
                 if order.isbuy():
 
-                    direction = "buy"
-
                     # Tracer les traites allant des ouvertures de positions vers la fermeture de position
                     if currentPositionSize < 0:
 
@@ -172,8 +170,6 @@ def drawOrders(self, orders = None):
                 # Sell
                 ##############
                 elif order.issell():
-                    direction = "sell"
-
 
                     if currentPositionSize < 0:
                         # Augmentation de la postion
@@ -220,7 +216,7 @@ def drawOrders(self, orders = None):
                 currentPositionSize += order.size
 
                 # Todo: We could display the size of the order with a label on the chart
-                fplt.add_order(bt.num2date(order.executed.dt), order.executed.price, direction, ax=self.ax0)
+                fplt.add_order(bt.num2date(order.executed.dt), order.executed.price, order.isbuy(), ax=self.ax0)
 
         pass
 

loadDataFilesUI.py

@@ -1,6 +1,7 @@
 from PyQt6 import QtCore, QtWidgets, uic
 import pandas as pd
-import os 
+import os
+from DataFile import DataFile 
 
 from userConfig import UserConfig
 from dataManager import DataManager
@@ -33,13 +34,16 @@ def __init__(self, controller, parent = None):
         self.deletePB = self.findChild(QtWidgets.QLineEdit, "deletePB")
         self.importPB = self.findChild(QtWidgets.QPushButton, "importPB")
 
+        self.deleteDataFilePB = self.findChild(QtWidgets.QPushButton, "deleteDataFilePB")
+
         self.errorLabel = self.findChild(QtWidgets.QLabel, "errorLabel")
 
         self.dataFilesListWidget = self.findChild(QtWidgets.QListWidget, "dataFilesListWidget")
 
         # Connect slots : open file
         self.openFilePB.clicked.connect( self.openFileDialog )
-        self.loadFilePB.clicked.connect( self.loadFile )
+        self.loadFilePB.clicked.connect( self.createDataFile )
+        self.deleteDataFilePB.clicked.connect(self.deleteFile)
         self.importPB.clicked.connect( self.importFiles )
 
         self.dataManager = DataManager()
@@ -55,56 +59,83 @@ def openFileDialog(self):
 
         pass
 
-    def loadFile(self):
+    def createDataFile(self):
 
-        # try loading file by controller
-        separator = '\t' if self.tabRB.isChecked() else ',' if self.commaRB.isChecked() else ';'
+        dataFile = DataFile()
 
-        timeFormat = self.datetimeFormatLE.text()
+        # try loading file by controller
+        dataFile.separator = '\t' if self.tabRB.isChecked() else ',' if self.commaRB.isChecked() else ';'
+        dataFile.timeFormat = self.datetimeFormatLE.text()
+        dataFile.filePath = self.dataFilePath
+        dataFile.fileName = os.path.basename(self.dataFilePath)
 
-        if not self.dataFilePath in self.controller.dataframes:
+        if not dataFile.timeFormat in self.controller.dataFiles:
 
-            fileName = os.path.basename(self.dataFilePath)
+            dataFile.dataFrame, errorMessage = self.dataManager.loadDataFrame(dataFile)
 
-            df, errorMessage = self.dataManager.loadDataFile(self.dataFilePath, timeFormat, separator)
+            # Store data file in the user config parameters to later use
+            dataFile.timeFrame = self.dataManager.findTimeFrame(dataFile.dataFrame)
 
-            if df is not None:
-
-                # ugly to reference the controller this way
-                self.controller.dataframes[fileName] = df
+            if dataFile.dataFrame is not None:
 
                 self.errorLabel.setStyleSheet("color:green")
                 self.errorLabel.setText("The file has been loaded correctly.")
 
                 # Add file name
-                items = self.dataFilesListWidget.findItems(fileName, QtCore.Qt.MatchFixedString)
+                items = self.dataFilesListWidget.findItems(dataFile.fileName, QtCore.Qt.MatchFixedString)
 
                 if len(items) == 0:
-                    self.dataFilesListWidget.addItem(os.path.basename(self.dataFilePath))
-
-                # Store data file in the user config parameters to later use
-                timeframe = self.dataManager.findTimeFrame(df)
-                self.userConfig.saveParameter(timeframe, {"filePath": self.dataFilePath, "separator" : separator, "timeFormat": timeFormat})
+                    self.dataFilesListWidget.addItem(os.path.basename(dataFile.filePath))
+                
+                self.controller.dataFiles[dataFile.timeFrame] = dataFile;
+                self.userConfig.saveObject(dataFile.timeFrame, dataFile)
 
             else:
                 self.errorLabel.setStyleSheet("color:red")
                 self.errorLabel.setText(errorMessage)
-
+        else:
+                self.errorLabel.setStyleSheet("color:red")
+                self.errorLabel.setText("The file is already in the list")
         pass
 
 
-    def importFiles(self):
+    def loadDataFileFromConfig(self, dataPath, datetimeFormat, separator):
+
+        fileName = os.path.basename(dataPath)
+        df, errorMessage = self.dataManager.loadDataFrame(dataPath, datetimeFormat, separator)
+
+        if df is not None:
 
-        # Get all element in list widget
-        #items = []
-        #for x in range(self.dataFilesListWidget.count()):
-            #items.append(self.dataFilesListWidget.item(x).text())
+            # Add file name
+            items = self.dataFilesListWidget.findItems(fileName, QtCore.Qt.MatchFixedString)
 
-        # Sort item by timeframe
+            if len(items) == 0:
+                self.dataFilesListWidget.addItem(os.path.basename(dataPath))
+
+        return df
+    
+    def deleteFile(self):
+
+        listItems=self.dataFilesListWidget.selectedItems()
+        if not listItems: return        
+        for item in listItems:
+            itemTaken = self.dataFilesListWidget.takeItem(self.dataFilesListWidget.row(item))
+
+            # Delete from dataFrames
+            del self.controller.dataframes[itemTaken.text()]
+
+            # Delete from Cerebro ?
+
+
+            # Delete from config
+            self.userConfig.removeParameter(timeframe);
+
+        pass
+
+    def importFiles(self):
 
         # Give all ordered data path to the controller
         if self.controller.importData():
-            self.dataFilesListWidget.clear()
             self.hide()
 
         pass