sftp-pilot 2.0.0__py3-none-any.whl

sftp_pilot/__init__.py

@@ -0,0 +1,17 @@
+"""
+SFTP Pilot - SFTP file transfer and scheduling application
+
+A Python application for SFTP file operations with a task scheduler and two
+interfaces (GUI and console). It uses paramiko.
+Formerly WinSCP Manager (winscp_tools).
+
+Author: Pandiyaraj Karuppasamy
+Date: Oct-19-2025
+Modified: Oct-18-2026
+Repository: https://github.com/Pandiyarajk/sftp-pilot
+"""
+
+__version__ = "2.0.0"
+__author__ = "Pandiyaraj Karuppasamy"
+__license__ = "MIT"
+__url__ = "https://github.com/Pandiyarajk/sftp-pilot"

sftp_pilot/__main__.py

@@ -0,0 +1,13 @@
+"""
+Allows `python -m sftp_pilot`.
+
+Author: Pandiyaraj Karuppasamy
+Date: Oct-17-2026
+Modified: Oct-18-2026
+"""
+
+import sys
+
+from .cli import main
+
+sys.exit(main())

sftp_pilot/cli.py

@@ -0,0 +1,107 @@
+"""
+SFTP Pilot command-line entry point (installed as `sftp-pilot`).
+
+Author: Pandiyaraj Karuppasamy
+Date: Oct-19-2025
+Modified: Oct-18-2026
+"""
+
+import argparse
+import logging
+import os
+import sys
+from typing import List, Optional
+
+from . import __version__
+
+WARNING = """\
+WARNING: this tool uploads, overwrites and deletes files on remote servers,
+including unattended through the scheduler. It is provided AS IS, without
+warranty of any kind, and you use it entirely at your own risk. Check every
+target path, keep tested backups, and only act on servers you are authorised
+to change. See DISCLAIMER.md; LICENSE is the governing text.
+"""
+
+
+def setup_logging(config_path: str) -> None:
+    """
+    Configure root logging from the [LOGGING] section, falling back to INFO
+    on the console when the configuration cannot be read.
+
+    Args:
+        config_path: Path to the configuration file
+    """
+    level_name, log_file = "INFO", ""
+    if os.path.exists(config_path):
+        try:
+            from .config_manager import ConfigManager
+            cfg = ConfigManager(config_path).get_logging_config()
+            level_name, log_file = cfg['log_level'], cfg['log_file']
+        except Exception as e:
+            print(f"Warning: could not read logging settings: {e}", file=sys.stderr)
+
+    handlers: List[logging.Handler] = [logging.StreamHandler()]
+    if log_file:
+        handlers.append(logging.FileHandler(log_file, encoding='utf-8'))
+    logging.basicConfig(
+        level=getattr(logging, level_name, logging.INFO),
+        format='%(asctime)s - %(levelname)s - %(name)s - %(message)s',
+        handlers=handlers,
+        force=True,
+    )
+    # paramiko is chatty at INFO; keep its noise out unless DEBUG was asked for.
+    if level_name != "DEBUG":
+        logging.getLogger("paramiko").setLevel(logging.WARNING)
+
+
+def main(argv: Optional[List[str]] = None) -> int:
+    """
+    Parse arguments and start the chosen interface
+
+    Args:
+        argv: Argument list (defaults to sys.argv[1:])
+
+    Returns:
+        Process exit code
+    """
+    parser = argparse.ArgumentParser(
+        prog='sftp-pilot',
+        description='SFTP Pilot - SFTP file transfer and scheduler',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=f"""
+Examples:
+  sftp-pilot                      # GUI (default)
+  sftp-pilot --console            # console menu
+  sftp-pilot -c D:\\cfg\\prod.ini   # use another config file
+
+{WARNING}"""
+    )
+    group = parser.add_mutually_exclusive_group()
+    group.add_argument('--gui', action='store_true', help='Run GUI interface (default)')
+    group.add_argument('--console', action='store_true', help='Run console interface')
+    parser.add_argument('-c', '--config', default='config.ini',
+                        help='Configuration file (default: config.ini in the current directory)')
+    parser.add_argument('--tasks-file', default='scheduled_tasks.json',
+                        help='Where scheduled tasks are stored (default: scheduled_tasks.json)')
+    parser.add_argument('--version', action='version', version=f'SFTP Pilot {__version__}')
+
+    args = parser.parse_args(argv)
+    setup_logging(args.config)
+
+    if args.console:
+        from .console import run_console
+        run_console(args.config, args.tasks_file)
+        return 0
+
+    try:
+        from .gui import run_gui
+    except ImportError as e:
+        print(f"Error: Failed to load GUI. {e}", file=sys.stderr)
+        print("Try running with --console for console interface", file=sys.stderr)
+        return 1
+    run_gui(args.config, args.tasks_file)
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main())

