feat: support Google Drive folder leeching by running gdown with --folder and matching files recursively

plugins/file_rename.py

@@ -577,19 +577,22 @@ async def _download_url_with_progress(url: str, output_path: str, task: dict):
     
     # ── Google Drive Intercept ──
     if "drive.google.com" in url:
+        is_folder = "/folders/" in url or "/drive/folders/" in url
         for attempt in range(1, DOWNLOAD_MAX_RETRIES + 1):
             try:
                 task["retry_info"] = f"Initializing Google Drive (Attempt {attempt})" if attempt > 1 else None
-                await _update_leech_status(task, "Downloading (Google Drive)", force=True)
+                status_label = "Downloading (GDrive Folder)" if is_folder else "Downloading (GDrive)"
+                await _update_leech_status(task, status_label, force=True)
                 
                 # Use gdown in a temporary directory to auto-extract the real filename
                 tmp_gdrive_dir = output_path + "_gdrive_tmp"
                 os.makedirs(tmp_gdrive_dir, exist_ok=True)
                 
-                gdown_cmd = [
-                    "gdown",
-                    url
-                ]
+                gdown_cmd = ["gdown"]
+                if is_folder:
+                    gdown_cmd.append("--folder")
+                gdown_cmd.append(url)
+                
                 proc = await asyncio.create_subprocess_exec(
                     *gdown_cmd, cwd=tmp_gdrive_dir, stdout=asyncio.subprocess.PIPE, stderr=asyncio.subprocess.PIPE
                 )
@@ -600,17 +603,36 @@ async def _download_url_with_progress(url: str, output_path: str, task: dict):
                     raise asyncio.CancelledError()
                     
                 if proc.returncode == 0:
-                    downloaded_files = os.listdir(tmp_gdrive_dir)
-                    if downloaded_files:
-                        true_name = downloaded_files[0]
-                        # Overwrite the placeholder "view" name with the real Google Drive filename
-                        task["display_name"] = true_name
-                        shutil.move(os.path.join(tmp_gdrive_dir, true_name), output_path)
+                    if is_folder:
+                        # Find all files recursively in tmp_gdrive_dir and move them to parent directory (temp_dir)
+                        parent_dir = os.path.dirname(output_path)
+                        moved_count = 0
+                        for root, _, files_in_dir in os.walk(tmp_gdrive_dir):
+                            for name in files_in_dir:
+                                src_file = os.path.join(root, name)
+                                dst_file = os.path.join(parent_dir, name)
+                                # Avoid collision if the file exists
+                                base, ext = os.path.splitext(name)
+                                counter = 1
+                                while os.path.exists(dst_file):
+                                    dst_file = os.path.join(parent_dir, f"{base}_{counter}{ext}")
+                                    counter += 1
+                                shutil.move(src_file, dst_file)
+                                moved_count += 1
                         shutil.rmtree(tmp_gdrive_dir, ignore_errors=True)
-                        return output_path
+                        if moved_count > 0:
+                            return parent_dir
+                    else:
+                        downloaded_files = os.listdir(tmp_gdrive_dir)
+                        if downloaded_files:
+                            true_name = downloaded_files[0]
+                            # Overwrite the placeholder "view" name with the real Google Drive filename
+                            task["display_name"] = true_name
+                            shutil.move(os.path.join(tmp_gdrive_dir, true_name), output_path)
+                            shutil.rmtree(tmp_gdrive_dir, ignore_errors=True)
+                            return output_path
                         
                 shutil.rmtree(tmp_gdrive_dir, ignore_errors=True)
-                    
                 err_text = stderr.decode('utf-8', errors='ignore')
                 raise RuntimeError(f"gdown failed with code {proc.returncode}: {err_text}")
                 
@@ -992,14 +1014,17 @@ async def _run_leech_task(client, task: dict):
         if source_type == "telegram_file":
             await _download_telegram_file_with_progress(client, task["source_media_message"], temp_archive, task)
         else:
-            await _download_url_with_progress(url, temp_archive, task)
+            download_result = await _download_url_with_progress(url, temp_archive, task)
+            if download_result and os.path.isdir(download_result):
+                temp_archive = download_result
         if task.get("cancelled"):
             raise asyncio.CancelledError()
 
         # Re-read display_name AFTER download - Google Drive download updates task["display_name"]
         # with the real filename. Without this, the old URL-guessed name (e.g. "view") is used.
         new_display = task.get("display_name") or display_name
