Merge pull request #41 from Cyber-Syntax:fix/no-such-dir

Cyber-Syntax · web-flow · commit 293b54cb2577 · 2025-09-19T12:59:06.000+03:00
fix: no such file or dir error by new validation logic
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -1,6 +1,7 @@
 # Changelog
 All notable changes to this project will be documented in this file. Commits automatically generated by github actions.
 
+## v0.7.1-beta
 ## v0.7.0-beta
 ### BREAKING CHANGES
 This release introduces a new command-line interface (CLI) for AutoTarCompress, enabling users to perform all operations via terminal commands. The previous interactive menu mode still exists but may be deprecated in future releases. Users are encouraged to transition to the CLI for better automation and scripting capabilities. For detailed usage instructions, please refer to the updated documentation in [docs/wiki.md](docs/wiki.md).
diff --git a/autotarcompress/commands/backup.py b/autotarcompress/commands/backup.py
@@ -17,7 +17,11 @@
 
 from autotarcompress.commands.command import Command
 from autotarcompress.config import BackupConfig
-from autotarcompress.utils import SizeCalculator
+from autotarcompress.utils import (
+    SizeCalculator,
+    ensure_backup_folder,
+    validate_and_expand_paths,
+)
 
 
 class BackupCommand(Command):
@@ -40,15 +44,49 @@ def execute(self) -> bool:
             bool: True if backup succeeded, False otherwise.
 
         """
+        # Validate and ensure backup directories
+        existing_dirs, missing_dirs = validate_and_expand_paths(
+            self.config.dirs_to_backup
+        )
+        if missing_dirs:
+            # Log missing directories; no need to print to stdout here.
+            self.logger.warning(
+                "Some configured backup directories do not exist: %s",
+                missing_dirs,
+            )
+
+        # Use equality comparison instead of identity; lists with the same
+        # contents should be compared by value.
+        if existing_dirs != self.config.dirs_to_backup:
+            self.logger.info(
+                "Proceeding with existing directories only: %s",
+                existing_dirs,
+            )
+            self.config.dirs_to_backup = existing_dirs
+
+        # Ensure backup folder exists
+        try:
+            backup_folder_path = ensure_backup_folder(
+                self.config.backup_folder
+            )
+            self.config.backup_folder = str(backup_folder_path)
+            self.logger.info(
+                "Backup folder ensured at: %s",
+                self.config.backup_folder,
+            )
+        except (OSError, PermissionError) as e:
+            self.logger.error("Failed to ensure backup folder: %s", e)
+            return False
+
         if not self.config.dirs_to_backup:
-            self._print_and_log(
-                "No directories configured for backup. Skipping backup.", level="error"
+            self.logger.error(
+                "No directories configured for backup. Skipping backup."
             )
             return False
         total_size: int = self._calculate_total_size()
         if total_size == 0:
-            self._print_and_log(
-                "Total backup size is 0 bytes. Nothing to back up.", level="warning"
+            self.logger.warning(
+                "Total backup size is 0 bytes. Nothing to back up."
             )
             return False
         success: bool = self._run_backup_process(total_size)
@@ -63,7 +101,10 @@ def _calculate_total_size(self) -> int:
             int: Total size in bytes.
 
         """
-        calculator = SizeCalculator(self.config.dirs_to_backup, self.config.ignore_list)
+        calculator = SizeCalculator(
+            self.config.dirs_to_backup,
+            self.config.ignore_list,
+        )
         return calculator.calculate_total_size()
 
     def _run_backup_process(self, total_size: int) -> bool:
