Update ccc.py

ccc.py

@@ -1,8 +1,6 @@
 import aiohttp
-import time
 import asyncio
 import random
-import multiprocessing
 from dateutil import parser
 import os
 import logging
@@ -14,12 +12,6 @@ discord_webhook_url = os.environ['webhook']
 api_batch_url = "https://epic-alligator-77.deno.dev/post"
 asset_info_url = "https://economy.roproxy.com/v2/assets/"
 
-assets_checked = multiprocessing.Value('i', 0)
-valid_assets_found = multiprocessing.Value('i', 0)
-
-last_used_ids = {}
-base_ids = {}
-
 async def send_to_discord(session, asset_id, name, creator_id, creator_name, creator_type, asset_type, created_date):
     embed = {
         "embeds": [
@@ -54,7 +46,6 @@ async def send_to_discord(session, asset_id, name, creator_id, creator_name, cre
         pass
 
 async def check_asset_batch(session, asset_ids):
-    global assets_checked, valid_assets_found
     payload = [{"assetId": asset_id} for asset_id in asset_ids]
 
     try:
@@ -78,11 +69,7 @@ async def check_asset_batch(session, asset_ids):
         pass
 
 async def fetch_asset_info(session, asset_id):
-    global assets_checked, valid_assets_found
     try:
-        with assets_checked.get_lock():
-            assets_checked.value += 1
-
         async with session.get(f"{asset_info_url}{asset_id}/details") as asset_info_response:
             if asset_info_response.status == 200:
                 asset_info = await asset_info_response.json()
@@ -95,13 +82,8 @@ async def fetch_asset_info(session, asset_id):
                 creator_type = creator.get("CreatorType", "Unknown")
                 created_date_str = asset_info.get("Created", "Unknown")
                 created_date = parse_iso8601(created_date_str)
-                if created_date:
-                    created_date_formatted = created_date.strftime("%Y-%m-%d %H:%M:%S")
-                else:
-                    created_date_formatted = "Unknown"
+                created_date_formatted = created_date.strftime("%Y-%m-%d %H:%M:%S") if created_date else "Unknown"
 
-                with valid_assets_found.get_lock():
-                    valid_assets_found.value += 1
                 await send_to_discord(session, asset_id, name, creator_id, creator_name, creator_type, asset_type, created_date_formatted)
     except (aiohttp.ClientError, asyncio.TimeoutError, ConnectionError):
         pass
@@ -112,51 +94,34 @@ def parse_iso8601(date_str):
     except ValueError:
         return None
 
-def generate_base_id():
-    base = random.randint(70000000000000, 140000000000000)
-    return str(base)
-
-def initialize_base_ids():
-    for digit in range(7, 15):
-        base_ids[digit] = generate_base_id()
-        last_used_ids[digit] = int(base_ids[digit])
-
 def generate_ids_batch(digit, batch_size=10000):
-    last_used_id = last_used_ids[digit]
-    offset = random.randint(-1000000, 1000000)
-    ids_batch = [str(last_used_id + offset + i) for i in range(batch_size)]
-    last_used_ids[digit] += batch_size
-    return ids_batch
-
-async def run_scanner_instance(digit):
-    while True:
-        try:
-            async with aiohttp.ClientSession() as session:
-                batch = generate_ids_batch(digit)
-                await check_asset_batch(session, batch)
-        except (aiohttp.ClientError, asyncio.TimeoutError, ConnectionError):
-            await asyncio.sleep(1)  # Add a small delay before retrying
+    base = random.randint(70000000000000, 140000000000000)
+    for i in range(batch_size):
+        yield str(base + i)
+
+async def run_scanner_instance(digit, semaphore):
+    async with aiohttp.ClientSession() as session:
+        while True:
+            try:
+                async with semaphore:
+                    batch = list(generate_ids_batch(digit))
+                    await check_asset_batch(session, batch)
+            except (aiohttp.ClientError, asyncio.TimeoutError, ConnectionError):
+                await asyncio.sleep(1)
 
 async def print_status_periodically():
     while True:
         print("Working")
         await asyncio.sleep(60)
 
-def run_scanner_in_process(digit):
-    asyncio.run(run_scanner_instance(digit))
-
-if __name__ == "__main__":
-    initialize_base_ids()
-    processes = []
-    instances_per_digit = 20000
-    
-    for i in range(instances_per_digit):
+async def main():
+    semaphore = asyncio.Semaphore(100)  # Limit concurrent tasks
+    tasks = []
+    for i in range(160000):  # 20000 instances per digit * 8 digits
         digit = 7 + (i % 8)
-        process = multiprocessing.Process(target=run_scanner_in_process, args=(digit,))
-        processes.append(process)
-        process.start()
-
-    asyncio.run(print_status_periodically())
+        tasks.append(run_scanner_instance(digit, semaphore))
+    tasks.append(print_status_periodically())
+    await asyncio.gather(*tasks)
 
-    for process in processes:
-        process.join()
+if __name__ == "__main__":
+    asyncio.run(main())