예제 #1
0
def test_empty_dict():
    '''Test with an empty dictionary.
    '''
    
    program_output = bacon_functions.invert_actor_dict({})
    assert program_output == {},\
    'Empty dictionary test'
예제 #2
0
def test_empty_dict():
    '''Test with an empty dictionary.
    '''

    program_output = bacon_functions.invert_actor_dict({})
    assert program_output == {},\
    'Empty dictionary test'
예제 #3
0
def test_single_key_single_value_dict():
    '''Test with a single key dictionary which is the
    empty string.
    '''
    
    program_output = bacon_functions.invert_actor_dict({'tart': ['sugar']})
    assert program_output == {'sugar': ['tart']},\
    'Empty string key (dictionary) test'
예제 #4
0
def test_single_key_single_value_dict():
    '''Test with a single key dictionary which is the
    empty string.
    '''

    program_output = bacon_functions.invert_actor_dict({'tart': ['sugar']})
    assert program_output == {'sugar': ['tart']},\
    'Empty string key (dictionary) test'
예제 #5
0
def test_empty_dict_value():
    '''Test with a single key dictionary mapping onto
    the empty list (value).
    '''

    program_output = bacon_functions.invert_actor_dict({'cake': []})
    assert program_output == {},\
    'Empty dictionary value test'
예제 #6
0
def test_empty_dict_value():
    '''Test with a single key dictionary mapping onto
    the empty list (value).
    '''
    
    program_output = bacon_functions.invert_actor_dict({'cake': []})
    assert program_output == {},\
    'Empty dictionary value test'
예제 #7
0
def test_single_key_multiple_values_dict():
    '''Test with a dictionary containing a single key, with multiple
    items in the list (value) which it maps to.
    '''
    
    program_output = bacon_functions.invert_actor_dict({'cake': ['icing','cherry']})
    correct_output = { 'icing': ['cake'], 'cherry': ['cake'] }
    assert program_output == correct_output,\
    'Single key multiple value list dictionary test'
예제 #8
0
def test_single_key_multiple_values_dict():
    '''Test with a dictionary containing a single key, with multiple
    items in the list (value) which it maps to.
    '''

    program_output = bacon_functions.invert_actor_dict(
        {'cake': ['icing', 'cherry']})
    correct_output = {'icing': ['cake'], 'cherry': ['cake']}
    assert program_output == correct_output,\
    'Single key multiple value list dictionary test'
예제 #9
0
def test_multiple_key_multiple_unique_values_dict():
    '''Test with a dictionary containing multiple keys, with multiple
    distinct items in the list (value) which they map to.
    '''
    
    D = { 'salad': ['lettuce','dressing','broccoli'], 'sandwich': [ 'ham', 'cheese'] }
    program_output = bacon_functions.invert_actor_dict(D)
    correct_output = { 'lettuce': ['salad'], 'dressing': ['salad'], 'broccoli':
                       ['salad'], 'ham': ['sandwich'], 'cheese': ['sandwich'] }
    
    assert program_output == correct_output,\
    'Multiple key multiple (distinct) value list dictionary test'
예제 #10
0
def test_multiple_key_multiple_overlapping_values_dict():
    '''Test with a dictionary containing multiple keys, with multiple
    overlapping items in the list (value) which they map to.
    '''
    
    D = { 'modern warfare': ['brutal','entertaining','addictive'],
          'angry birds': [ 'awesome', 'addictive'], 'counter-strike': ['brutal',
          'awesome','addictive','entertaining'] }
    program_output = bacon_functions.invert_actor_dict(D)
    correct_output = { 'awesome': ['angry birds','counter-strike'],
                       'brutal': ['counter-strike','modern warfare'],
                       'addictive': ['modern warfare','angry birds','counter-strike'],
                       'entertaining': ['counter-strike','modern warfare'] }
    sort_dict_values(program_output)
    sort_dict_values(correct_output)
    
    assert program_output == correct_output,\
    'Multiple key multiple (overlapping) value list dictionary test'
예제 #11
0
def test_multiple_key_multiple_unique_values_dict():
    '''Test with a dictionary containing multiple keys, with multiple
    distinct items in the list (value) which they map to.
    '''

    D = {
        'salad': ['lettuce', 'dressing', 'broccoli'],
        'sandwich': ['ham', 'cheese']
    }
    program_output = bacon_functions.invert_actor_dict(D)
    correct_output = {
        'lettuce': ['salad'],
        'dressing': ['salad'],
        'broccoli': ['salad'],
        'ham': ['sandwich'],
        'cheese': ['sandwich']
    }

    assert program_output == correct_output,\
    'Multiple key multiple (distinct) value list dictionary test'