@@ -77,39 +118,56 @@ def _run_backup_process(self, total_size: int) -> bool:
 
         """
         if os.path.exists(self.config.backup_path):
-            self._print_and_log(f"File already exists: {self.config.backup_path}", level="warning")
+            print(f"File already exists: {self.config.backup_path}")
+            self.logger.warning(
+                "File already exists: %s",
+                self.config.backup_path,
+            )
             if not self._prompt_overwrite():
-                self._print_and_log("Backup aborted by user due to existing file.", level="info")
+                msg = "Backup aborted by user due to existing file."
+                self.logger.info("%s", msg)
                 return False
             try:
                 os.remove(self.config.backup_path)
-                self.logger.info("Removed existing backup file: %s", self.config.backup_path)
+                self.logger.info(
+                    "Removed existing backup file: %s",
+                    self.config.backup_path,
+                )
             # NOTE: Broad except is used here to ensure any file removal error
             # is caught during backup overwrite prompt. This is a critical IO
             # operation.
             except (OSError, PermissionError) as e:
-                self._print_and_log(f"Failed to remove existing backup: {e}", level="error")
+                self.logger.error("Failed to remove existing backup: %s", e)
                 return False
 
         cmd = self._build_tar_command()
         total_size_gb = total_size / 1024**3
 
-        self.logger.info("Starting backup to %s", self.config.backup_path)
-        self.logger.info("Total size: %.2f GB", total_size_gb)
+        self.logger.info(
+            "Starting backup to %s",
+            self.config.backup_path,
+        )
+        self.logger.info(
+            "Total size: %.2f GB",
+            total_size_gb,
+        )
 
         try:
             subprocess.run(cmd, shell=True, check=True)
             self.logger.info("Backup completed successfully")
-            self._print_and_log("Backup completed successfully.", level="info")
             return True
         except subprocess.CalledProcessError as e:
-            self._print_and_log(f"Backup failed: {e}", level="error")
+            self.logger.error("Backup failed: %s", e)
             return False
 
     def _build_tar_command(self) -> str:
         """Build the tar+xz command string for backup."""
-        exclude_options = " ".join(f"--exclude={path}" for path in self.config.ignore_list)
-        dir_paths = [os.path.expanduser(path) for path in self.config.dirs_to_backup]
+        exclude_options = " ".join(
+            f"--exclude={path}" for path in self.config.ignore_list
+        )
+        dir_paths = [
+            os.path.expanduser(path) for path in self.config.dirs_to_backup
+        ]
         quoted_paths = [shlex.quote(path) for path in dir_paths]
         cpu_count = os.cpu_count() or 1
         threads = max(1, cpu_count - 1)
@@ -124,18 +182,6 @@ def _prompt_overwrite(self) -> bool:
         response = input("Do you want to remove it? (y/n): ").strip().lower()
         return response == "y"
 
-    def _print_and_log(self, message: str, level: str = "info") -> None:
-        """Print and log a message at the specified level."""
-        print(message)
-        if level == "info":
-            self.logger.info(message)
-        elif level == "warning":
-            self.logger.warning(message)
-        elif level == "error":
-            self.logger.error(message)
-        else:
-            self.logger.debug(message)
-
     def _save_backup_info(self, total_size: int) -> None:
         """Save backup information to last-backup-info.json."""
         try:
@@ -149,7 +195,9 @@ def _save_backup_info(self, total_size: int) -> None:
             }
 
             # Save the info file in the backup folder
-            info_file_path = Path(self.config.backup_folder) / "last-backup-info.json"
+            info_file_path = (
+                Path(self.config.backup_folder) / "last-backup-info.json"
+            )
 
             with open(info_file_path, "w", encoding="utf-8") as f:
                 json.dump(backup_info, f, indent=2)
diff --git a/autotarcompress/utils.py b/autotarcompress/utils.py
@@ -8,21 +8,107 @@
 import os
 from pathlib import Path
 
+logger = logging.getLogger(__name__)
+
+
+def validate_and_expand_paths(
+    paths_to_check: list[str],
+) -> tuple[list[str], list[str]]:
+    """Validate and expand a list of candidate backup paths.
+
+    Args:
+        paths_to_check (list[str]): Candidate paths which may contain
+            shell user-expansions such as ``~``.
+
+    Returns:
+        tuple[list[str], list[str]]: A tuple ``(existing_paths,
+        missing_paths)``. ``existing_paths`` contains expanded absolute
+        paths that exist on disk. ``missing_paths`` contains expanded
+        absolute paths that do not exist.
+
+    Notes:
+        This function does not raise; the caller decides whether to
+        abort or proceed. Existing paths are returned as strings to
+        simplify insertion into shell commands.
+
+    """
+    existing: list[str] = []
+    missing: list[str] = []
+
+    # Iterate over the provided list, handling a possible ``None`` by
+    # falling back to an empty sequence.
+    for candidate in paths_to_check or []:
+        if not candidate:
+            continue
+        candidate_path = Path(candidate).expanduser()
+        if candidate_path.exists():
+            existing.append(str(candidate_path))
+        else:
+            missing.append(str(candidate_path))
+
+    if missing:
+        print(f"Some configured backup paths do not exist: {missing}")
+        logger.warning(
+            "Some configured backup paths do not exist: %s",
+            missing,
+        )
+
+    print("Proceeding with existing directories only.")
+    logger.info(
+        "Proceeding with existing directories only: %s",
+        existing,
+    )
+    return existing, missing
+
+
+def ensure_backup_folder(folder: str) -> Path:
+    """Ensure the backup folder exists, creating it if necessary.
+
+    Args:
+        folder (str): Path to the backup folder. May contain shell
+            user-expansions such as ``~``.
+
+    Returns:
+        pathlib.Path: Expanded ``Path`` pointing to the ensured folder.
+
+    Raises:
+        OSError: If the folder cannot be created due to permission or
+            filesystem errors.
+
+    """
+    path = Path(folder).expanduser()
+    if not path.exists():
+        print(f"Creating backup folder at {path}")
+        logger.info(
+            "Creating backup folder at %s",
+            path,
+        )
+        path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
 BYTES_IN_KB = 1024.0
 
+
 class SizeCalculator:
     """Calculate and display total size of backup directories."""
 
     def __init__(self, directories: list[str], ignore_list: list[str]) -> None:
         """Initialize SizeCalculator.
 
         Args:
