Update ccc.py

ccc.py

@@ -7,59 +7,23 @@ 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']
 BASE_URL = "https://tidal.com/browse/track/"
 
 # Configuration - Edit these values as needed
-START_TRACK_ID = 20753858  # Change this to your desired starting track ID
-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
+START_TRACK_ID = 20753929  # Change this to your desired starting track ID
+TRACK_CHECK_INTERVAL = 2.1  # Speed of checking in seconds (lower = faster)
 
-# 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 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}")
 
 async def check_tidal_track(track_id):
     try:
@@ -158,6 +122,7 @@ 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)
             
@@ -175,37 +140,25 @@ 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, semaphore):
+async def process_track(track_id):
     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)
             
-            # 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}")
+            # 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}")
         else:
             print(f"Track {track_id} does not exist")
         
@@ -216,38 +169,19 @@ async def process_track(track_id, semaphore):
 
 async def main():
     current_track_id = START_TRACK_ID
-    semaphore = asyncio.Semaphore(MAX_CONCURRENT_DOWNLOADS)
     
     print(f"Starting from track ID: {current_track_id}")
     
-    # 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()]
-            
-            # 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
+    while True:
+        try:
+            track_processed = await process_track(current_track_id)
+            current_track_id += 1
+            await asyncio.sleep(TRACK_CHECK_INTERVAL)
             
-            # Wait a bit before checking for more tasks to create
+        except Exception as e:
+            print(f"Error in main loop: {e}")
             await asyncio.sleep(TRACK_CHECK_INTERVAL)
-    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)
+            current_track_id += 1
 
 if __name__ == "__main__":
     asyncio.run(main())