setup 2n for infloxa

src/asset_selector.py

@@ -31,7 +31,7 @@ class AssetSelector:
         """Load video library from specific CSV file"""
         try:
             if os.getenv("INFLOXA", "false").lower() == "true":
-                csv_filename = "video_analyser/infloxa_video_analysis.csv"
+                csv_filename = "data/infloxa_video_library100.csv"
             elif os.getenv("USE_VEO", "false").lower() == "true":
                 csv_filename = "data/somira_video_library_veo.csv"
             else:
@@ -95,9 +95,23 @@ class AssetSelector:
             audios.remove("https://storage.googleapis.com/somira/ssstik.io_1762269951926.mp3")
 
         if os.getenv("INFLOXA", "false").lower() == "true":
-            audios = ["testData/infloxa/screenrecording.mp3"]
+            audios = ["testData/infloxa/audiopulse.mp3"]
         return audios
 
+    def audio_beats_map(self, audio_path: str) -> Optional[List[float]]:
+        """Load or compute audio beats map from local file"""
+        try:
+            audio_map = {
+                "testData/infloxa/audiopulse.mp3": [1.01, 1.17, 2.24, 4.06, 5.14, 6.21, 8.03, 9.11],
+            }
+            if audio_path in audio_map:
+                return audio_map[audio_path]
+
+        except Exception as e:
+            logger.error(f"Failed to compute audio beats map for {audio_path}: {e}")
+
+        return None
+
     async def select_videos(self, tts_script, timed_transcript, max_duration: int = 12) -> Tuple[List[Dict], str]:
         """Select videos using AI analysis of TTS script"""
         try:

src/automation.py

@@ -199,13 +199,23 @@ class ContentAutomation:
 
             music_duration = 10
             if os.getenv("INFLOXA", "false").lower() == "true":
-                music_duration = 23
+                music_duration = 15
 
             beat_times = None
             try_next = False
 
             while beat_times is None:
                 await self._download_bg_music(try_next)