예제 #12
0
def test_multiple_key_multiple_overlapping_values_dict():
    '''Test with a dictionary containing multiple keys, with multiple
    overlapping items in the list (value) which they map to.
    '''

    D = {
        'modern warfare': ['brutal', 'entertaining', 'addictive'],
        'angry birds': ['awesome', 'addictive'],
        'counter-strike': ['brutal', 'awesome', 'addictive', 'entertaining']
    }
    program_output = bacon_functions.invert_actor_dict(D)
    correct_output = {
        'awesome': ['angry birds', 'counter-strike'],
        'brutal': ['counter-strike', 'modern warfare'],
        'addictive': ['modern warfare', 'angry birds', 'counter-strike'],
        'entertaining': ['counter-strike', 'modern warfare']
    }
    sort_dict_values(program_output)
    sort_dict_values(correct_output)

    assert program_output == correct_output,\
    'Multiple key multiple (overlapping) value list dictionary test'
예제 #13
0
''')
      expected = {"Kevin Bacon": ["A Few Good Men (1992)"],
                "Robert De Niro": ["Sleepers (1996)"]}
      result = bacon_functions.parse_actor_data(reader)
      if expected != result:
          print "Failure of function parse_actor_data: " + \
                "Result should be %s, not %s" % (str(expected), str(result))
          ok = False
   else:
      print "Function 'parse_actor_data' is not defined"
      ok = False
       
   if hasattr(bacon_functions, 'invert_actor_dict'):
      expected = {"A Few Good Men (1992)": ["Kevin Bacon"],
                  "Sleepers (1996)": ["Kevin Bacon"]}
      result = bacon_functions.invert_actor_dict({"Kevin Bacon": ["A Few Good Men (1992)",
                                                        "Sleepers (1996)"]})
      if expected != result:
          print "Failure of function invert_actor_dict: " + \
                "Result should be %s, not %s" % (str(expected), str(result))
          ok = False
   else:
      print "Function 'invert_actor_dict' is not defined"
      ok = False

   if hasattr(bacon_functions, 'find_connection'):
      expected = [('Sleepers (1996)', 'Kevin Bacon')]
      result = bacon_functions.find_connection("Robert De Niro", 
                                     {"Kevin Bacon": ["Sleepers (1996)"],
                                      "Robert De Niro": ["Sleepers (1996)"]},
                                     {"Sleepers (1996)": ["Kevin Bacon", 
                                                          "Robert De Niro"]})
예제 #14
0
import bacon_functions

if __name__ == '__main__':
    actor_data = open('large_actor_data.txt','r')
    
    # Changes the actor_data and actor_dict into dictionaries that we can use
    actor_dict = bacon_functions.parse_actor_data(actor_data)
    movie_dict = bacon_functions.invert_actor_dict(actor_dict)   
    
    counter = 'continue'
    bacon_number_list = []
    
    while counter == 'continue':
    # As long as counter is 'continue', while loop will continue running
        
        # Take the raw input and remove all unnecessary spaces
        actor_name = raw_input\
                   ('Please enter an actor (or press return to exit): ').strip()
        if actor_name != '':
            
            # If Kevin Bacon is not in the list and he is being searched, print
            # bacon number is infinity and gets rid of roman numerals
            if 'Kevin Bacon' == bacon_functions.fix_actor_name(actor_name) and\
               'Kevin Bacon' not in actor_dict: 
                print 'Kevin Bacon has a Bacon Number of Infinity.' + '\n'
                
            # Exception: if the title of actor_name is 'Kevin Bacon', 
            # return 0 as the Bacon Number. (gets rid of roman numerals)           
            elif bacon_functions.fix_actor_name(actor_name) == 'Kevin Bacon':
                print bacon_functions.fix_actor_name(actor_name) + \
                      ' has a Bacon Number of 0.' + '\n'
예제 #15
0
        }
        result = bacon_functions.parse_actor_data(reader)
        if expected != result:
            print "Failure of function parse_actor_data: " + \
                  "Result should be %s, not %s" % (str(expected), str(result))
            ok = False
    else:
        print "Function 'parse_actor_data' is not defined"
        ok = False

    if hasattr(bacon_functions, 'invert_actor_dict'):
        expected = {
            "A Few Good Men (1992)": ["Kevin Bacon"],
            "Sleepers (1996)": ["Kevin Bacon"]
        }
        result = bacon_functions.invert_actor_dict(
            {"Kevin Bacon": ["A Few Good Men (1992)", "Sleepers (1996)"]})
        if expected != result:
            print "Failure of function invert_actor_dict: " + \
                  "Result should be %s, not %s" % (str(expected), str(result))
            ok = False
    else:
        print "Function 'invert_actor_dict' is not defined"
        ok = False

    if hasattr(bacon_functions, 'find_connection'):
        expected = [('Sleepers (1996)', 'Kevin Bacon')]
        result = bacon_functions.find_connection(
            "Robert De Niro", {
                "Kevin Bacon": ["Sleepers (1996)"],
                "Robert De Niro": ["Sleepers (1996)"]
            }, {"Sleepers (1996)": ["Kevin Bacon", "Robert De Niro"]})
예제 #16
0
import bacon_functions

filename = open("large_actor_data.txt")
actor_dict = bacon_functions.parse_actor_data(filename)
movie_dict = bacon_functions.invert_actor_dict(actor_dict)

c = 0
empty = [0]

while c >= 0:

    actor_name = raw_input(\
        "Please enter an actor (or press return to exit): ")
    actor_name = actor_name.title()

    if actor_name == "":

        # If an empty string was entred, we need to present the largest bacon
        # number that has been found. Because we collect all the bacon numbers
        # in a list, we just need to sort it and find the maxium number, which
        # is the last number. Then the whole game stopped.

        empty.sort()
        maxium = empty[-1]
        leave = "Thank you for playing! " + \
        "The largest Bacon Number you found was " + str(maxium)
        print leave
        print ''
        c = -1
        # -1 stopped the function from continuing.
예제 #17
0
파일: make_bacon.py 프로젝트: kod3r/bacon
    # Parsing file of actors (male)
    imdb_actors_file = open("actors.list")
    print "Parsing file (actors.list) of actors (male) ..."
    actors_dict = bacon_functions.parse_actor_data(imdb_actors_file)
    imdb_actors_file.close()

    # Parsing file of actors (female)
    imdb_actresses_file = open("actresses.list")
    print "Parsing file (actresses.list) of actresses (female) ..."
    actresses_dict = bacon_functions.parse_actor_data(imdb_actresses_file)
    imdb_actresses_file.close()

    # thanks for the quick reminder: http://stackoverflow.com/a/38990
    # Merging both the (actors to movies) data structures
    print "Merging both the (actors to movies) data structures ..."
    actors_to_movies = dict(actors_dict.items() + actresses_dict.items())

    # Creating a movies to actors data structure
    print "Creating a movies to actors data structure ..."
    movies_to_actors = bacon_functions.invert_actor_dict(actors_to_movies)

    # Pickling both the data structures
    # Pickling the actors to movies data structure
    print "Pickling the actors to movies data structure ..."
    pickle_dump(actors_to_movies, "actors_to_movies")
    # Pickling the actors to movies data structure
    print "Pickling the actors to movies data structure ..."
    pickle_dump(movies_to_actors, "movies_to_actors")

    print "Done! Run bacon.py to begin playing!"
예제 #18
0
if __name__ == "__main__":
    # Parsing file of actors (male)
    imdb_actors_file = open("actors.list")
    print('Parsing file (actors.list) of actors (male) ...')
    actors_dict = bacon_functions.parse_actor_data(imdb_actors_file)
    imdb_actors_file.close()

    # Parsing file of actors (female)
    imdb_actresses_file = open("actresses.list")
    print('Parsing file (actresses.list) of actresses (female) ...')
    actresses_dict = bacon_functions.parse_actor_data(imdb_actresses_file)
    imdb_actresses_file.close()

    # thanks for the quick reminder: http://stackoverflow.com/a/38990
    # Merging both the (actors to movies) data structures
    print('Merging both the (actors to movies) data structures ...')
    actors_to_movies = dict(actors_dict.items() + actresses_dict.items())

    # Creating a movies to actors data structure
    print('Creating a movies to actors data structure ...')
    movies_to_actors = bacon_functions.invert_actor_dict(actors_to_movies)

    # Pickling both the data structures
    # Pickling the actors to movies data structure
    print('Pickling the actors to movies data structure ...')
    pickle_dump(actors_to_movies, 'actors_to_movies')
    # Pickling the actors to movies data structure
    print('Pickling the actors to movies data structure ...')
    pickle_dump(movies_to_actors, 'movies_to_actors')

    print('Done! Run bacon.py to begin playing!')