easyclone 0.3.0__tar.gz → 1.1.0__tar.gz

{easyclone-0.3.0/src/easyclone.egg-info → easyclone-1.1.0}/PKG-INFO

@@ -1,10 +1,15 @@
 Metadata-Version: 2.4
 Name: easyclone
-Version: 0.3.0
+Version: 1.1.0
 Summary: Very convenient Rclone bulk backup wrapper
+Author-email: Ahmet Arda Kavakcı <ahmetardakavakci@gmail.com>
+Maintainer-email: Ahmet Arda Kavakcı <ahmetardakavakci@gmail.com>
+License-Expression: GPL-3.0-or-later
 Project-URL: Repository, https://github.com/dybdeskarphet/easyclone
 Project-URL: Documentation, https://github.com/dybdeskarphet/easyclone
 Project-URL: Issues, https://github.com/dybdeskarphet/easyclone/issues
+Project-URL: Changelog, https://github.com/dybdeskarphet/easyclone/blob/main/CHANGELOG.md
+Keywords: backup,sync,google,drive,easyclone
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -15,6 +20,8 @@ Dynamic: license-file
 
 # ☁️ easyclone
 
+[![Pepy Total Downloads](https://img.shields.io/pepy/dt/easyclone)](https://pypi.org/project/easyclone/) [![PyPI - Version](https://img.shields.io/pypi/v/easyclone)](https://pypi.org/project/easyclone/) [![PyPI - License](https://img.shields.io/pypi/l/easyclone)](https://pypi.org/project/easyclone/)
+
 **easyclone** is a lightweight, configurable CLI tool that wraps `rclone` to behave more like Google's *Backup and Sync* app.
 
 You define what to back up, where to back it up, and EasyClone handles the syncs and copies — clean, fast, and reliable.

{easyclone-0.3.0 → easyclone-1.1.0}/README.md

@@ -1,5 +1,7 @@
 # ☁️ easyclone
 
+[![Pepy Total Downloads](https://img.shields.io/pepy/dt/easyclone)](https://pypi.org/project/easyclone/) [![PyPI - Version](https://img.shields.io/pypi/v/easyclone)](https://pypi.org/project/easyclone/) [![PyPI - License](https://img.shields.io/pypi/l/easyclone)](https://pypi.org/project/easyclone/)
+
 **easyclone** is a lightweight, configurable CLI tool that wraps `rclone` to behave more like Google's *Backup and Sync* app.
 
 You define what to back up, where to back it up, and EasyClone handles the syncs and copies — clean, fast, and reliable.

{easyclone-0.3.0 → easyclone-1.1.0}/pyproject.toml

@@ -1,14 +1,18 @@
 [project]
 name = "easyclone"
-version = "0.3.0"
+version = "1.1.0"
 description = "Very convenient Rclone bulk backup wrapper"
+keywords = ["backup", "sync", "google", "drive", "easyclone"]
+authors = [
+  { name = "Ahmet Arda Kavakcı", email = "ahmetardakavakci@gmail.com" },
+]
+maintainers = [
+  { name = "Ahmet Arda Kavakcı", email = "ahmetardakavakci@gmail.com" },
+]
 readme = "README.md"
+license = "GPL-3.0-or-later"
 requires-python = ">=3.13"
-dependencies = [
-    "pydantic>=2.11.5",
-    "toml>=0.10.2",
-    "typer>=0.16.0",
-]
+dependencies = ["pydantic>=2.11.5", "toml>=0.10.2", "typer>=0.16.0"]
 
 [project.scripts]
 easyclone = "easyclone.main:app"
@@ -17,6 +21,7 @@ easyclone = "easyclone.main:app"
 Repository = "https://github.com/dybdeskarphet/easyclone"
 Documentation = "https://github.com/dybdeskarphet/easyclone"
 Issues = "https://github.com/dybdeskarphet/easyclone/issues"
+Changelog = "https://github.com/dybdeskarphet/easyclone/blob/main/CHANGELOG.md"
 
 [tool.basedpyright]
 reportAny = false

{easyclone-0.3.0 → easyclone-1.1.0}/src/easyclone/config.py

@@ -7,10 +7,11 @@ from easyclone.utypes.enums import LogLevel
 from easyclone.utypes.config import BackupConfigModel, ConfigModel
 import toml
 
+
 class Config:
     _instance: Config | None = None
     _lock: Lock = Lock()
-    _path: Path = Path.home() / '.config' / "easyclone" / "config.toml"
+    _path: Path = Path.home() / ".config" / "easyclone" / "config.toml"
     _config: ConfigModel | None = None
 
     def __new__(cls):
@@ -34,12 +35,12 @@ class Config:
                 root_dir="Backups/PC",
             )
         )
-    
+
         if xdg_config_home:
-            config_dir = Path(xdg_config_home) / 'easyclone'
-        else: 
-            config_dir = Path.home() / '.config' / "easyclone"
-    
+            config_dir = Path(xdg_config_home) / "easyclone"
+        else:
+            config_dir = Path.home() / ".config" / "easyclone"
+
         config_file = config_dir / "config.toml"
 
         if not config_dir.exists():
@@ -49,7 +50,7 @@ class Config:
             config_file.touch()
             with open(config_file, "w") as f:
                 _ = toml.dump(empty_config.model_dump(), f)
-    
+
         self._path = config_file
 
     def _config_normalize(self, config: ConfigModel):
@@ -58,6 +59,7 @@ class Config:
 
     def _load_config(self):
         from easyclone.utils.essentials import log
+
         self._get_config_path()
 
         try:
@@ -67,7 +69,9 @@ class Config:
             log(f"Config file not found at {self._path}.", LogLevel.ERROR)
             exit(1)
         except Exception as e:
-            log(f"Error while opening the config file {self._path}: {e}", LogLevel.ERROR)
+            log(
+                f"Error while opening the config file {self._path}: {e}", LogLevel.ERROR
+            )
             exit(1)
 
         try:
@@ -84,4 +88,5 @@ class Config:
             raise RuntimeError("Config is not loaded yet")
         return self._config
 
+
 cfg = Config().config()

easyclone-1.1.0/src/easyclone/ipc/__init__.py

@@ -0,0 +1,2 @@
+from .server import start_status_server, SOCKET_PATH
+from .client import listen_ipc

easyclone-1.1.0/src/easyclone/main.py

@@ -0,0 +1,178 @@
+import asyncio
+import sys
+from typing import Annotated, Any
+from easyclone.config import cfg
+from easyclone.ipc.client import listen_ipc
+from easyclone.ipc.server import start_status_server
+from easyclone.rclone.operations import make_backup_operation
+from easyclone.utils.path import collapseuser, find_missing
+import typer
+import json
+from easyclone.shared import sync_status
+from easyclone.utils.essentials import exit_if_currently_running, exit_if_no_rclone
+from easyclone.utypes.enums import CommandType, FindMissingOptions
+
+app = typer.Typer(
+    help="Very convenient Rclone bulk backup wrapper",
+    context_settings={"help_option_names": ["-h", "--help"]},
+)
+
+
+async def ipc():
+    server = await start_status_server()
+    async with server:
+        await server.serve_forever()
+
+
+@app.command(help="Starts the backup process using the details in the config file.")
+def start_backup(
+    verbose: Annotated[
+        bool,
+        typer.Option(
+            "--verbose", "-v", help="Enables the rclone logging (overrides config)."
+        ),
+    ] = False,
+):
+
+    import atexit
+    from os import path, remove
+    import signal
+    from types import FrameType
+    from easyclone.ipc.client import SOCKET_PATH
+    from easyclone.utils.essentials import log
+    from easyclone.utypes.enums import LogLevel
+
+    def cleanup():
+        if path.exists(SOCKET_PATH):
+            log("Cleaning up socket file...", LogLevel.WARN)
+            remove(SOCKET_PATH)
+
+    _ = atexit.register(cleanup)
+
+    def handle_signal(_signum: int, _frame: FrameType | None):
+        cleanup()
+        sys.exit(0)
+
+    _ = signal.signal(signal.SIGINT, handle_signal)
+    _ = signal.signal(signal.SIGTERM, handle_signal)
+
+    async def start():
+
+        exit_if_no_rclone()
+        exit_if_currently_running()
+        await sync_status.set_total_path_count(
+            len(cfg.backup.sync_paths) + len(cfg.backup.copy_paths)
+        )
+
+        _ipc_task = asyncio.create_task(ipc())
+
+        verbose_state = verbose or cfg.backup.verbose_log
+
+        await make_backup_operation(
+            CommandType.COPY, cfg.backup.copy_paths, verbose_state
+        )()
+        await make_backup_operation(
+            CommandType.SYNC, cfg.backup.sync_paths, verbose_state
+        )()
+
+    asyncio.run(start())
+
+
+@app.command(
+    help="Lists the directories and files that are not getting synced or backed up"
+)
+def get_missing(
+    recursive: Annotated[
+        bool, typer.Option("--recursive", "-r", help="Recurse into directories")
+    ] = False,
+    list: Annotated[
+        FindMissingOptions,
+        typer.Option("--list", "-l", help="Select the list you want to filter from"),
+    ] = FindMissingOptions.all,
+    want_json: Annotated[
+        bool, typer.Option("--json", "-j", help="Show the output in JSON format")
+    ] = False,
+):
+    missing = find_missing(recursive=recursive, list_type=list)
+
+    if want_json:
+        print(json.dumps(missing, indent=2))
+    else:
+        [print(collapseuser(p)) for p in missing]
+
+
+@app.command(help="Gets status information about the backup process.")
+def get_status(
+    all_args: Annotated[
+        bool,
+        typer.Option("--all", "-a", help="Show all the backup status information."),
+    ] = False,
+    show_total: Annotated[
+        bool, typer.Option("--show-total", "-t", help="Show the total amount of paths.")
+    ] = False,
+    show_current: Annotated[
+        bool,
+        typer.Option(
+            "--show-current", "-c", help="Show the total amount of pending paths."
+        ),
+    ] = False,
+    show_operations: Annotated[
+        bool,
+        typer.Option(
+            "--show-operations", "-o", help="Show currently running operations."
+        ),
+    ] = False,
+    show_finished_path_count: Annotated[
+        bool,
+        typer.Option(
+            "--show-finished", "-f", help="Show the total amount of finished paths."
+        ),
+    ] = False,
+    show_operation_count: Annotated[
+        bool,
+        typer.Option(
+            "--get-operation-count",
+            "-O",
+            help="Show the total amount of running operations.",
+        ),
+    ] = False,
+    show_empty_paths: Annotated[
+        bool, typer.Option("--show-empty-paths", "-e", help="Show all the empty paths.")
+    ] = False,
+):
+    data: Any = asyncio.run(listen_ipc())
+
+    args = [
+        show_total,
+        show_current,
+        show_operations,
+        show_operation_count,
+        show_finished_path_count,
+        show_empty_paths,
+    ]
+
+    if not any(args) or all_args:
+        print(json.dumps(data, indent=2))
+        return
+
+    if show_total:
+        print(data["total_path_count"])
+
+    if show_current:
+        print(data["operation_count"])
+
+    if show_operations:
+        print(json.dumps(data["operations"], indent=2))
+
+    if show_operation_count:
+        print(data["operation_count"])
+
+    if show_finished_path_count:
+        print(data["finished_path_count"])
+
+    if show_empty_paths:
+        print(data["empty_paths"])
+
+
+if __name__ == "__main__":
+    app()

{easyclone-0.3.0 → easyclone-1.1.0}/src/easyclone/rclone/backup.py

@@ -1,18 +1,40 @@
 import asyncio
 import shlex
 from easyclone.shared import sync_status
-from easyclone.utypes.enums import BackupLog, BackupStatus, CommandType, LogLevel, RcloneOperationType
+from easyclone.utypes.enums import (
+    BackupLog,
+    BackupStatus,
+    CommandType,
+    LogLevel,
+    RcloneOperationType,
+)
 from easyclone.utypes.models import PathItem
 from easyclone.utils.essentials import log
-from easyclone.utils.path_manipulation import collapseuser
+from easyclone.utils.path import collapseuser
 
-async def backup_command(rclone_command: list[str], source: str, dest: str, path_type: str, command_type: CommandType, verbose: bool = False):
+
+async def backup_command(
+    rclone_command: list[str],
+    source: str,
+    dest: str,
+    path_type: str,
+    command_type: CommandType,
+    verbose: bool = False,
+):
     cmd = rclone_command + [source, dest]
     operation_name = command_type.value.capitalize() + "ing"
 
     log(f"{operation_name} {collapseuser(source)}", BackupLog.WAIT)
-    process = await asyncio.create_subprocess_exec(*cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
-    process_id = await sync_status.add_operation(source=source, dest=dest, path_type=path_type, status=BackupStatus.IN_PROGRESS, operation_type=RcloneOperationType.BACKUP)
+    process = await asyncio.create_subprocess_exec(
+        *cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+    )
+    process_id = await sync_status.add_operation(
+        source=source,
+        dest=dest,
+        path_type=path_type,
+        status=BackupStatus.IN_PROGRESS,
+        operation_type=RcloneOperationType.BACKUP,
+    )
 
     stdout, stderr = await process.communicate()
     stdout = stdout.decode(errors="ignore").strip()
@@ -25,18 +47,28 @@ async def backup_command(rclone_command: list[str], source: str, dest: str, path
         case 1:
             log(f"Back up operation failed: {collapsed_source}", BackupLog.ERR)
         case _:
-            log(f"Back up operation failed with {process.returncode} exit code: {collapsed_source}", BackupLog.ERR)
+            log(
+                f"Back up operation failed with {process.returncode} exit code: {collapsed_source}",
+                BackupLog.ERR,
+            )
 
     await sync_status.delete_operation(process_id)
     await sync_status.add_currently_finished()
 
     if verbose:
-        if stderr: 
+        if stderr:
             log(f"{stderr}", LogLevel.WARN)
         if stdout:
             log(f"{stdout}", LogLevel.LOG)
 
-async def backup(paths: list[PathItem], command_type: CommandType, rclone_args: list[str], semaphore: asyncio.Semaphore, verbose: bool = False):
+
+async def backup(
+    paths: list[PathItem],
+    command_type: CommandType,
+    rclone_args: list[str],
+    semaphore: asyncio.Semaphore,
+    verbose: bool = False,
+):
     cmd = ["rclone", command_type.value]
 
     for arg in rclone_args:
@@ -48,11 +80,8 @@ async def backup(paths: list[PathItem], command_type: CommandType, rclone_args:
         async with semaphore:
             await backup_command(cmd, source, dest, path_type, command_type, verbose)
 
-
     tasks = [
-        backup_task(path["source"], path["dest"], path["path_type"])
-        for path in paths
+        backup_task(path["source"], path["dest"], path["path_type"]) for path in paths
     ]
-    
-    return await asyncio.gather(*tasks)
 
+    return await asyncio.gather(*tasks)

{easyclone-0.3.0 → easyclone-1.1.0}/src/easyclone/rclone/create_dirs.py

@@ -3,12 +3,19 @@ import asyncio
 from easyclone.shared import sync_status
 from easyclone.utils.essentials import log
 from easyclone.utypes.models import PathItem
-from easyclone.utypes.enums import BackupLog, BackupStatus, LogLevel, PathType, RcloneOperationType
+from easyclone.utypes.enums import (
+    BackupLog,
+    BackupStatus,
+    LogLevel,
+    PathType,
+    RcloneOperationType,
+)
 import os
 from pathlib import Path
 from collections import deque
 from easyclone.config import cfg
 
+
 class DirNode:
     def __init__(self, name: str, details: PathItem):
         self.name: str = name
@@ -29,12 +36,13 @@ class DirNode:
         self.children.append(new_child)
         return new_child
 
-    def print_tree(self, level: int=0):
+    def print_tree(self, level: int = 0):
         indent = "  " * level
         print(f"{indent}- {self.name} ({self.details.get('dest')})")
         for child in sorted(self.children, key=lambda c: c.name):
             child.print_tree(level + 1)
 
+
 def create_dirs_array(path_list: list[PathItem]):
     only_dirs: list[PathItem] = []
 
@@ -47,7 +55,7 @@ def create_dirs_array(path_list: list[PathItem]):
             new_dir_path = {
                 "source": os.path.dirname(path.get("source")),
                 "dest": path.get("dest"),
-                "path_type": PathType.DIR.value
+                "path_type": PathType.DIR.value,
             }
 
         if new_dir_path not in only_dirs:
@@ -55,13 +63,21 @@ def create_dirs_array(path_list: list[PathItem]):
 
     return only_dirs
 
+
 def create_dir_tree(path_list: list[PathItem]):
-    root = DirNode("Root", {"source": "/", "dest": f"{cfg.backup.remote_name}:{cfg.backup.root_dir}", "path_type": "dir",})
+    root = DirNode(
+        "Root",
+        {
+            "source": "/",
+            "dest": f"{cfg.backup.remote_name}:{cfg.backup.root_dir}",
+            "path_type": "dir",
+        },
+    )
 
     for path_item in path_list:
         source_str = path_item.get("source")
         dest_str = path_item.get("dest")
-    
+
         source_parts = Path(source_str).parts
         dest_main, _, dest_path = dest_str.partition(":")
 
@@ -69,33 +85,36 @@ def create_dir_tree(path_list: list[PathItem]):
             dest_parts = Path(dest_path).parts
         else:
             dest_parts = []
-    
+
         current = root
-    
+
         for i in range(1, len(source_parts)):
-            source_sub_path = str(Path(*source_parts[:i+1]))
+            source_sub_path = str(Path(*source_parts[: i + 1]))
 
             if dest_path:
                 dest_sub_path = f"{dest_main}:{Path(*dest_parts[:i+2])}"
             else:
                 dest_sub_path = ""
-    
+
             node_details: PathItem = {
                 "source": source_sub_path,
                 "dest": dest_sub_path,
-                "path_type": PathType.DIR.value
+                "path_type": PathType.DIR.value,
             }
-    
+
             part_name = source_parts[i]
             current = current.add_child(part_name, node_details)
 
     return root
 
+
 async def create_folder_command(source: str, dest: str, verbose: bool):
     lsd_cmd = ["rclone", "lsd", dest]
     log(f"Checking if directory exist at {dest}", BackupLog.WAIT)
 
-    process = await asyncio.create_subprocess_exec(*lsd_cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
+    process = await asyncio.create_subprocess_exec(
+        *lsd_cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+    )
     stdout, stderr = await process.communicate()
 
     if process.returncode == 0:
@@ -105,8 +124,16 @@ async def create_folder_command(source: str, dest: str, verbose: bool):
     mkdir_cmd = ["rclone", "mkdir", dest]
 
     log(f"Creating a directory at {dest}", BackupLog.WAIT)
-    process = await asyncio.create_subprocess_exec(*mkdir_cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE)
-    process_id = await sync_status.add_operation(source=source, dest=dest, path_type=PathType.DIR.value, status=BackupStatus.IN_PROGRESS, operation_type=RcloneOperationType.MKDIR)
+    process = await asyncio.create_subprocess_exec(
+        *mkdir_cmd, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
+    )
+    process_id = await sync_status.add_operation(
+        source=source,
+        dest=dest,
+        path_type=PathType.DIR.value,
+        status=BackupStatus.IN_PROGRESS,
+        operation_type=RcloneOperationType.MKDIR,
+    )
 
     stdout, stderr = await process.communicate()
     stdout = stdout.decode(errors="ignore").strip()
@@ -118,26 +145,38 @@ async def create_folder_command(source: str, dest: str, verbose: bool):
         case 1:
             log(f"Couldn't create the directory: {dest}", BackupLog.ERR)
         case _:
-            log(f"Operation failed with {process.returncode} exit code: {dest}", BackupLog.ERR)
+            log(
+                f"Operation failed with {process.returncode} exit code: {dest}",
+                BackupLog.ERR,
+            )
 
     await sync_status.delete_operation(process_id)
 
     if verbose:
-        if stderr: 
+        if stderr:
             log(f"{stderr}", LogLevel.WARN)
         if stdout:
             log(f"{stdout}", LogLevel.LOG)
 
-async def create_folders_on_remote(nodes: list[DirNode], semaphore: asyncio.Semaphore, verbose: bool):
+
+async def create_folders_on_remote(
+    nodes: list[DirNode], semaphore: asyncio.Semaphore, verbose: bool
+):
     async def mkdir_task(source: str, dest: str):
         async with semaphore:
             await create_folder_command(source, dest, verbose)
 
-    tasks = [mkdir_task(node.details.get("source"), node.details.get("dest")) for node in nodes]
+    tasks = [
+        mkdir_task(node.details.get("source"), node.details.get("dest"))
+        for node in nodes
+    ]
 
     _ = await asyncio.gather(*tasks)
 
-async def traverse_and_create_folders_by_depth(root: DirNode, verbose: bool, semaphore: asyncio.Semaphore):
+
+async def traverse_and_create_folders_by_depth(
+    root: DirNode, verbose: bool, semaphore: asyncio.Semaphore
+):
     queue = deque([(root, 0)])
     current_depth = 0
     current_level_nodes: list[DirNode] = []

{easyclone-0.3.0 → easyclone-1.1.0}/src/easyclone/rclone/operations.py

@@ -1,13 +1,20 @@
 import asyncio
 from easyclone.config import cfg
 from easyclone.rclone.backup import backup
-from easyclone.rclone.create_dirs import create_dir_tree, create_dirs_array, traverse_and_create_folders_by_depth
+from easyclone.rclone.create_dirs import (
+    create_dir_tree,
+    create_dirs_array,
+    traverse_and_create_folders_by_depth,
+)
 from easyclone.shared import sync_status
 from easyclone.utils.essentials import log
-from easyclone.utils.path_manipulation import organize_paths
+from easyclone.utils.path import organize_paths
 from easyclone.utypes.enums import CommandType, LogLevel
 
-def make_backup_operation(command_type: CommandType, paths_config: list[str], verbose: bool):
+
+def make_backup_operation(
+    command_type: CommandType, paths_config: list[str], verbose: bool
+):
     async def backup_operation():
         paths = organize_paths(paths_config, cfg.backup.remote_name)
         task_semaphore = asyncio.Semaphore(cfg.rclone.concurrent_limit)
@@ -15,21 +22,22 @@ def make_backup_operation(command_type: CommandType, paths_config: list[str], ve
         dirs_array = create_dirs_array(paths["valid_paths"])
         dirs_root = create_dir_tree(dirs_array)
 
-        log(f"Below paths couldn't be found:\n{"\n".join(paths["empty_paths"])}\n", LogLevel.WARN)
+        log(
+            f"Below paths couldn't be found:\n{"\n".join(paths["empty_paths"])}\n",
+            LogLevel.WARN,
+        )
         for path in paths["empty_paths"]:
             await sync_status.add_empty_path(path)
 
         _copy_folders_create_operation = await traverse_and_create_folders_by_depth(
-            root=dirs_root,
-            verbose=verbose,
-            semaphore=dirs_task_semaphore
+            root=dirs_root, verbose=verbose, semaphore=dirs_task_semaphore
         )
         _copy_operation = await backup(
             paths=paths["valid_paths"],
             command_type=command_type,
             rclone_args=cfg.rclone.args,
             semaphore=task_semaphore,
-            verbose=verbose
+            verbose=verbose,
         )
 
     return backup_operation

{easyclone-0.3.0 → easyclone-1.1.0}/src/easyclone/shared/sync_status.py

@@ -3,26 +3,36 @@ from easyclone.utypes.enums import BackupStatus, RcloneOperationType
 from easyclone.utypes.models import SyncStatusItem
 import uuid
 
+
 class SyncStatus:
     def __init__(self):
         self.total_path_count: int = 0
-        self.operations: list[SyncStatusItem]  = []
+        self.operations: list[SyncStatusItem] = []
         self.finished_path_count: int = 0
         self.empty_paths: list[str] = []
         self.lock: asyncio.Lock = asyncio.Lock()
 
-    async def add_operation(self, source: str, dest: str, path_type: str, status: BackupStatus, operation_type: RcloneOperationType):
+    async def add_operation(
+        self,
+        source: str,
+        dest: str,
+        path_type: str,
+        status: BackupStatus,
+        operation_type: RcloneOperationType,
+    ):
         random_id = str(uuid.uuid4())
 
         async with self.lock:
-            self.operations.append({
-                "id": random_id,
-                "source": source,
-                "dest": dest,
-                "status": status.value,
-                "path_type": path_type,
-                "operation_type": operation_type.value
-            })
+            self.operations.append(
+                {
+                    "id": random_id,
+                    "source": source,
+                    "dest": dest,
+                    "status": status.value,
+                    "path_type": path_type,
+                    "operation_type": operation_type.value,
+                }
+            )
 
         return random_id
 
@@ -31,12 +41,12 @@ class SyncStatus:
             for index, item in enumerate(self.operations):
                 if item.get("id") == target_id:
                     del self.operations[index]
-                    break;
+                    break
 
     async def get_operations(self):
         async with self.lock:
             return self.operations
-    
+
     async def get_operation_count(self):
         async with self.lock:
             return len(self.operations)

easyclone-1.1.0/src/easyclone/utils/__init__.py

@@ -0,0 +1,2 @@
+from .essentials import log, exit_if_no_rclone
+from .path import organize_paths, collapseuser

{easyclone-0.3.0 → easyclone-1.1.0}/src/easyclone/utils/essentials.py

@@ -1,6 +1,7 @@
 import os
 from easyclone.utypes.enums import LogLevel, BackupLog
 
+
 def log(message: str, logtype: LogLevel | BackupLog) -> None:
     color = "\033[32;1m"
 
@@ -19,21 +20,31 @@ def log(message: str, logtype: LogLevel | BackupLog) -> None:
             color = "\033[33;1m"
 
     full_msg = f"{color}{logtype.value}"
-    if(isinstance(logtype, LogLevel)):
+    if isinstance(logtype, LogLevel):
         full_msg = full_msg + ":"
 
     print(f"{full_msg}\033[0m {message}")
 
+
 def is_tool(name: str):
     from shutil import which
+
     return which(name) is not None
 
+
 def exit_if_no_rclone():
     if not is_tool("rclone"):
-        log("Rclone is not installed on your system, 'rclone' command should be in the $PATH.", LogLevel.ERROR)
+        log(
+            "Rclone is not installed on your system, 'rclone' command should be in the $PATH.",
+            LogLevel.ERROR,
+        )
         exit(1)
 
+
 def exit_if_currently_running():
-    if os.path.exists('/tmp/easyclone.sock'):
-        log("Easyclone is already running. Delete /tmp/easyclone.sock if you think this is a mistake.", LogLevel.WARN)
+    if os.path.exists("/tmp/easyclone.sock"):
+        log(
+            "Easyclone is already running. Delete /tmp/easyclone.sock if you think this is a mistake.",
+            LogLevel.WARN,
+        )
         exit(1)

easyclone-1.1.0/src/easyclone/utils/path.py

@@ -0,0 +1,85 @@
+import json
+from ntpath import expanduser
+from pathlib import Path
+import os
+from easyclone.utypes.enums import FindMissingOptions, PathType
+from easyclone.utypes.models import OrganizedPaths, PathItem
+
+
+def organize_paths(paths: list[str], remote_name: str) -> OrganizedPaths:
+    from easyclone.config import cfg
+
+    source_dest_array: list[PathItem] = []
+    empty_paths: list[str] = []
+    root_dir = cfg.backup.root_dir
+
+    for path in paths:
+        p = Path(os.path.expandvars(os.path.expanduser(path)))
+
+        if not os.path.exists(p):
+            empty_paths.append(path)
+
+        if p.is_dir():
+            source_dest_array.append(
+                {
+                    "source": f"{p}",
+                    "dest": f"{remote_name}:{root_dir}{p}",
+                    "path_type": PathType.DIR.value,
+                }
+            )
+        elif p.is_file():
+            dest_dir = p.parent
+            source_dest_array.append(
+                {
+                    "source": f"{p}",
+                    "dest": f"{remote_name}:{root_dir}{dest_dir}",
+                    "path_type": PathType.FILE.value,
+                }
+            )
+
+    return {"valid_paths": source_dest_array, "empty_paths": empty_paths}
+
+
+def collapseuser(path: str) -> str:
+    """
+    Opposite of path.expanduser()
+    """
+    home = os.path.expanduser("~")
+    if path.startswith(home):
+        return path.replace(home, "~", 1)
+    return path
+
+
+def find_missing(
+    recursive=False, list_type: FindMissingOptions = FindMissingOptions.all
+):
+    from easyclone.config import cfg
+
+    filter_list: list[str] = []
+
+    if list_type is FindMissingOptions.all:
+        filter_list += cfg.backup.copy_paths + cfg.backup.sync_paths
+    elif list_type is FindMissingOptions.copy:
+        filter_list += cfg.backup.copy_paths
+    elif list_type is FindMissingOptions.sync:
+        filter_list += cfg.backup.sync_paths
+
+    filter_paths = [
+        Path(os.path.expandvars(os.path.expanduser(p))).absolute() for p in filter_list
+    ]
+
+    cwd_path = Path.cwd()
+    cwd_func = cwd_path.rglob("*") if recursive else cwd_path.iterdir()
+
+    if recursive:
+        missing = [
+            str(item)
+            for item in cwd_func
+            if not any(item.is_relative_to(fp) for fp in filter_paths)
+        ]
+    else:
+        cwd_content = [str(item) for item in cwd_func]
+        filter_content = [str(fp) for fp in filter_paths]
+        missing = list(set(cwd_content) - set(filter_content))
+
+    return missing

{easyclone-0.3.0 → easyclone-1.1.0}/src/easyclone/utypes/config.py

@@ -1,5 +1,6 @@
 from pydantic import BaseModel
 
+
 class BackupConfigModel(BaseModel):
     sync_paths: list[str]
     copy_paths: list[str]
@@ -7,6 +8,7 @@ class BackupConfigModel(BaseModel):
     root_dir: str
     verbose_log: bool = False
 
+
 class RcloneConfigModel(BaseModel):
     args: list[str] = [
         "--update",
@@ -17,10 +19,11 @@ class RcloneConfigModel(BaseModel):
         "--timeout 300s",
         "--retries 3",
         "--low-level-retries 10",
-        "--stats 1s"
+        "--stats 1s",
     ]
     concurrent_limit: int = 50
 
+
 class ConfigModel(BaseModel):
     backup: BackupConfigModel
     rclone: RcloneConfigModel = RcloneConfigModel()

{easyclone-0.3.0 → easyclone-1.1.0}/src/easyclone/utypes/enums.py

@@ -1,11 +1,13 @@
 from enum import Enum
 
+
 class LogLevel(Enum):
     ERROR = "error"
     LOG = "log"
     INFO = "info"
     WARN = "warn"
 
+
 class BackupLog(Enum):
     OK = "✓"
     ERR = "⛌"
@@ -16,14 +18,23 @@ class CommandType(Enum):
     COPY = "copy"
     SYNC = "sync"
 
+
 class PathType(Enum):
     FILE = "file"
     DIR = "dir"
 
+
 class BackupStatus(Enum):
     IN_PROGRESS = "in_progress"
     FINISHED = "finished"
 
+
 class RcloneOperationType(Enum):
     BACKUP = "backup"
     MKDIR = "mkdir"
+
+
+class FindMissingOptions(Enum):
+    copy = "copy"
+    sync = "sync"
+    all = "all"

{easyclone-0.3.0 → easyclone-1.1.0/src/easyclone.egg-info}/PKG-INFO

@@ -1,10 +1,15 @@
 Metadata-Version: 2.4
 Name: easyclone
-Version: 0.3.0
+Version: 1.1.0
 Summary: Very convenient Rclone bulk backup wrapper
+Author-email: Ahmet Arda Kavakcı <ahmetardakavakci@gmail.com>
+Maintainer-email: Ahmet Arda Kavakcı <ahmetardakavakci@gmail.com>
+License-Expression: GPL-3.0-or-later
 Project-URL: Repository, https://github.com/dybdeskarphet/easyclone
 Project-URL: Documentation, https://github.com/dybdeskarphet/easyclone
 Project-URL: Issues, https://github.com/dybdeskarphet/easyclone/issues
+Project-URL: Changelog, https://github.com/dybdeskarphet/easyclone/blob/main/CHANGELOG.md
+Keywords: backup,sync,google,drive,easyclone
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
@@ -15,6 +20,8 @@ Dynamic: license-file
 
 # ☁️ easyclone
 
+[![Pepy Total Downloads](https://img.shields.io/pepy/dt/easyclone)](https://pypi.org/project/easyclone/) [![PyPI - Version](https://img.shields.io/pypi/v/easyclone)](https://pypi.org/project/easyclone/) [![PyPI - License](https://img.shields.io/pypi/l/easyclone)](https://pypi.org/project/easyclone/)
+
 **easyclone** is a lightweight, configurable CLI tool that wraps `rclone` to behave more like Google's *Backup and Sync* app.
 
 You define what to back up, where to back it up, and EasyClone handles the syncs and copies — clean, fast, and reliable.

{easyclone-0.3.0 → easyclone-1.1.0}/src/easyclone.egg-info/SOURCES.txt

@@ -21,7 +21,7 @@ src/easyclone/shared/__init__.py
 src/easyclone/shared/sync_status.py
 src/easyclone/utils/__init__.py
 src/easyclone/utils/essentials.py
-src/easyclone/utils/path_manipulation.py
+src/easyclone/utils/path.py
 src/easyclone/utypes/__init__.py
 src/easyclone/utypes/config.py
 src/easyclone/utypes/enums.py

easyclone-0.3.0/src/easyclone/ipc/__init__.py

@@ -1,2 +0,0 @@
-from .server import start_status_server
-from .client import listen_ipc

easyclone-0.3.0/src/easyclone/main.py

@@ -1,70 +0,0 @@
-import asyncio
-from typing import Annotated, Any
-from easyclone.config import cfg
-from easyclone.ipc.client import listen_ipc
-from easyclone.ipc.server import start_status_server
-from easyclone.rclone.operations import make_backup_operation
-import typer
-import json
-from easyclone.shared import sync_status
-from easyclone.utils.essentials import exit_if_currently_running, exit_if_no_rclone
-from easyclone.utypes.enums import CommandType
-
-app = typer.Typer(
-    help="Very convenient Rclone bulk backup wrapper",
-    context_settings={"help_option_names": ["-h", "--help"]}
-)
-
-async def ipc():
-    server = await start_status_server()
-    async with server:
-        await server.serve_forever()
-
-@app.command(help="Starts the backup process using the details in the config file.")
-def start_backup(verbose: Annotated[bool, typer.Option("--verbose", "-v", help="Enables the rclone logging (overrides config).")] = False):
-    async def start():
-        exit_if_no_rclone() 
-        exit_if_currently_running() 
-        await sync_status.set_total_path_count(len(cfg.backup.sync_paths) + len(cfg.backup.copy_paths))
-
-        _ipc_task = asyncio.create_task(ipc()) 
-
-        verbose_state = verbose or cfg.backup.verbose_log
-
-        await make_backup_operation(CommandType.COPY, cfg.backup.copy_paths, verbose_state)()
-        await make_backup_operation(CommandType.SYNC, cfg.backup.sync_paths, verbose_state)()
-
-    asyncio.run(start())
-
-@app.command(help="Gets status information about the backup process.")
-def get_status(
-        all: Annotated[bool, typer.Option("--all", "-a", help="Show all the backup status information.")] = False,
-        show_total: Annotated[bool, typer.Option("--show-total", "-t", help="Show the total amount of paths.")] = False,
-        show_current: Annotated[bool, typer.Option("--show-current", "-c", help="Show the total amount of pending paths.")] = False,
-        show_operations: Annotated[bool, typer.Option("--show-operations", "-o", help="Show currently running operations.")] = False,
-        show_operation_count: Annotated[bool, typer.Option("--get-operation-count", "-O", help="Show the total amount of running operations.")] = False,
-        show_empty_paths: Annotated[bool, typer.Option("--show-empty-paths", "-e", help="Show all the empty paths.")] = False
-):
-    data: Any = asyncio.run(listen_ipc())
-
-    if (not show_total and not show_current and not show_operations and not show_operation_count and not show_empty_paths or all) or (show_total and show_current and show_operations and show_operation_count and show_empty_paths):
-        print(json.dumps(data, indent=2))
-        return
-
-    if show_total:
-        print(data["total_path_count"])
-
-    if show_current:
-        print(data["operation_count"])
-
-    if show_operations:
-        print(json.dumps(data["operations"], indent=2))
-
-    if show_operation_count:
-        print(json.dumps(data["operation_count"], indent=2))
-
-    if show_empty_paths:
-        print(json.dumps(data["empty_paths"], indent=2))
-
-if __name__ == "__main__":
-    app()

easyclone-0.3.0/src/easyclone/utils/__init__.py

@@ -1,2 +0,0 @@
-from .essentials import log, exit_if_no_rclone
-from .path_manipulation import organize_paths, collapseuser

easyclone-0.3.0/src/easyclone/utils/path_manipulation.py

@@ -1,45 +0,0 @@
-import json
-from pathlib import Path
-import os
-from easyclone.utypes.enums import PathType
-from easyclone.utypes.models import OrganizedPaths, PathItem
-
-def organize_paths(paths: list[str], remote_name: str) -> OrganizedPaths:
-    from easyclone.config import cfg
-    source_dest_array: list[PathItem] = []
-    empty_paths: list[str] = []
-    root_dir = cfg.backup.root_dir
-
-    for path in paths:
-        p = Path(os.path.expandvars(os.path.expanduser(path)))
-
-        if not os.path.exists(p):
-            empty_paths.append(path)
-
-        if p.is_dir():
-            source_dest_array.append({
-                "source": f"{p}",
-                "dest": f"{remote_name}:{root_dir}{p}",
-                "path_type": PathType.DIR.value
-            })
-        elif p.is_file():
-            dest_dir = p.parent
-            source_dest_array.append({
-                "source": f"{p}",
-                "dest": f"{remote_name}:{root_dir}{dest_dir}",
-                "path_type": PathType.FILE.value
-            })
-    
-    return { 
-        "valid_paths": source_dest_array,
-        "empty_paths": empty_paths
-    }
-
-def collapseuser(path: str) -> str:
-    """
-    Opposite of path.expanduser()
-    """
-    home = os.path.expanduser("~")
-    if path.startswith(home):
-        return path.replace(home, "~", 1)
-    return path