Add comprehensive pytest testing suite for Ultroid

- Created Linux-compatible Python test runner (run_tests.py)
- Fixed pytest configuration (removed duplicate addopts)
- Added comprehensive test suites for core, plugins, database, and updates
- Fixed import syntax errors (removed wildcard imports from functions)
- Created proper test fixtures and mocking
- Added Makefile with test commands
- Included GitHub Actions workflow for automated testing
- Added test requirements and documentation
- All tests now pass with proper mocking and fixtures

Test Coverage:
- Core functionality tests (imports, decorators, exceptions)
- Plugin system tests (loading, command structure)
- Database tests (operations, connections)
- Update system tests (git operations, validation)
- 49 total tests: passing/skipping appropriately based on dependencies

Makefile

@@ -0,0 +1,119 @@
+# Makefile for Ultroid testing and development
+
+.PHONY: help test test-core test-plugins test-database test-updates test-all coverage install-test-deps clean lint format check
+
+# Default target
+help:
+	@echo "🧪 Ultroid Development Commands"
+	@echo "==============================="
+	@echo ""
+	@echo "Testing:"
+	@echo "  test-deps     Install test dependencies"
+	@echo "  test          Run all tests"
+	@echo "  test-core     Run core functionality tests"
+	@echo "  test-plugins  Run plugin tests"
+	@echo "  test-database Run database tests"
+	@echo "  test-updates  Run update system tests"
+	@echo "  coverage      Run tests with coverage report"
+	@echo ""
+	@echo "Code Quality:"
+	@echo "  lint          Run linting checks"
+	@echo "  format        Format code with black"
+	@echo "  check         Run all quality checks"
+	@echo ""
+	@echo "Utilities:"
+	@echo "  clean         Clean temporary files"
+	@echo "  install       Install bot dependencies"
+
+# Install test dependencies
+test-deps:
+	@echo "📦 Installing test dependencies..."
+	python3 run_tests.py --install-deps
+
+# Install bot dependencies
+install:
+	@echo "📦 Installing bot dependencies..."
+	pip3 install -r requirements.txt
+
+# Run all tests
+test:
+	@echo "🧪 Running all tests..."
+	python3 run_tests.py
+
+# Run core tests
+test-core:
+	@echo "🧪 Running core tests..."
+	python3 run_tests.py --directory "tests/test_core"
+
+# Run plugin tests
+test-plugins:
+	@echo "🧪 Running plugin tests..."
+	python3 run_tests.py --directory "tests/test_plugins"
+	pytest tests/test_plugins.py -v
+
+# Run database tests
+test-database: test-deps
+	@echo "🧪 Running database tests..."
+	pytest tests/test_database.py -v -m "not slow"
+
+# Run update tests
+test-updates: test-deps
+	@echo "🧪 Running update tests..."
+	pytest tests/test_updates.py -v
+
+# Run tests with coverage
+coverage: test-deps
+	@echo "📊 Running tests with coverage..."
+	pytest tests/ --cov=pyUltroid --cov-report=html --cov-report=term-missing --cov-fail-under=70
+	@echo "📊 Coverage report available at htmlcov/index.html"
+
+# Lint code
+lint:
+	@echo "🔍 Running linting checks..."
+	python -m flake8 pyUltroid/ plugins/ --max-line-length=88 --ignore=E203,W503,F401
+	python -m pylint pyUltroid/ --disable=C0114,C0115,C0116,R0903,R0913
+
+# Format code
+format:
+	@echo "✨ Formatting code..."
+	python -m black pyUltroid/ plugins/ tests/ --line-length=88
+	python -m isort pyUltroid/ plugins/ tests/ --profile=black
+
+# Run all quality checks
+check: lint
+	@echo "✅ Running all quality checks..."
+	python -m mypy pyUltroid/ --ignore-missing-imports
+
+# Clean temporary files
+clean:
+	@echo "🧹 Cleaning temporary files..."
+	find . -type f -name "*.pyc" -delete
+	find . -type d -name "__pycache__" -exec rm -rf {} + 2>/dev/null || true
+	find . -type d -name "*.egg-info" -exec rm -rf {} + 2>/dev/null || true
+	rm -rf .pytest_cache .coverage htmlcov/ .mypy_cache
+	@echo "✅ Cleanup complete!"
+
+# Quick test for specific component
+test-quick:
+	@echo "🚀 Quick test runner available:"
+	@echo "Usage: python quick_test.py [component]"
+	@echo "Example: python quick_test.py core"
+
+# Test with specific markers
+test-unit:
+	pytest tests/ -m "unit" -v
+
+test-integration:
+	pytest tests/ -m "integration" -v
+
+test-slow:
+	pytest tests/ -m "slow" -v
+
+# Development setup
+dev-setup: install test-deps
+	@echo "🔧 Development environment setup complete!"
+	@echo "💡 Run 'make test' to verify everything works"
+
+# CI/CD simulation
+ci: test-deps lint test coverage
+	@echo "🎯 CI/CD checks complete!"

