POWER STATION

def power_station(sources):
    """Yield data from multiple sources round-robin."""
    while True:
        for source in sources:
            try:
                yield next(source)
            except StopIteration:
                # Remove exhausted sources
                sources.remove(source)
                if not sources:
                    return

# Sub-generators (e.g., sensor feeds)
sensor1 = (x for x in [10, 20, 30])
sensor2 = (x for x in [40, 50])
aggregator = power_station([sensor1, sensor2])

print(list(aggregator))  # Output: [10, 40, 20, 50, 30]

from concurrent.futures import ThreadPoolExecutor

def task_generator(tasks):
    """Generate tasks for parallel execution."""
    for task in tasks:
        yield task

def power_station_executor(tasks, max_workers=4):
    with ThreadPoolExecutor(max_workers) as executor:
        futures = []
        for task in task_generator(tasks):
            futures.append(executor.submit(process_task, task))  # Assume process_task is defined
        for future in futures:
            yield future.result()  # Yield results as they complete

# Usage
tasks = ["task1", "task2", "task3", "task4"]
for result in power_station_executor(tasks):
    print(result)

def worker(input_queue):
    for item in input_queue:
        yield process_item(item)  # Simulate work

def power_station_router(workers, data_stream):
    queues = {worker: [] for worker in workers}
    for data in data_stream:
        # Route to the least busy worker
        target = min(workers, key=lambda w: len(queues[w]))
        queues[target].append(data)
        # Yield results from workers
        for worker in workers:
            if queues[worker]:
                yield next(worker(queues[worker]))

# Usage
worker1 = worker([])
worker2 = worker([])
data_stream = [1, 2, 3, 4, 5]
router = power_station_router([worker1, worker2], data_stream)
print(list(router))  # Output: [1, 2, 3, 4, 5] (processed)

def resilient_generator(tasks, max_retries=3):
    for task in tasks:
        retries = 0
        success = False
        while not success and retries < max_retries:
            try:
                result = process_unstable_task(task)
                success = True
                yield result
            except Exception as e:
                retries += 1
                if retries == max_retries:
                    yield f"Failed: {task}"

# Usage
tasks = ["data1", "data2", "data3"]
for result in resilient_generator(tasks):
    print(result)

def connection_pool():
    pool = []
    while True:
        if not pool:
            # Create 5 new connections
            pool = [create_connection() for _ in range(5)]  # Assume create_connection exists
        yield pool.pop()

# Usage
pool_gen = connection_pool()
for _ in range(10):
    conn = next(pool_gen)
    use_connection(conn)
    # Connections are recycled automatically