Update ccc.py

ccc.py

@@ -7,6 +7,7 @@ import aiohttp
 import asyncio
 from bs4 import BeautifulSoup
 import io
+from collections import deque
 
 # Get webhook URL from environment variable
 WEBHOOK_URL = os.environ['web']
@@ -14,16 +15,51 @@ BASE_URL = "https://tidal.com/browse/track/"
 
 # Configuration - Edit these values as needed
 START_TRACK_ID = 200353201  # Change this to your desired starting track ID
-TRACK_CHECK_INTERVAL = 2.1  # Speed of checking in seconds (lower = faster)
+TRACK_CHECK_INTERVAL = 0.5  # Speed of checking in seconds (lower = faster)
+WEBHOOK_INTERVAL = 10  # Send webhook messages every 10 seconds
+MAX_CONCURRENT_DOWNLOADS = 30  # Maximum number of concurrent downloads
 
-async def send_webhook_message(track_link, track_info):
-    data = {
-        "content": f"{track_link}\n{track_info}"
-    }
-    async with aiohttp.ClientSession() as session:
-        async with session.post(WEBHOOK_URL, json=data) as response:
-            if response.status != 204:
-                print(f"Failed to send webhook: {response.status}")
+# Queue to store messages to be sent to webhook
+webhook_queue = deque()
+processed_tracks = []  # List to store information about processed tracks
+
+async def send_webhook_messages():
+    while True:
+        if webhook_queue:
+            message = webhook_queue.popleft()
+            async with aiohttp.ClientSession() as session:
+                try:
+                    async with session.post(WEBHOOK_URL, json=message) as response:
+                        if response.status != 204:
+                            print(f"Failed to send webhook: {response.status}")
+                except Exception as e:
+                    print(f"Error sending webhook: {e}")
+                    webhook_queue.appendleft(message)  # Put the message back in the queue
+        
+        # If there are processed tracks to report in a batch
+        if processed_tracks:
+            # Create a summary message of recently processed tracks
+            summary = "Recently processed tracks:\n"
+            count = 0
+            while processed_tracks and count < 15:  # Limit to 15 tracks per message
+                track = processed_tracks.pop(0)
+                summary += f"• {track['song_name']} - {track['artist_name']}\n"
+                count += 1
+
+            # Add completion stats
+            if count > 0:
+                message = {
+                    "content": summary
+                }
+                async with aiohttp.ClientSession() as session:
+                    try:
+                        async with session.post(WEBHOOK_URL, json=message) as response:
+                            if response.status != 204:
+                                print(f"Failed to send webhook: {response.status}")
+                    except Exception as e:
+                        print(f"Error sending webhook: {e}")
+        
+        await asyncio.sleep(WEBHOOK_INTERVAL)
 
 async def check_tidal_track(track_id):
     try:
@@ -122,7 +158,6 @@ async def upload_to_service(file_content, song_name, artist_name):
                           content_type='audio/flac')
             
             # Add metadata fields if needed
-            # The server might be expecting these fields
             form.add_field('song_name', song_name)
             form.add_field('artist', artist_name)
             
@@ -140,25 +175,37 @@ async def upload_to_service(file_content, song_name, artist_name):
         print(f"Error uploading file: {e}")
         return None
 
-async def process_track(track_id):
+async def process_track(track_id, semaphore):
     try:
         track_exists, track_info, song_name, artist_name = await check_tidal_track(track_id)
         
         if track_exists:
             track_link = f"{BASE_URL}{track_id}/u"
             print(f"Found valid track: {track_link} - {track_info}")
-            await send_webhook_message(track_link, track_info)
             
-            # Download the track
-            download_url = await tidal_downloader(track_id, song_name, artist_name)
-            if download_url:
-                # Download the file content
-                file_content = await download_file(download_url)
-                if file_content:
-                    # Upload the file to the service
-                    upload_url = await upload_to_service(file_content, song_name, artist_name)
-                    if upload_url:
-                        await send_webhook_message(f"Uploaded: {song_name} - {artist_name}", f"URL: {upload_url}")
+            # Add notification to webhook queue for discovery
+            webhook_queue.append({
+                "content": f"{track_link}\n{track_info}"
+            })
+            
+            # Download and upload with semaphore to limit concurrency
+            async with semaphore:
+                # Download the track
+                download_url = await tidal_downloader(track_id, song_name, artist_name)
+                if download_url:
+                    # Download the file content
+                    file_content = await download_file(download_url)
+                    if file_content:
+                        # Upload the file to the service
+                        upload_url = await upload_to_service(file_content, song_name, artist_name)
+                        if upload_url:
+                            # Add to processed tracks list for batch reporting
+                            processed_tracks.append({
+                                'song_name': song_name,
+                                'artist_name': artist_name,
+                                'url': upload_url
+                            })
+                            print(f"Successfully processed: {song_name} - {artist_name}")
         else:
             print(f"Track {track_id} does not exist")
         
@@ -169,19 +216,38 @@ async def process_track(track_id):
 
 async def main():
     current_track_id = START_TRACK_ID
+    semaphore = asyncio.Semaphore(MAX_CONCURRENT_DOWNLOADS)
     
     print(f"Starting from track ID: {current_track_id}")
     
-    while True:
-        try:
-            track_processed = await process_track(current_track_id)
-            current_track_id += 1
-            await asyncio.sleep(TRACK_CHECK_INTERVAL)
+    # Start webhook sender task
+    webhook_task = asyncio.create_task(send_webhook_messages())
+    
+    # Tasks list to manage concurrent jobs
+    tasks = []
+    
+    try:
+        while True:
+            # Cleanup completed tasks
+            tasks = [t for t in tasks if not t.done()]
             
-        except Exception as e:
-            print(f"Error in main loop: {e}")
+            # Create new tasks up to the maximum allowed concurrency
+            while len(tasks) < MAX_CONCURRENT_DOWNLOADS * 2:  # Allow more tasks in queue than concurrent downloads
+                task = asyncio.create_task(process_track(current_track_id, semaphore))
+                tasks.append(task)
+                current_track_id += 1
+            
+            # Wait a bit before checking for more tasks to create
             await asyncio.sleep(TRACK_CHECK_INTERVAL)
-            current_track_id += 1
+    except Exception as e:
+        print(f"Error in main loop: {e}")
+    finally:
+        # Cancel webhook task on exit
+        webhook_task.cancel()
+        
+        # Wait for all tasks to complete
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
 
 if __name__ == "__main__":
     asyncio.run(main())