-            directories (list[str]): Directories to include in size calculation.
-            ignore_list (list[str]): Paths to ignore during calculation.
+            directories (list[str]): Directories to include in size
+                calculation.
+            ignore_list (list[str]): Paths to ignore during
+                calculation.
 
         """
-        self.directories: list[Path] = [Path(os.path.expanduser(d)) for d in directories]
-        self.ignore_list: list[Path] = [Path(os.path.expanduser(p)) for p in ignore_list]
+        self.directories: list[Path] = [
+            Path(os.path.expanduser(d)) for d in directories
+        ]
+        self.ignore_list: list[Path] = [
+            Path(os.path.expanduser(p)) for p in ignore_list
+        ]
 
     def calculate_total_size(self) -> int:
         """Sum the sizes of all directories, printing a summary.
@@ -31,7 +117,7 @@ def calculate_total_size(self) -> int:
             int: Total size in bytes.
 
         """
-        print("\n\U0001f4c2 **Backup Size Summary**")
+        print("\n\U0001f4c2 Backup Directories (Exist Only)")
         print("=" * 40)
         total: int = 0
         for directory in self.directories:
@@ -73,23 +159,33 @@ def _calculate_directory_size(self, directory: Path) -> int:
                                 total += file_path.stat().st_size
                             else:
                                 # Broken symlink, skip silently
-                                logging.debug(
+                                logger.debug(
                                     "Skipping broken symlink: %s -> %s",
                                     file_path,
                                     file_path.readlink(),
                                 )
                         except OSError as e:
-                            logging.debug("Error handling symlink %s: %s", file_path, e)
+                            logger.debug(
+                                "Error handling symlink %s: %s",
+                                file_path,
+                                e,
+                            )
                     else:
                         # Regular file
                         try:
                             total += file_path.stat().st_size
                         except OSError as e:
-                            logging.warning(
-                                "\u26a0\ufe0f Error accessing file %s: %s", file_path, e
+                            logger.warning(
+                                "\u26a0\ufe0f Error accessing file %s: %s",
+                                file_path,
+                                e,
                             )
         except OSError as e:
-            logging.warning("\u26a0\ufe0f Error accessing directory %s: %s", directory, e)
+            logger.warning(
+                "\u26a0\ufe0f Error accessing directory %s: %s",
+                directory,
+                e,
+            )
         return total
 
     def _should_ignore(self, path: Path | str) -> bool:
@@ -114,8 +210,11 @@ def _should_ignore(self, path: Path | str) -> bool:
         # Convert to absolute path for consistent comparison
         absolute_path = path.absolute()
 
+        # Return True if the absolute path starts with any of the
+        # ignored paths. Normalize both sides for reliable comparison.
         return any(
-            str(absolute_path).startswith(str(ignored.absolute())) for ignored in self.ignore_list
+            str(absolute_path).startswith(str(ignored.absolute()))
+            for ignored in self.ignore_list
         )
 
     def _format_size(self, size_in_bytes: int) -> str:
diff --git a/pyproject.toml b/pyproject.toml
@@ -1,6 +1,6 @@
 [project]
 name = 'AutoTarCompress'
-version = '0.7.0-beta'
+version = '0.7.1-beta'
 maintainers = [{ name = "Cyber-Syntax" }]
 description = 'It downloads/updates appimages via GitHub API. It also validates the appimage with SHA256 and SHA512.'
 keywords = ["tar", "compress", "autotarcompress", "backup"]
@@ -59,7 +59,7 @@ exclude = [
     "__init__.py",
 ]
 
-line-length = 100
+line-length = 79
 indent-width = 4
 # target-version = [
 #     'py38',
diff --git a/tests/test_utils.py b/tests/test_utils.py
