import asyncio
import concurrent.futures
import multiprocessing

def cpu_intensive_task(data: list, multiplier: int = 2):
    """CPU-intensive task that should run in separate process"""
    result = []
    for item in data:
        # Simulate CPU-intensive work
        value = sum(i * multiplier for i in range(item * 1000))
        result.append(value)
    return result

async def optimize_cpu_bound_work():
    """Optimize CPU-bound work using process pools"""
    
    # Prepare data chunks
    data_chunks = [
        list(range(10, 20)),
        list(range(20, 30)),
        list(range(30, 40)),
        list(range(40, 50))
    ]
    
    # Use process pool for CPU-bound work
    with concurrent.futures.ProcessPoolExecutor(max_workers=4) as executor:
        loop = asyncio.get_event_loop()
        
        # Submit tasks to process pool
        tasks = [
            loop.run_in_executor(executor, cpu_intensive_task, chunk)
            for chunk in data_chunks
        ]
        
        # Wait for all tasks to complete
        results = await asyncio.gather(*tasks)
        
        return results

# Usage
async def main():
    results = await optimize_cpu_bound_work()
    print(f"Processed {len(results)} chunks")

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import concurrent.futures
import requests
import json

def process_api_response(response_data: dict):
    """CPU-intensive processing of API response"""
    # Simulate complex data processing
    processed = {}
    for key, value in response_data.items():
        if isinstance(value, (int, float)):
            processed[key] = value ** 2
        elif isinstance(value, str):
            processed[key] = len(value)
        else:
            processed[key] = str(value)
    
    return processed

async def fetch_and_process_data(url: str):
    """Fetch data and process it using thread pool"""
    
    # I/O-bound: fetch data asynchronously
    import aiohttp
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            data = await response.json()
    
    # CPU-bound: process data in thread pool
    loop = asyncio.get_event_loop()
    with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
        processed_data = await loop.run_in_executor(
            executor, process_api_response, data
        )
    
    return processed_data

async def process_multiple_apis():
    """Process multiple APIs concurrently"""
    urls = [
        "https://api1.example.com/data",
        "https://api2.example.com/data",
        "https://api3.example.com/data"
    ]
    
    tasks = [fetch_and_process_data(url) for url in urls]
    results = await asyncio.gather(*tasks, return_exceptions=True)
    
    return results

import asyncio
import aiofiles

async def process_large_file(filename: str):
    """Process large file line by line"""
    
    batch = []
    batch_size = 1000
    
    async with aiofiles.open(filename, 'r') as file:
        async for line in file:
            processed_line = line.strip().upper()
            batch.append(processed_line)
            
            if len(batch) >= batch_size:
                # Process batch in thread pool
                loop = asyncio.get_event_loop()
                with concurrent.futures.ThreadPoolExecutor() as executor:
                    result = await loop.run_in_executor(
                        executor, lambda: "\n".join(batch)
                    )
                    yield result
                    batch = []
    
    # Process remaining items
    if batch:
        loop = asyncio.get_event_loop()
        with concurrent.futures.ThreadPoolExecutor() as executor:
            result = await loop.run_in_executor(
                executor, lambda: "\n".join(batch)
            )
            yield result