backupchan-cli 0.1.0__tar.gz

backupchan_cli-0.1.0/.gitignore

@@ -0,0 +1,5 @@
+build/
+*.egg-info
+*.swp
+__pycache__/
+dist/

backupchan_cli-0.1.0/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2025 moltony
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS “AS IS” AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

backupchan_cli-0.1.0/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: backupchan-cli
+Version: 0.1.0
+Summary: Command-line interface for interacting with Backup-chan.
+Author-email: Moltony <koronavirusnyj@gmail.com>
+License: BSD-3-Clause
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: System :: Archiving :: Backup
+Classifier: Typing :: Typed
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: backupchan-client-lib
+Requires-Dist: keyring
+Requires-Dist: platformdirs
+Dynamic: license-file
+
+# Backup-chan CLI
+
+This is the command-line interface program for interacting with a Backup-chan server.
+
+## Installing
+
+```bash
+pip install .
+```
+
+You can also run right from source if you don't feel like installing the program. In
+this case, you'll have to install dependencies manually.
+
+```bash
+./cli.py
+```
+
+## Configuring
+
+The CLI has to first be configured before you can use it. Run:
+
+```bash
+# Interactive configuration.
+backupchan config new -i
+
+# Non-interactive configuration.
+backupchan config new -H "http://host" -p 5050 -a "your api key"
+```
+
+Run `backupchan --help` to see all the commands you can use.

backupchan_cli-0.1.0/README.md

@@ -0,0 +1,30 @@
+# Backup-chan CLI
+
+This is the command-line interface program for interacting with a Backup-chan server.
+
+## Installing
+
+```bash
+pip install .
+```
+
+You can also run right from source if you don't feel like installing the program. In
+this case, you'll have to install dependencies manually.
+
+```bash
+./cli.py
+```
+
+## Configuring
+
+The CLI has to first be configured before you can use it. Run:
+
+```bash
+# Interactive configuration.
+backupchan config new -i
+
+# Non-interactive configuration.
+backupchan config new -H "http://host" -p 5050 -a "your api key"
+```
+
+Run `backupchan --help` to see all the commands you can use.

backupchan_cli-0.1.0/backupchan_cli/__init__.py

@@ -0,0 +1 @@
+# so like

backupchan_cli-0.1.0/backupchan_cli/commands/backup.py

