dedrive 0.1.0__py3-none-any.whl

dedrive/__init__.py

@@ -0,0 +1,84 @@
+"""Google Drive Deduplication Tool - package API."""
+
+__version__ = "0.1.0"
+
+from dedrive.drive import (
+    SCOPES,
+    setup_logging,
+    authenticate,
+    create_oauth_flow,
+    run_oauth_callback_server,
+    save_token,
+    load_existing_token,
+    get_user_info,
+    fetch_with_retry,
+    fetch_all_files,
+    build_lookups,
+    get_path,
+)
+from dedrive.dedup import (
+    filter_by_path,
+    filter_excluded_paths,
+    find_duplicates,
+    write_csv,
+    calculate_savings,
+    format_size,
+)
+from dedrive.config import (
+    get_exclude_paths,
+    get_credentials_path,
+    get_token_path,
+    get_output_dir,
+    get_dupes_folder,
+    get_batch_size,
+    get_max_preview_size,
+    set_active_profile,
+    set_active_profile_from_email,
+    create_default_config,
+    print_config,
+)
+from dedrive.profiles import (
+    init_profile,
+    list_profiles,
+    delete_profile_token,
+)
+
+__all__ = [
+    "__version__",
+    # drive
+    "SCOPES",
+    "setup_logging",
+    "authenticate",
+    "create_oauth_flow",
+    "run_oauth_callback_server",
+    "save_token",
+    "load_existing_token",
+    "get_user_info",
+    "fetch_with_retry",
+    "fetch_all_files",
+    "build_lookups",
+    "get_path",
+    # dedup
+    "filter_by_path",
+    "filter_excluded_paths",
+    "find_duplicates",
+    "write_csv",
+    "calculate_savings",
+    "format_size",
+    # config
+    "get_exclude_paths",
+    "get_credentials_path",
+    "get_token_path",
+    "get_output_dir",
+    "get_dupes_folder",
+    "get_batch_size",
+    "get_max_preview_size",
+    "set_active_profile",
+    "set_active_profile_from_email",
+    "create_default_config",
+    "print_config",
+    # profiles
+    "init_profile",
+    "list_profiles",
+    "delete_profile_token",
+]

dedrive/cli.py