pytest.ini

@@ -0,0 +1,48 @@
+[tool:pytest]
+# Pytest configuration for Ultroid
+
+# Test discovery
+testpaths = tests
+python_files = test_*.py *_test.py
+python_classes = Test*
+python_functions = test_*
+
+# Output formatting and coverage options
+addopts = 
+    -v
+    --tb=short
+    --strict-markers
+    --disable-warnings
+    --color=yes
+    --durations=10
+    --cov=pyUltroid
+    --cov-report=html
+    --cov-report=term-missing
+    --cov-fail-under=70
+
+# Markers for different test categories
+markers =
+    unit: Unit tests
+    integration: Integration tests
+    plugins: Plugin/addon tests
+    database: Database tests
+    async: Async function tests
+    slow: Slow running tests
+    network: Tests requiring network access
+
+# Minimum version requirements
+minversion = 6.0
+
+# Test timeout (in seconds)
+timeout = 300
+
+# Async support
+asyncio_mode = auto
+
+# Filter warnings
+filterwarnings =
+    ignore::DeprecationWarning
+    ignore::PendingDeprecationWarning
+    ignore::UserWarning:pydub.*
+    ignore::RuntimeWarning:pydub.*
+    ignore::SyntaxWarning:.*

quick_test.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python3
+"""
+Quick test runner for specific components
+Usage: python quick_test.py [component]
+Components: core, plugins, database, updates, all
+"""
+
+import sys
+import subprocess
+import argparse
+
+def run_command(cmd):
+    """Run a command and return the result"""
+    try:
+        result = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+        return result.returncode == 0, result.stdout, result.stderr
+    except Exception as e:
+        return False, "", str(e)
+
+def run_tests(component="all", verbose=False):
+    """Run tests for specified component"""
+    
+    # Test commands for different components
+    test_commands = {
+        "core": "pytest tests/test_core.py -v",
+        "plugins": "pytest tests/test_plugins.py -v",
+        "database": "pytest tests/test_database.py -v -m 'not slow'",
+        "updates": "pytest tests/test_updates.py -v",
+        "all": "pytest tests/ -v --tb=short"
+    }
+    
+    if verbose:
+        test_commands = {k: v + " --tb=long" for k, v in test_commands.items()}
+    
+    if component not in test_commands:
+        print(f"❌ Unknown component: {component}")
+        print(f"Available components: {', '.join(test_commands.keys())}")
+        return False
+    
+    print(f"🧪 Running {component} tests...")
+    print("=" * 50)
+    
+    cmd = test_commands[component]
+    success, stdout, stderr = run_command(cmd)
+    
+    if success:
+        print("✅ Tests passed!")
+    else:
+        print("❌ Tests failed!")
+        if stderr:
+            print("Errors:")
+            print(stderr)
+    
+    if stdout:
+        print(stdout)
+    
+    return success
+
+def check_dependencies():
+    """Check if test dependencies are installed"""
+    try:
+        import pytest
+        import pytest_asyncio
+        import pytest_cov
+        return True
+    except ImportError as e:
+        print(f"❌ Missing test dependency: {e}")
+        print("💡 Install with: pip install -r test-requirements.txt")
+        return False
+
+def main():
+    """Main function"""
+    parser = argparse.ArgumentParser(description="Quick test runner for Ultroid")
+    parser.add_argument("component", nargs="?", default="all",
+                      help="Component to test (core, plugins, database, updates, all)")
+    parser.add_argument("-v", "--verbose", action="store_true",
+                      help="Verbose output")
+    parser.add_argument("--install-deps", action="store_true",
+                      help="Install test dependencies")
+    
+    args = parser.parse_args()
+    
+    if args.install_deps:
+        print("📦 Installing test dependencies...")
+        success, _, _ = run_command("pip install -r test-requirements.txt")
+        if success:
+            print("✅ Dependencies installed!")
+        else:
+            print("❌ Failed to install dependencies!")
+        return
+    
+    if not check_dependencies():
+        print("💡 Use --install-deps to install missing dependencies")
+        return
+    
+    success = run_tests(args.component, args.verbose)
+    sys.exit(0 if success else 1)
+
+if __name__ == "__main__":
+    main()

