Build out user dir

.pre-commit-config.yaml

@@ -6,11 +6,11 @@ repos:
       - id: end-of-file-fixer
       - id: check-yaml
       - id: check-added-large-files
-  - repo: http://gitlab.com/PyCQA/flake8
-    rev: 3.9.0
+  - repo: https://gitlab.com/PyCQA/flake8
+    rev: 3.9.2
     hooks:
       - id: flake8
-  - repo: http://github.com/PyCQA/isort
+  - repo: https://github.com/PyCQA/isort
     rev: 5.7.0
     hooks:
       - id: isort

algobot/__main__.py

@@ -26,8 +26,8 @@
                                    setup_graph_plots, setup_graphs,
                                    update_backtest_graph_limits,
                                    update_main_graphs)
-from algobot.helpers import (ROOT_DIR, create_folder, create_folder_if_needed,
-                             get_caller_string, open_file_or_folder)
+from algobot.helpers import (PATHS, create_folder_if_needed, get_caller_string,
+                             open_file_or_folder)
 from algobot.interface.about import About
 from algobot.interface.config_utils.state_utils import load_state, save_state
 from algobot.interface.config_utils.strategy_utils import get_strategies
@@ -47,7 +47,7 @@
 from algobot.traders.simulationtrader import SimulationTrader
 
 app = QApplication(sys.argv)
-mainUi = os.path.join(ROOT_DIR, 'UI', 'algobot.ui')
+mainUi = os.path.join(PATHS.get_ui_dir(), 'algobot.ui')
 
 
 class Interface(QMainWindow):
@@ -252,21 +252,23 @@ def export_optimizer(self, file_type: str):
         """
         if self.optimizer:
             if len(self.optimizer.optimizerRows) > 0:
-                optimizerFolderPath = create_folder('Optimizer Results')
-                innerPath = os.path.join(optimizerFolderPath, self.optimizer.symbol)
-                create_folder_if_needed(innerPath, optimizerFolderPath)
-                defaultFileName = self.optimizer.get_default_result_file_name('optimizer', ext=file_type.lower())
-                defaultPath = os.path.join(innerPath, defaultFileName)
-                filePath, _ = QFileDialog.getSaveFileName(self, 'Save Optimizer', defaultPath,
-                                                          f'{file_type} (*.{file_type.lower()})')
-                if not filePath:
+                optimizer_folder_path = PATHS.get_optimizer_results_dir()
+                create_folder_if_needed(optimizer_folder_path)
+                inner_path = os.path.join(optimizer_folder_path, self.optimizer.symbol)
+                create_folder_if_needed(inner_path)
+                default_file_name = self.optimizer.get_default_result_file_name(optimizer_folder_path,
+                                                                                'optimizer', ext=file_type.lower())
+                default_path = os.path.join(inner_path, default_file_name)
+                file_path, _ = QFileDialog.getSaveFileName(self, 'Save Optimizer', default_path,
+                                                           f'{file_type} (*.{file_type.lower()})')
+                if not file_path:
                     create_popup(self, "Export cancelled.")
                 else:
-                    self.optimizer.export_optimizer_rows(filePath, file_type)
-                    create_popup(self, f'Exported successfully to {filePath}.')
+                    self.optimizer.export_optimizer_rows(file_path, file_type)
+                    create_popup(self, f'Exported successfully to {file_path}.')
 
                 if open_from_msg_box(text='Do you want to open the optimization report?', title='Optimizer Report'):
-                    open_file_or_folder(filePath)
+                    open_file_or_folder(file_path)
 
             else:
                 create_popup(self, "No table rows found.")
@@ -331,7 +333,6 @@ def initiate_optimizer(self):
 
         self.threads[OPTIMIZER] = optimizerThread.OptimizerThread(gui=self, logger=self.logger, combos=combos)
         worker = self.threads[OPTIMIZER]
-        worker.signals.started.connect(lambda: self.set_optimizer_buttons(running=True, clear=True))
         worker.signals.restore.connect(lambda: self.set_optimizer_buttons(running=False, clear=False))
         worker.signals.error.connect(lambda x: create_popup(self, x))
         if self.configuration.enabledOptimizerNotification.isChecked():
@@ -407,18 +408,19 @@ def end_backtest(self):
         """
         Ends backtest and prompts user if they want to see the results.
         """
-        backtestFolderPath = create_folder('Backtest Results')
-        innerPath = os.path.join(backtestFolderPath, self.backtester.symbol)
-        create_folder_if_needed(innerPath, backtestFolderPath)
-        defaultFile = os.path.join(innerPath, self.backtester.get_default_result_file_name())
-        fileName, _ = QFileDialog.getSaveFileName(self, 'Save Result', defaultFile, 'TXT (*.txt)')
-        fileName = fileName.strip()
-        fileName = fileName if fileName != '' else None
+        backtest_folder_path = PATHS.get_backtest_results_dir()
+        create_folder_if_needed(backtest_folder_path)
+        inner_path = os.path.join(backtest_folder_path, self.backtester.symbol)
+        create_folder_if_needed(inner_path)
+        default_file = os.path.join(inner_path, self.backtester.get_default_result_file_name(backtest_folder_path))
+        file_name, _ = QFileDialog.getSaveFileName(self, 'Save Result', default_file, 'TXT (*.txt)')
+        file_name = file_name.strip()
+        file_name = file_name if file_name != '' else None
 
-        if not fileName:
+        if not file_name:
             self.add_to_backtest_monitor('Ended backtest.')
         else:
-            path = self.backtester.write_results(resultFile=fileName)
+            path = self.backtester.write_results(resultFile=file_name)
             self.add_to_backtest_monitor(f'Ended backtest and saved results to {path}.')
 
             if open_from_msg_box(text=f"Backtest results have been saved to {path}.", title="Backtest Results"):
@@ -1293,12 +1295,13 @@ def export_trades(self, caller):
                 trade.append(item.text())
             trades.append(trade)
 
-        path = create_folder("Trade History")
+        trade_history_dir = PATHS.get_trade_history_dir()
+        create_folder_if_needed(trade_history_dir)
 
         if caller == LIVE:
-            defaultFile = os.path.join(path, 'live_trades.csv')
+            defaultFile = os.path.join(trade_history_dir, 'live_trades.csv')
         else:
-            defaultFile = os.path.join(path, 'simulation_trades.csv')
+            defaultFile = os.path.join(trade_history_dir, 'simulation_trades.csv')
 
         path, _ = QFileDialog.getSaveFileName(self, 'Export Trades', defaultFile, 'CSV (*.csv)')
 
@@ -1317,8 +1320,9 @@ def import_trades(self, caller):
         """
         table = self.interfaceDictionary[caller]['mainInterface']['historyTable']
         label = self.interfaceDictionary[caller]['mainInterface']['historyLabel']
