Aprenda a copiar pastas públicas do Google Drive para a sua conta usando Google Colab

Copiar arquivos individuais no Google Drive é bastante simples: botão direito, "Fazer uma cópia". Mas e quando você encontra aquela pasta compartilhada incrível com centenas de arquivos e subpastas? O Google Drive nativamente não oferece um botão para "Duplicar Pasta" inteira para o seu armazenamento.

Muitos usuários recorrem ao recurso "Adicionar atalho ao Drive", mas isso não cria uma cópia real. Se o dono original apagar os arquivos, você perde o acesso. Para garantir que os dados sejam seus, você precisa fazer uma cópia física dos arquivos.

Neste tutorial, vamos ensinar a solução definitiva usando o Google Colab. Apresentaremos dois métodos: um via Script Python Avançado (que permite pausar e continuar) e outro via Comandos Linux (para cópias rápidas).

O que é o Google Colab?

O Google Colaboratory (ou Colab) é uma plataforma de computação em nuvem gratuita do Google. Ele permite escrever e executar códigos Python direto no navegador, oferecendo acesso a máquinas potentes. Para nós, a grande vantagem é que ele se integra nativamente ao Google Drive, permitindo manipular arquivos na nuvem sem gastar a internet do seu computador.

Passo 0: Preparando o Ambiente

Antes de copiar, precisamos conectar o Colab ao seu Google Drive. Abra um novo notebook no Colab e execute o seguinte código:

from google.colab import drive
# Isso pedirá permissão para acessar seus arquivos
drive.mount('/content/drive')

Dica: Para copiar uma pasta pública, primeiro adicione um atalho dela no seu "Meu Drive" para facilitar a localização do caminho (path).

Método 1: Script Python Profissional (Recomendado para pastas grandes)

O script abaixo foi desenvolvido para ser robusto. Diferente de scripts simples, este possui as seguintes vantagens:

• Barra de Progresso: Mostra visualmente quanto falta.
• Sistema de Retomada: Se a conexão cair ou o tempo do Colab estourar, basta rodar de novo. Ele verifica um arquivo de registro (log) e continua exatamente de onde parou, sem duplicar arquivos.
• Verificação de Integridade: Checa o tamanho dos arquivos para garantir que não houve corrupção.

Copie e cole o código abaixo em uma célula do Colab. Lembre-se de alterar as variáveis origem e destino no final do código.

import os
import shutil
import json
import time
from tqdm import tqdm

class DriveSmartCopier:
    def __init__(self, src_root, dst_root, log_filename='migration_log.json', save_interval=50):
        self.src_root = src_root
        self.dst_root = dst_root
        self.log_path = os.path.join(dst_root, log_filename)
        self.save_interval = save_interval
        self.files_processed_count = 0
        
        # Cria a pasta de destino se não existir
        if not os.path.exists(self.dst_root):
            os.makedirs(self.dst_root)
            
        self.history = self._load_history()

    def _load_history(self):
        if os.path.exists(self.log_path):
            try:
                with open(self.log_path, 'r') as f:
                    print(f"🔄 Histórico encontrado. Carregando progresso...")
                    return json.load(f)
            except json.JSONDecodeError:
                return {}
        return {}

    def _save_history(self):
        with open(self.log_path, 'w') as f:
            json.dump(self.history, f, indent=4)

    def _get_relative_path(self, full_path, root):
        return os.path.relpath(full_path, root)

    def scan_files(self):
        print("🔍 Mapeando arquivos... (Aguarde)")
        tasks = []
        for root, dirs, files in os.walk(self.src_root):
            rel_dir = self._get_relative_path(root, self.src_root)
            dest_dir = os.path.join(self.dst_root, rel_dir)
            if not os.path.exists(dest_dir):
                os.makedirs(dest_dir)
            for file in files:
                tasks.append(os.path.join(root, file))
        return tasks

    def run(self):
        all_files = self.scan_files()
        pbar = tqdm(total=len(all_files), unit=' arq')
        
        for src_path in all_files:
            rel_path = self._get_relative_path(src_path, self.src_root)
            dst_path = os.path.join(self.dst_root, rel_path)
            file_id = rel_path
            
            # Lógica de retomada inteligente
            if file_id in self.history and self.history[file_id]['status'] == 'OK':
                if os.path.exists(dst_path) and os.path.getsize(src_path) == os.path.getsize(dst_path):
                    pbar.update(1)
                    continue

            try:
                if os.path.exists(dst_path):
                    os.remove(dst_path)
                shutil.copy2(src_path, dst_path)
                
                self.history[file_id] = {'status': 'OK', 'timestamp': time.time()}
            except Exception as e:
                print(f"Erro em {rel_path}: {e}")
            
            self.files_processed_count += 1
            pbar.update(1)
            
            if self.files_processed_count % self.save_interval == 0:
                self._save_history()

        self._save_history()
        pbar.close()
        print("\n✅ Cópia finalizada com sucesso!")

# --- CONFIGURE AQUI ---
# Caminho da pasta de origem (pode ser o atalho da pasta compartilhada)
origem = r'/content/drive/MyDrive/Pasta_Compartilhada_Origem' 

# Caminho onde os arquivos serão salvos
destino = r'/content/drive/MyDrive/Minha_Copia_Final'  

# Executa
app = DriveSmartCopier(origem, destino)
app.run()

Método 2: Comandos Linux (Rápido e Simples)

O Google Colab roda em cima de Linux. Se a pasta for pequena e você quiser apenas uma cópia rápida sem se preocupar com logs ou retomada, você pode usar os "Magic Commands" do Jupyter.

1. Navegando até a pasta:
Primeiro, usamos o comando %cd para entrar no diretório onde está o atalho ou a pasta de origem.

%cd '/content/drive/MyDrive/'
%ls -l # Lista os arquivos para você conferir o nome da pasta

2. Executando a cópia:
Usamos o comando cp (copy) com as flags -av (archive e verbose) para copiar recursivamente e mostrar o que está acontecendo na tela.

# Sintaxe: %cp -av 'Pasta de Origem' 'Pasta de Destino'
%cp -av 'Pasta Compartilhada' 'Backup_da_Pasta'

Nota: Se o nome das pastas tiver espaços, é obrigatório usar aspas simples ou duplas ao redor do nome.

Conclusão

Para backups grandes e importantes, recomendamos fortemente o Método 1 (Python). Ele garante que, mesmo que o navegador feche ou a internet caia, você não precisará começar do zero, economizando horas de processamento. Já o método Linux é perfeito para tarefas rápidas do dia a dia.