allow to create backup from command line

Author: falk-werner

README.md

@@ -23,6 +23,13 @@ Run the application.
 ./backup.py
 ```
 
+## Run from Command Line
+
+| Option | Type | Description |
+| ------ | ---- | ----------- |
+| -p, --project | str | Specify backup project file |
+| -t, --target | str | Run from command line and save backup to target directory |
+
 ## Install Development Dependencies
 
 ```bash

backup.py

@@ -7,12 +7,13 @@
 import shutil
 import hashlib
 from pathlib import Path
+from dataclasses import dataclass
+
 import tkinter as tk
 from tkinter import ttk
 from tkfilebrowser import askopendirnames, askopenfilenames, askopenfilename, askopendirname
 from PIL import Image, ImageTk
 import yaml
-
 import tk_async_execute as tae
 
 DEFAULT_TITLE = 'Backup'
@@ -27,12 +28,100 @@ def load_image(filename):
     img2.paste(img)
     return ImageTk.PhotoImage(img2)
 
+
+@dataclass
+class BackupItem:
+    """Backup Item."""
+    name: str
+    itemtype: str
+    path: str
+
+@dataclass
+class BackupFile:
+    """Backup File."""
+    source: str
+    target: str
+
+class BackupProject:
+    """Backup Project."""
+
+    filename: str
+    items: list[BackupItem]
+
+    def __init__(self, filename: str):
+        self.filename = filename
+        self.items = []
+        try:
+            with open(self.filename, 'r', encoding='utf-8') as f:
+                doc = yaml.load(f, Loader=yaml.SafeLoader)
+                if doc['schema_version'] != 1:
+                    raise AssertionError('unknown schema')
+                for item in doc['items']:
+                    name = item['name']
+                    itemtype = item['type']
+                    path = item['path']
+                    self.items.append(BackupItem(name, itemtype, path))
+        # pylint: disable-next=broad-exception-caught
+        except Exception as ex:
+            print(f'warn: failed to load project \'{self.filename}\': {ex}')
+            self.items = []
+
+    def save(self):
+        """Saves the backup project."""
+        try:
+            items = []
+            for item in self.items:
+                items.append({'name': item.name, 'type': item.itemtype, 'path': item.path})
+            data = {'schema_version': 1, 'items': items}
+            with open(self.filename, 'w', encoding='utf-8') as f:
+                f.write(yaml.dump(data, sort_keys=False))
+        # pylint: disable-next=broad-exception-caught
+        except Exception as ex:
+            print(f'failed to save \'{self.filename}\': {ex}')
+
+    def backup(self, folder):
+        """Performs a backup."""
+        if not os.path.exists(folder):
+            os.makedirs(folder)
+
+        if os.listdir(folder):
+            print('error: folder is not empty')
+            return
+
+        files = []
+        for item in self.items:
+            if item.itemtype == 'Folder':
+                for dirname, _, fnames in os.walk(item.path):
+                    targetdir = dirname[len(os.path.commonpath([item.path, dirname])):]
+                    if targetdir.startswith('/'):
+                        targetdir = targetdir[1:]
+                    targetdir = os.path.join(item.name, targetdir)
+                    for fname in fnames:
+                        source = os.path.join(dirname, fname)
+                        target = os.path.join(targetdir, fname)
+                        files.append(BackupFile(source, target))
+            elif item.itemtype == 'File':
+                files.append(BackupFile(item.path, item.name))
+
+        with open(os.path.join(folder, 'checksums.txt'), 'w',
+                  newline='\n', encoding='utf-8') as checksum_file:
+            for file in files:
+                target = os.path.join(folder, file.target)
+                os.makedirs(os.path.dirname(target), exist_ok=True)
+                shutil.copy2(file.source, target)
+                with open(target, 'rb') as f:
+                    digest = hashlib.file_digest(f, "sha256")
+                    checksum_file.write(f'SHA256 ({file.target}) = {digest.hexdigest()}\n')
+
 # pylint: disable-next=too-many-instance-attributes
 class MainWindow:
     """MainWindow class."""
 
+    root: tk.Tk
+    project: BackupProject
+
     # pylint: disable-next=too-many-locals,too-many-statements
-    def __init__(self, project: str):
+    def __init__(self, project: BackupProject):
         root = tk.Tk()
         self.root = root
         root.title(DEFAULT_TITLE)
@@ -136,15 +225,24 @@ def __init__(self, project: str):
         self.progressbar.pack(side=tk.TOP, fill=tk.X, padx=(5,5), pady=(5,5))
 
         # load project
-        items = self.load_project()
+        items = self.project.items
         for item in items:
-            name = item['name']
-            itemtype = item['type']
-            path = item['path']
-            image = self.get_image(itemtype)
-            self.listbox.insert('', tk.END, text=name, image=image, values=(itemtype , path))
+            image = self.get_image(item.itemtype)
+            self.listbox.insert('', tk.END, text=item.name,
+                image=image, values=(item.itemtype , item.path))
         self.on_selection_changed(None)
 
