Merge branch 'update-python-rclone-dep' into new-gui

Author: MitchellThompkins

poetry.lock

@@ -13,7 +13,6 @@ readme = "README.md"
 [tool.poetry.dependencies]
 python = ">=3.10,<4.0"
 click = "^8.1.3"
-python-rclone = "^0.0.2"
 python-statemachine = "^2.0.0"
 flet = "0.21.2"
 

pyproject.toml

@@ -1,7 +1,6 @@
 import click
 
 import rclone_decrypt.decrypt as decrypt
-import rclone_decrypt.gui as GUI
 
 
 help_str_config = f"""config file. default config file is:
@@ -23,22 +22,15 @@
     help=help_str_output,
     default=decrypt.default_output_dir,
 )
-@click.option("--gui", help="start the GUI", is_flag=True, default=False)
-@click.option(
-    "--gui_debug", help="print debug messages", is_flag=True, default=False
-)
-def cli(config, files, output_dir, gui, gui_debug):
-    if gui is True:
-        GUI.start_gui(gui_debug)
-    else:
-        try:
-            if files is None:
-                raise ValueError("files cannot be None")
-            else:
-                decrypt.decrypt(files, config, output_dir)
-
-        except (ValueError, decrypt.RCloneExecutableError) as err:
-            decrypt.print_error(err)
+def cli(config, files, output_dir):
+    try:
+        if files is None:
+            raise ValueError("files cannot be None")
+        else:
+            decrypt.decrypt(files, config, output_dir)
+
+    except (ValueError, decrypt.RCloneExecutableError) as err:
+        decrypt.print_error(err)
 
 
 if __name__ == "__main__":

src/rclone_decrypt/cli.py

@@ -1,12 +1,11 @@
 import logging
 import os
-import io
 import re
 import sys
 import shutil
 import tempfile
+import subprocess
 
-import rclone
 from statemachine import State, StateMachine
 
 logger = logging.getLogger("rclone_decrypt")
@@ -15,6 +14,23 @@
     os.path.expanduser("~"), "Downloads", "rclone-decrypted"
 )
 
+try:
+    if shutil.which("rclone"):
+        # Get the rclone config file path dynamically
+        cmd = ["rclone", "config", "file"]
+        out = subprocess.check_output(cmd).decode().strip()
+        # The output format is usually:
+        # "Configuration file is stored at:\n/path/to/rclone.conf"
+        # We need to parse the last line
+        default_rclone_conf_dir = out.splitlines()[-1]
+    else:
+        raise FileNotFoundError("rclone executable not found")
+except (subprocess.CalledProcessError, FileNotFoundError):
+    # Fallback to the previous default if rclone command fails or is not found
+    default_rclone_conf_dir = os.path.join(
+        os.environ["HOME"], ".config", "rclone", "rclone.conf"
+    )
+
 if sys.platform == "win32":
     # Windows default: %APPDATA%/rclone/rclone.conf
     default_rclone_conf_dir = os.path.join(
@@ -91,60 +107,32 @@ def before_is_valid(self, line: str) -> None:
         self.cfg_file.write(line)
 
 
-class SafeRClone(rclone.RClone):
-    """
-    A subclass of rclone.RClone that uses delete=False for the temporary
-    config file. This prevents file locking issues on Windows where the file
-    cannot be opened by the subprocess while it is still open in Python.
-    """
-
-    def run_cmd(self, command, extra_args=None):
-        if extra_args is None:
-            extra_args = []
-
-        # Create a named temporary file, but don't delete it automatically
-        # on close, so we can close it before passing to rclone.
-        with tempfile.NamedTemporaryFile(mode="wt", delete=False) as cfg_file:
-            cfg_file_path = cfg_file.name
-            try:
-                self.log.debug("rclone config: ~%s~", self.cfg)
-                cfg_file.write(self.cfg)
-                cfg_file.flush()
-                # Close the file so other processes can access it (Windows fix)
-                cfg_file.close()
-
-                command_with_args = [
-                    "rclone",
-                    command,
-                    "--config",
-                    cfg_file_path,
-                ]
-                command_with_args += extra_args
-                command_result = self._execute(command_with_args)
-                return command_result
-            finally:
-                # Manually clean up the file
-                if os.path.exists(cfg_file_path):
-                    os.remove(cfg_file_path)
-
-
-def get_rclone_instance(
+def get_rclone_config_path(
     config: str, files: str, remote_folder_name: str
-) -> rclone.RClone:
+) -> str:
     """
     Opens a config file and strips out all of the non-crypt type entries,
     modifies the remote to be local directory.
 