sftp_pilot/config_manager.py

@@ -0,0 +1,120 @@
+"""
+Configuration Manager for SFTP Pilot credentials and settings.
+
+Secrets can be kept out of the file: the environment variables
+SFTP_PILOT_PASSWORD and SFTP_PILOT_KEY_PASSPHRASE override the
+`password` and `private_key_passphrase` keys when set.
+
+Author: Pandiyaraj Karuppasamy
+Date: Oct-19-2025
+Modified: Oct-18-2026
+"""
+
+import configparser
+import os
+from typing import Any, Dict
+
+PASSWORD_ENV = "SFTP_PILOT_PASSWORD"
+PASSPHRASE_ENV = "SFTP_PILOT_KEY_PASSPHRASE"
+
+HOST_KEY_POLICIES = ("accept_new", "reject", "auto_add")
+
+
+class ConfigManager:
+    """Manages configuration file reading and validation"""
+
+    def __init__(self, config_path: str = "config.ini"):
+        """
+        Initialize the configuration manager
+
+        Args:
+            config_path: Path to the configuration file
+        """
+        self.config_path = config_path
+        self.config = configparser.ConfigParser()
+        self.load_config()
+
+    def load_config(self) -> None:
+        """Load configuration from file"""
+        if not os.path.exists(self.config_path):
+            raise FileNotFoundError(f"Configuration file not found: {self.config_path}")
+
+        self.config.read(self.config_path, encoding="utf-8")
+
+    def get_connection_details(self) -> Dict[str, Any]:
+        """
+        Get connection details from config, with secrets taken from the
+        environment when the matching variable is set.
+
+        Returns:
+            Dictionary containing connection parameters
+
+        Raises:
+            ValueError: If a setting has an unsupported value
+        """
+        protocol = self.config.get('DEFAULT', 'protocol', fallback='sftp').strip().lower()
+        if protocol != 'sftp':
+            raise ValueError(f"Unsupported protocol '{protocol}': only 'sftp' is supported")
+
+        policy = self.config.get('DEFAULT', 'host_key_policy', fallback='accept_new').strip().lower()
+        if policy not in HOST_KEY_POLICIES:
+            raise ValueError(
+                f"Unsupported host_key_policy '{policy}': use one of {', '.join(HOST_KEY_POLICIES)}"
+            )
+
+        return {
+            'protocol': protocol,
+            'host': self.config.get('DEFAULT', 'host'),
+            'port': self.config.getint('DEFAULT', 'port', fallback=22),
+            'username': self.config.get('DEFAULT', 'username'),
+            'password': os.environ.get(PASSWORD_ENV)
+            or self.config.get('DEFAULT', 'password', fallback=''),
+            'private_key_path': os.path.expanduser(
+                self.config.get('DEFAULT', 'private_key_path', fallback='')
+            ),
+            'private_key_passphrase': os.environ.get(PASSPHRASE_ENV)
+            or self.config.get('DEFAULT', 'private_key_passphrase', fallback=''),
+            'host_key_policy': policy,
+            'known_hosts_file': os.path.expanduser(
+                self.config.get('DEFAULT', 'known_hosts_file', fallback='known_hosts')
+            ),
+            'timeout': self.config.getfloat('DEFAULT', 'timeout', fallback=30.0),
+        }
+
+    def get_paths(self) -> Dict[str, str]:
+        """Get path configurations"""
+        return {
+            'remote_upload_dir': self.config.get('PATHS', 'remote_upload_dir', fallback='/'),
+            'local_download_dir': self.config.get('PATHS', 'local_download_dir', fallback='./downloads'),
+        }
+
+    def get_scheduling_config(self) -> Dict[str, Any]:
+        """Get scheduling configuration"""
+        return {
+            'enabled': self.config.getboolean('SCHEDULING', 'enabled', fallback=True),
+            'check_interval': max(1, self.config.getint('SCHEDULING', 'check_interval', fallback=60)),
+        }
+
+    def get_logging_config(self) -> Dict[str, str]:
+        """Get logging configuration"""
+        return {
+            'log_file': self.config.get('LOGGING', 'log_file', fallback='sftp_pilot.log'),
+            'log_level': self.config.get('LOGGING', 'log_level', fallback='INFO').upper(),
+        }
+
+    def update_config(self, section: str, key: str, value: str) -> None:
+        """
+        Update configuration value
+
+        Args:
+            section: Configuration section
+            key: Configuration key
+            value: New value
+        """
+        if section != 'DEFAULT' and section not in self.config:
+            self.config.add_section(section)
+
+        self.config.set(section, key, value)
+
+        with open(self.config_path, 'w', encoding="utf-8") as configfile:
+            self.config.write(configfile)