+    def get_items(self) -> list[BackupItem]:
+        """Return the list of items"""
+        items = []
+        for itemid in self.listbox.get_children():
+            item = self.listbox.item(itemid)
+            name = item['text']
+            itemtype = item['values'][0]
+            path = item['values'][1]
+            items.append(BackupItem(name, itemtype, path))
+        return items
+
     def get_image(self, itemtype: str):
         """Returns an image by the provided items type."""
         if itemtype == 'Folder':
@@ -153,37 +251,10 @@ def get_image(self, itemtype: str):
             return self.file_image
         return self.file_image
 
-    def load_project(self):
-        """Loads the project file."""
-        items = []
-        try:
-            with open(self.project, 'r', encoding='utf-8') as f:
-                doc = yaml.load(f, Loader=yaml.SafeLoader)
-                if doc['schema_version'] != 1:
-                    raise AssertionError('unknown schema')
-                for item in doc['items']:
-                    items.append(item)
-        # pylint: disable-next=broad-exception-caught
-        except Exception as ex:
-            print(f'warn: failed to load project \'{self.project}\': {ex}')
-        return items
-
     def save_project(self):
         """Saves the proves file."""
-        try:
-            items = []
-            for itemid in self.listbox.get_children():
-                item = self.listbox.item(itemid)
-                name = item['text']
-                itemtype = item['values'][0]
-                path = item['values'][1]
-                items.append({'name': name, 'type': itemtype, 'path': path})
-            data = {'schema_version': 1, 'items': items}
-            with open(self.project, 'w', encoding='utf-8') as f:
-                f.write(yaml.dump(data, sort_keys=False))
-        # pylint: disable-next=broad-exception-caught
-        except Exception as ex:
-            print(f'failed to save \'{self.project}\': {ex}')
+        self.project.items = self.get_items()
+        self.project.save()
 
     def add_folder(self):
         """Adds a new folder."""
@@ -262,53 +333,15 @@ def start_backup(self):
         folder = askopendirname()
         if folder:
             print('backup started')
-            items = []
-            for itemid in self.listbox.get_children():
-                item = self.listbox.item(itemid)
-                name = item['text']
-                itemtype = item['values'][0]
-                path = item['values'][1]
-                items.append({'name': name, 'type': itemtype, 'path': path})
+            self.project.items = self.get_items()
             self.progressbar.start()
-            tae.async_execute(self.do_backup(items, folder),
+            tae.async_execute(self.do_backup(self.project, folder),
                 callback=self.finish_backup, wait=False, visible=False)
 
     # pylint: disable-next=too-many-locals
-    async def do_backup(self, items, folder):
+    async def do_backup(self, project, folder):
         """Performs the actual backup"""
-        # get file list
-        if os.listdir(folder):
-            print('error: folder is not empty')
-            return
-
-        files = []
-        for item in items:
-            itemtype = item['type']
-            if itemtype == 'Folder':
-                path = item['path']
-                for dirname, _, fnames in os.walk(item['path']):
-                    targetdir = dirname[len(os.path.commonpath([path, dirname])):]
-                    if targetdir.startswith('/'):
-                        targetdir = targetdir[1:]
-                    targetdir = os.path.join(item['name'], targetdir)
-                    for fname in fnames:
-                        source = os.path.join(dirname, fname)
-                        target = os.path.join(targetdir, fname)
-                        files.append({'source': source, 'target': target})
-            elif itemtype == 'File':
-                files.append({'source': item['path'], 'target': item['name']})
-
-        with open(os.path.join(folder, 'checksums.txt'), 'w',
-                  newline='\n', encoding='utf-8') as checksum_file:
-            for file in files:
-                source = file['source']
-                rel_target = file['target']
-                target = os.path.join(folder, rel_target)
-                os.makedirs(os.path.dirname(target), exist_ok=True)
-                shutil.copy2(source, target)
-                with open(target, 'rb') as f:
-                    digest = hashlib.file_digest(f, "sha256")
-                    checksum_file.write(f'SHA256 ({rel_target}) = {digest.hexdigest()}\n')
+        project.backup(folder)
 
     def on_closing(self):
         """Saves the project when the application is closed."""
@@ -331,9 +364,16 @@ def main():
     default_project = os.path.join(Path.home(), 'backup-py.yaml')
     parser = argparse.ArgumentParser()
     parser.add_argument('-p', '--project', type=str, help='project file', default=default_project)
+    parser.add_argument('-t', '--target', type=str, help='target directory', default=None)
     args = parser.parse_args()
-    app = MainWindow(args.project)
-    app.run()
+
+    project = BackupProject(args.project)
+
+    if args.target:
+        project.backup(args.target)
+    else:
+        app = MainWindow(project)
+        app.run()
 
 
 if __name__ == '__main__':