@@ -0,0 +1,151 @@
+import requests.exceptions
+import os
+import sys
+import tarfile
+import tempfile
+import uuid
+from backupchan_cli import utility
+from backupchan import API, BackupchanAPIError, Backup, BackupType
+
+#
+# Utilities
+#
+
+def print_backup(backup: Backup, spaces: str, show_recycled: bool, index: int):
+    print(f" {index + 1}. | ID: {backup.id}")
+    print(f" {spaces} | Created at: {backup.pretty_created_at()}")
+    if show_recycled:
+        print(f" {spaces} | Recycled: {'Yes' if backup.is_recycled else 'No'}")
+    print(f" {spaces} | Size: {utility.humanread_file_size(backup.filesize)}")
+    if backup.manual:
+        print(f" {spaces} | Uploaded manually")
+    else:
+        print(f" {spaces} | Uploaded automatically")
+    print("=========")
+
+#
+#
+#
+
+def setup_subcommands(subparser):
+    #
+    #
+    #
+
+    upload_cmd = subparser.add_parser("upload", help="Upload a backup")
+    # For things like cron jobs etc. using the cli
+    upload_cmd.add_argument("--automatic", "-a", action="store_true", help="Mark backup as having been added automatically")
+    upload_cmd.add_argument("target_id", type=str, help="ID of the target to upload backup to")
+    upload_cmd.add_argument("filename", type=str, help="Name of the file to upload")
+    upload_cmd.set_defaults(func=do_upload)
+
+    #
+    #
+    #
+
+    delete_cmd = subparser.add_parser("delete", help="Delete an existing backup")
+    delete_cmd.add_argument("id", type=str, help="ID of the backup to delete")
+    delete_cmd.add_argument("--delete-files", "-d", action="store_true", help="Delete backup files as well")
+    delete_cmd.set_defaults(func=do_delete)
+
+    #
+    #
+    #
+
+    recycle_cmd = subparser.add_parser("recycle", help="Recycle an existing backup")
+    recycle_cmd.add_argument("id", type=str, help="ID of the backup to recycle")
+    recycle_cmd.set_defaults(func=do_recycle)
+
+    #
+    #
+    #
+
+    restore_cmd = subparser.add_parser("restore", help="Restore an existing backup")
+    restore_cmd.add_argument("id", type=str, help="ID of the backup to restore")
+    restore_cmd.set_defaults(func=do_restore)
+
+#
+# backupchan backup upload
+#
+
+def do_upload(args, _, api: API):
+    if os.path.isdir(args.filename):
+        # Cannot upload a directory to a single-file target.
+        target_type = api.get_target(args.target_id)[0].target_type
+        if target_type == BackupType.SINGLE:
+            utility.failure("Cannot upload directory to a single file target")
+
+        # Make a temporary gzipped tarball containing the directory contents.
+        temp_dir = tempfile.gettempdir()
+        temp_tar_path = os.path.join(temp_dir, f"bakch-{uuid.uuid4().hex}.tar.gz")
+        with tarfile.open(temp_tar_path, "w:gz") as tar:
+            tar.add(args.filename, arcname=os.path.basename(args.filename))
+        
+        # Upload our new tar.
+        with open(temp_tar_path, "rb") as tar:
+            try:
+                api.upload_backup(args.target_id, tar, os.path.basename(args.filename) + ".tar.gz", not args.automatic)
+            except requests.exceptions.ConnectionError:
+                utility.failure_network()
+            except BackupchanAPIError as exc:
+                utility.failure(f"Failed to upload backup: {str(exc)}")
+
+    else:
+        with open(args.filename, "rb") as file:
+            try:
+                api.upload_backup(args.target_id, file, os.path.basename(args.filename), not args.automatic)
+            except requests.exceptions.ConnectionError:
+                utility.failure_network()
+            except BackupchanAPIError as exc:
+                utility.failure(f"Failed to upload backup: {str(exc)}")
+    print("Backup uploaded.")
+
+#
+# backupchan backup delete
+#
+
+def do_delete(args, _, api: API):
+    delete_files = args.delete_files
+
+    try:
+        api.delete_backup(args.id, delete_files)
+    except requests.exceptions.ConnectionError:
+        utility.failure_network()
+    except BackupchanAPIError as exc:
+        if exc.status_code == 404:
+            utility.failure("Backup not found")
+        utility.failure(f"Failed to delete backup: {str(exc)}")
+
+    print("Backup deleted.")
+
+#
+# backupchan backup recycle
+#
+
+def do_recycle(args, _, api: API):
+    try:
+        api.recycle_backup(args.id, True)
+    except requests.exceptions.ConnectionError:
+        utility.failure_network()
+    except BackupchanAPIError as exc:
+        if exc.status_code == 404:
+            utility.failure("Backup not found")
+        utility.failure(f"Failed to recycle backup: {str(exc)}")
+
+    print("Backup recycled.")
+
+#
+# backupchan backup restore
+#
+
+def do_restore(args, _, api: API):
+    try:
+        api.recycle_backup(args.id, False)
+    except requests.exceptions.ConnectionError:
+        utility.failure_network()
+    except BackupchanAPIError as exc:
+        if exc.status_code == 404:
+            utility.failure("Backup not found")
+        utility.failure(f"Failed to restore backup: {str(exc)}")
+
+    print("Backup restored.")

backupchan_cli-0.1.0/backupchan_cli/commands/config.py