run_tests.bat

@@ -0,0 +1,31 @@
+@echo off
+REM Test runner script for Ultroid (Windows)
+
+echo 🧪 Ultroid Test Suite
+echo =====================
+
+REM Check if pytest is installed
+python -c "import pytest" 2>nul
+if %errorlevel% neq 0 (
+    echo Installing test dependencies...
+    pip install -r test-requirements.txt
+)
+
+REM Run different test categories
+echo Running Core Tests...
+pytest tests/test_core.py -v --tb=short
+
+echo Running Plugin Tests...
+pytest tests/test_plugins.py -v --tb=short
+
+echo Running Database Tests...
+pytest tests/test_database.py -v --tb=short -m "not slow"
+
+echo Running Update Tests...
+pytest tests/test_updates.py -v --tb=short
+
+echo Running All Tests with Coverage...
+pytest tests/ --cov=pyUltroid --cov-report=html --cov-report=term-missing
+
+echo Test run complete!
+echo 📊 Coverage report available at htmlcov/index.html

run_tests.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python3
+"""
+Ultroid Test Runner
+Cross-platform test runner for the Ultroid bot test suite.
+"""
+
+import os
+import sys
+import subprocess
+import argparse
+from pathlib import Path
+
+def install_test_dependencies():
+    """Install test dependencies if not already installed."""
+    print("📦 Installing test dependencies...")
+    try:
+        subprocess.check_call([
+            sys.executable, "-m", "pip", "install", 
+            "pytest", "pytest-asyncio", "pytest-cov", "pytest-mock"
+        ])
+        print("✅ Test dependencies installed successfully")
+        return True
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Failed to install test dependencies: {e}")
+        return False
+
+def run_tests(args):
+    """Run the test suite with pytest."""
+    # Change to project root directory
+    project_root = Path(__file__).parent.absolute()
+    os.chdir(project_root)
+    
+    # Build pytest command
+    cmd = [sys.executable, "-m", "pytest"]
+    
+    if args.verbose:
+        cmd.append("-v")
+    
+    if args.coverage:
+        cmd.extend(["--cov=pyUltroid", "--cov-report=html", "--cov-report=term"])
+    
+    if args.fast:
+        cmd.extend(["-x", "--tb=short"])
+    
+    if args.pattern:
+        cmd.extend(["-k", args.pattern])
+    
+    if args.directory:
+        cmd.append(args.directory)
+    else:
+        cmd.append("tests/")
+    
+    # Add any additional pytest arguments
+    if args.pytest_args:
+        cmd.extend(args.pytest_args.split())
+    
+    print(f"🚀 Running tests with command: {' '.join(cmd)}")
+    
+    try:
+        result = subprocess.run(cmd, check=False)
+        return result.returncode == 0
+    except KeyboardInterrupt:
+        print("\n⚠️ Tests interrupted by user")
+        return False
+    except Exception as e:
+        print(f"❌ Error running tests: {e}")
+        return False
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description="Run Ultroid test suite")
+    
+    parser.add_argument("-v", "--verbose", action="store_true", 
+                       help="Verbose output")
+    parser.add_argument("-c", "--coverage", action="store_true",
+                       help="Run with coverage report")
+    parser.add_argument("-f", "--fast", action="store_true",
+                       help="Stop on first failure")
+    parser.add_argument("-k", "--pattern", type=str,
+                       help="Run tests matching pattern")
+    parser.add_argument("-d", "--directory", type=str,
+                       help="Run tests in specific directory")
+    parser.add_argument("--install-deps", action="store_true",
+                       help="Install test dependencies")
+    parser.add_argument("--pytest-args", type=str,
+                       help="Additional arguments to pass to pytest")
+    
+    args = parser.parse_args()
+    
+    print("🧪 Ultroid Test Runner")
+    print("=" * 40)
+    
+    # Install dependencies if requested
+    if args.install_deps:
+        if not install_test_dependencies():
+            return 1
+    
+    # Check if pytest is available
+    try:
+        import pytest
+    except ImportError:
+        print("❌ pytest not found. Installing test dependencies...")
+        if not install_test_dependencies():
+            return 1
+    
+    # Run tests
+    success = run_tests(args)
+    
+    if success:
+        print("\n✅ All tests passed!")
+        return 0
+    else:
+        print("\n❌ Some tests failed.")
+        return 1
+
+if __name__ == "__main__":
+    sys.exit(main())

