If there are fewer than 3 people in your group, merge your group with another group in the room. If your group has 6 or more students, you're welcome to split into two sub-groups and then sync up at the end. If you want two separate Pensieve documents for the two sub-groups, just have one sub-group add 1000 to their group number.

Switch to Pensieve:

• Everyone: Go to pensieve.co, log in with your @berkeley.edu email, and enter your group number as the room number (which was in the email that assigned you to this discussion). As long as you all enter the same number (any number), you'll all be using a shared document.

Once you're on Pensieve, you don't need to return to this page; Pensieve has all the same content (but more features). If for some reason Penseive doesn't work, return to this page and continue with the discussion.

Attendance

Your TA will come around during discussion to check you in. You can start on the worksheet before being checked in; you don't need to wait for your TA to get started.

If you didn't attend for a good reason (such as being sick), fill out this form (within 2 weeks of your discussion): attendance form

Getting Started

Intros: Say your name and your favorite food or beverage to enjoy in Berkeley. Optionally go have that food or beverage as a group after section!

Python Coroutines

• An async def statement creates a coroutine function. Calling it creates a coroutine.
• Within a coroutine function, await another coroutine (or other awaitable object) to pause the current coroutine and only start it again some time after the awaited coroutine returns. Use x = await c to assign x to the return value of the coroutine c.
• After an await, mutable objects passed into a coroutine may have been changed by another coroutine.
• To start some first coroutine c, use asyncio.run(c).
• To pause the current coroutine for k seconds and let other coroutines run, use await asyncio.sleep(k).

• To run two coroutines c and d concurrently until both return and name their return values c_val and d_val:

  c_val, d_val = await asyncio.gather(c, d)

async def wait_for(seconds):
    await asyncio.sleep(seconds)

asyncio.run(wait_for(5))

async def concurrent_wait_fors():
    await asyncio.gather(wait_for(5), wait_for(5), wait_for(5))

Q1: Understanding Concurrent Execution

The following code starts 3 coroutines that each use the wait_for function above to sleep for different amounts of time.

import asyncio

async def wait_for(seconds):
    await asyncio.sleep(seconds)

async def go():
    await asyncio.gather(wait_for(5), wait_for(3), wait_for(4))

asyncio.run(go())

How many seconds does this code take to run?

Implementing a WWPD Race

Q2: Status

Here's a class that can be used to coordinate two different coroutines using a shared object.

The Status class keeps track of whether some operation is finished.

The is_done method returns a boolean indicating whether the operation that a Status represents is done or not. When a Status is newly created, is_done() returns False.

The done method indicates that the operation that a Status represents has completed. After done is called on a Status, all future calls to is_done return True.

Q3: Wait for User Input

Implement the coroutine function get_user_input, which takes a Status instance. It waits for one line of user input, marks the status as done, and returns the user input.

Q4: Timer

The coroutine function timer takes a status and a positive number period. It repeatedly prints out how many seconds have elapsed, once every period seconds, until it detects that the status is done. The first message it prints is 0 seconds have passed.... While it's waiting to print the next message, it uses await so that other coroutines can run concurrently. It returns the number of seconds that passed before it observes that the status is done, which should be a multiple of period.

When printing that 1 second has passed, use 1 second has passed... instead of 1 seconds have passed... to respect the grammar of English.

For example:

async def timer_example():
    """An example of using a timer.

    >>> asyncio.run(timer_example())
    0 seconds have passed...
    0.5 seconds have passed...
    1 second has passed...
    1.5 seconds have passed...
    Status updated after 1.7 seconds
    The timer counted up to 2.0 seconds
    """
    async def update_status(status: Status):
        await asyncio.sleep(1.7)
        print('Status updated after 1.7 seconds')
        status.done()

    status = Status()
    _, elapsed = await asyncio.gather(update_status(status), timer(status, 0.5))
    print(f'The timer counted up to {elapsed} seconds')

def race_example():
    """Run an example with a simulated user input.

    >>> race_example()
    >>> print(asyncio.run(run_challenge("fake human")))
    -- Good job fake human; you correctly evaluated '1 + 1' --
    -- Good job fake human; you correctly evaluated '[1, 2].append([5, 6])' --
    -- Good job computer; you correctly evaluated '1 + 1' --
    -- Not quite fake human. Try to evaluate '[1, 2] + [5, 6]' again! --
    -- Good job computer; you correctly evaluated '[1, 2] + [5, 6]' --
    -- Not quite fake human. Try to evaluate '[1, 2] + [5, 6]' again! --
    {'1 + 1': 'fake human', '[1, 2].append([5, 6])': 'fake human', '[1, 2] + [5, 6]': 'computer'}
    """
    # Swap this simulated "fake human" response function for the one that gets input
    async def mock_get_input_from_user(expression):
        if expression in ['1 + 1', '[1, 2].append([5, 6])']:
            await asyncio.sleep(0.1)
            return str(eval(expression))
        else:
            await asyncio.sleep(0.2)
            return 'incorrect'
    global get_input_from_user
    get_input_from_user = mock_get_input_from_user