@@ -0,0 +1,80 @@
+import os
+from backupchan_cli.config import Config
+from backupchan_cli import utility
+
+#
+#
+#
+
+def setup_subcommands(subparser):
+    new_cmd = subparser.add_parser("new", help="Create a new config")
+    new_cmd.add_argument("--interactive", "-i", action="store_true", help="Make a new config interactively (no need for other options)")
+    new_cmd.add_argument("--host", "-H", type=str, help="Hostname of Backup-chan server")
+    new_cmd.add_argument("--port", "-p", type=int, help="Port of Backup-chan server")
+    new_cmd.add_argument("--api-key", "-a", type=str, help="Backup-chan API key")
+    new_cmd.set_defaults(func=do_new)
+
+    view_cmd = subparser.add_parser("view", help="View current configuration")
+    view_cmd.set_defaults(func=do_view)
+
+    reset_cmd = subparser.add_parser("reset", help="Reset current configuration")
+    reset_cmd.set_defaults(func=do_reset)
+
+#
+# backupchan config new
+#
+
+def do_new(args, config: Config, _):
+    if args.interactive:
+        if has_argument_new_args(args):
+            utility.failure("Do not pass new config values as arguments when running interactively")
+        interactive_new_config(config)
+    else:
+        if not has_argument_new_args(args):
+            utility.failure("Host, port or api key argument not passed, or run interactively")
+        argument_new_config(args, config)
+
+def has_argument_new_args(args) -> bool:
+    return args.host or args.port or args.api_key
+
+def interactive_new_config(config: Config):
+    host = input("Host: ").strip().lower()
+    port = input("Port: ").strip().lower()
+    if not utility.is_parsable_int(port):
+        utility.failure("Port must be an integer number")
+    api_key = input("API key (leave blank if auth is disabled): ").strip()
+
+    config.host = host
+    config.port = port
+    config.api_key = api_key
+    config.save_config()
+
+    print("Configuration saved.")
+
+def argument_new_config(args, config: Config):
+    config.host = args.host
+    config.port = args.port
+    config.api_key = args.api_key
+    config.save_config()
+
+    print("Configuration saved.")
+
+#
+# backupchan config view
+#
+
+def do_view(args, config: Config, _):
+    if config.is_incomplete():
+        utility.failure(utility.NO_CONFIG_MESSAGE)
+
+    print(f"Host: {config.host}")
+    print(f"Port: {config.port}")
+    print(f"API key: {config.api_key}")
+
+#
+# backupchan config reset
+#
+
+def do_reset(args, config: Config, _):
+    config.reset(True)
+    print("Configuration reset.")

backupchan_cli-0.1.0/backupchan_cli/commands/log.py

@@ -0,0 +1,17 @@
+from backupchan import API
+
+#
+#
+#
+
+def setup_subcommands(subparser):
+    view_cmd = subparser.add_parser("view", help="View log")
+    view_cmd.add_argument("--tail", "-t", type=int, help="Trim log to show this many last lines", default=0)
+    view_cmd.set_defaults(func=do_view)
+
+#
+# backupchan log view
+#
+
+def do_view(args, _, api: API):
+    print(api.get_log(args.tail))

backupchan_cli-0.1.0/backupchan_cli/commands/recyclebin.py

@@ -0,0 +1,41 @@
+from backupchan import API
+from .backup import print_backup
+from backupchan_cli import utility
+
+#
+#
+#
+
+def setup_subcommands(subparser):
+    view_cmd = subparser.add_parser("view", help="View recycle bin")
+    view_cmd.set_defaults(func=do_view)
+
+    clear_cmd = subparser.add_parser("clear", help="Clear recycle bin")
+    clear_cmd.add_argument("--delete-files", "-d", action="store_true", help="Delete backup files as well")
+    clear_cmd.set_defaults(func=do_clear)
+
+#
+# backupchan recyclebin view
+#
+
+def do_view(args, _, api: API):
+    try:
+        backups = api.list_recycled_backups()
+    except requests.exceptions.ConnectionError:
+        utility.failure_network()
+
+    for index, backup in enumerate(backups):
+        spaces = " " * (len(str(index + 1)) + 1)
+        print_backup(backup, spaces, False, index)
+
+#
+# backupchan recyclebin clear
+#
+
+def do_clear(args, _, api: API):
+    try:
+        api.clear_recycle_bin(args.delete_files)
+    except requests.exceptions.ConnectionError:
+        utility.failure_network()
+
+    print("Recycle bin cleared.")