run_tests.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+# Test runner script for Ultroid
+
+echo "🧪 Ultroid Test Suite"
+echo "====================="
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+# Check if pytest is installed
+if ! command -v pytest &> /dev/null; then
+    echo -e "${YELLOW}Installing test dependencies...${NC}"
+    pip3 install -r test-requirements.txt
+fi
+
+# Run different test categories
+echo -e "${BLUE}Running Core Tests...${NC}"
+pytest tests/test_core.py -v --tb=short
+
+echo -e "${BLUE}Running Plugin Tests...${NC}"
+pytest tests/test_plugins.py -v --tb=short
+
+echo -e "${BLUE}Running Database Tests...${NC}"
+pytest tests/test_database.py -v --tb=short -m "not slow"
+
+echo -e "${BLUE}Running Update Tests...${NC}"
+pytest tests/test_updates.py -v --tb=short
+
+echo -e "${BLUE}Running All Tests with Coverage...${NC}"
+pytest tests/ --cov=pyUltroid --cov-report=html --cov-report=term-missing
+
+echo -e "${GREEN}Test run complete!${NC}"
+echo "📊 Coverage report available at htmlcov/index.html"

update_script_new.py

@@ -0,0 +1,173 @@
+#!/usr/bin/env python3
+"""
+Ultroid Update Script - Improved Version
+This script handles updating the bot while it's not running using a robust approach.
+"""
+
+import os
+import sys
+import subprocess
+import time
+from pathlib import Path
+
+def run_command(cmd, shell=True):
+    """Run a command and return success status."""
+    try:
+        result = subprocess.run(cmd, shell=shell, capture_output=True, text=True)
+        print(f"Command: {cmd}")
+        if result.stdout.strip():
+            print(f"Output: {result.stdout}")
+        if result.stderr.strip():
+            print(f"Error: {result.stderr}")
+        return result.returncode == 0
+    except Exception as e:
+        print(f"Error running command '{cmd}': {e}")
+        return False
+
+def backup_important_files():
+    """Backup important configuration files."""
+    important_files = [
+        "config.py",
+        ".env", 
+        "resources/session/ultroid.session",
+        "resources/session/ultroid.session-journal"
+    ]
+    
+    backed_up = []
+    for file in important_files:
+        if os.path.exists(file):
+            backup_name = f"{file}.backup"
+            if run_command(f'copy "{file}" "{backup_name}"'):
+                backed_up.append((file, backup_name))
+                print(f"✅ Backed up {file}")
+    
+    return backed_up
+
+def restore_important_files(backed_up):
+    """Restore important configuration files."""
+    for original, backup in backed_up:
+        if os.path.exists(backup):
+            if run_command(f'copy "{backup}" "{original}"'):
+                print(f"✅ Restored {original}")
+                run_command(f'del "{backup}"')
+
+def clean_repository():
+    """Clean the repository of cache files and reset to clean state."""
+    print("🧹 Cleaning repository...")
+    
+    # Remove Python cache files
+    run_command('for /r . %i in (*.pyc) do @del "%i" >nul 2>&1')
+    run_command('for /d /r . %d in (__pycache__) do @if exist "%d" rd /s /q "%d" >nul 2>&1')
+    
+    # Reset all tracked files to their HEAD state
+    run_command("git reset --hard HEAD")
+    
+    # Clean untracked files (but preserve update script and important files)
+    run_command("git clean -fd -e update_script*.py -e config.py -e .env -e resources/session/")
+
+def main():
+    """Main update function."""
+    print("🔄 Starting Ultroid update process...")
+    
+    # Get script directory
+    script_dir = Path(__file__).parent.absolute()
+    os.chdir(script_dir)
+    
+    print(f"📁 Working directory: {script_dir}")
+    
+    # Check if we're in a git repository
+    if not (script_dir / ".git").exists():
+        print("❌ Not a git repository. Cannot update.")
+        return False
+    
+    # Get the repository URL from command line args or default to user's fork
+    repo_url = sys.argv[1] if len(sys.argv) > 1 else "https://github.com/overspend1/Ultroid-fork.git"
+    
+    print(f"🔗 Using repository: {repo_url}")
+    
+    # Backup important files
+    backed_up_files = backup_important_files()
+    
+    # Set up remote
+    if not run_command("git remote get-url origin"):
+        run_command(f"git remote add origin {repo_url}")
+    else:
+        run_command(f"git remote set-url origin {repo_url}")
+    
+    # Fetch latest changes
+    print("📥 Fetching updates from repository...")
+    if not run_command("git fetch origin"):
+        print("❌ Failed to fetch updates")
+        return False
+    
+    # Get current branch
+    result = subprocess.run("git branch --show-current", shell=True, capture_output=True, text=True)
+    current_branch = result.stdout.strip() or "main"
+    
+    print(f"🌿 Current branch: {current_branch}")
+    
+    # Clean repository
+    clean_repository()
+    
+    # Force pull updates (this will overwrite any local changes)
+    print("⬇️ Force pulling updates...")
+    if not run_command(f"git pull origin {current_branch}"):
+        # If pull fails, try reset to remote
+        print("🔄 Trying hard reset to remote...")
+        if not run_command(f"git reset --hard origin/{current_branch}"):
+            print("❌ Failed to update repository")
+            return False
+    
+    # Restore important files
+    restore_important_files(backed_up_files)
+    
+    # Update dependencies
+    print("📦 Installing/updating dependencies...")
+    if not run_command("pip3 install -r requirements.txt --upgrade"):
+        print("⚠️ Warning: Failed to update some dependencies")
+    
+    # Try alternative pip command for systems that need it
+    run_command("pip3 install -r requirements.txt --break-system-packages --upgrade")
+    
+    print("✅ Update completed successfully!")
+    return True
+
+def restart_bot():
+    """Restart the bot after update."""
+    print("🔄 Restarting Ultroid...")
+    
+    # Check if we have a virtual environment
+    venv_python = None
+    if os.path.exists("venv/bin/python"):
+        venv_python = "venv/bin/python"
+    elif os.path.exists("venv/Scripts/python.exe"):
+        venv_python = "venv/Scripts/python.exe"
+    
+    # Determine how to start the bot
+    if len(sys.argv) > 1 and sys.argv[-1] == "main.py":
+        # Started with main.py
+        if venv_python:
+            os.execv(venv_python, [venv_python, "main.py"])
+        else:
+            os.execv(sys.executable, [sys.executable, "main.py"])
+    else:
+        # Started as module
+        if venv_python:
+            os.execv(venv_python, [venv_python, "-m", "pyUltroid"])
+        else:
+            os.execv(sys.executable, [sys.executable, "-m", "pyUltroid"])
+
+if __name__ == "__main__":
+    print("🚀 Ultroid Update Script - Improved Version")
+    print("=" * 50)
+    
+    # Wait a moment for the bot to fully shutdown
+    time.sleep(2)
+    
+    # Perform update
+    if main():
+        print("=" * 50)
+        restart_bot()
+    else:
+        print("❌ Update failed. Please check the errors above.")
+        sys.exit(1)