@@ -0,0 +1,259 @@
+"""CLI entry point for dedrive."""
+
+import argparse
+import logging
+import sys
+import webbrowser
+
+from dedrive.config import (
+    get_credentials_path,
+    get_token_path,
+    set_active_profile,
+    set_active_profile_from_email,
+)
+from dedrive.drive import (
+    create_oauth_flow,
+    run_oauth_callback_server,
+    save_token,
+    load_existing_token,
+    get_user_info,
+    setup_logging,
+    authenticate,
+)
+from dedrive.profiles import (
+    list_profiles,
+    get_profile_token_path,
+    delete_profile_token,
+    PROFILES_DIR,
+)
+
+
+def cmd_login(args):
+    """Handle the login subcommand."""
+    credentials_path = get_credentials_path()
+
+    try:
+        auth_url, flow, port = create_oauth_flow(credentials_path)
+    except FileNotFoundError as e:
+        print(f"Error: {e}")
+        print()
+        print("To fix this:")
+        print("  1. Go to https://console.cloud.google.com/apis/credentials")
+        print("  2. Create a project (if you haven't already)")
+        print("  3. Enable the Google Drive API")
+        print("  4. Create OAuth 2.0 Client ID (choose 'Desktop app')")
+        print("  5. Download the JSON file")
+        print(f"  6. Save it as: {credentials_path}")
+        print(f"     Or save it to: {PROFILES_DIR / 'credentials.json'}")
+        sys.exit(1)
+
+    print(f"Opening browser for Google sign-in...")
+    print(f"If the browser doesn't open, visit: {auth_url}")
+    webbrowser.open(auth_url)
+
+    print("Waiting for authentication...")
+    try:
+        creds = run_oauth_callback_server(flow, port)
+    except TimeoutError:
+        print("Error: Authentication timed out.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error: Authentication failed: {e}")
+        sys.exit(1)
+
+    # Build service to get user info
+    from googleapiclient.discovery import build
+    service = build("drive", "v3", credentials=creds)
+    user_info = get_user_info(service)
+    email = user_info["email"]
+    name = user_info["name"]
+
+    # Create/activate profile based on email
+    profile_name = set_active_profile_from_email(email)
+
+    # Save token to profile
+    token_path = get_token_path()
+    save_token(creds, token_path)
+
+    display_name = f"{name} ({email})" if name else email
+    print(f"Logged in as {display_name}")
+    print(f"Profile: {profile_name}")
+    print(f"Token saved to: {token_path}")
+
+
+def cmd_logout(args):
+    """Handle the logout subcommand."""
+    profile = args.profile
+
+    if not profile:
+        # Auto-detect: find profiles with tokens
+        logged_in = []
+        for name in list_profiles():
+            token_path = get_profile_token_path(name)
+            if token_path.exists():
+                logged_in.append(name)
+
+        if not logged_in:
+            print("No logged-in profiles found.")
+            sys.exit(0)
+        elif len(logged_in) == 1:
+            profile = logged_in[0]
+        else:
+            print("Multiple logged-in profiles found. Specify one with --profile:")
+            for name in logged_in:
+                print(f"  dedrive logout --profile {name}")
+            sys.exit(1)
+
+    deleted = delete_profile_token(profile)
+    if deleted:
+        print(f"Logged out from profile: {profile}")
+    else:
+        print(f"Profile '{profile}' was not logged in.")
+
+
+def cmd_list_profiles(args):
+    """Handle --list-profiles."""
+    profiles = list_profiles()
+    if not profiles:
+        print("No profiles found. Run 'dedrive login' to create one.")
+        return
+
+    print("Profiles:")
+    for name in profiles:
+        token_path = get_profile_token_path(name)
+        status = " (logged in)" if token_path.exists() else ""
+        print(f"  {name}{status}")
+
+
+def cmd_ui(args):
+    """Handle the default command (launch Gradio UI)."""
+    if not args.profile:
+        profiles = list_profiles()
+        if not profiles:
+            print("No profiles found. Run 'dedrive login' first.")
+            sys.exit(1)
+
+        logged_in = [
+            name for name in profiles
+            if get_profile_token_path(name).exists()
+        ]
+
+        if len(logged_in) == 1:
+            args.profile = logged_in[0]
+            print(f"Using profile: {args.profile}")
+        else:
+            display = logged_in if logged_in else profiles
+            print("Select a profile:")
+            for i, name in enumerate(display, 1):
+                status = " (logged in)" if name in logged_in else ""
+                print(f"  {i}) {name}{status}")
+            print()
+            try:
+                choice = input("Enter number: ").strip()
+                idx = int(choice) - 1
+                if 0 <= idx < len(display):
+                    args.profile = display[idx]
+                else:
+                    print("Invalid selection.")
+                    sys.exit(1)
+            except (ValueError, EOFError, KeyboardInterrupt):
+                print()
+                sys.exit(1)
+
+    set_active_profile(args.profile)
+
+    setup_logging(verbose=args.verbose, log_file=args.log_file)
+
+    if args.validate:
+        logger = logging.getLogger(__name__)
+        credentials_path = get_credentials_path()
+        try:
+            from googleapiclient.discovery import build
+            creds = authenticate(credentials_path)
+            service = build("drive", "v3", credentials=creds)
+            user_info = get_user_info(service)
+            logger.info(f"Credentials valid. Connected as: {user_info['name']} <{user_info['email']}>")
+            sys.exit(0)
+        except Exception as e:
+            logger.error(f"Credential validation failed: {e}")
+            sys.exit(1)
+
+    from dedrive.ui import create_ui
+    from dedrive.config import get_output_dir
+    app = create_ui()
+    app.launch(share=args.share, server_port=args.port, allowed_paths=[str(get_output_dir())])
+
+
+def main():
+    """CLI entry point."""
+    parser = argparse.ArgumentParser(
+        prog="dedrive",
+        description="Google Drive Deduplication Manager",
+    )
+    parser.add_argument(
+        "--profile", "-P",
+        help="Use a named profile",
+    )
+    parser.add_argument(
+        "--list-profiles",
+        action="store_true",
+        help="List available profiles and exit",
+    )
+
+    subparsers = parser.add_subparsers(dest="command")
+
+    # login subcommand
+    login_parser = subparsers.add_parser("login", help="Authenticate with Google (opens browser)")
+    login_parser.add_argument("--profile", "-P", default=argparse.SUPPRESS, help="Use a named profile")
+
+    # logout subcommand
+    logout_parser = subparsers.add_parser("logout", help="Remove saved authentication token")
+    logout_parser.add_argument("--profile", "-P", default=argparse.SUPPRESS, help="Use a named profile")
+
+    # UI flags (only apply when no subcommand)
+    parser.add_argument(
+        "--validate",
+        action="store_true",
+        help="Validate credentials and exit without launching the UI",
+    )
+    parser.add_argument(
+        "--verbose", "-v",
+        action="store_true",
+        help="Enable verbose/debug logging",
+    )
+    parser.add_argument(
+        "--log-file",
+        help="Write logs to file (in addition to console)",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=7860,
+        help="Gradio server port (default: 7860)",
+    )
+    parser.add_argument(
+        "--share",
+        action="store_true",
+        help="Enable Gradio public sharing link",
+    )
+
+    args = parser.parse_args()
+
+    # Handle --list-profiles
+    if args.list_profiles:
+        cmd_list_profiles(args)
+        sys.exit(0)
+
+    # Handle subcommands
+    if args.command == "login":
+        if args.profile:
+            set_active_profile(args.profile)
+        cmd_login(args)
+    elif args.command == "logout":
+        cmd_logout(args)
+    else:
+        cmd_ui(args)
+
+
+if __name__ == "__main__":
+    main()