backupchan_cli-0.1.0/backupchan_cli/commands/target.py

@@ -0,0 +1,273 @@
+import requests
+from backupchan_cli import utility
+from .backup import print_backup
+from backupchan import API, BackupType, BackupRecycleCriteria, BackupTarget, BackupRecycleAction, BackupchanAPIError
+
+#
+# Utilities
+#
+
+def print_target(target: BackupTarget, spaces: str | None, index: int):
+    prefix = "" if spaces is None else f" {spaces} | "
+    if spaces is None:
+        print(f"Name: {target.name}")
+    else:
+        print(f" {index + 1}. |  {target.name}")
+    if target.alias is not None:
+        print(f"{prefix}Alias: {target.alias}")
+    print(f"{prefix}ID: {target.id}")
+    print(f"{prefix}Type: {HR_TYPES[target.target_type]}")
+    print(f"{prefix}Recycle criteria: {hr_recycle_criteria(target)}")
+    if target.recycle_criteria != BackupRecycleCriteria.NONE:
+        print(f"{prefix}Recycle action: {HR_RECYCLE_ACTIONS[target.recycle_action]}")
+    print(f"{prefix}Location: {target.location}")
+    print(f"{prefix}Name template: {target.name_template}")
+    print(f"{prefix}Deduplication {'on' if target.deduplicate else 'off'}")
+    print("=========")
+
+#
+#
+#
+
+
+def setup_subcommands(subparser):
+    #
+    #
+    #
+
+    list_cmd = subparser.add_parser("list", help="List all targets")
+    list_cmd.add_argument("--page", "-p", type=int, default=1, help="Page in the list")
+    list_cmd.set_defaults(func=do_list)
+
+    #
+    #
+    #
+
+    view_cmd = subparser.add_parser("view", help="View a specific target")
+    view_cmd.add_argument("id", type=str, help="ID of the target to view")
+    view_cmd.add_argument("--include-recycled", "-r", action="store_true", help="Include recycled backups too")
+    view_cmd.set_defaults(func=do_view)
+
+    #
+    #
+    #
+
+    new_cmd = subparser.add_parser("new", help="Create a new target")
+    new_cmd.add_argument("--name", "-n", type=str, help="Name of the new target")
+    new_cmd.add_argument("--type", "-t", type=lambda t: BackupType(t), choices=list(BackupType), help="Type of the new target")
+    new_cmd.add_argument("--recycle-criteria", "-c", type=lambda c: BackupRecycleCriteria(c), choices=list(BackupRecycleCriteria), help="Recycle criteria")
+    new_cmd.add_argument("--recycle-value", "-v", type=int, help="Recycle value (optional if criteria is none)")
+    new_cmd.add_argument("--recycle-action", "-a", type=lambda a: BackupRecycleAction(a), choices=list(BackupRecycleAction), help="Recycle action")
+    new_cmd.add_argument("--location", "-l", type=str, help="Location of the new target")
+    new_cmd.add_argument("--name-template", "-m", type=str, help="Name template for backups. Must include either $I or $D, or both.")
+    new_cmd.add_argument("--deduplicate", "-d", action="store_true", help="(optional) Enable deduplication")
+    new_cmd.add_argument("--alias", type=str, help="(optional) Target alias. It can be used as the ID.")
+    new_cmd.set_defaults(func=do_new)
+
+    #
+    #
+    #
+
+    delete_cmd = subparser.add_parser("delete", help="Delete an existing target")
+    delete_cmd.add_argument("id", type=str, help="ID of the target to delete")
+    delete_cmd.add_argument("--delete-files", "-d", action="store_true", help="Delete backup files as well")
+    delete_cmd.set_defaults(func=do_delete)
+
+    #
+    #
+    #
+
+    edit_cmd = subparser.add_parser("edit", help="Edit an existing target")
+    edit_cmd.add_argument("id", type=str, help="ID of the target to edit")
+    edit_cmd.add_argument("--name", "-n", type=str, help="New name of the target")
+    edit_cmd.add_argument("--recycle-criteria", "-c", type=lambda c: BackupRecycleCriteria(c), choices=list(BackupRecycleCriteria), help="New recycle criteria")
+    edit_cmd.add_argument("--recycle-value", "-v", type=int, help="New recycle value")
+    edit_cmd.add_argument("--recycle-action", "-a", type=lambda a: BackupRecycleAction(a), choices=list(BackupRecycleAction), help="New recycle action")
+    edit_cmd.add_argument("--location", "-l", type=str, help="New location of the target")
+    edit_cmd.add_argument("--name-template", "-m", type=str, help="New name template of the target")
+    edit_cmd.add_argument("--toggle-deduplication", "-d", action="store_true", help="Toggle target deduplication")
+    edit_cmd.add_argument("--alias", type=str, help="Target alias")
+    edit_cmd.add_argument("--remove-alias", action="store_true", help="Remove alias from the target if it has one")
+    edit_cmd.set_defaults(func=do_edit)
+
+    #
+    #
+    #
+
+    delete_backups_cmd = subparser.add_parser("deletebackups", help="Delete all backups of a target")
+    delete_backups_cmd.add_argument("id", type=str, help="ID of the target to delete backups of")
+    delete_backups_cmd.add_argument("--delete-files", "-d", action="store_true", help="Delete backup files as well")
+    delete_backups_cmd.set_defaults(func=do_delete_backups)
+
+#
+# Value to human-readable string conversions and lookup tables
+#
+
+HR_TYPES = {
+    BackupType.SINGLE: "Single file",
+    BackupType.MULTI: "Multiple files"
+}
+
+HR_RECYCLE_ACTIONS = {
+    BackupRecycleAction.DELETE: "Delete",
+    BackupRecycleAction.RECYCLE: "Recycle"
+}
+
+def hr_recycle_criteria(target: BackupTarget) -> str:
+    if target.recycle_criteria == BackupRecycleCriteria.NONE:
+        return "None"
+    elif target.recycle_criteria == BackupRecycleCriteria.AGE:
+        return f"After {target.recycle_value} days"
+    elif target.recycle_criteria == BackupRecycleCriteria.COUNT:
+        return f"After {target.recycle_value} copies"
+    return "(broken value)"
+
+#
+# backupchan target list
+#
+
+def do_list(args, _, api: API):
+    try:
+        targets = api.list_targets(args.page)
+    except requests.exceptions.ConnectionError:
+        utility.failure_network()
+
+    print(f"Showing page {args.page}\n")
+
+    if not targets:
+        print("There are no targets.")
+        return
+
+    for index, target in enumerate(targets):
+        spaces = " " * (len(str(index + 1)) + 1)
+        print_target(target, spaces, index)
+
+#
+# backupchan target view
+#
+
+# TODO is it necessary to pass config to every subcommand?
+def do_view(args, _, api: API):
+    try:
+        target, backups = api.get_target(args.id)
+    except requests.exceptions.ConnectionError:
+        utility.failure_network()
+    except BackupchanAPIError as exc:
+        if exc.status_code == 404:
+            utility.failure("Target not found")
+        raise
+
+    print_target(target, None, 0)
+
+    if len(backups) == 0:
+        print("This target has no backups.")
+        return
+    elif args.include_recycled:
+        print("Backups:")
+    else:
+        print("Backups (pass -r to view recycled ones too):")
+    print()
+
+    if not args.include_recycled:
+        backups = [backup for backup in backups if not backup.is_recycled]
+
+    for index, backup in enumerate(backups):
+        spaces = " " * (len(str(index + 1)) + 1)
+        print_backup(backup, spaces, args.include_recycled, index)
+
+#
+# backupchan target new
+#
+
+def do_new(args, _, api: API):
+    utility.required_args(args, "name", "type", "recycle_criteria", "location", "name_template")
+
+    name = args.name
+    target_type = args.type
+    recycle_criteria = args.recycle_criteria
+    location = args.location
+    name_template = args.name_template
+    deduplicate = args.deduplicate
+    alias = args.alias
+
+    recycle_value = 0
+    recycle_action = BackupRecycleAction.RECYCLE
+    if args.recycle_criteria != BackupRecycleCriteria.NONE:
+        utility.required_args(args, "recycle_value", "recycle_action")
+        recycle_value = args.recycle_value
+        recycle_action = args.recycle_action
+
+    try:
+        target_id = api.new_target(name, target_type, recycle_criteria, recycle_value, recycle_action, location, name_template, deduplicate, alias)
+    except requests.exceptions.ConnectionError:
+        utility.failure_network()
+    except BackupchanAPIError as exc:
+        utility.failure(f"Failed to create new target: {str(exc)}")
+
+    print(f"Created new target. ID: {target_id}")
+
+#
+# backupchan target delete
+#
+
+def do_delete(args, _, api: API):
+    delete_files = args.delete_files
+
+    try:
+        api.delete_target(args.id, delete_files)
+    except requests.exceptions.ConnectionError:
+        utility.failure_network()
+    except BackupchanAPIError as exc:
+        utility.failure(f"Failed to delete target: {str(exc)}")
+    print("Target deleted.")
+
+#
+# backupchan target edit
+#
+
+def do_edit(args, _, api: API):
+    target_id = args.id
+
+    try:
+        target = api.get_target(target_id)[0]
+    except requests.exceptions.ConnectionError:
+        utility.failure_network()
+    except BackupchanAPIError as exc:
+        if exc.status_code == 404:
+            utility.failure("Target not found")
+        raise
+
+    name = args.name or target.name
+    recycle_criteria = args.recycle_criteria or target.recycle_criteria
+    recycle_value = args.recycle_value or target.recycle_value
+    recycle_action = args.recycle_action or target.recycle_action
+    location = args.location or target.location
+    name_template = args.name_template or target.name_template
+    deduplicate = target.deduplicate
+    if args.toggle_deduplication:
+        deduplicate = not deduplicate
+    alias = (None if args.remove_alias else args.alias) or target.alias
+
+    try:
+        api.edit_target(target_id, name, recycle_criteria, recycle_value, recycle_action, location, name_template, deduplicate, alias)
+    except requests.exceptions.ConnectionError:
+        utility.failure_network()
+    except BackupchanAPIError as exc:
+        utility.failure(f"Failed to edit target: {str(exc)}")
+
+    print("Target edited.")
+
+#
+# backupchan target deletebackups
+#
+
+def do_delete_backups(args, _, api: API):
+    delete_files = args.delete_files
+
+    try:
+        api.delete_target_backups(args.id, delete_files)
+    except requests.exceptions.ConnectionError:
+        utility.failure_network()
+    except BackupchanAPIError as exc:
+        utility.failure(f"Failed to delete target backups: {str(exc)}")
+    print("Target backups deleted.")

