def accumulate():
    total = 0
    while True:
        new_num = yield
        if new_num is None:
            break
        
        total += new_num

    return total

accumulator = accumulate()
accum_inputs = list(range(10))
accum_inputs.insert(0, None)
accum_inputs.append(None)

try:
    for ii in accum_inputs:
        accumulator.send(ii)
        
except StopIteration as exception:
    print(f'Sum is {exception.value}')

def accumulate():
    ''' Same accumulate function as last week

        Totals all values sent from the caller. Returns None on each
        iteration. Once complete, returns the total accumulated value.

        To 'complete' an accumulator, send the value None

        :return: Total sum of all accumulated objects
        '''
    total = 0
    while True:
        new_num = yield
        if new_num is None:
            break
        
        total += new_num
    return total

def delegator(generator):
    ''' New 'delegator' function

        'Yields from' a specified generator and prints the return

    :param: Function (as object) that takes no arguments
    :return: 
    '''
    while True:
        ret_val = yield from generator()
        print(f'Return value is {ret_val}')

# Builds up a list of numbers to add
# [None (primer), 0-9, None (to notify accumulator to complete]
accumulator = delegator(accumulate)
accum_inputs = list(range(10))
accum_inputs.insert(0, None)
accum_inputs.append(None)

for ii in accum_inputs:
    accumulator.send(ii)

def yielding_counter():
    ''' Yields the numbers 0 through 99 using the 'yield' keyword '''
    for num in range(100):
        yield(num)
        
def yield_from_counter():
    ''' Yields the numbers 0 through 99 using 'yield from' '''
    yield from range(100)

# Main script body
if __name__ == '__main__':
    # Generate numbers 0 through 4 using yielding counter
    generator = yielding_counter()
    for num in range(5):
        print(f'Yielding counter: {next(generator)}')

    # Generate numbers 0 through 4 using 'yield from' counter
    print()
    generator = yield_from_counter()
    for num in range(5):
        print(f'Yield from counter: {next(generator)}')

def yield_range_100():
    ''' Yields the numbers 0 through 99 '''
    yield from range(100)

def yield_from_counter():
    ''' Yields the numbers 0 through 99 using 'yield from' '''
    yield from yield_range_100()

# Main script body
if __name__ == '__main__':
    # Generate numbers 0 through 4 using 'yield from' counter
    print()
    generator = yield_from_counter()
    for num in range(5):
        print(f'Yield from counter: {next(generator)}')

def file_reader(file_name):
    ''' Opens a given file name for reading and yields contents

        :param file_name:  Path to file
        :return: None
        '''
    with open(file_name, 'r') as file_handle:
        for line_no, line_contents in enumerate(file_handle):
            # For each call to next(), yield the file name,
            # the line number, and the line contents in a tuple
            yield file_name, line_no, line_contents

def file_list_reader(files):
    ''' Iterates through file list and yields their contents

        :param files:  Containing paths to files to read
        :return: None
        '''
    for file_name in files:
        # Delegates to file_reader. Any caller will be yielded
        # the file name, line number, and line contents of the
        # current line/file since 'yield from' essentially opens
        # a pipe from the delegate to the caller.
        yield from file_reader(file_name)

def file_search(search_string, files):
    ''' Searches the contents of the file list for the search_string

        Raises EOFError if end of file list is reached without success

        :param search_string:  To search for
        :param files:  Containing paths to files to search
        :return:  Containing file name, line number, contents
        '''
    # Loop through the file_list_reader generator. Since it is a
    # generator, looping can simply be done with the 'in' keyword
    # without any knowledge of when the end of a file has been reached.
    #
    # Note that a tuple with the file name, line number, and line
    # contents is returned for each iteration of the loop because
    # of the tuple yielded by file_reader.
    file_contents = file_list_reader(files)
    for file_name, line_no, line_contents in file_contents:

        # If the search string is within line_contents, return the
        # tuple. 
        if search_string in line_contents:
            return file_name, line_no, line_contents

    # If we've made it this far without finding anything, raise an
    # error.
    raise EOFError(
        f'End of files encountered before finding str "{search_string}"')

# Main function
if __name__ == '__main__':

    # Define list of files to search and search string
    search_string = 'Plumber'
    list_of_files = [
        'city_names.txt',
        'favorite_colors.csv',
        'haiku.txt',
        'contact_info.dat'
    ]
    
    # Search for contents
    try:
        file_name, line_number, line_contents = file_search(
            search_string,
            list_of_files)
    except EOFError as err:
        print(err)
    else:
        # We found our search string! Print out the result
        print(f'Found in {file_name} Line {line_number}: "{line_contents}"')