1--------------------------------------------------------------------

!pip -q install --upgrade google-api-python-client google-auth-httplib2 google-auth-oauthlib

2---------------------------------------------------------------------

from google.colab import auth auth.authenticate_user()

import google.auth from googleapiclient.discovery import build from googleapiclient.errors import HttpError import time

creds, _ = google.auth.default( scopes=["https://www.googleapis.com/auth/drive"] )

drive = build( "drive", "v3", credentials=creds )

print("✅ Google Drive connected")

3-------------------------------------------------------------

SOURCE_URLS = [ "PAST YOUR LINKS", "PAST YOUR LINKS", "PAST YOUR LINKS" ]

print("✅ 3 source folders loaded")

4------------------------------------------------------------------

DESTINATION_FOLDER_NAME = input( "Destination folder ka naam: " ).strip()

if not DESTINATION_FOLDER_NAME: raise ValueError("Destination folder name empty hai.")

print("Destination:", DESTINATION_FOLDER_NAME)

6-----------------------------------------------------------------------

============================================================

GOOGLE DRIVE SERVER-SIDE 3 FOLDER SYNC

============================================================

IMPORTANT:

Files are copied directly inside Google Drive.

They are NOT downloaded to Colab and re-uploaded.

Features:

- Recursive folders

- Large files

- Google Docs/Sheets/Slides preserved

- Existing files replaced

- Identical files skipped

- Human-readable file sizes

- Verification after copy

- Resume by simply running again after interruption

============================================================

import re import time from googleapiclient.errors import HttpError

------------------------------------------------------------

SETTINGS

------------------------------------------------------------

MAX_RETRIES = 8

FOLDER_MIME = "application/vnd.google-apps.folder"

------------------------------------------------------------

FOLDER ID FROM URL

------------------------------------------------------------

def get_folder_id(url):

match = re.search(
    r"/folders/([a-zA-Z0-9_-]+)",
    url
)

if not match:
    raise ValueError(
        f"Invalid Google Drive folder URL:\n{url}"
    )

return match.group(1)

SOURCE_FOLDER_IDS = [ get_folder_id(url) for url in SOURCE_URLS ]

------------------------------------------------------------

HUMAN READABLE SIZE

------------------------------------------------------------

def format_size(size):

if size is None:
    return "N/A"

size = int(size)

units = [
    "B",
    "KB",
    "MB",
    "GB",
    "TB",
    "PB"
]

value = float(size)

for unit in units:

    if value < 1024 or unit == units[-1]:

        if unit == "B":
            return f"{int(value):,} {unit}"

        return f"{value:,.2f} {unit}"

    value /= 1024

------------------------------------------------------------

GET FILE/FOLDER

------------------------------------------------------------

def get_item(file_id):

return drive.files().get(
    fileId=file_id,
    fields=(
        "id,"
        "name,"
        "mimeType,"
        "size,"
        "md5Checksum,"
        "modifiedTime,"
        "parents,"
        "trashed"
    ),
    supportsAllDrives=True
).execute()

------------------------------------------------------------

LIST ALL CHILDREN

------------------------------------------------------------

def list_children(parent_id):

all_items = []

page_token = None

while True:

    response = drive.files().list(

        q=(
            f"'{parent_id}' in parents "
            f"and trashed = false"
        ),

        spaces="drive",

        fields=(
            "nextPageToken,"
            "files("
            "id,"
            "name,"
            "mimeType,"
            "size,"
            "md5Checksum,"
            "modifiedTime,"
            "parents"
            ")"
        ),

        pageSize=1000,

        pageToken=page_token,

        supportsAllDrives=True,

        includeItemsFromAllDrives=True

    ).execute()

    all_items.extend(
        response.get("files", [])
    )

    page_token = response.get(
        "nextPageToken"
    )

    if not page_token:
        break

return all_items

------------------------------------------------------------

FIND ROOT DESTINATION FOLDER

------------------------------------------------------------

def find_root_folder(name):

safe_name = name.replace("'", "\\'")

response = drive.files().list(

    q=(
        f"name = '{safe_name}' "
        f"and mimeType = '{FOLDER_MIME}' "
        f"and 'root' in parents "
        f"and trashed = false"
    ),

    spaces="drive",

    fields="files(id,name,mimeType)",

    pageSize=100,

    supportsAllDrives=True,

    includeItemsFromAllDrives=True

).execute()

folders = response.get(
    "files",
    []
)

if folders:
    return folders[0]

return None

------------------------------------------------------------

CREATE FOLDER

------------------------------------------------------------

def create_folder(name, parent_id):

metadata = {

    "name": name,

    "mimeType": FOLDER_MIME,

    "parents": [
        parent_id
    ]

}

return drive.files().create(

    body=metadata,

    fields="id,name,mimeType,parents",

    supportsAllDrives=True

).execute()

------------------------------------------------------------

