Bulk operations

import requests
from typing import List, Dict, Any

def batch_items(items: List[str], batch_size: int = 50):
    """
    Split items into batches of specified size
    """
    for i in range(0, len(items), batch_size):
        yield items[i:i + batch_size]

def fetch_coins_in_batches(mints: List[str], batch_size: int = 50) -> List[Dict[Any, Any]]:
    """
    Fetch coin data for large lists of mints
    """
    url = "https://advanced-api-v2.pump.fun/coins/mints"
    headers = {
        "Authorization": "Bearer <your_token>",
        "Content-Type": "application/json"
    }
    
    all_coins = []
    
    for batch in batch_items(mints, batch_size):
        data = {"mints": batch}
        response = requests.post(url, headers=headers, json=data)
        
        if response.status_code == 200:
            coins = response.json()
            all_coins.extend(coins)
        else:
            print(f"Error fetching batch: {response.status_code}")
    
    return all_coins

# Usage
mints = [
    "CxLHsqvjfisgPAGwcZJsTn6nzZXJLxmVYM7v9pump",
    "7GCihgDB8fe6KNjn2MYtkzZcRjQy3t9GHdC8uHYmW2hr",
    # ... many more mints
]

coins = fetch_coins_in_batches(mints, batch_size=50)
print(f"Fetched {len(coins)} coins from {len(mints)} mints")

import requests
import concurrent.futures
from typing import List, Dict, Any

def fetch_batch(batch: List[str], headers: Dict[str, str]) -> List[Dict[Any, Any]]:
    """
    Fetch a single batch of coins
    """
    url = "https://advanced-api-v2.pump.fun/coins/mints"
    data = {"mints": batch}
    
    try:
        response = requests.post(url, headers=headers, json=data, timeout=10)
        if response.status_code == 200:
            return response.json()
    except Exception as e:
        print(f"Error fetching batch: {e}")
    
    return []

def fetch_coins_parallel(mints: List[str], batch_size: int = 50, max_workers: int = 5):
    """
    Fetch coins using parallel batch requests
    """
    headers = {
        "Authorization": "Bearer <your_token>",
        "Content-Type": "application/json"
    }
    
    # Split into batches
    batches = [mints[i:i + batch_size] for i in range(0, len(mints), batch_size)]
    
    all_coins = []
    
    # Process batches in parallel
    with concurrent.futures.ThreadPoolExecutor(max_workers=max_workers) as executor:
        future_to_batch = {
            executor.submit(fetch_batch, batch, headers): batch 
            for batch in batches
        }
        
        for future in concurrent.futures.as_completed(future_to_batch):
            coins = future.result()
            all_coins.extend(coins)
    
    return all_coins

# Usage
mints = ["mint1", "mint2", "mint3"]  # ... many mints
coins = fetch_coins_parallel(mints, batch_size=50, max_workers=5)

import requests
import time
from typing import List, Dict, Any, Optional

class BulkOperationHandler:
    def __init__(self, token: str, max_retries: int = 3):
        self.token = token
        self.max_retries = max_retries
        self.headers = {
            "Authorization": f"Bearer {token}",
            "Content-Type": "application/json"
        }
    
    def fetch_coins_with_retry(self, mints: List[str]) -> Optional[List[Dict[Any, Any]]]:
        """
        Fetch coins with exponential backoff retry
        """
        url = "https://advanced-api-v2.pump.fun/coins/mints"
        data = {"mints": mints}
        
        for attempt in range(self.max_retries):
            try:
                response = requests.post(url, headers=self.headers, json=data, timeout=30)
                
                if response.status_code == 200:
                    return response.json()
                elif response.status_code == 429:  # Rate limited
                    wait_time = 2 ** attempt
                    print(f"Rate limited. Waiting {wait_time}s...")
                    time.sleep(wait_time)
                else:
                    print(f"Error {response.status_code}: {response.text}")
                    return None
                    
            except requests.exceptions.Timeout:
                print(f"Timeout on attempt {attempt + 1}")
                if attempt < self.max_retries - 1:
                    time.sleep(2 ** attempt)
            except Exception as e:
                print(f"Error: {e}")
                return None
        
        return None
    
    def process_large_list(self, mints: List[str], batch_size: int = 50):
        """
        Process a large list with proper error handling
        """
        successful = []
        failed = []
        
        batches = [mints[i:i + batch_size] for i in range(0, len(mints), batch_size)]
        
        for i, batch in enumerate(batches, 1):
            print(f"Processing batch {i}/{len(batches)}...")
            result = self.fetch_coins_with_retry(batch)
            
            if result:
                successful.extend(result)
            else:
                failed.extend(batch)
            
            # Rate limit friendly delay between batches
            time.sleep(0.5)
        
        return {
            "successful": successful,
            "failed": failed,
            "success_rate": len(successful) / len(mints) * 100
        }

# Usage
handler = BulkOperationHandler("your_token")
mints = ["mint1", "mint2", "mint3"]  # ... many mints
result = handler.process_large_list(mints, batch_size=50)

print(f"Success rate: {result['success_rate']:.2f}%")
print(f"Failed items: {len(result['failed'])}")