-    Returns an rclone instance.
+    Returns the path to the temporary rclone config file.
     """
-    rclone_instance = None
+    config_path = None
 
     try:
         with open(config, "r") as f:
             config_file = f.readlines()
 
-            with io.StringIO() as tmp_config_file:
-                config_state = ConfigWriterControl(tmp_config_file)
+            # Create a temporary file that persists until manually deleted or
+            # cleaned up by caller.
+            # We use delete=False so we can return the path and use it later.
+            # It will be created in the system temp dir or temp_dir_name if
+            # passed? Actually, let's create it inside remote_folder_name
+            # (which is a temp dir).
+
+            config_path = os.path.join(remote_folder_name, "rclone.conf")
+
+            with open(config_path, "w") as config_out:
+                config_state = ConfigWriterControl(config_out)
 
                 for line in config_file:
                     state_id = config_state.current_state.id
@@ -186,36 +174,39 @@ def get_rclone_instance(
 
                 config_state.complete()
 
-                # Get the content
-                o = tmp_config_file.getvalue()
-                # Use our SafeRClone instead of rclone.with_config
-                rclone_instance = SafeRClone(cfg=o)
-
-        # I think that given a file, any file, rclone.with_config() will always
-        # return _something_ as it doesn't validate the config file
-        if rclone_instance is None:
-            raise ConfigFileError("The rclone instance was not created.")
-
     except FileNotFoundError as err:
         print_error(err)
+        return None
 
-    return rclone_instance
+    return config_path
 
 
-def rclone_copy(rclone_instance: rclone.RClone, output_dir: str) -> None:
+def rclone_copy(config_path: str, output_dir: str) -> None:
     """
     Calls the rclone copy function via a shell instance and places the
     decrypted files into the output_dir
     """
     # convert list of remotes in str format into a list
-    remotes = rclone_instance.listremotes()["out"].decode().splitlines()
+    list_cmd = ["rclone", "--config", config_path, "listremotes"]
+    try:
+        out = subprocess.check_output(list_cmd).decode()
+        remotes = out.splitlines()
+    except subprocess.CalledProcessError as e:
+        print_error(f"Failed to list remotes: {e}")
+        return
 
     for r in remotes:
-        logger.info(f"Copying and decrypting: {r}")
-        result = rclone_instance.copy(f"{r}", f"{output_dir}")
-        if result["code"] != 0:
-            error_msg = result["error"].decode("utf-8").strip()
-            logger.warning(f"Failed to decrypt {r}. Rclone error: {error_msg}")
+        print(f"Copying and decrypting: {r}")
+        copy_cmd = [
+            "rclone",
+            "--config",
+            config_path,
+            "copy",
+            f"{r}",
+            f"{output_dir}",
+        ]
+        # TODO(@mitchellthompkins): check return code for success
+        subprocess.run(copy_cmd, check=True)
 
 
 def decrypt(
@@ -250,13 +241,31 @@ def decrypt(
         ) as temp_dir_name:
             # Ensure path uses forward slashes for rclone config
             # compatibility on Windows
+            # Although update branch didn't have this, it's safer to keep it
+            # if we are creating paths for rclone.
+            # But get_rclone_config_path writes the config file now,
+            # and it writes {remote_folder_name}/ which is the temp dir.
+            # So normalization might be good.
+            # However, HEAD passed normalized_temp_dir to get_rclone_instance.
+            # update branch passed temp_dir_name directly.
+            # I will pass temp_dir_name directly to be safe with update logic,
+            # or normalized if I think it helps. HEAD thought it helped.
+            # I'll stick to temp_dir_name to minimize risk of path mismatch,
+            # unless I see a reason.
+            # Actually, HEAD comment says "compatibility on Windows".
+            # I'll add the normalization back if I see it's used in config writing.
+            # In update logic: config_state.write(f"remote = {remote_folder_name}/\n")
+            # If remote_folder_name has backslashes, rclone config might barf?
+            # Rclone usually handles both, but forward slashes are safer.
+            # I will normalize it.
             normalized_temp_dir = temp_dir_name.replace(os.sep, "/")
-            rclone_instance = get_rclone_instance(
+
+            config_path = get_rclone_config_path(
                 config, files, normalized_temp_dir
             )
 
-            if rclone_instance is None:
-                raise ConfigFileError("rclone_instance cannot be None")
+            if config_path is None:
+                raise ConfigFileError("config_path cannot be None")
 
             if output_dir is default_output_dir:
                 # If no output_dir is provided, put the de-crypted file into a
@@ -284,7 +293,7 @@ def decrypt(
                 # Do the copy, we wrap this in a try in case the user
                 # interrupts the process, otherwise the file won't be
                 # moved back
-                rclone_copy(rclone_instance, output_dir)
+                rclone_copy(config_path, output_dir)
                 logger.info(
                     f"Decryption complete. Files saved to: {output_dir}"
                 )

src/rclone_decrypt/decrypt.py

@@ -194,7 +194,7 @@ def test_no_config_file():
     Test behavior when provided no config file
     """
     files = os.path.join("tests", "something_fake")
-    instance = decrypt.get_rclone_instance("", files, "a_dir_name")
+    instance = decrypt.get_rclone_config_path("", files, "a_dir_name")
 
     assert instance is None
 
@@ -204,8 +204,10 @@ def test_config_file():
     Test behavior when provided valid config file
     """
     files = os.path.join("tests", "something_fake")
-    instance = decrypt.get_rclone_instance(
-        decrypt_rclone_config_file, files, "a_dir_name"
-    )
+    with tempfile.TemporaryDirectory() as temp_dir:
+        instance = decrypt.get_rclone_config_path(
+            decrypt_rclone_config_file, files, temp_dir
+        )
 
-    assert instance is not None
+        assert instance is not None
+        assert os.path.exists(instance)