+                with AudioFileClip(self.data_holder.visual_assets["background_music_local"]) as audio_clip:
+                    music_duration = audio_clip.duration - 0.5
+
+
+                if self.asset_selector.audio_beats_map().get(self.data_holder.visual_assets.get("background_music_url", ""), None):
+                    beat_times = self.asset_selector.audio_beats_map()[self.data_holder.visual_assets.get("background_music_url", "")]
+                    method_used = "cached"
+                    logger.info("Using cached beat times.")
+                    break
+
                 # Get ALL beats (no filtering yet - we'll handle min duration in render_random_video)
                 beat_times, method_used = utils.get_best_beat_method(
                     self.data_holder.visual_assets["background_music_local"],
@@ -238,7 +248,7 @@ class ContentAutomation:
             if os.getenv("HARD_CUT_RANDOM_VIDEOS", "false").lower() == "true":
                 # IMPORTANT: Pass filtered_beat_times, not beat_intervals!
                 video_no_audio_path = await self.video_renderer.render_interval_video(
-                    0.3,
+                    0.5,
                     music_duration
                 )
             else:
@@ -316,10 +326,10 @@ class ContentAutomation:
         await self._download_to_local(
             self.data_holder.visual_assets["background_music_url"], "background_music.mp3", self.data_holder.visual_assets, "background_music_local"
         )
-        if os.getenv("INFLOXA", "false").lower() == "true":
-            output_path = "/tmp/repeated_bg_music.mp3"
-            output_path = utils.repeat_audio_ffmpeg(self.data_holder.visual_assets["background_music_local"], output_path, 5)
-            self.data_holder.visual_assets["background_music_local"] = output_path
+        # if os.getenv("INFLOXA", "false").lower() == "true":
+        #     output_path = "/tmp/repeated_bg_music.mp3"
+        #     output_path = utils.repeat_audio_ffmpeg(self.data_holder.visual_assets["background_music_local"], output_path, 5)
+        #     self.data_holder.visual_assets["background_music_local"] = output_path
 
     async def create_audio(self):
         try_again = False
@@ -372,6 +382,8 @@ class ContentAutomation:
             from video_downloader import VideoDownloader
             download_path="testData/infloxa"
 
+            allowed_videos = []
+
             self.data_holder.visual_assets["all_videos"] = [
                 {
                     "url": row.get("video_filename", "").strip(),
@@ -381,7 +393,7 @@ class ContentAutomation:
                     )
                 }
                 for _, row in self.asset_selector.video_library.iterrows()
-                if row.get("video_filename", "").strip() and row.get("final_selection_score", 0) > 80
+                if row.get("video_filename", "").strip() in allowed_videos
             ]
         else:
             self.data_holder.visual_assets["all_videos"] = [

src/video_downloader.py

@@ -5,9 +5,13 @@ Download videos by filename from Google Drive
 
 import os
 import csv
+from pathlib import Path
 import sys
+import re
 from typing import Optional, List, Dict
 import shutil
+from concurrent.futures import ThreadPoolExecutor, as_completed
+import threading
 
 # Try to import logger from utils, fallback to print
 try:
@@ -44,6 +48,7 @@ class VideoDownloader:
         self.config_path = config_path
         self.video_library = self._load_video_library()
         self.drive_downloader = None
+        self.lock = threading.Lock()  # Thread-safe lock for drive operations
     
     def _load_video_library(self) -> List[Dict]:
         """Load video library from CSV file"""
@@ -84,20 +89,338 @@ class VideoDownloader:
                 raise FileNotFoundError(f"Config file not found: {self.config_path}")
             
             with open(self.config_path, 'r') as f:
-                config = yaml.safe_load(f)
+                self.config = yaml.safe_load(f)
             
             # Override the local directory with our download path
-            config['output']['local_video_dir'] = download_path
+            self.config['output']['local_video_dir'] = download_path
             
             # Initialize and authenticate
             logger.info("Initializing Google Drive connection...")
-            self.drive_downloader = DriveDownloader(config)
+            self.drive_downloader = DriveDownloader(self.config)
             self.drive_downloader.authenticate()
             logger.info("✓ Google Drive authenticated")
             
         except Exception as e:
             logger.error(f"Failed to initialize DriveDownloader: {e}")
             raise
+    
+    def _get_thread_service(self):
+        """Get a thread-local Google Drive service instance"""
+        import threading
+        thread_id = threading.get_ident()
+        
+        # Check if this thread already has a service
+        if not hasattr(self, '_thread_services'):
+            self._thread_services = {}
+        
+        if thread_id not in self._thread_services:
+            # Create a new service for this thread
+            from modules import DriveDownloader
+            import yaml
+            
+            with open(self.config_path, 'r') as f:
+                config = yaml.safe_load(f)
+            
+            downloader = DriveDownloader(config)
+            downloader.authenticate()
+            self._thread_services[thread_id] = downloader.service
+            logger.info(f"Created new Drive service for thread {thread_id}")
+        
+        return self._thread_services[thread_id]
+
+    def _extract_folder_id_from_link(self, drive_link: str) -> Optional[str]:
+        """
+        Extract folder ID from Google Drive link
+        
+        Args:
+            drive_link: Google Drive folder URL
+            
+        Returns:
+            Folder ID or None if not found
+        """
+        patterns = [
+            r'folders/([a-zA-Z0-9_-]+)',
+            r'id=([a-zA-Z0-9_-]+)',
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, drive_link)
+            if match:
+                return match.group(1)
+        
+        logger.error(f"Could not extract folder ID from link: {drive_link}")
+        return None
+
+    def _list_folder_contents_recursive(self, folder_id: str, parent_path: str = "") -> List[Dict]:
+        """
+        Recursively list all files in a folder and its subfolders
+        
+        Args:
+            folder_id: Google Drive folder ID
+            parent_path: Path of parent folder for tracking structure
+            
+        Returns:
+            List of dictionaries with file info including relative path
+        """
+        try:
+            files_and_folders = []
+            
+            # Query for all items in this folder
+            query = f"'{folder_id}' in parents and trashed=false"
+            results = self.drive_downloader.service.files().list(
+                q=query,
+                fields="files(id, name, mimeType, webViewLink)",
+                pageSize=1000
+            ).execute()
+            
+            items = results.get('files', [])
+            
+            for item in items:
+                item_name = item['name']
+                item_id = item['id']
+                mime_type = item['mimeType']
+                
+                # Build current path
+                current_path = os.path.join(parent_path, item_name) if parent_path else item_name
+                
+                if mime_type == 'application/vnd.google-apps.folder':
+                    # It's a folder - recurse into it
+                    logger.info(f"Scanning folder: {current_path}")
+                    subfolder_contents = self._list_folder_contents_recursive(item_id, current_path)
+                    files_and_folders.extend(subfolder_contents)
+                else:
+                    # It's a file
+                    files_and_folders.append({
+                        'id': item_id,
+                        'name': item_name,
+                        'path': current_path,
+                        'mimeType': mime_type,
+                        'webViewLink': item.get('webViewLink', '')
+                    })
+            
+            return files_and_folders
+            
+        except Exception as e:
+            logger.error(f"Error listing folder contents: {e}")
+            return []
+
+    def _download_single_file(
+        self,
+        file_info: Dict,
+        download_root: str,
+        idx: int,
+        total: int
+    ) -> Dict[str, any]:
+        """
+        Download a single file from Google Drive (for parallel execution)
+        
+        Args:
+            file_info: Dictionary with file information
+            download_root: Root directory for downloads
+            idx: Current file index
+            total: Total number of files
+            
+        Returns:
+            Dictionary with download result
+        """
+        result = {
+            'file': file_info['name'],
+            'status': 'unknown',
+            'path': None,
+            'error': None
+        }
+        
+        try:
+            # Build local path preserving folder structure
+            relative_path = file_info['path']
+            local_path = os.path.join(download_root, relative_path)
+            local_dir = os.path.dirname(local_path)
+            
+            # Check if file already exists
+            if os.path.exists(local_path):
+                logger.info(f"[{idx}/{total}] Skipped (exists): {relative_path}")
+                result['status'] = 'skipped'
+                result['path'] = local_path
+                return result
+            
+            # Create directory structure BEFORE downloading
+            os.makedirs(local_dir, exist_ok=True)
+            logger.info(f"[{idx}/{total}] Downloading: {relative_path}")
+            
+            # Get thread-local service instance
+            service = self._get_thread_service()
+            
+            # Download file DIRECTLY to the final destination
+            request = service.files().get_media(fileId=file_info['id'])
+            
+            with open(local_path, 'wb') as f:
+                from googleapiclient.http import MediaIoBaseDownload
+                downloader = MediaIoBaseDownload(f, request)
+                done = False
+                last_progress = 0
+                while not done:
+                    status, done = downloader.next_chunk()
+                    if status:
+                        progress = int(status.progress() * 100)
+                        # Log every 25% to avoid spam
+                        if progress >= last_progress + 25:
+                            logger.info(f"  [{file_info['name']}] Progress: {progress}%")
+                            last_progress = progress
+            
+            logger.info(f"✓ Successfully downloaded: {local_path}")
+            result['status'] = 'downloaded'
+            result['path'] = local_path
+            
+        except Exception as e:
+            logger.error(f"Failed to download {file_info['name']}: {e}")
+            result['status'] = 'failed'
+            result['error'] = str(e)
+            
+            # Clean up partial download if it exists
+            if 'local_path' in locals() and os.path.exists(local_path):
+                try:
+                    os.remove(local_path)
+                except:
+                    pass
+        
+        return result
+
+    def download_from_drive_link(
+        self, 
+        drive_link: str, 
+        download_root: str,
+        file_extensions: Optional[List[str]] = None,
+        max_workers: int = 10  # Number of parallel downloads
+    ) -> Dict[str, any]:
+        """
+        Download all files from a Google Drive folder link, preserving folder structure
+        (with parallel downloads)
+        
+        Args:
+            drive_link: Google Drive folder URL
+                       e.g., https://drive.google.com/drive/folders/1WSrVAyqvPJzpRnoUxkNx0LqK9VlDs432
+            download_root: Root directory where files should be downloaded
+            file_extensions: Optional list of file extensions to filter (e.g., ['.mp4', '.avi'])
+                           If None, downloads all files
+            max_workers: Number of parallel downloads (default: 10)
+            
+        Returns:
+            Dictionary with download statistics:
+            {
+                'total_files': int,
+                'downloaded': int,
+                'skipped': int,
+                'failed': int,
+                'files': List[str]  # paths of downloaded files
+            }
+            
+        Example:
+            >>> downloader = VideoDownloader()
+            >>> result = downloader.download_from_drive_link(
+            ...     drive_link="https://drive.google.com/drive/folders/1WSrVAyqvPJzpRnoUxkNx0LqK9VlDs432",
+            ...     download_root="downloads/my_videos",
+            ...     file_extensions=['.mp4', '.mov', '.avi'],
+            ...     max_workers=10
+            ... )
+            >>> print(f"Downloaded {result['downloaded']} files")
+        """
+        try:
+            # Initialize Drive downloader (pass None to avoid auto path setup)
+            self._init_drive_downloader(None)
+            
+            # Extract folder ID from link
+            folder_id = self._extract_folder_id_from_link(drive_link)
+            if not folder_id:
+                return {
+                    'total_files': 0,
+                    'downloaded': 0,
+                    'skipped': 0,
+                    'failed': 0,
+                    'files': []
+                }
+            
+            logger.info(f"Scanning Google Drive folder: {folder_id}")
+            
+            # Get all files recursively
+            all_files = self._list_folder_contents_recursive(folder_id)
+            
+            # Filter by file extensions if provided
+            if file_extensions:
+                file_extensions = [ext.lower() if ext.startswith('.') else f'.{ext.lower()}' 
+                                 for ext in file_extensions]
+                all_files = [f for f in all_files 
+                           if any(f['name'].lower().endswith(ext) for ext in file_extensions)]
+            
+            logger.info(f"Found {len(all_files)} files to download")
+            
+            # Statistics
+            stats = {
+                'total_files': len(all_files),
+                'downloaded': 0,
+                'skipped': 0,
+                'failed': 0,
+                'files': []
+            }
+            
+            # Download files in parallel using ThreadPoolExecutor
+            logger.info(f"Starting parallel downloads with {max_workers} workers...")
+            
+            with ThreadPoolExecutor(max_workers=max_workers) as executor:
+                # Submit all download tasks
+                future_to_file = {
+                    executor.submit(
+                        self._download_single_file,
+                        file_info,
+                        download_root,
+                        idx,
+                        len(all_files)
+                    ): file_info
+                    for idx, file_info in enumerate(all_files, 1)
+                }
+                
+                # Collect results as they complete
+                for future in as_completed(future_to_file):
+                    file_info = future_to_file[future]
+                    try:
+                        result = future.result()
+                        
+                        if result['status'] == 'downloaded':
+                            stats['downloaded'] += 1
+                            if result['path']:
+                                stats['files'].append(result['path'])
+                        elif result['status'] == 'skipped':
+                            stats['skipped'] += 1
+                            if result['path']:
+                                stats['files'].append(result['path'])
+                        elif result['status'] == 'failed':
+                            stats['failed'] += 1
+                            
+                    except Exception as e:
+                        logger.error(f"Error processing {file_info['name']}: {e}")
+                        stats['failed'] += 1
+            
+            # Summary
+            logger.info("=" * 60)
+            logger.info("Download Summary:")
+            logger.info(f"  Total files: {stats['total_files']}")
+            logger.info(f"  Downloaded: {stats['downloaded']}")
+            logger.info(f"  Skipped (already exist): {stats['skipped']}")
+            logger.info(f"  Failed: {stats['failed']}")
+            logger.info("=" * 60)
+            
+            return stats
+            
+        except Exception as e:
+            logger.error(f"Error downloading from drive link: {e}")
+            import traceback
+            traceback.print_exc()
+            return {
+                'total_files': 0,
+                'downloaded': 0,
+                'skipped': 0,
+                'failed': 0,
+                'files': []
+            }
 
     def get_folder_name(
         self, 
@@ -124,6 +447,22 @@ class VideoDownloader:
                 return matching_video["path"].split("/")[0]
         except: return None
 
+
+
+    def get_video_link(self, video_filename: str) -> Optional[str]:
+        """Fetches the Google Drive webViewLink for the file"""
+        try:
+            self._init_drive_downloader(None)
+            all_videos = self.drive_downloader.list_all_videos()
+            for video_item in all_videos:
+                if video_item['name'] == video_filename:
+                    # Return the webLink if available, otherwise construct one from ID
+                    return video_item.get('webViewLink') or f"https://drive.google.com/file/d/{video_item.get('id')}/view"
+            return None
+        except Exception as e:
+            logger.error(f"Error fetching link for {video_filename}: {e}")
+            return None
+
     def download_video(
         self, 
         video_filename: str, 
@@ -237,6 +576,7 @@ class VideoDownloader:
         
         return results
 
+
 def add_folder_name_column(input_csv, output_csv, downloader):
     processed = set()
 
@@ -273,18 +613,112 @@ def add_folder_name_column(input_csv, output_csv, downloader):
             writer.writerow([folder_name] + list(row.values()))
             outfile.flush()
 
-try:
-    from dotenv import load_dotenv
-    load_dotenv()
-
-    csv_path = "video_analyser/infloxa_video_analysis.csv"
-    video_filename = "Copy of Sunset View Balcony.MOV"
-    downloader = VideoDownloader(csv_path)
-    add_folder_name_column(
-        input_csv=csv_path,
-        output_csv="video_analyser/infloxa_video_analysis_with_folders.csv",
-        downloader=downloader
-    )
-
-except KeyboardInterrupt:
-    print("\nStopped by Ctrl+C")
+
+def add_link_column(input_csv, output_csv, downloader):
+    """Reads input_csv and writes to output_csv with an added 'video_link' column"""
+    processed = set()
+
+    # 1. Load already processed filenames to allow resuming
+    if os.path.exists(output_csv):
+        with open(output_csv, newline="", encoding="utf-8") as f:
+            reader = csv.DictReader(f)
+            if reader.fieldnames and "video_filename" in reader.fieldnames:
+                for row in reader:
+                    processed.add(row["video_filename"].split("/")[-1])
+
+    # 2. Process the files
+    with open(input_csv, newline="", encoding="utf-8") as infile:
+        reader = csv.DictReader(infile)
+        fieldnames = reader.fieldnames
+        
+        # Determine if we need to write the header
+        file_exists = os.path.exists(output_csv) and os.path.getsize(output_csv) > 0
+        
+        with open(output_csv, "a", newline="", encoding="utf-8") as outfile:
+            # We want 'video_link' to be the first column
+            writer = csv.DictWriter(outfile, fieldnames=["video_link"] + fieldnames)
+            
+            if not file_exists:
+                writer.writeheader()
+
+            for row in reader:
+                video_filename = row["video_filename"].split("/")[-1]
+
+                if video_filename in processed:
+                    continue
+
+                logger.info(f"Fetching link for: {video_filename}")
+                video_link = downloader.get_video_link(video_filename)
+
+                if not video_link:
+                    logger.warning(f"Could not find link for {video_filename}")
+                    continue
+
+                # Prepare new row
+                new_row = {"video_link": video_link}
+                new_row.update(row)
+                
+                writer.writerow(new_row)
+                outfile.flush() # Ensure it saves frequently
+                processed.add(video_filename)
+
+
+# Example usage
+if __name__ == "__main__":
+    try:
+        from dotenv import load_dotenv
+        load_dotenv()
+
+        downloader = VideoDownloader()
+        downloader._init_drive_downloader(download_path="testData/infloxa")
+        add_link_column("testData/infloxa_copy/videos.csv", "testData/infloxa_copy/videos_with_links.csv", downloader)
+        
+        # Download from Drive folder link
+        # result = downloader.download_from_drive_link(
+        #     drive_link="https://drive.google.com/drive/folders/1WSrVAyqvPJzpRnoUxkNx0LqK9VlDs432",
+        #     download_root="testData/infloxa",
+        #     file_extensions=['.mp4', '.mov', '.avi', '.mkv']  # Only video files
+        # )
+        
+        # print(f"\nDownload completed!")
+        # print(f"Total: {result['total_files']}, Downloaded: {result['downloaded']}, "
+            #   f"Skipped: {result['skipped']}, Failed: {result['failed']}")
+
+        # paths = [
+        #     "testData/infloxa_copy/Infloxa_ Lifestyle_125videos",
+        #     "testData/infloxa_copy/Infloxa_LuxuryCars_125videos",
+        #     "testData/infloxa_copy/Infloxa_LuxuryItems_125videos",
+        #     "testData/infloxa_copy/Infloxa_LuxuryRealEstate_125videos",
+        #     "testData/infloxa_copy/Infloxa_Models_125videos",
+        #     "testData/infloxa_copy/Infloxa_PrivateJets_125videos",
+        #     "testData/infloxa_copy/Infloxa_Wealth&Exclusivity_125videos",
+        #     "testData/infloxa_copy/Infloxa_Yachts_125videos",
+        # ]
+
+        # output_csv = "testData/infloxa_copy/videos_with_links.csv"
+
+        # VIDEO_EXTENSIONS = {".mp4", ".mov", ".mkv", ".avi", ".webm"}
+
+        # rows = []
+
+        # for base_path in paths:
+        #     base_path = Path(base_path)
+
+        #     if not base_path.exists():
+        #         print(f"Skipping missing folder: {base_path}")
+        #         continue
+
+        #     for file in base_path.iterdir():
+        #         if file.is_file() and file.suffix.lower() in VIDEO_EXTENSIONS:
+        #             rows.append([file.name])
+
+        # # Write CSV
+        # with open(output_csv, "w", newline="", encoding="utf-8") as f:
+        #     writer = csv.writer(f)
+        #     writer.writerow(["video_filename"])
+        #     writer.writerows(rows)
+
+        # print(f"CSV created with {len(rows)} entries → {output_csv}")
+
+    except KeyboardInterrupt:
+        print("\nStopped by Ctrl+C")

video_analyser/get_refresh_token.py

@@ -1,62 +1,21 @@
-"""
-Helper script to get a Google Drive refresh token with the correct scopes.
-Run this once to generate a new refresh token for video_analyser.
-"""
-
-import os
 from google_auth_oauthlib.flow import InstalledAppFlow
-from dotenv import load_dotenv
-
-# Load existing credentials
-load_dotenv()
 
-# Scopes needed for video analyser
+# ✅ Use YouTube scope (not Drive)
 SCOPES = ['https://www.googleapis.com/auth/drive.readonly']
 
-def get_refresh_token():
-    """Get a new refresh token with Drive readonly scope"""
-    
-    client_id = os.getenv('SERVER_GOOGLE_CLIENT_ID')
-    client_secret = os.getenv('SERVER_GOOGLE_CLIENT_SECRET')
-    
-    if not client_id or not client_secret:
-        print("ERROR: Missing SERVER_GOOGLE_CLIENT_ID or SERVER_GOOGLE_CLIENT_SECRET in .env")
-        return
-    
-    # Create OAuth flow with manual client config
-    client_config = {
-        "installed": {
-            "client_id": client_id,
-            "client_secret": client_secret,
-            "auth_uri": "https://accounts.google.com/o/oauth2/auth",
-            "token_uri": "https://oauth2.googleapis.com/token",
-            "redirect_uris": ["http://localhost"]
-        }
-    }
-    
-    flow = InstalledAppFlow.from_client_config(client_config, SCOPES)
-    
-    print("\n" + "="*60)
-    print("Google Drive Refresh Token Generator")
-    print("="*60)
-    print(f"\nRequesting scopes: {', '.join(SCOPES)}")
-    print("\nA browser window will open for authorization...")
-    print("Sign in and grant access to Google Drive (read-only)")
-    print("="*60 + "\n")
-    
-    # Run OAuth flow
-    creds = flow.run_local_server(port=8080)
-    
-    print("\n" + "="*60)
-    print("✅ Authorization successful!")
-    print("="*60)
-    print("\nAdd this to your .env file:")
-    print("-"*60)
-    print(f"DRIVE_GOOGLE_REFRESH_TOKEN={creds.refresh_token}")
-    print("-"*60)
-    print("\nThen update video_analyser to use DRIVE_GOOGLE_REFRESH_TOKEN")
-    print("instead of SERVER_GOOGLE_REFRESH_TOKEN for Drive operations.")
-    print("="*60 + "\n")
+def main():
+    print("🔑 Starting OAuth flow...")
+
+    flow = InstalledAppFlow.from_client_secrets_file(
+        "whoa/client_secret_688373610660-vtr5l8q7s4is9kkvd7hla1cqg273emfs.apps.googleusercontent.com.json",
+        SCOPES
+    )
+
+    creds = flow.run_local_server(port=0)
+
+    print("\n✅ AUTH SUCCESS")
+    print("REFRESH TOKEN:\n")
+    print(creds.refresh_token)
 
-if __name__ == '__main__':
-    get_refresh_token()
+if __name__ == "__main__":
+    main()

video_analyser/modules/drive_downloader.py

@@ -12,7 +12,6 @@ from tqdm import tqdm
 
 from google.auth.transport.requests import Request
 from google.oauth2.credentials import Credentials
-from google_auth_oauthlib.flow import InstalledAppFlow
 from googleapiclient.discovery import build
 from googleapiclient.http import MediaIoBaseDownload