backupchan_cli-0.1.0/backupchan_cli/config.py

@@ -0,0 +1,72 @@
+import json
+import sys
+import platformdirs
+import keyring
+import os
+from pathlib import Path
+
+class ConfigException(Exception):
+    pass
+
+CONFIG_FILE_DIR = platformdirs.user_config_dir('backupchan')
+CONFIG_FILE_PATH = f"{CONFIG_FILE_DIR}/config.json"
+
+class Config:
+    def __init__(self):
+        self.port: int | None = None
+        self.host: str | None = None
+        self.api_key: str | None = None
+
+    def read_config(self):
+        if not os.path.exists(CONFIG_FILE_PATH):
+            raise ConfigException("Config file not found")
+
+        with open(CONFIG_FILE_PATH, "r") as config_file:
+            self.parse_config(config_file.read())
+        self.retrieve_api_key()
+
+    def reset(self, write: bool = False):
+        self.port = None
+        self.host = None
+        self.api_key = None
+
+        if write:
+            self.delete_api_key()
+            if os.path.exists(CONFIG_FILE_PATH):
+                os.remove(CONFIG_FILE_PATH)
+
+    def is_incomplete(self):
+        return self.port is None or self.host is None or self.api_key is None
+
+    def parse_config(self, config: str):
+        config_json = json.loads(config)
+        self.port = config_json["port"]
+        self.host = config_json["host"]
+
+    def retrieve_api_key(self):
+        self.api_key = keyring.get_password("backupchan", "api_key")
+
+    def save_config(self):
+        if self.is_incomplete():
+            raise ConfigException("Cannot save incomplete config")
+        
+        Path(CONFIG_FILE_DIR).mkdir(exist_ok=True, parents=True)
+
+        config_dict = {
+            "host": self.host,
+            "port": self.port
+        }
+
+        with open(CONFIG_FILE_PATH, "w") as config_file:
+            json.dump(config_dict, config_file)
+
+        self.save_api_key()
+
+    def delete_api_key(self):
+        try:
+            keyring.delete_password("backupchan", "api_key")
+        except keyring.errors.PasswordDeleteError:
+            pass
+    
+    def save_api_key(self):
+        keyring.set_password("backupchan", "api_key", self.api_key)

