Pitfall16 future

conlcusion: watch out for the format !!!!!
**********************
import concurrent.futures
import time

def api_call():
    time.sleep(2)  # Simulating a long-running API call
    return "API call completed successfully"

def main():
    t0=time.time()
    try:
        with concurrent.futures.ThreadPoolExecutor() as executor:
            future = executor.submit(api_call)
            result = future.result(timeout=5)
            print("Got result:", result)
    except concurrent.futures.TimeoutError:
        print('entering time out:',time.time()-t0)
        print("TimeoutError: Future result not available within 1 second")

if __name__ == "__main__":
    main()

Got result: API call completed successfully

**********************
import concurrent.futures
import time

def api_call():
    time.sleep(5)  # Simulating a long-running API call
    return "API call completed successfully"

def main():
    t0=time.time()
    try:
        with concurrent.futures.ThreadPoolExecutor() as executor:
            future = executor.submit(api_call)
            result = future.result(timeout=1)
            print("Got result:", result)
    except concurrent.futures.TimeoutError:
        print('entering time out:',time.time()-t0)
        print("TimeoutError: Future result not available within 1 second")

if __name__ == "__main__":
    main()

entering time out: 5.002657890319824
TimeoutError: Future result not available within 1 second

**********************
import concurrent.futures
import time

def api_call():
    time.sleep(2)  # Simulating a long-running API call
    return "API call completed successfully"

def main():
    t0=time.time()
    with concurrent.futures.ThreadPoolExecutor() as executor:
        future = executor.submit(api_call)
        try:
            print("Waiting for result with a timeout of 1 second")
            result = future.result(timeout=1)
            print("Got result:", result)
        except concurrent.futures.TimeoutError:
            print('entering time out:',time.time()-t0)
            print("TimeoutError: Future result not available within 1 second")

if __name__ == "__main__":
    main()

Waiting for result with a timeout of 1 second
entering time out: 0.10640907287597656
TimeoutError: Future result not available within 1 second

***********************************************************************************************
# if you handle exception in your function, futures.FIRST_EXCEPTION will not work. The real result is that it will wait for both threads to complete == ALL_COMPLETED
import concurrent.futures
import time

def api_call():
    time.sleep(2)  # Simulating a long-running API call
    return "API call completed successfully"

def function_with_exception():
    try:
        raise ValueError("This is a sample exception")
    except:
        return 'raised exception'

def main():
    with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
        future1 = executor.submit(function_with_exception)
        future2 = executor.submit(api_call)
        print('***** function_with_exception:', future1.done())
        print('***** api_call:', future2.done())
        tt1 = time.time()

        completed_futures, _ = concurrent.futures.wait([future1, future2], return_when=concurrent.futures.FIRST_EXCEPTION)
        tt2 = time.time()
        print(f"Time spent in wait: {tt2 - tt1} seconds")

        print('***** completed_futures:', completed_futures)

        for completed_future in completed_futures:
            try:
                result = completed_future.result()
                print("Result:", result)
            except Exception as e:
                print(f"Exception occurred: {e}")

        print('***** function_with_exception:', future1.done())
        print('***** api_call:', future2.done())

if __name__ == "__main__":
    main()

***********************************************************************************************
# if you not handle exception, then FIRST_EXCEPTION will work
import concurrent.futures
import time

def api_call():
    time.sleep(2)  # Simulating a long-running API call
    return "API call completed successfully"

def function_with_exception():
    # try:
    raise ValueError("This is a sample exception")
    # except:
    #     return 'raised exception'

def main():
    with concurrent.futures.ThreadPoolExecutor(max_workers=2) as executor:
        future1 = executor.submit(function_with_exception)
        future2 = executor.submit(api_call)
        print('***** function_with_exception:', future1.done())
        print('***** api_call:', future2.done())
        tt1 = time.time()

        completed_futures, _ = concurrent.futures.wait([future1, future2], return_when=concurrent.futures.FIRST_EXCEPTION)
        tt2 = time.time()
        print(f"Time spent in wait: {tt2 - tt1} seconds")

        print('***** completed_futures:', completed_futures)

        for completed_future in completed_futures:
            try:
                result = completed_future.result()
                print("Result:", result)
            except Exception as e:
                print(f"Exception occurred: {e}")

        print('***** function_with_exception:', future1.done())
        print('***** api_call:', future2.done())

if __name__ == "__main__":
    main()

***** function_with_exception: True
***** api_call: False
Time spent in wait: 0.00099945068359375 seconds
***** completed_futures: {<Future at 0x1c9a7195970 state=finished raised ValueError>}
Exception occurred: This is a sample exception
***** function_with_exception: True
***** api_call: False

***********************************************************************************************
***********************************************************************************************
problem with with block statement, it will wait for both threads to complete and then start another function.
unless, the with block is in the main thread. if in a separate standalone function, the first complete will not work as expected

import concurrent.futures
import time
from concurrent.futures import ThreadPoolExecutor


def some_long_running_task1():
    time.sleep(3)
    return "Task 1 completed successfully!"

def some_long_running_task2():
    time.sleep(10)
    return "Task 2 completed successfully!"

def run_task_in_executor():
    executor = ThreadPoolExecutor(max_workers=2)
    future_result1 = executor.submit(some_long_running_task1)
    future_result2 = executor.submit(some_long_running_task2)
    print("Tasks submitted, not waiting for completion.", time.time())

    completed_futures, _ = concurrent.futures.wait(
        [future_result1, future_result2],
        timeout=None,
        return_when=concurrent.futures.FIRST_COMPLETED
    )

    # You can iterate over completed futures without blocking
    for future in completed_futures:
        # Handle the completed future, if needed
        result = future.result()
        print("Task completed in wait loop.", result, time.time())
        try:
            result = future_result2.result(timeout=6)
        except Exception as err:
            print(err)
            print('serve task 1...........')

# This part is reached after exiting the with block

def my_func():
    run_task_in_executor()
    print('after run_task_in_executor:', time.time())

# Call the function that sets up the ThreadPoolExecutor
my_func()