dedrive/config.py

@@ -0,0 +1,284 @@
+"""Configuration module for Google Drive Deduplication Tool."""
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from dotenv import load_dotenv
+
+from dedrive.profiles import load_profile, get_profile_token_path, get_profile_output_dir, init_profile, PROFILES_DIR
+
+# Load .env file if present
+load_dotenv()
+
+# Active profile (set via set_active_profile)
+active_profile: str | None = None
+_profile_config: dict = {}
+
+
+def set_active_profile(name: str):
+    """Activate a profile, loading its config.yaml."""
+    global active_profile, _profile_config
+    active_profile = name
+    _profile_config = load_profile(name)
+
+
+def set_active_profile_from_email(email: str) -> str:
+    """Create (if needed) and activate a profile based on user email.
+
+    Args:
+        email: The user's email address, used as the profile name.
+
+    Returns:
+        The profile name (same as email).
+    """
+    init_profile(email)
+    set_active_profile(email)
+    return email
+
+
+# Default configuration values
+DEFAULTS = {
+    "credentials_path": "credentials.json",
+    "token_path": "token.json",
+    "output_dir": ".output",
+    "dupes_folder": "/_dupes",
+    "batch_size": 100,
+    "max_preview_mb": 10,
+    "exclude_paths": [],
+}
+
+# Environment variable names
+ENV_VARS = {
+    "credentials_path": "GDRIVE_CREDENTIALS_PATH",
+    "token_path": "GDRIVE_TOKEN_PATH",
+    "output_dir": "GDRIVE_OUTPUT_DIR",
+    "dupes_folder": "GDRIVE_DUPES_FOLDER",
+    "batch_size": "GDRIVE_BATCH_SIZE",
+    "max_preview_mb": "GDRIVE_MAX_PREVIEW_MB",
+    "exclude_paths": "GDRIVE_EXCLUDE_PATHS",
+}
+
+CONFIG_FILE = "config.json"
+
+
+def expand_path(path: str) -> Path:
+    """Expand ~ and environment variables in path."""
+    return Path(os.path.expanduser(os.path.expandvars(path)))
+
+
+def load_config() -> dict:
+    """Load configuration from config file if it exists.
+
+    Checks cwd config.json first, then falls back to ~/.dedrive/config.json.
+    """
+    for config_path in [Path(CONFIG_FILE), PROFILES_DIR / CONFIG_FILE]:
+        if config_path.exists():
+            try:
+                with open(config_path) as f:
+                    return json.load(f)
+            except json.JSONDecodeError as e:
+                print(f"Error: Invalid JSON in {config_path}: {e}")
+                print(f"Please fix the syntax in {config_path} or delete it to use defaults.")
+            except PermissionError:
+                print(f"Error: Cannot read {config_path} - permission denied.")
+            except Exception as e:
+                print(f"Warning: Failed to load {config_path}: {e}")
+    return {}
+
+
+def get_config_value(key: str, cli_value: Any = None) -> Any:
+    """Get configuration value with precedence: CLI > ENV > config file > default.
+
+    Args:
+        key: Configuration key (e.g., 'credentials_path')
+        cli_value: Value from CLI argument (highest precedence if not None)
+
+    Returns:
+        Configuration value from highest precedence source.
+    """
+    # CLI argument has highest precedence
+    if cli_value is not None:
+        return cli_value
+
+    # Profile config.yaml (when a profile is active)
+    if active_profile and key in _profile_config:
+        return _profile_config[key]
+
+    # Environment variable
+    env_var = ENV_VARS.get(key)
+    if env_var:
+        env_value = os.environ.get(env_var)
+        if env_value is not None:
+            # Handle type conversion
+            if key == "batch_size":
+                try:
+                    return int(env_value)
+                except ValueError:
+                    print(f"Warning: Invalid {env_var} value '{env_value}', using default.")
+            elif key == "max_preview_mb":
+                try:
+                    return int(env_value)
+                except ValueError:
+                    print(f"Warning: Invalid {env_var} value '{env_value}', using default.")
+            else:
+                return env_value
+
+    # Config file
+    config = load_config()
+    if key in config:
+        return config[key]
+
+    # Default
+    return DEFAULTS.get(key)
+
+
+def get_credentials_path(cli_value: str = None) -> Path:
+    """Get credentials file path.
+
+    Falls back to ~/.dedrive/credentials.json when the default
+    credentials.json doesn't exist in cwd.
+    """
+    path = get_config_value("credentials_path", cli_value)
+    resolved = expand_path(path)
+    if not resolved.exists() and path == DEFAULTS["credentials_path"]:
+        fallback = PROFILES_DIR / "credentials.json"
+        if fallback.exists():
+            return fallback
+    return resolved
+
+
+def get_token_path(credentials_path: Path = None) -> Path:
+    """Get token file path.
+
+    By default, token.json is stored next to credentials.json.
+    Can be overridden via GDRIVE_TOKEN_PATH or config file.
+    """
+    if active_profile:
+        return get_profile_token_path(active_profile)
+
+    explicit_path = get_config_value("token_path")
+
+    # If explicitly set (not default), use that
+    if explicit_path != DEFAULTS["token_path"]:
+        return expand_path(explicit_path)
+
+    # Otherwise, store next to credentials file
+    if credentials_path:
+        return credentials_path.parent / "token.json"
+
+    return Path("token.json")
+
+
+def get_output_dir() -> Path:
+    """Get output directory path."""
+    if active_profile:
+        return get_profile_output_dir(active_profile)
+    path = get_config_value("output_dir")
+    return expand_path(path)
+
+
+def get_dupes_folder() -> str:
+    """Get the name of the dupes folder in Google Drive."""
+    return get_config_value("dupes_folder")
+
+
+def get_batch_size() -> int:
+    """Get batch size for API operations."""
+    return get_config_value("batch_size")
+
+
+def get_max_preview_size() -> int:
+    """Get max preview size in bytes."""
+    mb = get_config_value("max_preview_mb")
+    return mb * 1024 * 1024
+
+
+def get_exclude_paths(cli_excludes: list[str] = None) -> list[str]:
+    """Get exclude paths from CLI, config file, and environment variable.
+
+    Sources (combined):
+    1. CLI arguments (--exclude flags)
+    2. Config file: config.json with "exclude_paths" array
+    3. Environment variable: GDRIVE_EXCLUDE_PATHS (comma-separated paths)
+
+    Returns:
+        List of paths to exclude from scans.
+    """
+    exclude_paths = []
+
+    # CLI arguments
+    if cli_excludes:
+        exclude_paths.extend(cli_excludes)
+
+    # Profile config.yaml (when a profile is active)
+    if active_profile and "exclude_paths" in _profile_config:
+        profile_paths = _profile_config["exclude_paths"]
+        if isinstance(profile_paths, list):
+            exclude_paths.extend(profile_paths)
+
+    # Load from config file
+    config = load_config()
+    file_paths = config.get("exclude_paths", [])
+    if isinstance(file_paths, list):
+        exclude_paths.extend(file_paths)
+
+    # Load from environment variable (comma-separated)
+    env_var = ENV_VARS.get("exclude_paths")
+    env_paths = os.environ.get(env_var, "")
+    if env_paths:
+        for path in env_paths.split(","):
+            path = path.strip()
+            if path:
+                exclude_paths.append(path)
+
+    # Normalize paths (ensure they start with / and don't end with /)
+    normalized = []
+    for path in exclude_paths:
+        path = path.strip()
+        # Skip comment lines in config
+        if path.startswith("#"):
+            continue
+        if not path.startswith("/"):
+            path = "/" + path
+        path = path.rstrip("/")
+        if path:
+            normalized.append(path)
+
+    return list(set(normalized))  # Remove duplicates
+
+
+def create_default_config():
+    """Create a default config file with all available options."""
+    default_config = {
+        "# credentials_path": "~/.config/dedrive/credentials.json",
+        "# token_path": "~/.config/dedrive/token.json",
+        "# output_dir": ".output",
+        "# dupes_folder": "/_dupes",
+        "# batch_size": 100,
+        "# max_preview_mb": 10,
+        "exclude_paths": [
+            "# Add paths to exclude from scans, e.g.:",
+            "# /Backup/Old",
+            "# /tmp"
+        ]
+    }
+
+    config_path = Path(CONFIG_FILE)
+    if not config_path.exists():
+        with open(config_path, "w") as f:
+            json.dump(default_config, f, indent=2)
+        print(f"Created default config file: {CONFIG_FILE}")
+
+
+def print_config():
+    """Print current configuration for debugging."""
+    print("Current configuration:")
+    print(f"  credentials_path: {get_credentials_path()}")
+    print(f"  token_path: {get_token_path(get_credentials_path())}")
+    print(f"  output_dir: {get_output_dir()}")
+    print(f"  dupes_folder: {get_dupes_folder()}")
+    print(f"  batch_size: {get_batch_size()}")
+    print(f"  max_preview_mb: {get_config_value('max_preview_mb')}")
+    print(f"  exclude_paths: {get_exclude_paths()}")