backupchan_cli-0.1.0/backupchan_cli/main.py

@@ -0,0 +1,49 @@
+from .commands import config, target, backup, log, recyclebin
+from .config import Config, ConfigException
+from .utility import failure, NO_CONFIG_MESSAGE
+from backupchan import API
+import argparse
+
+def main():
+    parser = argparse.ArgumentParser(prog="backupchan")
+    subparsers = parser.add_subparsers(dest="command")
+
+    config_parser = subparsers.add_parser("config")
+    config_sub = config_parser.add_subparsers(dest="subcommand", help="View and edit configuration")
+    config.setup_subcommands(config_sub)
+
+    target_parser = subparsers.add_parser("target")
+    target_sub = target_parser.add_subparsers(dest="subcommand", help="View and manage targets")
+    target.setup_subcommands(target_sub)
+
+    backup_parser = subparsers.add_parser("backup")
+    backup_sub = backup_parser.add_subparsers(dest="subcommand", help="Add and manage backups")
+    backup.setup_subcommands(backup_sub)
+
+    log_parser = subparsers.add_parser("log")
+    log_sub = log_parser.add_subparsers(dest="subcommand", help="View the execution log")
+    log.setup_subcommands(log_sub)
+
+    recycle_bin_parser = subparsers.add_parser("recyclebin")
+    recycle_bin_sub = recycle_bin_parser.add_subparsers(dest="subcommand", help="View and clear the recycle bin")
+    recyclebin.setup_subcommands(recycle_bin_sub)
+
+    app_config = Config()
+    try:
+        app_config.read_config()
+    except ConfigException:
+        app_config.reset()
+        pass
+
+    api = None if app_config.is_incomplete() else API(app_config.host, app_config.port, app_config.api_key)
+
+    args = parser.parse_args()
+    if hasattr(args, "func"):
+        if args.command != "config" and app_config.is_incomplete():
+            failure(NO_CONFIG_MESSAGE)
+
+        args.func(args, app_config, api)
+    else:
+        parser.print_help()
+
+    return 0

