import asyncio
import time

async def async_task_1():
    print('async_task_1 시작')
    print('sync_task_1 3초 대기')
    await asyncio.sleep(3)
    print('sync_task_1 재시작')

async def async_task_2():
    print('async_task_2 시작')
    print('sync_task_2 2초 대기')
    await asyncio.sleep(2)
    print('sync_task_2 재시작')

async def main():
    start = time.time()
    await async_task_1()
    await async_task_2()
    end = time.time()
    print(f'time taken: {end - start}')

asyncio.run(main())

# async_task_1 시작
# sync_task_1 3초 대기
# sync_task_1 재시작
# async_task_2 시작
# sync_task_2 2초 대기
# sync_task_2 재시작
# time taken: 5.004269123077393

import asyncio
import time

async def async_task_1():
    print('async_task_1 시작')
    print('sync_task_1 3초 대기')
    await asyncio.sleep(3)
    print('sync_task_1 재시작')

async def async_task_2():
    print('async_task_2 시작')
    print('sync_task_2 2초 대기')
    await asyncio.sleep(2)
    print('sync_task_2 재시작')

async def main():
    start = time.time()
    task1 = asyncio.create_task(async_task_1())
    task2 = asyncio.create_task(async_task_2())
    await task1
    await task2
    end = time.time()
    print(f'time taken: {end - start}')

asyncio.run(main())

# async_task_1 시작
# sync_task_1 3초 대기
# async_task_2 시작
# sync_task_2 2초 대기
# sync_task_2 재시작
# sync_task_1 재시작
# time taken: 3.0023632049560547

def run(main, *, debug=None):
    """Execute the coroutine and return the result.

    This function runs the passed coroutine, taking care of
    managing the asyncio event loop and finalizing asynchronous
    generators.

    This function cannot be called when another asyncio event loop is
    running in the same thread.

    If debug is True, the event loop will be run in debug mode.

    This function always creates a new event loop and closes it at the end.
    It should be used as a main entry point for asyncio programs, and should
    ideally only be called once.

    Example:

        async def main():
            await asyncio.sleep(1)
            print('hello')

        asyncio.run(main())
    """
    if events._get_running_loop() is not None:
        raise RuntimeError(
            "asyncio.run() cannot be called from a running event loop")

    if not coroutines.iscoroutine(main):
        raise ValueError("a coroutine was expected, got {!r}".format(main))

    loop = events.new_event_loop()
    try:
        events.set_event_loop(loop)
        if debug is not None:
            loop.set_debug(debug)
        return loop.run_until_complete(main)
    finally:
        try:
            _cancel_all_tasks(loop)
            loop.run_until_complete(loop.shutdown_asyncgens())
        finally:
            events.set_event_loop(None)
            loop.close()

import asyncio

async def factorial(name, number):
    f = 1
    for i in range(2, number + 1):
        print(f"Task {name}: Compute factorial({i})...")
        await asyncio.sleep(1)
        f *= i
    print(f"Task {name}: factorial({number}) = {f}")
    return f

async def main():
    # 동시에 3개를 예약
    result = await asyncio.gather(factorial("A", 2), factorial("B", 3), factorial("C", 4))
    # 또는
    # result = await asyncio.gather(*[factorial("A", 2), factorial("B", 3), factorial("C", 4)])

    print(result)

asyncio.run(main())

# Task A: Compute factorial(2)...
# Task B: Compute factorial(2)...
# Task C: Compute factorial(2)...
# Task A: factorial(2) = 2
# Task B: Compute factorial(3)...
# Task C: Compute factorial(3)...
# Task B: factorial(3) = 6
# Task C: Compute factorial(4)...
# Task C: factorial(4) = 24
# [2, 6, 24]

import asyncio

async def factorial(name, number):
    f = 1
    if number == 4:
        raise ValueError('에러')
    for i in range(2, number + 1):
        print(f"Task {name}: Compute factorial({i})...")
        await asyncio.sleep(1)
        f *= i
    print(f"Task {name}: factorial({number}) = {f}")
    return f