-        path = create_folder("Trade History")
-        path, _ = QFileDialog.getOpenFileName(self, 'Import Trades', path, "CSV (*.csv)")
+        trade_history_dir = PATHS.get_trade_history_dir()
+        create_folder_if_needed(trade_history_dir)
+        path, _ = QFileDialog.getOpenFileName(self, 'Import Trades', trade_history_dir, "CSV (*.csv)")
 
         try:
             with open(path, 'r') as f:

algobot/data.py

@@ -9,7 +9,8 @@
 from binance.client import Client
 from binance.helpers import interval_to_milliseconds
 
-from algobot.helpers import (ROOT_DIR, get_logger, get_normalized_data,
+from algobot import helpers
+from algobot.helpers import (PATHS, get_logger, get_normalized_data,
                              get_ups_and_downs)
 from algobot.typing_hints import DATA_TYPE
 
@@ -142,12 +143,12 @@ def get_database_file(self) -> str:
         Retrieves database file path.
         :return: Database file path.
         """
-        database_folder = os.path.join(ROOT_DIR, 'Databases')
+        database_folder = PATHS.get_database_dir()
         if not os.path.exists(database_folder):
-            os.mkdir(database_folder)
+            os.makedirs(database_folder)
 
-        filePath = os.path.join(database_folder, f'{self.symbol}.db')
-        return filePath
+        file_path = os.path.join(database_folder, f'{self.symbol}.db')
+        return file_path
 
     def create_table(self):
         """
@@ -521,19 +522,20 @@ def get_interval_minutes(self) -> int:
         else:
             raise ValueError("Invalid interval.", 4)
 
-    def create_folders_and_change_path(self, folderName: str):
+    def create_folders_and_change_path(self, folder_name: str):
         """
         Creates appropriate folders for data storage then changes current working directory to it.
-        :param folderName: Folder to create.
+        :param folder_name: Folder to create.
         """
-        os.chdir(ROOT_DIR)
-        if not os.path.exists(folderName):  # Create CSV folder if it doesn't exist
-            os.mkdir(folderName)
-        os.chdir(folderName)  # Go inside the folder.
+        if not os.path.exists(folder_name):
+            helpers.create_folder_if_needed(folder_name)
 
-        if not os.path.exists(self.symbol):  # Create symbol folder inside CSV folder if it doesn't exist.
+        os.chdir(folder_name)
+
+        if not os.path.exists(self.symbol):
             os.mkdir(self.symbol)
-        os.chdir(self.symbol)  # Go inside the folder.
+
+        os.chdir(self.symbol)
 
     def write_csv_data(self, totalData: list, fileName: str, armyTime: bool = True) -> str:
         """
@@ -544,7 +546,7 @@ def write_csv_data(self, totalData: list, fileName: str, armyTime: bool = True)
         :return: Absolute path to CSV file.
         """
         currentPath = os.getcwd()
-        self.create_folders_and_change_path(folderName="CSV")
+        self.create_folders_and_change_path(PATHS.get_csv_dir())
 
         with open(fileName, 'w') as f:
             f.write("Date_UTC, Open, High, Low, Close, Volume, Quote_Asset_Volume, Number_of_Trades, "