backupchan_cli-0.1.0/backupchan_cli/utility.py

@@ -0,0 +1,33 @@
+import sys
+
+NO_CONFIG_MESSAGE = "No configuration. Run `backupchan config new' to configure."
+
+def is_parsable_int(number_str: str) -> bool:
+    try:
+        int(number_str)
+        return True
+    except ValueError:
+        return False
+
+def failure(message: str):
+    print(f"{message}. Halting.", file=sys.stderr)
+    sys.exit(1)
+
+def failure_network():
+    failure("Failed to connect to server")
+
+SIZE_UNITS = [
+    "B", "KiB", "MiB", "GiB", "TiB"
+]
+
+def humanread_file_size(size: float):
+    i = 0
+    while size > 1024:
+        size /= 1024
+        i += 1
+    return f"{size:.2f} {SIZE_UNITS[i]}"
+
+def required_args(args_object, *args):
+    for arg in args:
+        if not getattr(args_object, arg):
+            failure(f"Argument '{arg}' is required")

backupchan_cli-0.1.0/backupchan_cli.egg-info/PKG-INFO

@@ -0,0 +1,51 @@
+Metadata-Version: 2.4
+Name: backupchan-cli
+Version: 0.1.0
+Summary: Command-line interface for interacting with Backup-chan.
+Author-email: Moltony <koronavirusnyj@gmail.com>
+License: BSD-3-Clause
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: System :: Archiving :: Backup
+Classifier: Typing :: Typed
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: backupchan-client-lib
+Requires-Dist: keyring
+Requires-Dist: platformdirs
+Dynamic: license-file
+
+# Backup-chan CLI
+
+This is the command-line interface program for interacting with a Backup-chan server.
+
+## Installing
+
+```bash
+pip install .
+```
+
+You can also run right from source if you don't feel like installing the program. In
+this case, you'll have to install dependencies manually.
+
+```bash
+./cli.py
+```
+
+## Configuring
+
+The CLI has to first be configured before you can use it. Run:
+
+```bash
+# Interactive configuration.
+backupchan config new -i
+
+# Non-interactive configuration.
+backupchan config new -H "http://host" -p 5050 -a "your api key"
+```
+
+Run `backupchan --help` to see all the commands you can use.