async def main():
    # 동시에 3개를 예약
    result = await asyncio.gather(
        factorial("A", 2),
        factorial("B", 3),
        factorial("C", 4),
        return_exceptions=True
    )

    print(result)

asyncio.run(main())

# Task A: Compute factorial(2)...
# Task B: Compute factorial(2)...
# Task A: factorial(2) = 2
# Task B: Compute factorial(3)...
# Task B: factorial(3) = 6
# [2, 6, ValueError('에러')]

import asyncio

async def eternity():
    await asyncio.sleep(4)
    print('살았다.')

async def main():
    try:
        # 대기 시간이 1초가 넘어가면 에러처리
        await asyncio.wait_for(eternity(), timeout=1.0)
    except asyncio.TimeoutError:
        print('timeout!')

asyncio.run(main())
# timeout!

async def nested():
    return 42

async def main():
    # 코루틴 함수를 await을 안붙이고 호출하면 호출되지 않음
    # 코루틴은 생성이 되지만 await하지 않음 -> 그래서 아무것도 실행하지 않는다.
    nested()

    # 42 반환됨
    print(await nested()) 

asyncio.run(main())

async def nested():
    return 42

async def main():
    # nested()함수가 동시에 실행되도록 예약
    task = asyncio.create_task(nested())

    # task 변수를 취소하거나 완료될때까지 대기
    await task

asyncio.run(main())

import asyncio
import concurrent.futures

def blocking_io():
    # 로깅과 같은 파일 작업은 이벤트 루프를 차단할 수 있으므로 스레드 풀에서 실행합니다.
    with open('/dev/urandom', 'rb') as f:
        return f.read(100)

def cpu_bound():
    # CPU bound 작업은 이벤트 루프를 차단하므로 프로세스 풀에서 실행하는 것이 좋습니다.
    return sum(i * i for i in range(10 ** 7))

async def main():
    loop = asyncio.get_running_loop()

    # 첫 번째 인자가 None이면 자체적으로 ThreadPoolExecutor를 생성 - 테스트 했을 때, worker가 41개 등록됐음 
    result = await loop.run_in_executor(None, blocking_io)
    print('default thread pool', result)

    with concurrent.futures.ThreadPoolExecutor() as pool:
        result = await loop.run_in_executor(pool, blocking_io)
        print('custom thread pool', result)

    with concurrent.futures.ProcessPoolExecutor() as pool:
        result = await loop.run_in_executor(pool, cpu_bound)
        print('custom process pool', result)

asyncio.run(main())

from time import time
import aiohttp
import asyncio

async def call(session, delay):
    print(f'call {delay}짜리 시작')
    # 전달 받은 session으로 async 처리
    async with session.get(f'http://httpbin.org/delay/{delay}') as response:
        result = await response.json()
        print(f'call {delay}짜리 끝')
        return result

async def main():
    # 타이머 시작
    start = time()

    # 비동기 처리 세션 생성
    async with aiohttp.ClientSession() as session:
        # 작업 동시 예약
        two_task = asyncio.create_task(call(session, 2))
        three_task = asyncio.create_task(call(session, 3))

        # await asyncio.sleep(1)
        # 다른 작업도 가능

        result1 = await two_task
        result2 = await three_task

        end = time()
        print(end - start)

asyncio.run(main())

# call 2짜리 시작
# call 3짜리 시작
# call 2짜리 끝
# call 3짜리 끝
# 3.465127944946289

# Create a database instance, and connect to it.
from databases import Database
database = Database('sqlite:///example.db')
await database.connect()

# Create a table.
query = """CREATE TABLE HighScores (id INTEGER PRIMARY KEY, name VARCHAR(100), score INTEGER)"""
await database.execute(query=query)

# Insert some data.
query = "INSERT INTO HighScores(name, score) VALUES (:name, :score)"
values = [
    {"name": "Daisy", "score": 92},
    {"name": "Neil", "score": 87},
    {"name": "Carol", "score": 43},
]
await database.execute_many(query=query, values=values)

# Run a database query.
query = "SELECT * FROM HighScores"
rows = await database.fetch_all(query=query)
print('High Scores:', rows)