def _createSpeakerObject(self, request):
"""Create a Speaker object, returning SpeakerForm/request."""
# Getting and Verifying current user
user = getUser()
# Confirm the field is filled out
checkField(request.name, 'name')
# Copy SpeakerForm/ProtoRPC Message into dict
data = ({field.name: getattr(request, field.name)
for field in request.all_fields()})
# Create a key for the Speaker
s_id = Session.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
# Update stored session with session keys
data['key'] = s_key
# Create and update session and return the form
Speaker(**data).put()
taskqueue.add(
params = {
'email' : user.email(),
'subject' : 'You Added %s as a Speaker!' % data['name'],
'body' : 'Here are the details for the added speaker:',
'info' : repr(request)},
url = '/tasks/send_confirmation_email')
return request
def _createSpeakerObject(self, request):
"""Create Speaker Object, returning SessionForm/request."""
data = {field.name: getattr(request, field.name)
for field in request.all_fields()}
del data['speakerId']
key = Speaker(**data).put()
return self._copySpeakerToForm(key.get())
def _createSpeakerObject(self, request):
"""Create Speaker object, returning SpeakerForm."""
# check for auth'ed and valid user
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# Speaker name must be filled
if not request.name:
raise endpoints.BadRequestException("Field 'name' required")
# copy SpeakerForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
# allocate new Speaker ID
s_id = Speaker.allocate_ids(size=1)[0]
# make Speaker key from ID
s_key = ndb.Key(Speaker, s_id)
data['key'] = s_key
# create Speaker & return SpeakerForm
speaker = Speaker(**data)
speaker.put()
return self._copySpeakerToForm(speaker)
def _createSpeakerObject(self, request):
"""Create Speaker object, returning SpeakerForm/request."""
# preload necessary data items
user = endpoints.get_current_user()
# make sure user is authenticated
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
# make sure session name is entered
if not request.name:
raise endpoints.BadRequestException(
"Session name field required")
# copy SessionForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name)
for field in request.all_fields()}
# generate Speaker Key based on Profile key and
# profile ID
p_key = ndb.Key(Profile, user_id)
s_id = Speaker.allocate_ids(size=1, parent=p_key)[0]
s_key = ndb.Key(Speaker, s_id, parent=p_key)
data['key'] = s_key
# save form data to datastore
Speaker(**data).put()
# create Speaker & return (modified) SpeakerForm
return request
def _createSpeakerObject(self, request):
"""Create or update Speaker object, returning SpeakerForm."""
if not request.name:
raise endpoints.BadRequestException(
"Speaker 'name' field required")
q = Speaker.query()
q = q.filter(Speaker.name == request.name)
if q.count() != 0:
raise endpoints.BadRequestException("Speaker already excists")
# copy SpeakerForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
# Create session id from parent COnference Key and
# a Session key from that id
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
data['key'] = s_key
del data['websafeKey']
# Save session and return a SessionForm to the user
Speaker(**data).put()
return self._copySpeakerToForm(s_key.get())
def createSpeaker(self, request):
"""Create Speaker object, returning SpeakerForm/request."""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
if not request.name:
raise endpoints.BadRequestException("Speaker 'name' field required")
if not request.mainEmail:
raise endpoints.BadRequestException("Speaker 'mainEmail' field required")
sp_key = ndb.Key(Speaker, request.mainEmail)
speaker = sp_key.get()
if not speaker:
speaker = Speaker(
key = sp_key,
name = request.name,
mainEmail = request.mainEmail,
)
if request.title:
speaker.title = request.title
if request.bio:
speaker.bio = request.bio
speaker.put()
return request
def _createSpeakerObject(self, request):
"""Create a speaker, returning SpeakerForm/request."""
# Preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = user.email()
if not request.name:
raise endpoints.BadRequestException(
"Speaker 'name' field required")
# Copy SpeakerForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
del data['websafeKey']
# Add default values for those missing (both data model and
# outbound Message)
for df in SPEAKER_DEFAULTS:
if data[df] in (None, []):
data[df] = SPEAKER_DEFAULTS[df]
# Create Speaker and return SpeakerForm
speaker = Speaker(**data)
speaker.put()
return self._copySpeakerToForm(speaker)
def _createSpeakerObject(self, request):
"""Create or update Speaker object, returning Speaker/request."""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
if not request.name:
raise endpoints.BadRequestException(
"Speaker 'name' field required")
# copy Speaker/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) \
for field in request.all_fields()}
del data['websafeKey']
# add defaults for missing values (both data model & outbound Message)
for df in DEFAULTS_SPEAKER:
if data.get(df, None) is None:
data[df] = DEFAULTS_SPEAKER[df]
setattr(request, df, DEFAULTS_SPEAKER[df])
# create Speaker and return updated SpeakerForm with websafeKey
request.websafeKey = Speaker(**data).put().urlsafe()
return request
def _createSpeakerObject(self, request):
"""Create Speaker object,
returning SpeakerForm/request."""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
if not request.name:
raise endpoints.BadRequestException(
"Speaker 'name' field required")
# copy SpeakerForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) \
for field in request.all_fields()}
del data['websafeKey']
speaker_id = Speaker.allocate_ids(size=1)[0]
speaker_key = ndb.Key(Speaker, speaker_id)
data['key'] = speaker_key
# create Speaker
speaker = Speaker(**data)
speaker.put()
# return the modified SpeakerForm
return self._copySpeakerToForm(speaker)
def _createSpeakerObject(self, request):
"""Create a Speaker object."""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
if not request.firstName:
raise endpoints.BadRequestException(
"Speaker 'firstName' field required")
if not request.lastName:
raise endpoints.BadRequestException(
"Speaker 'lastName' field required")
# copy SpeakerForm Message into dict
data = {field.name: getattr(request, field.name) for field
in request.all_fields()}
# generate Profile Key based on user ID and Speaker
# ID based on Profile key get Speaker key from ID
p_key = ndb.Key(Profile, user_id)
speaker_id = Speaker.allocate_ids(size=1, parent=p_key)[0]
speaker_key = ndb.Key(Speaker, speaker_id, parent=p_key)
data['key'] = speaker_key
del data['speakerWebSafeKey']
# creation Speaker entity
Speaker(**data).put()
return request
def _createSpeakerObject(self, request):
"""Create or update Speaker object, returning SpeakerForm/request."""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
if not request.displayName:
raise endpoints.BadRequestException("Speaker 'displayName' field required")
# copy ConferenceForm/ProtoRPC Message into dict
data = {field.name: getattr(request, field.name) for field in request.all_fields()}
# this is automatically generated for display but should
# be ignored if it is input.
del data['websafeKey']
# Now create the speaker key.
# NOTE: allocate_ids returns a list, so take the first element.
speaker_id = Speaker.allocate_ids(size=1)[0]
speaker_key = ndb.Key(Speaker, speaker_id)
data['key'] = speaker_key
# create Speaker, send email to creator confirming
# creation of Speaker & return (modified) SpeakerForm
Speaker(**data).put()
taskqueue.add(params={'email': user.email(),
'speakerInfo': repr(request)},
url='/tasks/send_speaker_confirmation_email'
)
return request
def _createSpeakerObject(self, request):
"""Create a Speaker object, returning SpeakerForm/request."""
# Ensure that the current user is logged in and get user ID
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# Verify that a name was provided for the speaker
if not request.name:
raise endpoints.BadRequestException(
"Speaker 'name' field required")
# Copy SpeakerForm/ProtoRPC Message into dict
data = ({
field.name: getattr(request, field.name)
for field in request.all_fields()
})
# Create a key for the Speaker
s_id = Session.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
# Update stored session with session keys
data['key'] = s_key
# create Session, send email to organizer confirming
# creation of Session & return (modified) SessionForm
Speaker(**data).put()
taskqueue.add(params={
'email': user.email(),
'subject': 'You Added %s as a Speaker!' % data['name'],
'body': 'Here are the details for the added speaker:',
'info': repr(request)
},
url='/tasks/send_confirmation_email')
return request
def create_speaker(self, request):
"""Create a new speaker."""
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException("Authorization required.")
speaker = Speaker(name=request.name)
speaker.put()
return speaker.to_message()
def _createSpeakerObject(self, request):
speaker_id = request.mainEmail
sp_key = ndb.Key(Speaker, speaker_id)
speaker = Speaker(
key=sp_key,
name=request.name,
mainEmail=request.mainEmail,
phone=request.phone,
)
speaker.put()
return request
def _createSpeakerObject(self, name):
"""Create or update Speaker object,\
returning SpeakerForm/request."""
sp_key = ndb.Key(Speaker, name)
speaker = sp_key.get()
if not speaker:
speaker = Speaker(
key=sp_key,
name=name,
details='',
)
speaker.put()
return speaker
def createSpeaker(self, request):
"""Create new speaker"""
# check for required fields
if not request.name:
raise endpoints.BadRequestException(
"Speaker 'name' field required")
# create speaker
speaker = Speaker(
name=request.name.title(
), #store in fixed title case for case-independent string request later
bio=request.bio)
speaker.put()
# return SpeakerForm
return self._copySpeakerToForm(speaker)
def _getSpeaker(self, email):
# Create a new key of kind Speaker from the id.
s_key = ndb.Key(Speaker, email)
# Get the entity from datastore by using get() on the key
speaker = s_key.get()
# If speaker doesn't exist, we create a new one
if not speaker:
speaker = Speaker(
key=s_key,
email=email, # e-mail is enough, no name to store
)
# Save the speaker to datastore
speaker.put()
return speaker # return Speaker
def add_speakers(payload):
body = request.get_json()
new_name = body.get("event", None)
new_expertise = body.get("event_date", None)
if body is None:
abort(400)
try:
speaker = Speaker(name=new_name, expertise=new_expertise)
speaker.insert()
return jsonify({"success": True, "created": speaker})
except Exception:
abort(422)
def _createSpeakerObject(self, request):
"""
Creates a Speaker entity in datastore based on the information provided
by client.
Sends a confirmation email after adding the new Speaker
"""
# preload necessary data items
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
if not request.name:
raise endpoints.BadRequestException("Speaker 'name' \
field required")
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
del data['websafeSpeakerKey']
# create Speaker & return (modified) SpeakerForm
speaker_key = Speaker(**data).put()
taskqueue.add(params={
'email': user.email(),
'speakerInfo': repr(request)
},
url='/tasks/send_speaker_confirmation_email')
# Return data as SpeakerForm
speakerform = SpeakerForm()
for field in speakerform.all_fields():
if data.has_key(field.name):
setattr(speakerform, field.name, data[field.name])
# Checks if the field is websafeSpeakerKey, then converts it into
# urlsafe key
elif field.name == "websafeSpeakerKey":
setattr(speakerform, field.name, speaker_key.urlsafe())
speakerform.check_initialized()
return speakerform
def _createSpeakerObject(self, request):
"""Create speaker object"""
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
if not request.name:
raise endpoints.BadRequestException(
"Speaker 'name' field required")
# copy SpeakerForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
s_key = Speaker(**data).put()
return request
def _createSpeakerObject(self, request):
""" Create or update Speaker object, returning SpeakerForm
"""
if not request.name:
raise endpoints.BadRequestException(
"Session 'name' field required")
# copy SpeakerForm/ProtoRPC Message into dict
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
del data['websafeKey']
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
data['key'] = s_key
spkr_key = Speaker(**data).put()
return self._copySpeakerToForm(spkr_key.get())
def __init__(self,
target_size,
vocab_size,
bias,
test_data,
seed,
episodes=1000):
self.data = test_data
self.vocab_size = vocab_size
self.target_size = target_size
self.speaker_bias = 1.0 - bias
self.listener_bias = bias
self.speaker = Speaker(512, self.target_size, self.vocab_size,
self.speaker_bias, seed)
self.listener = Listener(512, self.vocab_size, self.target_size,
self.listener_bias, seed)
self.episode_rewards = []
self.accuracy_history = deque(maxlen=100)
self.symbols_used = {}
self.synonym_array = np.zeros((target_size, vocab_size))
self.accuracy_record = []
self.episodes = 1000
def addSpeaker(self, request):
"""Add speaker"""
# verify user is authed
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# generate unique id for speaker
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
# save into datastore
speaker = Speaker(key=s_key, displayName=request.displayName)
speaker_key = speaker.put()
# get speaker urlsafe string
s_uss = speaker_key.urlsafe()
if not s_uss:
raise endpoints.NotFoundException(
'Unable to get speakerKey from Datastore')
return SpeakerForm(speakerKey=s_uss)
def _doSpeaker(self, request):
"""Get, create or update speaker"""
sp_key = ndb.Key(Speaker, request.displayName)
speaker = sp_key.get()
# if speaker exists, process user-modifyable fields
if speaker:
for field in ('displayName', 'bio'):
if hasattr(request, field):
val = getattr(request, field)
if val:
setattr(speaker, field, str(val))
# if speaker doesn't exist, create new speaker object
else:
speaker = Speaker(key=sp_key,
displayName=request.displayName,
mainEmail=request.mainEmail,
bio=request.bio,
sessionKeys=[])
# put the modified speaker to datastore
speaker.put()
# return SpeakerForm
return self._copySpeakerToForm(speaker)
def _createSpeakerObject(self, request):
"""Create or update a Speaker object"""
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
user_id = getUserId(user)
if not request.name:
raise endpoints.BadRequestException(
"Speaker 'name' field required")
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
s_id = Speaker.allocate_ids(size=1)[0]
s_key = ndb.Key(Speaker, s_id)
data['key'] = s_key
Speaker(**data).put()
return request
def _getKeyForSpeaker(self, request):
"""
This function gets the key for an existing speaker that has been
requested.
"""
if not request.name:
raise endpoints.BadRequestException("Speaker 'name' field \
required")
# creates new key for Speaker
spkr_key = Speaker().key
# for all noted speakers, make a query
notedSpeakersQuery = Speaker.query()
# lists noted speakers
notedSpeakers = []
for ns in notedSpeakersQuery:
notedSpeakers.append(ns.name)
# When no speaker is found with a name, a NotFoundException is raised.
if request.name not in notedSpeakers:
raise endpoints.NotFoundException(
'No speaker found with name: %s' % request.name)
# Otherwise, have its key returned.
else:
spkr_key = Speaker.query(Speaker.name == request.name).get().key
return spkr_key
def _createSpeakerObject(self, request):
"""Create or update Speaker object, returning SpeakerForm/request."""
# preload necessary data items
user = endpoints.get_current_user()
#check if logged in
if not user:
raise endpoints.UnauthorizedException('Authorization required')
#check if the user specified a name
if not request.name:
raise endpoints.BadRequestException(
"Speaker 'name' field required")
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
#delete, doesn't exist in model
del data['websafeKey']
Speaker(**data).put()
return request
def createSpeaker(self, request):
"""Create a new spaeker form with provided speaker name and
organization"""
# make sure user is logged in.
user = endpoints.get_current_user()
if not user:
raise endpoints.UnauthorizedException('Authorization required')
# copy request data into a dictionary.
data = {
field.name: getattr(request, field.name)
for field in request.all_fields()
}
# get a key for the speaker.
speaker_id = Speaker.allocate_ids(size=1)[0]
speaker_key = ndb.Key(Speaker, speaker_id)
data['key'] = speaker_key
new_speaker = Speaker(**data)
new_speaker.put()
return self._copySpeakerToForm(new_speaker)
def _createSpeakerObject(self, request):
speaker = Speaker(name=request.name, mainEmail=request.mainEmail)
speaker.put()
speaker.websafeKey = speaker.key.urlsafe()
speaker.put()
return self._copySpeakerToForm(speaker)
("Your silence will not protect you", "1990-01-02 01:01:01"),
],
},
]
# Delete database file if it exists currently
if os.path.exists('speakers.db'):
os.remove('speakers.db')
if os.path.exists('truths.db'):
os.remove('truths.db')
# Create the database
db.create_all()
# Iterate over the TRUTHS structure and populate the database
for speaker in SPEAKERS:
s = Speaker(name=speaker.get("name"), )
# Add the truths for each person
for truth in speaker.get("truths"):
content, timestamp = truth
s.truths.append(
Truth(
content=content,
timestamp=datetime.strptime(timestamp, "%Y-%m-%d %H:%M:%S"),
))
db.session.add(s)
db.session.commit()