backupchan_cli-0.1.0/backupchan_cli.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+.gitignore
+LICENSE
+README.md
+cli.py
+pyproject.toml
+backupchan_cli/__init__.py
+backupchan_cli/config.py
+backupchan_cli/main.py
+backupchan_cli/utility.py
+backupchan_cli.egg-info/PKG-INFO
+backupchan_cli.egg-info/SOURCES.txt
+backupchan_cli.egg-info/dependency_links.txt
+backupchan_cli.egg-info/entry_points.txt
+backupchan_cli.egg-info/requires.txt
+backupchan_cli.egg-info/top_level.txt
+backupchan_cli/commands/backup.py
+backupchan_cli/commands/config.py
+backupchan_cli/commands/log.py
+backupchan_cli/commands/recyclebin.py
+backupchan_cli/commands/target.py

backupchan_cli-0.1.0/backupchan_cli.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

backupchan_cli-0.1.0/backupchan_cli.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+backupchan = backupchan_cli.main:main

backupchan_cli-0.1.0/backupchan_cli.egg-info/requires.txt

@@ -0,0 +1,3 @@
+backupchan-client-lib
+keyring
+platformdirs

backupchan_cli-0.1.0/backupchan_cli.egg-info/top_level.txt

@@ -0,0 +1 @@
+backupchan_cli

backupchan_cli-0.1.0/cli.py

@@ -0,0 +1,6 @@
+#!/usr/bin/python3
+
+from backupchan_cli.main import main
+
+if __name__ == "__main__":
+    main()

backupchan_cli-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "backupchan-cli"
+version = "0.1.0"
+description = "Command-line interface for interacting with Backup-chan."
+authors = [
+    { name = "Moltony", email = "koronavirusnyj@gmail.com" }
+]
+dependencies = [
+    "backupchan-client-lib",
+    "keyring",
+    "platformdirs"
+]
+
+readme = "README.md"
+license = {text = "BSD-3-Clause"}
+
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Environment :: Console",
+    "License :: OSI Approved :: BSD License",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3 :: Only",
+    "Topic :: System :: Archiving :: Backup",
+    "Typing :: Typed"
+]
+
+[project.scripts]
+backupchan = "backupchan_cli.main:main"
+
+[build-system]
+requires = ["setuptools", "wheel"]
+build-backend = "setuptools.build_meta"

backupchan_cli-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+