sftp_pilot/console.py

@@ -0,0 +1,391 @@
+"""
+Console Interface for SFTP Pilot
+
+Author: Pandiyaraj Karuppasamy
+Date: Oct-19-2025
+Modified: Oct-18-2026
+"""
+
+import logging
+import uuid
+from datetime import datetime, timedelta
+from typing import Optional
+
+from .config_manager import ConfigManager
+from .runner import make_task_executor
+from .scheduler import ScheduledTask, TaskScheduler, TaskType
+from .sftp_handler import SFTPHandler
+
+
+def _progress_printer(verb: str):
+    def callback(done: int, total: int) -> None:
+        percent = (done / total * 100) if total else 100.0
+        print(f"\r{verb}: {percent:5.1f}% ({done}/{total} bytes)", end='', flush=True)
+    return callback
+
+
+def _ask_int(prompt: str, default: int, minimum: int = 0) -> Optional[int]:
+    raw = input(f"{prompt} [{default}]: ").strip()
+    if not raw:
+        return default
+    try:
+        value = int(raw)
+    except ValueError:
+        print(f"FAILED: '{raw}' is not a whole number")
+        return None
+    if value < minimum:
+        print(f"FAILED: must be at least {minimum}")
+        return None
+    return value
+
+
+class ConsoleInterface:
+    """Console-based interface for SFTP Pilot"""
+
+    def __init__(self, config_path: str = "config.ini", tasks_file: str = "scheduled_tasks.json"):
+        """
+        Initialize console interface
+
+        Args:
+            config_path: Configuration file to read
+            tasks_file: Where scheduled tasks are stored
+        """
+        self.config_path = config_path
+        self.tasks_file = tasks_file
+        self.config_manager: Optional[ConfigManager] = None
+        self.sftp_handler: Optional[SFTPHandler] = None
+        self.scheduler = TaskScheduler(tasks_file)
+        self.running = True
+        self.logger = logging.getLogger(__name__)
+
+    @property
+    def connected(self) -> bool:
+        """True while the interactive connection is alive"""
+        return bool(self.sftp_handler and self.sftp_handler.is_connected())
+
+    def run(self):
+        """Run the console interface"""
+        print("=" * 60)
+        print("SFTP Pilot - Console Interface")
+        print("=" * 60)
+
+        try:
+            self.config_manager = ConfigManager(self.config_path)
+            self.logger.info("Configuration loaded successfully")
+        except Exception as e:
+            self.logger.error(f"Failed to load configuration: {e}")
+            print(f"Warning: Could not load configuration file {self.config_path}")
+
+        if self.config_manager:
+            self.scheduler.check_interval = self.config_manager.get_scheduling_config()['check_interval']
+            self.scheduler.set_task_executor(
+                make_task_executor(self.config_manager.get_connection_details)
+            )
+
+        try:
+            while self.running:
+                self.show_menu()
+                choice = input("\nEnter your choice: ").strip()
+                self.handle_choice(choice)
+        except (KeyboardInterrupt, EOFError):
+            print()
+            self.exit_app()
+
+    def show_menu(self):
+        """Display main menu"""
+        state = "connected" if self.connected else "not connected"
+        sched = "running" if self.scheduler.running else "stopped"
+        print("\n" + "=" * 60)
+        print(f"Main Menu   (server: {state}, scheduler: {sched})")
+        print("=" * 60)
+        print("1. Connect to server")
+        print("2. Disconnect from server")
+        print("3. Upload file")
+        print("4. Download file")
+        print("5. Delete file")
+        print("6. List remote files")
+        print("7. Schedule task")
+        print("8. View scheduled tasks")
+        print("9. Remove scheduled task")
+        print("10. Start scheduler")
+        print("11. Stop scheduler")
+        print("12. Exit")
+        print("=" * 60)
+
+    def handle_choice(self, choice: str):
+        """Handle menu choice"""
+        actions = {
+            '1': self.connect,
+            '2': self.disconnect,
+            '3': self.upload_file,
+            '4': self.download_file,
+            '5': self.delete_file,
+            '6': self.list_files,
+            '7': self.schedule_task,
+            '8': self.view_tasks,
+            '9': self.remove_task,
+            '10': self.start_scheduler,
+            '11': self.stop_scheduler,
+            '12': self.exit_app
+        }
+
+        action = actions.get(choice)
+        if not action:
+            print("\nInvalid choice. Please try again.")
+            return
+        try:
+            action()
+        except (KeyboardInterrupt, EOFError):
+            raise
+        except Exception as e:
+            self.logger.error(f"Error: {e}")
+            print(f"\nError: {e}")
+
+    def _require_connection(self) -> Optional[SFTPHandler]:
+        if self.sftp_handler and self.sftp_handler.is_connected():
+            return self.sftp_handler
+        if self.sftp_handler:
+            print("\nFAILED: the connection was lost. Please connect again.")
+        else:
+            print("\nFAILED: not connected to server. Please connect first.")
+        return None
+
+    def connect(self):
+        """Connect to server"""
+        if self.connected:
+            print("\nAlready connected to server")
+            return
+
+        if not self.config_manager:
+            print("\nConfiguration not loaded. Cannot connect.")
+            return
+
+        conn_details = self.config_manager.get_connection_details()
+        print(f"\nConnecting to {conn_details['host']}:{conn_details['port']}...")
+
+        self.sftp_handler = SFTPHandler.from_config(conn_details)
+        if self.sftp_handler.connect():
+            print("OK: connected")
+        else:
+            print(f"FAILED: {self.sftp_handler.last_error}")
+
+    def disconnect(self):
+        """Disconnect from server"""
+        if not self.sftp_handler:
+            print("\nNot connected to server")
+            return
+
+        self.sftp_handler.disconnect()
+        self.sftp_handler = None
+        print("\nOK: disconnected")
+
+    def upload_file(self):
+        """Upload file to server"""
+        handler = self._require_connection()
+        if not handler:
+            return
+
+        local_path = input("\nEnter local file path: ").strip().strip('"')
+        default_dir = self.config_manager.get_paths()['remote_upload_dir'] if self.config_manager else ''
+        remote_path = input(f"Enter remote destination path (end with / for a folder) [{default_dir}]: ").strip()
+        remote_path = remote_path or default_dir
+
+        if not local_path or not remote_path:
+            print("FAILED: both paths are required")
+            return
+        if not remote_path.endswith('/') and remote_path == default_dir:
+            remote_path += '/'
+
+        print(f"\nUploading {local_path} to {remote_path}...")
+        if handler.upload_file(local_path, remote_path, _progress_printer("Uploading")):
+            print("\nOK: upload completed")
+        else:
+            print("\nFAILED: upload failed (see log)")
+
+    def download_file(self):
+        """Download file from server"""
+        handler = self._require_connection()
+        if not handler:
+            return
+
+        remote_path = input("\nEnter remote file path: ").strip()
+        default_dir = self.config_manager.get_paths()['local_download_dir'] if self.config_manager else ''
+        local_path = input(f"Enter local destination (file or folder) [{default_dir}]: ").strip().strip('"')
+        local_path = local_path or default_dir
+
+        if not remote_path or not local_path:
+            print("FAILED: both paths are required")
+            return
+
+        print(f"\nDownloading {remote_path} to {local_path}...")
+        if handler.download_file(remote_path, local_path, _progress_printer("Downloading")):
+            print("\nOK: download completed")
+        else:
+            print("\nFAILED: download failed (see log)")
+
+    def delete_file(self):
+        """Delete file from server"""
+        handler = self._require_connection()
+        if not handler:
+            return
+
+        remote_path = input("\nEnter remote file path to delete: ").strip()
+
+        if not remote_path:
+            print("FAILED: path is required")
+            return
+
+        confirm = input(f"Permanently delete {remote_path} on the server? Type 'yes' to confirm: ").strip().lower()
+        if confirm != 'yes':
+            print("Cancelled")
+            return
+
+        if handler.delete_file(remote_path):
+            print("OK: file deleted")
+        else:
+            print("FAILED: delete failed (see log)")
+
+    def list_files(self):
+        """List files in remote directory"""
+        handler = self._require_connection()
+        if not handler:
+            return
+
+        remote_path = input("\nEnter remote directory path [/]: ").strip() or "/"
+        files = handler.list_files(remote_path)
+
+        if files:
+            print(f"\nFiles in {remote_path}:")
+            print("-" * 60)
+            for name in files:
+                print(f"  {name}")
+            print("-" * 60)
+        else:
+            print("\nNo files found or error occurred")
+
+    def schedule_task(self):
+        """Schedule a new task"""
+        print("\nSchedule New Task")
+        print("-" * 60)
+        print("Task Types: 1) Upload  2) Download  3) Delete")
+        task_choice = input("Select task type (1-3): ").strip()
+
+        task_type = {'1': TaskType.UPLOAD, '2': TaskType.DOWNLOAD, '3': TaskType.DELETE}.get(task_choice)
+        if not task_type:
+            print("FAILED: invalid task type")
+            return
+
+        label = "remote file to delete" if task_type == TaskType.DELETE else "source path"
+        source_path = input(f"Enter {label}: ").strip().strip('"')
+        dest_path = ""
+        if task_type in (TaskType.UPLOAD, TaskType.DOWNLOAD):
+            dest_path = input("Enter destination path: ").strip().strip('"')
+
+        delay_minutes = _ask_int("Run in how many minutes?", 5)
+        if delay_minutes is None:
+            return
+
+        recurring = input("Recurring task? (yes/no) [no]: ").strip().lower() == 'yes'
+        interval_minutes = 0
+        if recurring:
+            interval_minutes = _ask_int("Interval in minutes", 60, minimum=1)
+            if interval_minutes is None:
+                return
+
+        task_id = str(uuid.uuid4())
+        scheduled_time = datetime.now() + timedelta(minutes=delay_minutes)
+        try:
+            task = ScheduledTask(task_id, task_type, source_path, dest_path,
+                                 scheduled_time, recurring, interval_minutes)
+        except ValueError as e:
+            print(f"FAILED: {e}")
+            return
+
+        self.scheduler.add_task(task)
+        print(f"\nOK: task scheduled (ID: {task_id[:8]})")
+        print(f"  Will run at: {scheduled_time:%Y-%m-%d %H:%M:%S}")
+        if not self.scheduler.running:
+            print("  The scheduler is stopped: start it (option 10) for the task to run.")
+
+    def view_tasks(self):
+        """View all scheduled tasks"""
+        tasks = self.scheduler.get_all_tasks()
+
+        if not tasks:
+            print("\nNo scheduled tasks")
+            return
+
+        print("\nScheduled Tasks")
+        print("=" * 80)
+
+        for task in tasks:
+            print(f"\nTask ID: {task.task_id}")
+            print(f"Type: {task.task_type.value}")
+            print(f"Source: {task.source_path}")
+            print(f"Destination: {task.dest_path or 'N/A'}")
+            print(f"Next Run: {task.next_run:%Y-%m-%d %H:%M:%S}" if task.next_run else "Next Run: N/A")
+            print(f"Status: {task.describe_status()}")
+            if task.error_message:
+                print(f"Last error: {task.error_message}")
+            print(f"Recurring: {'every %d minutes' % task.interval_minutes if task.recurring else 'No'}")
+            print("-" * 80)
+
+    def remove_task(self):
+        """Remove a scheduled task"""
+        task_id = input("\nEnter task ID to remove (at least the first 4 characters): ").strip()
+        task = self.scheduler.find_task(task_id)
+        if not task:
+            print("FAILED: no single task matches that ID")
+            return
+        if self.scheduler.remove_task(task.task_id):
+            print(f"OK: task {task.task_id[:8]} removed")
+        else:
+            print("FAILED: could not remove task")
+
+    def start_scheduler(self):
+        """Start the scheduler"""
+        if self.scheduler.running:
+            print("\nScheduler is already running")
+            return
+        if not self.config_manager:
+            print("\nFAILED: the scheduler needs a loaded configuration to connect")
+            return
+        if not self.config_manager.get_scheduling_config()['enabled']:
+            print("\nFAILED: scheduling is disabled ([SCHEDULING] enabled = false)")
+            return
+
+        self.scheduler.start()
+        print("\nOK: scheduler started")
+
+    def stop_scheduler(self):
+        """Stop the scheduler"""
+        if not self.scheduler.running:
+            print("\nScheduler is not running")
+            return
+
+        self.scheduler.stop()
+        print("\nOK: scheduler stopped")
+
+    def exit_app(self):
+        """Exit the application"""
+        print("\nExiting...")
+
+        if self.scheduler.running:
+            self.scheduler.stop()
+
+        if self.sftp_handler:
+            self.sftp_handler.disconnect()
+
+        self.running = False
+        print("Goodbye!")
+
+
+def run_console(config_path: str = "config.ini", tasks_file: str = "scheduled_tasks.json"):
+    """
+    Run the console interface
+
+    Args:
+        config_path: Configuration file to read
+        tasks_file: Where scheduled tasks are stored
+    """
+    ConsoleInterface(config_path, tasks_file).run()