-        if new_display != display_name:
+        # Bypass rename if temp_archive is a directory
+        if not os.path.isdir(temp_archive) and new_display != display_name:
             # Physical rename so the file's extension is correct on disk
             new_temp_archive = os.path.join(temp_dir, new_display)
             if os.path.exists(temp_archive) and temp_archive != new_temp_archive:
@@ -1008,38 +1033,46 @@ async def _run_leech_task(client, task: dict):
             temp_archive = new_temp_archive
             display_name = new_display
 
-        if _is_archive(temp_archive):
-            task["is_extracting"] = True
-            await _update_leech_status(task, "Extracting")
-            extracted_dir = os.path.join(temp_dir, "extracted")
-            os.makedirs(extracted_dir, exist_ok=True)
-            task["temp_paths"].append(extracted_dir)
-            await _extract_archive(temp_archive, extracted_dir, task)
+        is_archive_file = _is_archive(temp_archive) if os.path.isfile(temp_archive) else False
+        is_directory_download = os.path.isdir(temp_archive)
+
+        if is_archive_file or is_directory_download:
+            task["is_extracting"] = True if is_archive_file else False
+            if is_archive_file:
+                await _update_leech_status(task, "Extracting")
+                extracted_dir = os.path.join(temp_dir, "extracted")
+                os.makedirs(extracted_dir, exist_ok=True)
+                task["temp_paths"].append(extracted_dir)
+                await _extract_archive(temp_archive, extracted_dir, task)
+                scan_dir = extracted_dir
+            else:
+                scan_dir = temp_archive
 
             # Some releases ship a zip-inside-a-zip (or rar-inside-a-zip).
             # Recursively extract any nested archives we find (max 2 levels deep)
             # before scanning for media, so those aren't silently missed.
-            for _pass in range(2):
-                nested = []
-                for root, _, files in os.walk(extracted_dir):
-                    for name in files:
-                        path = os.path.join(root, name)
-                        if _is_archive(path):
-                            nested.append(path)
-                if not nested:
-                    break
-                for nested_path in nested:
-                    try:
-                        nested_out = nested_path + "_extracted"
-                        os.makedirs(nested_out, exist_ok=True)
-                        await _extract_archive(nested_path, nested_out, task)
-                        os.remove(nested_path)
-                    except Exception as e:
-                        logger.warning(f"Could not extract nested archive {nested_path}: {e}")
+            if is_archive_file:
+                for _pass in range(2):
+                    nested = []
+                    for root, _, files in os.walk(scan_dir):
+                        for name in files:
+                            path = os.path.join(root, name)
+                            if _is_archive(path):
+                                nested.append(path)
+                    if not nested:
+                        break
+                    for nested_path in nested:
+                        try:
+                            nested_out = nested_path + "_extracted"
+                            os.makedirs(nested_out, exist_ok=True)
+                            await _extract_archive(nested_path, nested_out, task)
+                            os.remove(nested_path)
+                        except Exception as e:
+                            logger.warning(f"Could not extract nested archive {nested_path}: {e}")
 
             media_files = []
             all_extracted_files = []
-            for root, _, files in os.walk(extracted_dir):
+            for root, _, files in os.walk(scan_dir):
                 for name in files:
                     path = os.path.join(root, name)
                     all_extracted_files.append(path)
@@ -1047,12 +1080,12 @@ async def _run_leech_task(client, task: dict):
                         media_files.append(path)
             if not media_files:
                 logger.error(
-                    f"No media files matched. Archive extracted {len(all_extracted_files)} file(s): "
+                    f"No media files matched. Directory contains {len(all_extracted_files)} file(s): "
                     f"{[os.path.basename(p) for p in all_extracted_files[:30]]}"
                 )
                 raise RuntimeError(
-                    f"No supported media files found in archive "
-                    f"({len(all_extracted_files)} file(s) extracted, none matched known media extensions)"
+                    f"No supported media files found "
+                    f"({len(all_extracted_files)} file(s) found, none matched known media extensions)"
                 )
             auto_merge = await codeflixbots.get_auto_merge(task["user_id"])
             if auto_merge and len(media_files) > 1:
@@ -1067,10 +1100,7 @@ async def _run_leech_task(client, task: dict):
                         task["user_id"],
                         item,
                         file_name,
-                        file_name,  # BUGFIX: use this file's own name, not the archive's constant
-                                    # display_name - previously every episode in a zip was
-                                    # getting season/episode/quality extracted from the ZIP's
-                                    # filename, so all episodes ended up with the same output name.
+                        file_name,
                         task,
                         task["chat_id"],
                         task["status_message"],