GET OR CREATE FOLDER

------------------------------------------------------------

def get_or_create_folder( name, parent_id, folder_cache ):

cache_key = (
    parent_id,
    name
)

if cache_key in folder_cache:

    return folder_cache[
        cache_key
    ]

children = list_children(
    parent_id
)

for item in children:

    if (
        item["mimeType"] == FOLDER_MIME
        and item["name"] == name
    ):

        folder_cache[
            cache_key
        ] = item

        return item

print(
    f"📁 Creating folder: {name}"
)

new_folder = create_folder(
    name,
    parent_id
)

folder_cache[
    cache_key
] = new_folder

return new_folder

------------------------------------------------------------

FILE MATCHING

------------------------------------------------------------

def find_existing_file( name, parent_id, children=None ):

if children is None:
    children = list_children(
        parent_id
    )

for item in children:

    if (
        item["mimeType"] != FOLDER_MIME
        and item["name"] == name
    ):

        return item

return None

------------------------------------------------------------

CHECK WHETHER FILES ARE IDENTICAL

------------------------------------------------------------

def files_are_identical( source, destination ):

# --------------------------------------------------------
# NORMAL FILES
# --------------------------------------------------------

source_md5 = source.get(
    "md5Checksum"
)

destination_md5 = destination.get(
    "md5Checksum"
)

if source_md5 and destination_md5:

    return (
        source_md5 ==
        destination_md5
    )

# --------------------------------------------------------
# GOOGLE WORKSPACE FILES
#
# Docs / Sheets / Slides do not normally have MD5.
# Compare modification time and name as fallback.
# --------------------------------------------------------

source_size = source.get(
    "size"
)

destination_size = destination.get(
    "size"
)

if (
    source_size is not None
    and destination_size is not None
):

    return (
        int(source_size)
        ==
        int(destination_size)
    )

return False

------------------------------------------------------------

SERVER SIDE COPY

------------------------------------------------------------

def copy_file( source_file, destination_parent_id, existing_file=None ):

source_id = source_file["id"]

source_name = source_file["name"]

# --------------------------------------------------------
# RETRY
# --------------------------------------------------------

for attempt in range(
    1,
    MAX_RETRIES + 1
):

    try:

        print(
            f"\n📄 {source_name}"
        )

        source_size = source_file.get(
            "size"
        )

        print(
            "   Source size:",
            format_size(source_size)
        )

        # ------------------------------------------------
        # COPY TO DESTINATION
        # ------------------------------------------------

        copied = drive.files().copy(

            fileId=source_id,

            body={
                "name": source_name,
                "parents": [
                    destination_parent_id
                ]
            },

            fields=(
                "id,"
                "name,"
                "mimeType,"
                "size,"
                "md5Checksum,"
                "modifiedTime,"
                "parents"
            ),

            supportsAllDrives=True

        ).execute()

        copied_id = copied["id"]

        # ------------------------------------------------
        # VERIFY COPIED FILE
        # ------------------------------------------------

        verified = get_item(
            copied_id
        )

        destination_size = verified.get(
            "size"
        )

        print(
            "   Copied size :",
            format_size(destination_size)
        )

        # ------------------------------------------------
        # VERIFY NORMAL FILE
        # ------------------------------------------------

        source_md5 = source_file.get(
            "md5Checksum"
        )

        copied_md5 = verified.get(
            "md5Checksum"
        )

        if source_md5 and copied_md5:

            if source_md5 != copied_md5:

                # Copy failed verification.
                # Delete bad copy.

                drive.files().update(
                    fileId=copied_id,
                    body={
                        "trashed": True
                    },
                    supportsAllDrives=True
                ).execute()

                raise Exception(
                    "MD5 verification failed"
                )

            print(
                "   MD5         : ✅ MATCH"
            )

        # ------------------------------------------------
        # VERIFY SIZE
        # ------------------------------------------------

        if (
            source_size is not None
            and destination_size is not None
        ):

            if (
                int(source_size)
                !=
                int(destination_size)
            ):

                drive.files().update(
                    fileId=copied_id,
                    body={
                        "trashed": True
                    },
                    supportsAllDrives=True
                ).execute()

                raise Exception(
                    "File size verification failed"
                )

            print(
                "   Size check  : ✅ MATCH"
            )

        # ------------------------------------------------
        # NOW REMOVE OLD VERSION
        # ------------------------------------------------

        if existing_file:

            print(
                "   Old file    : 🗑️ Replacing"
            )

            drive.files().update(

                fileId=existing_file["id"],

                body={
                    "trashed": True
                },

                supportsAllDrives=True

            ).execute()

            print(
                "   Result      : 🔄 REPLACED"
            )

        else:

            print(
                "   Result      : ✅ COPIED"
            )

        return copied

    except Exception as e:

        print(
            f"   ⚠️ Attempt "
            f"{attempt}/{MAX_RETRIES}: {e}"
        )

        if attempt < MAX_RETRIES:

            time.sleep(
                min(
                    2 ** attempt,
                    30
                )
            )

        else:

            raise

