def average_sentiments(tweets_by_state):
"""Calculate the average sentiment of the states by averaging over all
the tweets from each state. Return the result as a database from state
names to average sentiment values (numbers).
If a state has no tweets with sentiment values, leave it out of the
database entirely. Do NOT include states with no tweets, or with tweets
that have no sentiment, as 0. 0 represents neutral sentiment, not unknown
sentiment.
tweets_by_state -- A database from state names to lists of tweets
"""
averaged_state_sentiments = make_database()
"*** YOUR CODE HERE ***"
states = get_keys(tweets_by_state)
for state in states:
total_sentiment, i = 0, 0
list_tweets = get_value_from_key(tweets_by_state, state)
for tweet in list_tweets:
if has_sentiment(analyze_tweet_sentiment(tweet)):
total_sentiment += sentiment_value(analyze_tweet_sentiment(tweet))
i += 1
if i != 0:
aver = total_sentiment/i
averaged_state_sentiments = add_value(averaged_state_sentiments, state, aver)
return averaged_state_sentiments
def group_tweets_by_state(tweets):
"""Return a database that aggregates tweets by their nearest state center.
The keys of the returned database are state names, and the values are
lists of tweets that appear closer to that state center than any other.
tweets -- a sequence of tweet abstract data types
>>> sf = make_tweet("welcome to san francisco", None, 38, -122)
>>> ny = make_tweet("welcome to new york", None, 41, -74)
>>> two_tweets_by_state = group_tweets_by_state([sf, ny])
>>> get_len(two_tweets_by_state)
2
>>> california_tweets = get_value_from_key(two_tweets_by_state, 'CA')
>>> len(california_tweets)
1
>>> tweet_string(california_tweets[0])
'"welcome to san francisco" @ (38, -122)'
"""
tweets_by_state = make_database()
"*** YOUR CODE HERE ***"
states = []
tweets_lst = []
for tweet in tweets:
tweet_state = nearest_state(tweet_location(tweet))
if tweet_state in states:
i = find_position(tweet_state, states)
tweets_lst[i] += [tweet]
else:
states += [tweet_state]
tweets_lst += [[tweet]]
for i in range(len(states)):
tweets_by_state = add_value(tweets_by_state, states[i], tweets_lst[i])
return tweets_by_state
def group_tweets_by_state(tweets):
"""Return a database that aggregates tweets by their nearest state center.
The keys of the returned database are state names, and the values are
lists of tweets that appear closer to that state center than any other.
tweets -- a sequence of tweet abstract data types
>>> sf = make_tweet("welcome to san francisco", None, 38, -122)
>>> ny = make_tweet("welcome to new york", None, 41, -74)
>>> two_tweets_by_state = group_tweets_by_state([sf, ny])
>>> get_len(two_tweets_by_state)
2
>>> california_tweets = get_value_from_key(two_tweets_by_state, 'CA')
>>> len(california_tweets)
1
>>> tweet_string(california_tweets[0])
'"welcome to san francisco" @ (38, -122)'
"""
tweets_by_state = make_states_database_with_empty_lists()
"*** YOUR CODE HERE ***"
for i in range(len(tweets)):
state_of_tweet = closest_state_to_tweet(tweets[i])
state_list = get_value_from_key(tweets_by_state, state_of_tweet)
state_list.append(tweets[i])
tweets_by_state = add_value(tweets_by_state, state_of_tweet, state_list)
final_tweets_by_state_list = make_database()
for i in range(get_len(tweets_by_state)):
if get_values(tweets_by_state)[i] != []:
final_tweets_by_state_list = add_value(final_tweets_by_state_list, get_keys(tweets_by_state)[i], get_values(tweets_by_state)[i])
return final_tweets_by_state_list
def group_tweets_by_state(tweets):
"""Return a database that aggregates tweets by their nearest state center.
The keys of the returned database are state names, and the values are
lists of tweets that appear closer to that state center than any other.
tweets -- a sequence of tweet abstract data types
>>> sf = make_tweet("welcome to san francisco", None, 38, -122)
>>> ny = make_tweet("welcome to new york", None, 41, -74)
>>> two_tweets_by_state = group_tweets_by_state([sf, ny])
>>> get_len(two_tweets_by_state)
2
>>> california_tweets = get_value_from_key(two_tweets_by_state, 'CA')
>>> len(california_tweets)
1
>>> tweet_string(california_tweets[0])
'"welcome to san francisco" @ (38, -122)'
"""
"*** YOUR CODE HERE ***"
tweets_by_state = make_database()
for tweet in tweets:
checker = 1111111111
tweet_loc = tweet_location(tweet)
for state in get_keys(us_states):
state_center_loc = find_state_center(get_value_from_key(us_states, state))
geo_dist = geo_distance(tweet_loc, state_center_loc)
if geo_dist < checker:
checker = geo_dist
closest_state = state
if closest_state in get_keys(tweets_by_state):
tweets_by_state = add_value(tweets_by_state, closest_state, [tweet] + get_value_from_key(tweets_by_state, closest_state))
else:
tweets_by_state = add_value(tweets_by_state, closest_state, [tweet])
return tweets_by_state
def average_sentiments(tweets_by_state):
"""Calculate the average sentiment of the states by averaging over all
the tweets from each state. Return the result as a database from state
names to average sentiment values (numbers).
If a state has no tweets with sentiment values, leave it out of the
database entirely. Do NOT include states with no tweets, or with tweets
that have no sentiment, as 0. 0 represents neutral sentiment, not unknown
sentiment.
tweets_by_state -- A database from state names to lists of tweets
"""
"*** YOUR CODE HERE ***"
averaged_state_sentiments = make_database()
for states in get_keys(tweets_by_state):
state_tweet = get_value_from_key(tweets_by_state, states)
if state_tweet != 0:
counter = 0
average_counter = 0
for tweet in state_tweet:
if has_sentiment(analyze_tweet_sentiment(tweet)):
average_counter += sentiment_value(analyze_tweet_sentiment(tweet))
counter += 1
if counter != 0:
average_counter = average_counter / counter
averaged_state_sentiments = add_value(averaged_state_sentiments, states, average_counter)
return averaged_state_sentiments
def average_sentiments(tweets_by_state):
"""Calculate the average sentiment of the states by averaging over all
the tweets from each state. Return the result as a database from state
names to average sentiment values (numbers).
If a state has no tweets with sentiment values, leave it out of the
database entirely. Do NOT include states with no tweets, or with tweets
that have no sentiment, as 0. 0 represents neutral sentiment, not unknown
sentiment.
tweets_by_state -- A database from state names to lists of tweets
"""
averaged_state_sentiments = make_database()
"*** YOUR CODE HERE ***"
for i in range(get_len(tweets_by_state)):
list_of_tweets_by_state = get_value_from_key(tweets_by_state, get_keys(tweets_by_state)[i])
list_of_all_sentiments = []
for j in range(len(list_of_tweets_by_state)):
if has_sentiment(analyze_tweet_sentiment(list_of_tweets_by_state[j])):
list_of_all_sentiments.append(sentiment_value(analyze_tweet_sentiment(list_of_tweets_by_state[j])))
if len(list_of_all_sentiments) > 0:
average_sentiment_for_state = sum(list_of_all_sentiments)/len(get_value_from_key(tweets_by_state, get_keys(tweets_by_state)[i]))
averaged_state_sentiments = add_value(averaged_state_sentiments, get_keys(tweets_by_state)[i], average_sentiment_for_state)
return averaged_state_sentiments
def group_tweets_by_state(tweets):
"""Return a database that aggregates tweets by their nearest state center.
The keys of the returned database are state names, and the values are
lists of tweets that appear closer to that state center than any other.
tweets -- a sequence of tweet abstract data types
>>> sf = make_tweet("welcome to san francisco", None, 38, -122)
>>> ny = make_tweet("welcome to new york", None, 41, -74)
>>> two_tweets_by_state = group_tweets_by_state([sf, ny])
>>> get_len(two_tweets_by_state)
2
>>> california_tweets = get_value_from_key(two_tweets_by_state, 'CA')
>>> len(california_tweets)
1
>>> tweet_string(california_tweets[0])
'"welcome to san francisco" @ (38, -122)'
"""
tweets_by_state = make_database()
"*** YOUR CODE HERE ***"
for tweet in tweets:
minimum = 9999999999
for state in get_keys(us_states):
state_coor = find_state_center(get_value_from_key(
us_states, state))
distance = geo_distance(tweet_location(tweet), state_coor)
if distance < minimum:
minimum, state_name = distance, state
if state_name not in get_keys(tweets_by_state):
tweets_by_state = add_value(tweets_by_state, state_name, [tweet])
else:
get_value_from_key(tweets_by_state, state_name).append(tweet)
return tweets_by_state
def group_tweets_by_state(tweets):
"""Return a database that aggregates tweets by their nearest state center.
The keys of the returned database are state names, and the values are
lists of tweets that appear closer to that state center than any other.
tweets -- a sequence of tweet abstract data types
>>> sf = make_tweet("welcome to san francisco", None, 38, -122)
>>> ny = make_tweet("welcome to new york", None, 41, -74)
>>> two_tweets_by_state = group_tweets_by_state([sf, ny])
>>> get_len(two_tweets_by_state)
2
>>> california_tweets = get_value_from_key(two_tweets_by_state, 'CA')
>>> len(california_tweets)
1
>>> tweet_string(california_tweets[0])
'"welcome to san francisco" @ (38, -122)'
"""
tweets_by_state = make_database()
"*** YOUR CODE HERE ***"
for tweet in tweets:
distance = [(geo_distance(tweet_location(tweet),find_state_center(get_value_from_key(us_states,state))),state) for state in get_keys(us_states)]
distance =sorted(distance,key=lambda x:x[0])
if distance[0][1] not in get_keys(tweets_by_state):
tweets_by_state = add_value(tweets_by_state, distance[0][1], [tweet,])
else:
new_tweet = get_value_from_key(tweets_by_state, distance[0][1]) + [tweet,]
tweets_by_state = add_value(tweets_by_state, distance[0][1], new_tweet)
return tweets_by_state
def average_sentiments(tweets_by_state):
"""Calculate the average sentiment of the states by averaging over all
the tweets from each state. Return the result as a database from state
names to average sentiment values (numbers).
If a state has no tweets with sentiment values, leave it out of the
database entirely. Do NOT include states with no tweets, or with tweets
that have no sentiment, as 0. 0 represents neutral sentiment, not unknown
sentiment.
tweets_by_state -- A database from state names to lists of tweets
"""
averaged_state_sentiments = make_database()
"*** YOUR CODE HERE ***"
for i in range(get_len(tweets_by_state)):
list_of_tweets_by_state = get_value_from_key(
tweets_by_state,
get_keys(tweets_by_state)[i])
list_of_all_sentiments = []
for j in range(len(list_of_tweets_by_state)):
if has_sentiment(
analyze_tweet_sentiment(list_of_tweets_by_state[j])):
list_of_all_sentiments.append(
sentiment_value(
analyze_tweet_sentiment(list_of_tweets_by_state[j])))
if len(list_of_all_sentiments) > 0:
average_sentiment_for_state = sum(list_of_all_sentiments) / len(
get_value_from_key(tweets_by_state,
get_keys(tweets_by_state)[i]))
averaged_state_sentiments = add_value(averaged_state_sentiments,
get_keys(tweets_by_state)[i],
average_sentiment_for_state)
return averaged_state_sentiments
def draw_centered_map(center_state='TX', n=10):
"""Draw the n states closest to center_state."""
us_centers = make_database()
for state, s in get_items(us_states):
us_centers = add_value(us_centers, state, find_state_center(s))
center = get_value_from_key(us_centers, center_state.upper())
dist_from_center = lambda name: geo_distance(center, get_value_from_key(us_centers, name))
for name in sorted(get_keys(us_centers), key=dist_from_center)[:int(n)]:
draw_state(get_value_from_key(us_states, name))
draw_name(name, get_value_from_key(us_centers, name))
draw_dot(center, 1, 10) # Mark the center state with a red dot
wait()
def draw_centered_map(center_state='TX', n=10):
"""Draw the n states closest to center_state."""
us_centers = make_database()
for state, s in get_items(us_states):
us_centers = add_value(us_centers, state, find_state_center(s))
center = get_value_from_key(us_centers, center_state.upper())
dist_from_center = lambda name: geo_distance(
center, get_value_from_key(us_centers, name))
for name in sorted(get_keys(us_centers), key=dist_from_center)[:int(n)]:
draw_state(get_value_from_key(us_states, name))
draw_name(name, get_value_from_key(us_centers, name))
draw_dot(center, 1, 10) # Mark the center state with a red dot
wait()
def average_sentiments(tweets_by_state):
"""Calculate the average sentiment of the states by averaging over all
the tweets from each state. Return the result as a database from state
names to average sentiment values (numbers).
If a state has no tweets with sentiment values, leave it out of the
database entirely. Do NOT include states with no tweets, or with tweets
that have no sentiment, as 0. 0 represents neutral sentiment, not unknown
sentiment.
tweets_by_state -- A database from state names to lists of tweets
"""
averaged_state_sentiments = make_database()
"*** YOUR CODE HERE ***"
return averaged_state_sentiments
def closest_state_to_tweet(tweet):
#takes in a tweet and returns the two-letter state postal code for the
#closest state center to that tweet
database = us_states
new_dynamic_database = make_database()
list_of_keys = get_keys(database)
for i in range(get_len(database)):
dist = geo_distance(tweet_location(tweet), find_state_center(get_value_from_key(database, list_of_keys[i])))
new_dynamic_database = add_value(new_dynamic_database, list_of_keys[i], dist)
distances_from_states = get_values(new_dynamic_database)
closest_state = ""
for i in range(get_len(new_dynamic_database)):
if get_value_from_key(new_dynamic_database, get_keys(new_dynamic_database)[i]) == min(distances_from_states):
closest_state = get_keys(new_dynamic_database)[i]
return closest_state
def load_states():
"""Load the coordinates of all the state outlines and return them
in a database, from names to shapes lists.
>>> len(get_value_from_key(load_states(), 'HI')) # Hawaii has 5 islands
5
"""
json_data_file = open(DATA_PATH + 'states.json', encoding='utf8')
states = JSONDecoder().decode(json_data_file.read())
states_database = make_database()
for state, shapes in states.items():
states_database = add_value(states_database, state, shapes)
for state, shapes in get_items(states_database):
for index, shape in enumerate(shapes):
if type(shape[0][0]) == list: # the shape is a single polygon
assert len(shape) == 1, 'Multi-polygon shape'
shape = shape[0]
shapes[index] = [make_position(*reversed(pos)) for pos in shape]
return states_database
def load_states():
"""Load the coordinates of all the state outlines and return them
in a database, from names to shapes lists.
>>> len(get_value_from_key(load_states(), 'HI')) # Hawaii has 5 islands
5
"""
json_data_file = open(DATA_PATH + 'states.json', encoding='utf8')
states = JSONDecoder().decode(json_data_file.read())
states_database = make_database()
for state, shapes in states.items():
states_database = add_value(states_database, state, shapes)
for state, shapes in get_items(states_database):
for index, shape in enumerate(shapes):
if type(shape[0][0]) == list: # the shape is a single polygon
assert len(shape) == 1, 'Multi-polygon shape'
shape = shape[0]
shapes[index] = [make_position(*reversed(pos)) for pos in shape]
return states_database
def closest_state_to_tweet(tweet):
#takes in a tweet and returns the two-letter state postal code for the
#closest state center to that tweet
database = us_states
new_dynamic_database = make_database()
list_of_keys = get_keys(database)
for i in range(get_len(database)):
dist = geo_distance(
tweet_location(tweet),
find_state_center(get_value_from_key(database, list_of_keys[i])))
new_dynamic_database = add_value(new_dynamic_database, list_of_keys[i],
dist)
distances_from_states = get_values(new_dynamic_database)
closest_state = ""
for i in range(get_len(new_dynamic_database)):
if get_value_from_key(new_dynamic_database,
get_keys(new_dynamic_database)[i]) == min(
distances_from_states):
closest_state = get_keys(new_dynamic_database)[i]
return closest_state
def average_sentiments(tweets_by_state):
"""Calculate the average sentiment of the states by averaging over all
the tweets from each state. Return the result as a database from state
names to average sentiment values (numbers).
If a state has no tweets with sentiment values, leave it out of the
database entirely. Do NOT include states with no tweets, or with tweets
that have no sentiment, as 0. 0 represents neutral sentiment, not unknown
sentiment.
tweets_by_state -- A database from state names to lists of tweets
"""
averaged_state_sentiments = make_database()
"*** YOUR CODE HERE ***"
for state in get_keys(tweets_by_state):
sentiments_list = [ sentiment_value(analyze_tweet_sentiment(tweet)) for tweet in get_value_from_key(tweets_by_state,state) if has_sentiment(analyze_tweet_sentiment(tweet))]
if sentiments_list:
averaged = sum(sentiments_list)/len(sentiments_list)
averaged_state_sentiments = add_value(averaged_state_sentiments, state, averaged)
return averaged_state_sentiments
def group_tweets_by_state(tweets):
"""Return a database that aggregates tweets by their nearest state center.
The keys of the returned database are state names, and the values are
lists of tweets that appear closer to that state center than any other.
tweets -- a sequence of tweet abstract data types
>>> sf = make_tweet("welcome to san francisco", None, 38, -122)
>>> ny = make_tweet("welcome to new york", None, 41, -74)
>>> two_tweets_by_state = group_tweets_by_state([sf, ny])
>>> get_len(two_tweets_by_state)
2
>>> california_tweets = get_value_from_key(two_tweets_by_state, 'CA')
>>> len(california_tweets)
1
>>> tweet_string(california_tweets[0])
'"welcome to san francisco" @ (38, -122)'
"""
tweets_by_state = make_database()
"*** YOUR CODE HERE ***"
return tweets_by_state
def group_tweets_by_state(tweets):
"""Return a database that aggregates tweets by their nearest state center.
The keys of the returned database are state names, and the values are
lists of tweets that appear closer to that state center than any other.
tweets -- a sequence of tweet abstract data types
>>> sf = make_tweet("welcome to san francisco", None, 38, -122)
>>> ny = make_tweet("welcome to new york", None, 41, -74)
>>> two_tweets_by_state = group_tweets_by_state([sf, ny])
>>> get_len(two_tweets_by_state)
2
>>> california_tweets = get_value_from_key(two_tweets_by_state, 'CA')
>>> len(california_tweets)
1
>>> tweet_string(california_tweets[0])
'"welcome to san francisco" @ (38, -122)'
"""
tweets_by_state = make_states_database_with_empty_lists()
"*** YOUR CODE HERE ***"
for i in range(len(tweets)):
state_of_tweet = closest_state_to_tweet(tweets[i])
state_list = get_value_from_key(tweets_by_state, state_of_tweet)
state_list.append(tweets[i])
tweets_by_state = add_value(tweets_by_state, state_of_tweet,
state_list)
final_tweets_by_state_list = make_database()
for i in range(get_len(tweets_by_state)):
if get_values(tweets_by_state)[i] != []:
final_tweets_by_state_list = add_value(
final_tweets_by_state_list,
get_keys(tweets_by_state)[i],
get_values(tweets_by_state)[i])
return final_tweets_by_state_list
def create_server(target, email, password, root, modules,
listen_port='8080', smtp_host='localhost', log_email=None):
# Get modules
for module in modules:
exec('import %s' % module)
# Load the root class
if root is None:
root_class = Root
else:
modules.insert(0, root)
exec('import %s' % root)
exec('root_class = %s.Root' % root)
# Make folder
try:
mkdir(target)
except OSError:
raise ValueError('can not create the instance (check permissions)')
# The configuration file
config = template.format(
modules=" ".join(modules),
listen_port=listen_port or '8080',
smtp_host=smtp_host or 'localhost',
smtp_from=email,
log_email=log_email)
open('%s/config.conf' % target, 'w').write(config)
# Create the folder structure
database = make_database(target)
mkdir('%s/log' % target)
mkdir('%s/spool' % target)
# Create a fake context
context = get_fake_context(database)
context.set_mtime = True
# Make the root
metadata = Metadata(cls=root_class)
database.set_handler('.metadata', metadata)
root = root_class(metadata)
# Re-init context with context cls
context = get_fake_context(context.database, root.context_cls)
context.set_mtime = True
# Init root resource
root.init_resource(email, password)
# Set mtime
root.set_property('mtime', context.timestamp)
context.root = root
# Save changes
context.git_message = 'Initial commit'
database.save_changes()
# Index the root
catalog = database.catalog
catalog.save_changes()
catalog.close()
# Bravo!
print('*')
print('* Welcome to ikaaro')
print('* A user with administration rights has been created for you:')
print('* username: %s' % email)
print('* password: %s' % password)
print('*')
print('* To start the new instance type:')
print('* icms-start.py %s' % target)
print('*')
# Load the chemical and solid material database, create a new database file if no database file is available, update the database file if it is from the older version
try:
data = open(Filepath + r'/database/capsim3_chemicaldatabase', 'r')
database = pickle.load(data)
data.close()
except:
try:
data = open(Filepath + r'/database/capsim_chemicaldatabase', 'r')
database = pickle.load(data)
data.close()
database = get_updateddatabase(database)
pickle.dump(
database,
open(Filepath + r'/database/capsim3_chemicaldatabase', 'w'))
except:
data = make_database(Filepath)
database = pickle.load(data)
data.close()
try:
materialdata = open(Filepath + r'/database/capsim_soliddatabase', 'r')
except:
materialdata = make_soliddatabase(Filepath)
materials = pickle.load(materialdata)
materialdata.close()
option, filename = show_mainmenu(system)
# Create a new input file using the input window classes
if option == 0:
step = 1
def make_states_database_with_empty_lists():
database = make_database()
us_state_key_list = get_keys(us_states)
for i in range(get_len(us_states)):
database = add_value(database, us_state_key_list[i], [])
return database
def make_states_database_with_empty_lists():
database = make_database()
us_state_key_list = get_keys(us_states)
for i in range(get_len(us_states)):
database = add_value(database, us_state_key_list[i], [])
return database