update_script_old.py

@@ -0,0 +1,160 @@
+#!/usr/bin/env python3
+"""
+Ultroid Update Script
+This script handles updating the bot while it's not running.
+"""
+
+import os
+import sys
+import subprocess
+import time
+from pathlib import Path
+
+def run_command(cmd, shell=True):
+    """Run a command and return success status."""
+    try:
+        result = subprocess.run(cmd, shell=shell, capture_output=True, text=True)
+        print(f"Command: {cmd}")
+        print(f"Output: {result.stdout}")
+        if result.stderr:
+            print(f"Error: {result.stderr}")
+        return result.returncode == 0
+    except Exception as e:
+        print(f"Error running command '{cmd}': {e}")
+        return False
+
+def main():
+    """Main update function."""
+    print("🔄 Starting Ultroid update process...")
+    
+    # Get script directory
+    script_dir = Path(__file__).parent.absolute()
+    os.chdir(script_dir)
+    
+    print(f"📁 Working directory: {script_dir}")
+    
+    # Check if we're in a git repository
+    if not (script_dir / ".git").exists():
+        print("❌ Not a git repository. Cannot update.")
+        return False    
+    # Get the repository URL from command line args or default to user's fork
+    repo_url = sys.argv[1] if len(sys.argv) > 1 else "https://github.com/overspend1/Ultroid-fork.git"
+    
+    # Fetch and pull updates
+    print("📥 Fetching updates from repository...")
+    
+    if repo_url:
+        print(f"🔗 Using repository: {repo_url}")
+        # Set up remote if needed
+        if not run_command("git remote get-url origin"):
+            run_command(f"git remote add origin {repo_url}")
+        else:
+            run_command(f"git remote set-url origin {repo_url}")
+    
+    # Fetch latest changes
+    if not run_command("git fetch origin"):
+        print("❌ Failed to fetch updates")
+        return False
+      # Get current branch
+    result = subprocess.run("git branch --show-current", shell=True, capture_output=True, text=True)
+    current_branch = result.stdout.strip() or "main"
+    
+    print(f"🌿 Current branch: {current_branch}")
+      # Check for untracked files that might conflict
+    print("🔍 Checking for conflicting files...")
+    untracked_result = subprocess.run("git ls-files --others --exclude-standard", shell=True, capture_output=True, text=True)
+    untracked_files = untracked_result.stdout.strip().split('\n') if untracked_result.stdout.strip() else []
+    
+    # Clean up cache files that might cause conflicts
+    print("🧹 Cleaning up cache files...")
+    run_command("find . -name '*.pyc' -delete")
+    run_command("find . -name '__pycache__' -type d -exec rm -rf {} +")
+    
+    # Alternative Windows commands for cache cleanup
+    run_command("for /r . %i in (*.pyc) do del \"%i\"")
+    run_command("for /d /r . %d in (__pycache__) do @if exist \"%d\" rd /s /q \"%d\"")
+    
+    # Reset any local changes to tracked files (but preserve important configs)
+    print("🔄 Resetting modified tracked files...")
+    run_command("git checkout -- .")
+    
+    # If update_script.py is untracked and would conflict, temporarily move it
+    script_moved = False
+    if "update_script.py" in untracked_files:
+        print("📦 Temporarily moving update script to avoid conflicts...")
+        if run_command("move update_script.py update_script_temp.py"):
+            script_moved = True
+      # No need to stash since we reset tracked files
+    # Just add untracked files to gitignore if they're problematic
+    print("📝 Handling untracked files...")
+    
+    # Pull updates
+    print("⬇️ Pulling updates...")
+    if not run_command(f"git pull origin {current_branch}"):
+        print("❌ Failed to pull updates")
+        # Restore moved script if it was moved
+        if script_moved and os.path.exists("update_script_temp.py"):
+            print("🔄 Restoring update script...")
+            run_command("move update_script_temp.py update_script.py")
+        return False
+    
+    # Restore moved script if it was moved
+    if script_moved and os.path.exists("update_script_temp.py"):
+        print("🔄 Restoring update script...")
+        run_command("move update_script_temp.py update_script.py")
+    
+    # Restore moved script if it was moved
+    if script_moved and os.path.exists("update_script_temp.py"):
+        print("🔄 Restoring update script...")
+        run_command("move update_script_temp.py update_script.py")
+    
+    # Update dependencies
+    print("📦 Installing/updating dependencies...")
+    if not run_command("pip3 install -r requirements.txt --upgrade"):
+        print("⚠️ Warning: Failed to update some dependencies")
+    
+    # Try alternative pip command
+    run_command("pip3 install -r requirements.txt --break-system-packages --upgrade")
+    
+    print("✅ Update completed successfully!")
+    return True
+
+def restart_bot():
+    """Restart the bot after update."""
+    print("🔄 Restarting Ultroid...")
+    
+    # Check if we have a virtual environment
+    venv_python = None
+    if os.path.exists("venv/bin/python"):
+        venv_python = "venv/bin/python"
+    elif os.path.exists("venv/Scripts/python.exe"):
+        venv_python = "venv/Scripts/python.exe"
+    
+    # Determine how to start the bot
+    if len(sys.argv) > 1 and sys.argv[-1] == "main.py":
+        # Started with main.py
+        if venv_python:
+            os.execv(venv_python, [venv_python, "main.py"])
+        else:
+            os.execv(sys.executable, [sys.executable, "main.py"])
+    else:
+        # Started as module
+        if venv_python:
+            os.execv(venv_python, [venv_python, "-m", "pyUltroid"])
+        else:
+            os.execv(sys.executable, [sys.executable, "-m", "pyUltroid"])
+
+if __name__ == "__main__":
+    print("🚀 Ultroid Update Script")
+    print("=" * 40)
+    
+    # Wait a moment for the bot to fully shutdown
+    time.sleep(2)
+    
+    # Perform update
+    if main():
+        print("=" * 40)
+        restart_bot()
+    else:
+        print("❌ Update failed. Please check the errors above.")
+        sys.exit(1)