------------------------------------------------------------

STATISTICS

------------------------------------------------------------

stats = {

"folders_created": 0,

"files_copied": 0,

"files_replaced": 0,

"files_skipped": 0,

"errors": 0

}

------------------------------------------------------------

RECURSIVE SYNC

------------------------------------------------------------

def sync_folder( source_folder_id, destination_folder_id, current_path="" ):

children = list_children(
    source_folder_id
)

# --------------------------------------------------------
# PROCESS FOLDERS FIRST
# --------------------------------------------------------

for item in children:

    if item["mimeType"] != FOLDER_MIME:
        continue

    folder_name = item["name"]

    destination_folder = (
        get_or_create_folder(
            folder_name,
            destination_folder_id,
            folder_cache
        )
    )

    stats["folders_created"] += 1

    new_path = (
        f"{current_path}/{folder_name}"
        if current_path
        else folder_name
    )

    print(
        f"\n📁 Folder: {new_path}"
    )

    sync_folder(

        item["id"],

        destination_folder["id"],

        new_path

    )

# --------------------------------------------------------
# PROCESS FILES
# --------------------------------------------------------

for item in children:

    if item["mimeType"] == FOLDER_MIME:
        continue

    file_name = item["name"]

    existing = find_existing_file(

        file_name,

        destination_folder_id,

        children=destination_children_cache.get(
            destination_folder_id
        )

    )

    # ----------------------------------------------------
    # CACHE DESTINATION
    # ----------------------------------------------------

    if (
        destination_folder_id
        not in
        destination_children_cache
    ):

        destination_children_cache[
            destination_folder_id
        ] = list_children(
            destination_folder_id
        )

        existing = find_existing_file(

            file_name,

            destination_folder_id,

            destination_children_cache[
                destination_folder_id
            ]

        )

    # ----------------------------------------------------
    # ALREADY EXISTS
    # ----------------------------------------------------

    if existing:

        if files_are_identical(
            item,
            existing
        ):

            print(
                f"\n⏭️ SKIP: {file_name}"
            )

            print(
                "   Size:",
                format_size(
                    item.get("size")
                )
            )

            stats[
                "files_skipped"
            ] += 1

            continue

    # ----------------------------------------------------
    # COPY / REPLACE
    # ----------------------------------------------------

    try:

        result = copy_file(

            item,

            destination_folder_id,

            existing_file=existing

        )

        if existing:

            stats[
                "files_replaced"
            ] += 1

        else:

            stats[
                "files_copied"
            ] += 1

        # Update destination cache
        destination_children_cache[
            destination_folder_id
        ] = list_children(
            destination_folder_id
        )

    except Exception as e:

        stats[
            "errors"
        ] += 1

        print(
            f"\n❌ FAILED: {file_name}"
        )

        print(
            "   Error:",
            e
        )

------------------------------------------------------------

CREATE / FIND DESTINATION

------------------------------------------------------------

folder_cache = {}

destination_children_cache = {}

destination_root = find_root_folder( DESTINATION_FOLDER_NAME )

if destination_root:

print(
    "\n✅ Destination already exists:"
)

print(
    destination_root["name"]
)

else:

print(
    "\n📁 Creating destination:"
)

destination_root = create_folder(

    DESTINATION_FOLDER_NAME,

    "root"

)

print(
    "✅ Destination created"
)

DESTINATION_ROOT_ID = ( destination_root["id"] )

------------------------------------------------------------

RUN ALL THREE SOURCE FOLDERS

------------------------------------------------------------

print("\n") print("=" 75) print("🚀 STARTING 3-FOLDER GOOGLE DRIVE SYNC") print("=" 75)

for index, source_id in enumerate( SOURCE_FOLDER_IDS, start=1 ):

print("\n")
print("=" * 75)
print(
    f"📦 SOURCE {index} / 3"
)
print("=" * 75)

try:

    source_info = get_item(
        source_id
    )

    print(
        "Source folder:",
        source_info["name"]
    )

    sync_folder(

        source_id,

        DESTINATION_ROOT_ID,

        source_info["name"]

    )

except Exception as e:

    stats["errors"] += 1

    print(
        f"❌ SOURCE {index} FAILED:"
    )

    print(e)

------------------------------------------------------------

FINAL REPORT

------------------------------------------------------------

print("\n") print("=" 75) print("🎉 SYNC FINISHED") print("=" 75)

print( "📁 Folders processed :", stats["folders_created"] )

print( "📤 New files copied :", stats["files_copied"] )

print( "🔄 Files replaced :", stats["files_replaced"] )

print( "⏭️ Files skipped :", stats["files_skipped"] )

print( "❌ Errors :", stats["errors"] )

print("=" * 75)