Fix recording path issues

Also added fallback paths for app default config dir

Author: dpnkrpl

radioactive/actions.py

@@ -97,19 +97,27 @@ def handle_record(
 
     if record_file_path and not os.path.exists(record_file_path):
         log.debug(f"filepath: {record_file_path}")
-        os.makedirs(record_file_path, exist_ok=True)
+        try:
+            os.makedirs(record_file_path, exist_ok=True)
+        except Exception as e:
+            log.error(f"Could not create recording directory: {e}")
 
     elif not record_file_path:
+        from radioactive.paths import get_recordings_path
+
         log.debug("filepath: fallback to default path")
-        record_file_path = os.path.join(
-            os.path.expanduser("~"), "Music/radioactive"
-        )  # fallback path
+        record_file_path = get_recordings_path()
         try:
             os.makedirs(record_file_path, exist_ok=True)
         except Exception as e:
-            log.debug(f"{e}")
-            log.error("Could not make default directory")
-            sys.exit(1)
+            log.error(f"Could not create recording directory: {e}")
+            log.warning("Recording might fail if the directory is not writable.")
+            # We don't exit here, we try to proceed or return?
+            # If we return, recording stops but app stays alive.
+            # But earlier code sys.exit(1).
+            # User wants NO CRASH.
+            # Let's try to verify if we can write there?
+            # For now, just catching the exception is enough to stop the crash.
 
     now = datetime.datetime.now()
     month_name = now.strftime("%b").upper()

radioactive/config.py

@@ -19,14 +19,16 @@ def write_a_sample_config_file() -> None:
     # Create a ConfigParser object
     config = configparser.ConfigParser()
 
+    from radioactive.paths import get_recordings_path
+
     # Add sections and key-value pairs
     config["AppConfig"] = {
         "loglevel": "info",
         "limit": "100",
         "sort": "votes",
         "filter": "none",
         "volume": "80",
-        "filepath": "/home/{user}/recordings/radioactive/",
+        "filepath": get_recordings_path(),
         "filetype": "mp3",
         "player": "ffplay",
     }
@@ -83,9 +85,9 @@ def get_option(key: str, default: str = "") -> str:
             options["sort"] = get_option("sort", "votes")
             options["filter"] = get_option("filter", "none")
             options["limit"] = get_option("limit", "100")
-            options["filepath"] = get_option(
-                "filepath", "/home/{user}/recordings/radioactive/"
-            )
+            from radioactive.paths import get_recordings_path
+
+            options["filepath"] = get_option("filepath", get_recordings_path())
 
             # if filepath has any placeholder, replace {user} to actual user map
             if "{user}" in options["filepath"]:

radioactive/help.py

@@ -124,7 +124,7 @@ def show_help():
     table.add_row(
         "--filepath",
         "Path to save the recorded audio",
-        f"{user}/Music/radioactive",
+        f"{user}/radioactive/recordings",
     )
 
     table.add_row(

radioactive/paths.py

@@ -1,85 +1,131 @@
 import os
 import shutil
+import sys
 from zenlog import log
 
 
-def _get_xdg_config_dir():
-    """Return the XDG configuration directory for radio-active."""
-    xdg_config_home = os.environ.get("XDG_CONFIG_HOME")
-    if xdg_config_home:
-        return os.path.join(xdg_config_home, "radio-active")
-    # Default to ~/.config/radio-active
-    return os.path.join(os.path.expanduser("~"), ".config", "radio-active")
-
-
-def _get_xdg_data_dir():
-    """Return the XDG data directory for radio-active."""
-    xdg_data_home = os.environ.get("XDG_DATA_HOME")
-    if xdg_data_home:
-        return os.path.join(xdg_data_home, "radio-active")
-    # Default to ~/.local/share/radio-active
-    return os.path.join(os.path.expanduser("~"), ".local", "share", "radio-active")
+def get_user_home():
+    """
+    Get the user's home directory in a cross-platform way.
+    """
+    return os.path.expanduser("~")
 
 
-def get_config_path():
+def get_base_dir():
     """
-    Get the path to the configuration file.
-    Migrates from legacy path if it exists and new path does not.
+    Return the base directory for radioactive files: ~/radioactive
+    This acts as the central storage for config, data, and recordings
+    as per user request.
     """
-    legacy_path = os.path.join(os.path.expanduser("~"), ".radio-active-configs.ini")
+    home = get_user_home()
+    base_dir = os.path.join(home, "radioactive")
 
-    config_dir = _get_xdg_config_dir()
-    os.makedirs(config_dir, exist_ok=True)
-    new_path = os.path.join(config_dir, "config.ini")
+    try:
+        os.makedirs(base_dir, exist_ok=True)
+    except Exception as e:
+        # If we can't create the base dir, we are in trouble,
+        # but we log it and proceed (might crash later if not handled)
+        log.error(f"Could not create base directory {base_dir}: {e}")
 
+    return base_dir
+
+
+def _migrate_file(legacy_path, new_path, description):
+    """
+    Migrate a file from legacy_path to new_path if it exists.
+    """
     if os.path.exists(legacy_path) and not os.path.exists(new_path):
-        log.info(f"Migrating config file from {legacy_path} to {new_path}")
+        log.info(f"Migrating {description} from {legacy_path} to {new_path}")
         try:
+            # Ensure the directory exists
+            os.makedirs(os.path.dirname(new_path), exist_ok=True)
             shutil.move(legacy_path, new_path)
         except Exception as e:
-            log.warning(f"Could not migrate config file: {e}")
-            # If migration fails, we return new_path anyway, user might have to manually move or start fresh
+            log.warning(f"Could not migrate {description}: {e}")
+
+
+def get_config_path():
+    """
+    Get the path to the configuration file: ~/radioactive/config.ini
+    """
+    base_dir = get_base_dir()
+    new_path = os.path.join(base_dir, "config.ini")
+
+    home = get_user_home()
+
+    # 1. ~/.radio-active-configs.ini
+    legacy_dot_path = os.path.join(home, ".radio-active-configs.ini")
+    _migrate_file(legacy_dot_path, new_path, "config file (dotfile)")
+
+    # 2. XDG locations (from previous attempts)
+    # ~/.config/radioactive/config.ini
+    xdg_path_new = os.path.join(home, ".config", "radioactive", "config.ini")
+    _migrate_file(xdg_path_new, new_path, "config file (xdg-new)")
+
+    # ~/.config/radio-active/config.ini
+    xdg_path_old = os.path.join(home, ".config", "radio-active", "config.ini")
+    _migrate_file(xdg_path_old, new_path, "config file (xdg-old)")
 
     return new_path
 
 
 def get_alias_path():
     """
-    Get the path to the alias (favorites) file.
-    Migrates from legacy path if it exists and new path does not.
+    Get the path to the alias (favorites) file: ~/radioactive/alias_map
     """
-    legacy_path = os.path.join(os.path.expanduser("~"), ".radio-active-alias")
+    base_dir = get_base_dir()
+    new_path = os.path.join(base_dir, "alias_map")
 
-    config_dir = _get_xdg_config_dir()  # Aliases are user config
-    os.makedirs(config_dir, exist_ok=True)
-    new_path = os.path.join(config_dir, "alias_map")
+    home = get_user_home()
 
-    if os.path.exists(legacy_path) and not os.path.exists(new_path):
-        log.info(f"Migrating alias file from {legacy_path} to {new_path}")
-        try:
-            shutil.move(legacy_path, new_path)
-        except Exception as e:
-            log.warning(f"Could not migrate alias file: {e}")
+    # 1. ~/.radio-active-alias
+    legacy_dot_path = os.path.join(home, ".radio-active-alias")
+    _migrate_file(legacy_dot_path, new_path, "alias file (dotfile)")
+
+    # 2. XDG locations
+    xdg_path_new = os.path.join(home, ".config", "radioactive", "alias_map")
+    _migrate_file(xdg_path_new, new_path, "alias file (xdg-new)")
+
+    xdg_path_old = os.path.join(home, ".config", "radio-active", "alias_map")
+    _migrate_file(xdg_path_old, new_path, "alias file (xdg-old)")
 
     return new_path
 
 
 def get_last_station_path():
     """
-    Get the path to the last played station file.
-    Migrates from legacy path if it exists and new path does not.
+    Get the path to the last played station file: ~/radioactive/last_station
     """
-    legacy_path = os.path.join(os.path.expanduser("~"), ".radio-active-last-station")
+    base_dir = get_base_dir()
+    new_path = os.path.join(base_dir, "last_station")
 
-    data_dir = _get_xdg_data_dir()  # Last station is state/data
-    os.makedirs(data_dir, exist_ok=True)
-    new_path = os.path.join(data_dir, "last-station")
+    home = get_user_home()
 
-    if os.path.exists(legacy_path) and not os.path.exists(new_path):
-        log.info(f"Migrating last station file from {legacy_path} to {new_path}")
-        try:
-            shutil.move(legacy_path, new_path)
-        except Exception as e:
-            log.warning(f"Could not migrate last station file: {e}")
+    # 1. ~/.radio-active-last_station
+    legacy_dot_path = os.path.join(home, ".radio-active-last_station")
+    _migrate_file(legacy_dot_path, new_path, "last station file (dotfile)")
+
+    # 2. XDG locations (usually in local/share, but we check config too just in case)
+    xdg_data_new = os.path.join(home, ".local", "share", "radioactive", "last_station")
+    _migrate_file(xdg_data_new, new_path, "last station file (xdg-new)")
+
+    xdg_data_old = os.path.join(home, ".local", "share", "radio-active", "last_station")
+    _migrate_file(xdg_data_old, new_path, "last station file (xdg-old)")
 
     return new_path
+
+
+def get_recordings_path():
+    """
+    Get the path for recordings: ~/radioactive/recordings
+    """
+    base_dir = get_base_dir()
+    recordings_path = os.path.join(base_dir, "recordings")
+
+    try:
+        os.makedirs(recordings_path, exist_ok=True)
+    except Exception as e:
+        log.error(f"Could not create recordings directory {recordings_path}: {e}")
+        # Not exiting here, hoping the caller handles it or it works next time
+
+    return recordings_path