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

@@ -16,6 +16,7 @@
                              QMainWindow, QMessageBox, QTableWidgetItem)
 
 import algobot.assets
+from algobot import helpers
 from algobot.algodict import get_interface_dictionary
 from algobot.data import Data
 from algobot.enums import (AVG_GRAPH, BACKTEST, LIVE, LONG, NET_GRAPH,
@@ -26,7 +27,7 @@
                                    setup_graph_plots, setup_graphs,
                                    update_backtest_graph_limits,
                                    update_main_graphs)
-from algobot.helpers import (ROOT_DIR, create_folder, create_folder_if_needed,
+from algobot.helpers import (PATHS, create_folder, 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
@@ -47,7 +48,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,10 +253,11 @@ def export_optimizer(self, file_type: str):
         """
         if self.optimizer:
             if len(self.optimizer.optimizerRows) > 0:
-                optimizerFolderPath = create_folder('Optimizer Results')
+                optimizerFolderPath = create_folder(helpers.PATHS.get_optimizer_results_dir())
                 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())
+                create_folder_if_needed(innerPath)
+                defaultFileName = self.optimizer.get_default_result_file_name(helpers.PATHS.get_optimizer_results_dir(),
+                                                                              'optimizer', ext=file_type.lower())
                 defaultPath = os.path.join(innerPath, defaultFileName)
                 filePath, _ = QFileDialog.getSaveFileName(self, 'Save Optimizer', defaultPath,
                                                           f'{file_type} (*.{file_type.lower()})')
@@ -407,10 +409,11 @@ def end_backtest(self):
         """
         Ends backtest and prompts user if they want to see the results.
         """
-        backtestFolderPath = create_folder('Backtest Results')
+        backtestFolderPath = create_folder(helpers.PATHS.get_backtest_results_dir())
         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())
+        create_folder_if_needed(innerPath)
+        defaultFile = os.path.join(innerPath, self.backtester.get_default_result_file_name(
+            helpers.PATHS.get_backtest_results_dir()))
         fileName, _ = QFileDialog.getSaveFileName(self, 'Save Result', defaultFile, 'TXT (*.txt)')
         fileName = fileName.strip()
         fileName = fileName if fileName != '' else None
@@ -1293,7 +1296,7 @@ def export_trades(self, caller):
                 trade.append(item.text())
             trades.append(trade)
 
-        path = create_folder("Trade History")
+        path = create_folder(helpers.PATHS.get_trade_history_dir())
 
         if caller == LIVE:
             defaultFile = os.path.join(path, 'live_trades.csv')
@@ -1317,7 +1320,7 @@ def import_trades(self, caller):
         """
         table = self.interfaceDictionary[caller]['mainInterface']['historyTable']
         label = self.interfaceDictionary[caller]['mainInterface']['historyLabel']
-        path = create_folder("Trade History")
+        path = create_folder(helpers.PATHS.get_trade_history_dir())
         path, _ = QFileDialog.getOpenFileName(self, 'Import Trades', path, "CSV (*.csv)")
 
         try:

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(helpers.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, "

algobot/helpers.py

@@ -11,6 +11,7 @@
 from typing import Dict, List, Tuple, Union
 
 import requests
+from appdirs import AppDirs
 from dateutil import parser
 
 import algobot
@@ -19,7 +20,10 @@
 
 BASE_DIR = os.path.dirname(__file__)
 ROOT_DIR = os.path.dirname(BASE_DIR)
-LOG_FOLDER = 'Logs'
+
+APP_NAME = "algobot"
+APP_AUTHOR = "ZENALC"
+
 
 SHORT_INTERVAL_MAP = {
     '1m': '1 Minute',
@@ -40,6 +44,49 @@
 LONG_INTERVAL_MAP = {v: k for k, v in SHORT_INTERVAL_MAP.items()}
 
 
+class Paths:
+
+    def __init__(self, root_dir: str, app_dirs):
+        self.root_dir = root_dir
+        self.app_dirs = app_dirs
+
+    def get_ui_dir(self) -> str:
+        return os.path.join(self.root_dir, 'UI')
+
+    def get_log_dir(self) -> str:
+        return os.path.join(self.app_dirs.user_log_dir, 'Logs')
+
+    def get_database_dir(self) -> str:
+        return os.path.join(self.app_dirs.user_data_dir, 'Databases')
+
+    def get_state_path(self) -> str:
+        return os.path.join(self.app_dirs.user_data_dir, 'state.json')
+
+    def get_optimizer_results_dir(self) -> str:
+        return os.path.join(self.app_dirs.user_data_dir, 'Optimizer Results')
+
+    def get_backtest_results_dir(self) -> str:
+        return os.path.join(self.app_dirs.user_data_dir, 'Backtest Results')
+
+    def get_trade_history_dir(self) -> str:
+        return os.path.join(self.app_dirs.user_data_dir, 'Trade History')
+
+    def get_volatility_results_dir(self) -> str:
+        return os.path.join(self.app_dirs.user_data_dir, 'Volatility Results')
+
+    def get_csv_dir(self) -> str:
+        return os.path.join(self.app_dirs.user_data_dir, 'CSV')
+
+    def get_configuration_dir(self) -> str:
+        return os.path.join(self.app_dirs.user_data_dir, 'configuration')
+
+    def get_credentials_dir(self) -> str:
+        return os.path.join(self.app_dirs.user_data_dir, 'Credentials')
+
+
+PATHS = Paths(ROOT_DIR, AppDirs(APP_NAME, APP_AUTHOR))
+
+
 def get_latest_version() -> str:
     """
     Gets the latest Algobot version from GitHub.
@@ -90,65 +137,62 @@ def open_folder(folder: str):
     """
     This will open a folder even if it doesn't exist. It'll create one if it doesn't exist.
     """
-    targetPath = create_folder(folder)
-    open_file_or_folder(targetPath)
+    target_path = create_folder(folder)
+    open_file_or_folder(target_path)
 
 
-def create_folder(folder: str):
+def create_folder(folder: str) -> str:
     """
     This will create a folder if needed in the root directory.
     """
-    targetPath = os.path.join(ROOT_DIR, folder)
-    create_folder_if_needed(targetPath)
+    create_folder_if_needed(folder)
 
-    return targetPath
+    return folder
 
 
-def create_folder_if_needed(targetPath: str, basePath: str = ROOT_DIR) -> bool:
+def create_folder_if_needed(target_path: str) -> bool:
     """
     This function will create the appropriate folders in the root folder if needed.
-    :param targetPath: Target path to have exist.
-    :param basePath: Base path to start from. By default, it'll be the root directory.
+    :param target_path: Target path to have exist.
     :return: Boolean whether folder was created or not.
     """
-    if not os.path.exists(targetPath):
-        folder = os.path.basename(targetPath)
-        os.mkdir(os.path.join(basePath, folder))
+    if not os.path.exists(target_path):
+        os.makedirs(target_path)
         return True
     return False
 
 
-def open_file_or_folder(targetPath: str):
+def open_file_or_folder(target_path: str):
     """
     Opens a file or folder based on targetPath.
-    :param targetPath: File or folder to open with system defaults.
+    :param target_path: File or folder to open with system defaults.
     """
     if platform.system() == "Windows":
-        os.startfile(targetPath)
+        os.startfile(target_path)
     elif platform.system() == "Darwin":
-        subprocess.Popen(["open", targetPath])
+        subprocess.Popen(["open", target_path])
     else:
-        subprocess.Popen(["xdg-open", targetPath])
+        subprocess.Popen(["xdg-open", target_path])
 
 
-def setup_and_return_log_path(fileName: str) -> str:
+def setup_and_return_log_path(filename: str) -> str:
     """
     Creates folders (if needed) and returns default log path.
-    :param fileName: Log filename to be created.
+    :param filename: Log filename to be created.
     :return: Absolute path to log file.
     """
-    LOG_DIR = os.path.join(ROOT_DIR, LOG_FOLDER)
-    if not os.path.exists(LOG_DIR):
-        os.mkdir(LOG_DIR)
+    log_dir = PATHS.get_log_dir()
+    if not os.path.exists(log_dir):
+        os.makedirs(log_dir)
 
-    todayDate = datetime.today().strftime('%Y-%m-%d')
-    LOG_DATE_FOLDER = os.path.join(LOG_DIR, todayDate)
-    if not os.path.exists(LOG_DATE_FOLDER):
-        os.mkdir(LOG_DATE_FOLDER)
+    today_date = datetime.today().strftime('%Y-%m-%d')
+    log_date_folder = os.path.join(log_dir, today_date)
+    if not os.path.exists(log_date_folder):
+        os.mkdir(log_date_folder)
 
-    logFileName = f'{datetime.now().strftime("%H-%M-%S")}-{fileName}.log'
-    fullPath = os.path.join(LOG_DATE_FOLDER, logFileName)
-    return fullPath
+    log_file_name = f'{datetime.now().strftime("%H-%M-%S")}-{filename}.log'
+    full_path = os.path.join(log_date_folder, log_file_name)
+    return full_path
 
 
 def get_logger(log_file: str, logger_name: str) -> logging.Logger:
@@ -164,7 +208,7 @@ def get_logger(log_file: str, logger_name: str) -> logging.Logger:
         log_level = logging.DEBUG
     logger.setLevel(log_level)
     formatter = logging.Formatter('%(message)s')
-    handler = logging.FileHandler(filename=setup_and_return_log_path(fileName=log_file), delay=True)
+    handler = logging.FileHandler(filename=setup_and_return_log_path(filename=log_file), delay=True)
     handler.setFormatter(formatter)
     logger.addHandler(handler)
 

algobot/interface/config_utils/credential_utils.py

@@ -33,7 +33,7 @@ def save_credentials(config_obj):
     Function that saves credentials to base path in a JSON format. Obviously not very secure, but temp fix.
     :param config_obj: Configuration QDialog object (from configuration.py)
     """
-    targetFolder = os.path.join(helpers.ROOT_DIR, config_obj.credentialsFolder)
+    targetFolder = config_obj.credentialsFolder
     helpers.create_folder_if_needed(targetFolder)
 
     apiKey = config_obj.binanceApiKey.text()
@@ -60,7 +60,7 @@ def load_credentials(config_obj, auto: bool = True):
     :param auto: Boolean regarding whether bot called this function or not. If bot called it, silently try to load
     credentials. If a user called it, however, open a file dialog to ask for the file path to credentials.
     """
-    targetFolder = os.path.join(helpers.ROOT_DIR, config_obj.credentialsFolder)
+    targetFolder = config_obj.credentialsFolder
     if helpers.create_folder_if_needed(targetFolder):
         config_obj.credentialResult.setText('No credentials found.')
         return

algobot/interface/config_utils/data_utils.py

@@ -19,7 +19,7 @@ def import_data(config_obj, caller: int = BACKTEST):
     action = 'backtest' if caller == BACKTEST else 'optimization'
 
     inner_dict['infoLabel'].setText("Importing data...")
-    filePath, _ = QFileDialog.getOpenFileName(config_obj, 'Open file', helpers.ROOT_DIR, "CSV (*.csv)")
+    filePath, _ = QFileDialog.getOpenFileName(config_obj, 'Open file', helpers.PATHS.get_csv_dir(), "CSV (*.csv)")
     if filePath == '':
         inner_dict['infoLabel'].setText("Data not imported.")
         inner_dict['downloadProgress'].setValue(0)

algobot/interface/config_utils/user_config_utils.py

@@ -23,11 +23,10 @@ def create_appropriate_config_folders(config_obj, folder: str) -> str:
     :param folder: Folder to create inside configuration folder.
     :return: Absolute path to new folder.
     """
-    basePath = os.path.join(helpers.ROOT_DIR, config_obj.configFolder)
-    helpers.create_folder_if_needed(basePath)
+    basePath = config_obj.configFolder
 
     targetPath = os.path.join(basePath, folder)
-    helpers.create_folder_if_needed(targetPath, basePath=basePath)
+    helpers.create_folder_if_needed(targetPath)
 
     return targetPath
 

algobot/interface/configuration.py

@@ -22,7 +22,7 @@
 from algobot.strategies import *  # noqa: F403, F401
 from algobot.strategies.strategy import Strategy
 
-configurationUi = os.path.join(helpers.ROOT_DIR, 'UI', 'configuration.ui')
+configurationUi = os.path.join(helpers.PATHS.get_ui_dir(), 'configuration.ui')
 
 
 class Configuration(QDialog):
@@ -82,9 +82,9 @@ def __init__(self, parent: QMainWindow, logger: Logger = None):
         self.chatPass = False
 
         # Folders and files
-        self.credentialsFolder = "Credentials"
-        self.configFolder = 'Configuration'
-        self.stateFilePath = os.path.join(helpers.ROOT_DIR, 'state.json')
+        self.credentialsFolder = helpers.PATHS.get_credentials_dir()
+        self.configFolder = helpers.PATHS.get_configuration_dir()
+        self.stateFilePath = helpers.PATHS.get_state_path()
 
         self.categoryTabs = [
             self.mainConfigurationTabWidget,