script.py

import os
import sys
import json
from concurrent.futures import ThreadPoolExecutor
from PySide6.QtWidgets import (QApplication, QMainWindow, QFileDialog, QPushButton, 
                             QVBoxLayout, QWidget, QProgressBar, QLabel)
from PySide6.QtCore import Slot, Signal, QObject, QThread
from PySide6.QtGui import QPalette, QColor
from googleapiclient.discovery import build
from googleapiclient.http import MediaFileUpload
from google.oauth2.credentials import Credentials
from google_auth_oauthlib.flow import InstalledAppFlow
from google.auth.transport.requests import Request

SCOPES = ['https://www.googleapis.com/auth/drive.file']

class UploadSignals(QObject):
    progress = Signal(int)
    status = Signal(str)
    finished = Signal()

class UploadWorker(QThread):
    progress = Signal(int)
    status = Signal(str)
    finished = Signal(dict)

    def __init__(self, folder_path, uploader):
        super().__init__()
        self.folder_path = folder_path
        self.uploader = uploader
        self.uploaded_count = 0
        self.links = {}

    def run(self):
        service = build('drive', 'v3', credentials=self.uploader.creds)
        total_files = sum([len(files) for _, _, files in os.walk(self.folder_path)])
        self.progress.emit(0)

        def upload_with_progress(args):
            file_path, relative_path, parent_id = args
            try:
                link = self.uploader.upload_file(file_path, parent_id)
                self.uploaded_count += 1
                self.progress.emit(self.uploaded_count)
                self.status.emit(f"Uploading: {relative_path}")
                return relative_path, link
            except Exception as e:
                return relative_path, str(e)

        with ThreadPoolExecutor(max_workers=4) as executor:
            upload_tasks = []
            
            for root, dirs, files in os.walk(self.folder_path):
                relative_root = os.path.relpath(root, self.folder_path)
                
                current_parent_id = None
                if relative_root != '.':
                    folder_parts = relative_root.split(os.sep)
                    for i, folder in enumerate(folder_parts):
                        parent_path = os.sep.join(folder_parts[:i]) if i > 0 else None
                        parent_id = self.uploader.folder_cache.get(parent_path)
                        current_parent_id = self.uploader.get_or_create_folder(service, folder, parent_id)
                
                for file in files:
                    file_path = os.path.join(root, file)
                    relative_path = os.path.relpath(file_path, self.folder_path)
                    upload_tasks.append(executor.submit(
                        upload_with_progress, 
                        (file_path, relative_path, current_parent_id)
                    ))

            for task in upload_tasks:
                relative_path, link = task.result()
                self.links[relative_path] = link

        with open('uploaded_links.json', 'w') as f:
            json.dump(self.links, f, indent=4)

        self.finished.emit(self.links)

class GoogleDriveUploader:
    def __init__(self):
        self.creds = None
        self.authenticate()
        self.folder_cache = {}

    def authenticate(self):
        if os.path.exists('token.json'):
            with open('token.json', 'r') as token:
                self.creds = Credentials.from_authorized_user_info(json.load(token), SCOPES)

        if not self.creds or not self.creds.valid:
            if self.creds and self.creds.expired and self.creds.refresh_token:
                self.creds.refresh(Request())
            else:
                flow = InstalledAppFlow.from_client_secrets_file('credentials.json', SCOPES)
                self.creds = flow.run_local_server(port=0)

            with open('token.json', 'w') as token:
                token.write(self.creds.to_json())

    def get_or_create_folder(self, service, folder_name, parent_id=None):
        folder_path = f"{parent_id}/{folder_name}" if parent_id else folder_name
        
        if folder_path in self.folder_cache:
            return self.folder_cache[folder_path]

        query = f"name='{folder_name}' and mimeType='application/vnd.google-apps.folder'"
        if parent_id:
            query += f" and '{parent_id}' in parents"

        results = service.files().list(q=query, spaces='drive', fields='files(id)').execute()
        files = results.get('files', [])

        if files:
            folder_id = files[0]['id']
        else:
            file_metadata = {
                'name': folder_name,
                'mimeType': 'application/vnd.google-apps.folder'
            }
            if parent_id:
                file_metadata['parents'] = [parent_id]
            
            folder = service.files().create(body=file_metadata, fields='id').execute()
            folder_id = folder.get('id')

        self.folder_cache[folder_path] = folder_id
        return folder_id

    def upload_file(self, file_path, parent_id=None):
        service = build('drive', 'v3', credentials=self.creds)
        file_metadata = {
            'name': os.path.basename(file_path)
        }
        if parent_id:
            file_metadata['parents'] = [parent_id]

        media = MediaFileUpload(file_path, resumable=True)
        uploaded_file = service.files().create(body=file_metadata, media_body=media, fields='id').execute()
        file_id = uploaded_file.get('id')
        
        service.permissions().create(fileId=file_id, body={'type': 'anyone', 'role': 'reader'}).execute()
        return f'https://drive.google.com/file/d/{file_id}/view?usp=sharing'

class MainWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle("Google Drive Folder Uploader")
        self.setMinimumWidth(500)
        self.uploader = GoogleDriveUploader()
        self.signals = UploadSignals()
        self.init_ui()

    def init_ui(self):
        layout = QVBoxLayout()

        self.upload_button = QPushButton("Select Folder to Upload")
        self.upload_button.clicked.connect(self.select_folder)
        layout.addWidget(self.upload_button)

        self.status_label = QLabel("Ready")
        layout.addWidget(self.status_label)

        self.progress_bar = QProgressBar()
        layout.addWidget(self.progress_bar)

        self.signals.progress.connect(self.update_progress)
        self.signals.status.connect(self.update_status)
        self.signals.finished.connect(self.upload_finished)

        container = QWidget()
        container.setLayout(layout)
        self.setCentralWidget(container)

        self.apply_dark_theme()

    def apply_dark_theme(self):
        palette = QPalette()
        palette.setColor(QPalette.Window, QColor(53, 53, 53))
        palette.setColor(QPalette.WindowText, QColor(255, 255, 255))
        palette.setColor(QPalette.Base, QColor(42, 42, 42))
        palette.setColor(QPalette.AlternateBase, QColor(66, 66, 66))
        palette.setColor(QPalette.ToolTipBase, QColor(255, 255, 255))
        palette.setColor(QPalette.ToolTipText, QColor(255, 255, 255))
        palette.setColor(QPalette.Text, QColor(255, 255, 255))
        palette.setColor(QPalette.Button, QColor(53, 53, 53))
        palette.setColor(QPalette.ButtonText, QColor(255, 255, 255))
        palette.setColor(QPalette.BrightText, QColor(255, 0, 0))
        palette.setColor(QPalette.Link, QColor(42, 130, 218))
        palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
        palette.setColor(QPalette.HighlightedText, QColor(0, 0, 0))
        self.setPalette(palette)

    @Slot(int)
    def update_progress(self, value):
        self.progress_bar.setValue(value)

    @Slot(str)
    def update_status(self, message):
        self.status_label.setText(message)

    @Slot(dict)
    def upload_finished(self, links):
        self.upload_button.setEnabled(True)
        self.status_label.setText("Upload completed!")
        with open('uploaded_links.json', 'w') as f:
            json.dump(links, f, indent=4)

    def select_folder(self):
        folder_path = QFileDialog.getExistingDirectory(self, "Select Folder")
        if folder_path:
            self.upload_button.setEnabled(False)
            self.status_label.setText("Preparing upload...")
            self.start_upload(folder_path)

    def start_upload(self, folder_path):
        self.worker = UploadWorker(folder_path, self.uploader)
        self.worker.progress.connect(self.update_progress)
        self.worker.status.connect(self.update_status)
        self.worker.finished.connect(self.upload_finished)
        self.worker.start()

if __name__ == "__main__":
    app = QApplication(sys.argv)

    if not os.path.exists('credentials.json'):
        print("Error: 'credentials.json' file not found. Please provide it for Google Drive API authentication.")
        sys.exit(1)

    window = MainWindow()
    window.show()

    sys.exit(app.exec())