def get_all_route_table_ids_and_assoc_ids(self, vpc_id, include_main_route=False):
route_table_ids = []
assoc_ids = []
res = self.jclient.vpc.describe_route_tables()
items = utils.get_item(('DescribeRouteTablesResponse', 'routeTableSet', 'item'), res)
if isinstance(items, list):
for item in items:
if item['vpcId']==vpc_id:
if utils.get_item(('associationSet', 'item', 'routeTableAssociationId'), item):
if not include_main_route:
if not utils.get_item(('associationSet', 'item', 'main'), item):
assoc_ids.append(utils.get_item(('associationSet', 'item', 'routeTableAssociationId'), item))
route_table_ids.append(item['routeTableId'])
else:
assoc_ids.append(utils.get_item(('associationSet', 'item', 'routeTableAssociationId'), item))
route_table_ids.append(item['routeTableId'])
else:
route_table_ids.append(item['routeTableId'])
elif isinstance(items, dict):
if items['vpcId'] == vpc_id:
if utils.get_item(('associationSet', 'item', 'routeTableAssociationId'), items):
if not include_main_route:
if not utils.get_item(('associationSet', 'item', 'main'), items):
assoc_ids.append(utils.get_item(('associationSet', 'item', 'routeTableAssociationId'), items))
route_table_ids.append(items['allocationId'])
else:
assoc_ids.append(utils.get_item(('associationSet', 'item', 'routeTableAssociationId'), items))
else:
route_table_ids.append(items['allocationId'])
return (route_table_ids, assoc_ids)
def _assess_submission(self, item):
self._update_course(item)
(submission_id,
user_id) = get_items(item,
['event.submission_uuid', 'context.user_id'])
scores = get_item(item, 'event.parts', type_=list)
points = sum(
get_item(score, 'option.points', type_=int) for score in scores)
max_points = sum(
get_item(score, 'criterion.points_possible', type_=int)
for score in scores)
self.users.assess(submission_id, user_id, points, max_points)
def _problem_check_server(self, item):
self._update_course(item)
(problem_id, user_id,
time) = get_items(item,
['event.problem_id', 'context.user_id', 'time'])
subtasks = get_item(item, 'event.submission', type_=dict)
for (subtask_id, subtask) in subtasks.items():
(question, task_type) = get_items(subtask,
['question', 'response_type'])
correct = get_item(subtask, 'correct', type_=bool)
self.tasks.add_task(problem_id, subtask_id, question, task_type)
self.users.score_task(user_id, problem_id, subtask_id, correct,
time)
def create_route_table(self, vpc_id, logger=None):
resp = self.jclient.vpc.create_route_table(vpc_id=vpc_id)
if utils.get_status_code(resp):
logger and logger.info(resp)
return utils.get_item(('CreateRouteTableResponse', 'routeTable', 'routeTableId'), resp)
else:
logger and logger.error(resp)
def get_all_security_group_ids(self, vpc_id, include_default_group=False):
ids = []
items = None
res = self.jclient.vpc.describe_security_groups()
try:
items = utils.get_item(('DescribeSecurityGroupsResponse',
'securityGroupInfo', 'item'), res)
except KeyError as ex:
pass
if isinstance(items, list):
if include_default_group:
return [
item['groupId'] for item in items
if item.get('vpcId') == vpc_id
]
else:
return [
item['groupId'] for item in items
if item.get('vpcId') == vpc_id
if item.get('groupName') != 'default'
]
elif isinstance(items, dict):
if include_default_group:
if items['vpcId'] == vpc_id:
return [items['groupId']]
else:
if items['vpcId'] == vpc_id and items.get(
'groupName') != 'default':
return [items['groupId']]
return ids
def associate_route_table(self, subnet_id, route_table_id, logger=None):
resp = self.jclient.vpc.associate_route_table(route_table_id=route_table_id, subnet_id=subnet_id)
if utils.get_status_code(resp):
logger and logger.info(resp)
return utils.get_item(('AssociateRouteTableResponse', 'associationId'), resp)
else:
logger and logger.error(resp)
def allocate_address(self, logger=None):
resp = self.jclient.vpc.allocate_address(domain='vpc')
if utils.get_status_code(resp):
logger and logger.info(resp)
return utils.get_item(('AllocateAddressResponse', 'allocationId'), resp)
else:
logger and logger.error(resp)
def create_subnet(self, vpc_id, cidr_block, logger=None):
resp = self.jclient.vpc.create_subnet(vpc_id=vpc_id, cidr_block=cidr_block)
if utils.get_status_code(resp):
logger and logger.info(resp)
return utils.get_item(('CreateSubnetResponse', 'subnet', 'subnetId'), resp)
else:
logger and logger.error(resp)
def create_security_group(self, vpc_id, name, description, logger=None):
resp = self.jclient.vpc.create_security_group(vpc_id=vpc_id, group_name=name, group_description=description)
if utils.get_status_code(resp):
logger and logger.info(resp)
return utils.get_item(('CreateSecurityGroupResponse', 'groupId'), resp)
else:
logger and logger.error(resp)
def create_vpc(self, cidr_block, logger=None):
resp = self.jclient.vpc.create_vpc(cidr_block=cidr_block)
if utils.get_status_code(resp):
logger and logger.info(resp)
return utils.get_item(('CreateVpcResponse', 'vpc', 'vpcId'), resp)
else:
logger and logger.error(resp)
def associate_address(self, address_allocation_id, instance_id, logger=None):
resp = self.jclient.vpc.associate_address(allocation_id=address_allocation_id, instance_id=instance_id)
if utils.get_status_code(resp):
logger and logger.info(resp)
return utils.get_item(('AssociateAddressResponse', 'associationId'), resp)
else:
logger and logger.error(resp)
def test_getitem(self):
self.assertEqual(t.get_item(self.DATA, 'aa'), '1')
self.assertEqual(t.get_item(self.DATA, 'aa', type_=int), 1)
self.assertEqual(t.get_item(self.DATA, 'bb'), '1')
self.assertEqual(t.get_item(self.DATA, 'cc', type_=list), [1])
self.assertEqual(t.get_item(self.DATA, 'dd.aa'), '2')
self.assertEqual(t.get_item(self.DATA, 'dd.bb.cc.dd'), '3')
self.assertEqual(t.get_item(self.DATA, 'dd.cc'), '')
self.assertEqual(t.get_item(self.DATA, 'dd.cc', type_=int), 0)
def training_step(self, batch, batch_idx, optimizer_idx):
images = batch
# gp
apply_gp = self.iterations % self.gp_every == 0
# train discriminator
if optimizer_idx == 0:
images = images.requires_grad_()
# increase resolution
if self.iterations % self.add_layers_iters == 0:
if self.iterations != 0:
self.D.increase_resolution_()
image_size = self.D.resolution.item()
self.G.set_image_size(image_size)
self.image_dataset.set_transforms(image_size)
real_out = self.D(images)
fake_images = self.generate_samples(self.batch_size)
fake_out = self.D(fake_images.clone().detach())
divergence = (F.relu(1 + real_out) + F.relu(1 - fake_out)).mean()
loss_D = divergence
if apply_gp:
gp = gradient_penalty(images, real_out)
self.last_loss_gp = get_item(gp)
loss = loss_D + gp
else:
loss = loss_D
self.last_loss_D = loss_D
tqdm_dict = {'loss_D': loss_D}
output = OrderedDict({
'loss': loss,
'progress_bar': tqdm_dict,
'log': tqdm_dict
})
return output
# train generator
if optimizer_idx == 1:
fake_images = self.generate_samples(self.batch_size)
loss_G = self.D(fake_images).mean()
self.last_loss_G = loss_G
tqdm_dict = {'loss_G': loss_G}
output = OrderedDict({
'loss': loss_G,
'progress_bar': tqdm_dict,
'log': tqdm_dict
})
return output
def delete_item_page(item_id):
'''
The delete item page
'''
db.connect()
item, _ = get_item(db.session, item_id)
db.disconnect()
return render_template('page-item-delete.html', item=item)
def get_all_route_table_ids_and_assoc_ids(self,
vpc_id,
include_main_route=False):
route_table_ids = []
assoc_ids = []
res = self.jclient.vpc.describe_route_tables()
items = utils.get_item(
('DescribeRouteTablesResponse', 'routeTableSet', 'item'), res)
if isinstance(items, list):
for item in items:
if item['vpcId'] == vpc_id:
if utils.get_item(
('associationSet', 'item', 'routeTableAssociationId'),
item):
if not include_main_route:
if not utils.get_item(
('associationSet', 'item', 'main'), item):
assoc_ids.append(
utils.get_item(('associationSet', 'item',
'routeTableAssociationId'),
item))
route_table_ids.append(item['routeTableId'])
else:
assoc_ids.append(
utils.get_item(('associationSet', 'item',
'routeTableAssociationId'),
item))
route_table_ids.append(item['routeTableId'])
else:
route_table_ids.append(item['routeTableId'])
elif isinstance(items, dict):
if items['vpcId'] == vpc_id:
if utils.get_item(
('associationSet', 'item', 'routeTableAssociationId'),
items):
if not include_main_route:
if not utils.get_item(
('associationSet', 'item', 'main'), items):
assoc_ids.append(
utils.get_item(('associationSet', 'item',
'routeTableAssociationId'),
items))
route_table_ids.append(items['allocationId'])
else:
assoc_ids.append(
utils.get_item(('associationSet', 'item',
'routeTableAssociationId'), items))
else:
route_table_ids.append(items['allocationId'])
return (route_table_ids, assoc_ids)
def associate_route_table(self, subnet_id, route_table_id, logger=None):
resp = self.jclient.vpc.associate_route_table(
route_table_id=route_table_id, subnet_id=subnet_id)
if utils.get_status_code(resp):
logger and logger.info(resp)
return utils.get_item(
('AssociateRouteTableResponse', 'associationId'), resp)
else:
logger and logger.error(resp)
def create_route_table(self, vpc_id, logger=None):
resp = self.jclient.vpc.create_route_table(vpc_id=vpc_id)
if utils.get_status_code(resp):
logger and logger.info(resp)
return utils.get_item(
('CreateRouteTableResponse', 'routeTable', 'routeTableId'),
resp)
else:
logger and logger.error(resp)
def run_instances(image_id, instance_type_id, subnet_id, key_name=None, timeout=300, logger=None):
resp = self.jclient.compute.run_instances(image_id=image_id, instance_type_id=instance_type_id, subnet_id=subnet_id, key_name=key_name)
if self.get_status_code(resp):
logger and logger.info(resp)
instance_id = utils.get_item(('RunInstancesResponse', 'instancesSet', 'item', 'instanceId'), res)
self.check_instance_state(instance_id, timeout=timeout, logger=logger)
return instance_id
else:
logger and logger.error(resp)
def create_subnet(self, vpc_id, cidr_block, logger=None):
resp = self.jclient.vpc.create_subnet(vpc_id=vpc_id,
cidr_block=cidr_block)
if utils.get_status_code(resp):
logger and logger.info(resp)
return utils.get_item(
('CreateSubnetResponse', 'subnet', 'subnetId'), resp)
else:
logger and logger.error(resp)
def item_page(item_id):
'''
The item detail page
'''
db.connect()
item, item_categories = get_item(db.session, item_id)
db.disconnect()
return render_template('page-item.html',
item_categories=item_categories,
item=item)
def check_instance_state(self, instance_id, timeout=300, logger=None):
start_time = time.time()
while True:
resp = self.jclient.compute.describe_instances(instance_ids=instance_id)
state = utils.get_item(('DescribeInstancesResponse', 'instancesSet', 'item', 'instanceState', 'name'), resp)
if state in ['running']:
logger and logger.info(resp)
return
if (time.time() - start_time) >= timeout:
logger and logger.error(resp)
return
def get_all_subnet_ids(self, vpc_id):
ids = []
items = None
res = self.jclient.vpc.describe_subnets()
items = utils.get_item(('DescribeSubnetsResponse', 'subnetSet', 'item'), res)
if isinstance(items, list):
return [item['subnetId'] for item in items if item.get('vpcId')==vpc_id]
elif isinstance(items, dict):
if items['vpcId'] == vpc_id:
return [items['subnetId']]
return ids
def get_all_instance_ids(self, vpc_id):
ids = []
items = None
res = self.jclient.compute.describe_instances()
items = utils.get_item(('DescribeInstancesResponse', 'instancesSet', 'item'), res)
if isinstance(items, list):
return [item['instanceId'] for item in items if item.get('vpcId') == vpc_id]
elif isinstance(items, dict):
if items['vpcId'] == vpc_id:
return [items['instanceId']]
return ids
def get_all_vpc_ids(self, logger=None):
ids = []
items = None
res = self.jclient.vpc.describe_vpcs()
items = utils.get_item(('DescribeVpcsResponse', 'vpcSet', 'item'), res)
logger and logger.info(items)
if isinstance(items, list):
return [item['vpcId'] for item in items]
elif isinstance(items, dict):
return [items['vpcId']]
return ids
def item_json(item_id):
'''
JSON endpoint for retrieving an item's details
'''
db.connect()
item, item_categories = get_item(db.session, item_id)
db.disconnect()
return jsonify({
'item_categories': [x.serialize() for x in item_categories],
'item': item.serialize()
})
def update_item_page(item_id):
'''
The update item page
'''
db.connect()
item, categories = get_item(db.session, item_id)
item_category_ids = [x.id for x in categories]
item_categories = get_item_categories(db.session)
db.disconnect()
return render_template('page-item-update.html',
item=item,
item_category_ids=item_category_ids,
item_categories=item_categories)
def get_all_vpc_ids(self):
ids = []
items = None
res = self.jclient.vpc.describe_vpcs()
try:
items = utils.get_item(('DescribeVpcsResponse', 'vpcSet', 'item'), res)
except KeyError as ex:
pass
if isinstance(items, list):
return [item['vpcId'] for item in items]
elif isinstance(items, dict):
return [items['vpcId']]
return ids
def get_all_address_alloc_and_assoc_ids(self):
alloc_ids = []
assoc_ids = []
res = self.jclient.vpc.describe_addresses()
items = utils.get_item(('DescribeAddressesResponse', 'addressesSet', 'item'), res)
if isinstance(items, list):
alloc_ids = [item['allocationId'] for item in items if item.get('allocationId')]
assoc_ids = [item['associationId'] for item in items if item.get('associationId')]
elif isinstance(items, dict):
alloc_ids = [items.get('allocationId') and items['allocationId']]
if items.get('associationId'):
assoc_ids = [items['associationId']]
return (alloc_ids, assoc_ids)
def get_all_address_ids(self):
ids = []
items = None
res = self.jclient.vpc.describe_addresses()
try:
items = utils.get_item(('DescribeAddressesResponse', 'addressesSet', 'item'), res)
except KeyError as ex:
pass
if isinstance(items, list):
return [item['allocationId'] for item in items]
elif isinstance(items, dict):
return [items['allocationId']]
return ids
def compute(shift):
before_after = pandas.DataFrame()
for key in list(itertools.product(utils.get_projects(), utils.get_class_models(), utils.get_experiments(), ['ideal'], utils.get_smote(), utils.get_approaches(), utils.get_classifiers())):
data = utils.get_item(key, 'data')
before_after_local = compute_before_after_series(data, shift)
before_after_local['project'] = key[0]
before_after_local['approach'] = key[5]
before_after = before_after.append(before_after_local, sort=False)
utils.boxplot_approaches(before_after, 'before_after_fix_' + str(shift), 'difference', '', True, [-1, 1])
def check_instance_state(self, instance_id, timeout=300, logger=None):
start_time = time.time()
while True:
resp = self.jclient.compute.describe_instances(
instance_ids=instance_id)
state = utils.get_item(
('DescribeInstancesResponse', 'instancesSet', 'item',
'instanceState', 'name'), resp)
if state in ['running']:
logger and logger.info(resp)
return
if (time.time() - start_time) >= timeout:
logger and logger.error(resp)
return
def related(result_id):
related_news = []
related_tweets = []
wiki_article = dict()
news_articles = []
form = SearchForm();
global initial_query
initial_search_term = initial_query
nearby_tweets = False;
if 'near' in request.args:
if request.args['near'] == "true":
nearby_tweets = True;
wiki_article_solr = get_item(wiki, result_id)
if wiki_article_solr:
wiki_article = wiki_article_solr
query_terms = []
twitter_query = "";
keywords = wiki_article.get('keywords',[])
if not application.config.get('INDEX_KEYWORD_GENERATION'):
keywords = extract_keywords(wiki_article['wiki_body'][0].encode('utf-8')).get('keywords')
keywords.append(wiki_article["title"][0]);
print "keywords : " + str(keywords);
query_term = ""
#since we are favoring precision over recall
if len(keywords) > 1:
for t in keywords:
query_terms += t.split()
query_term = "+".join(query_terms)
query_term = "title:"+wiki_article["title"][0]+"^3 news_body:"+query_term;
news_articles = search(news, query_term)
# twitter_query = " OR ".join(query_terms)
twitter_query = wiki_article["title"][0];
related_tweets = search_twitter(twitter_query, nearby_tweets) ;
print "tweets :" + str(related_tweets);
if news_articles:
news_articles = news_articles[0]
#TODO: remove the list comprehension, it was just for design purposes
related_news = [news_article for news_article in news_articles if news_article.get('news_body')]
return render_template('related.html',**locals());
def get_all_vpc_ids(self):
ids = []
items = None
res = self.jclient.vpc.describe_vpcs()
try:
items = utils.get_item(('DescribeVpcsResponse', 'vpcSet', 'item'),
res)
except KeyError as ex:
pass
if isinstance(items, list):
return [item['vpcId'] for item in items]
elif isinstance(items, dict):
return [items['vpcId']]
return ids
def get_all_instance_ids(self, vpc_id):
ids = []
items = None
res = self.jclient.compute.describe_instances()
try:
items = utils.get_item(('DescribeInstancesResponse', 'instancesSet', 'item'), res)
except (KeyError, AttributeError) as ex:
pass
if isinstance(items, list):
return [item['instanceId'] for item in items if item.get('vpcId') == vpc_id]
elif isinstance(items, dict):
if items['vpcId'] == vpc_id:
return [items['instanceId']]
return ids
def get_all_subnet_ids(self, vpc_id):
ids = []
items = None
res = self.jclient.vpc.describe_subnets()
items = utils.get_item(
('DescribeSubnetsResponse', 'subnetSet', 'item'), res)
if isinstance(items, list):
return [
item['subnetId'] for item in items
if item.get('vpcId') == vpc_id
]
elif isinstance(items, dict):
if items['vpcId'] == vpc_id:
return [items['subnetId']]
return ids
def get_all_security_group_ids(self, vpc_id, include_default_group=False):
ids = []
items = None
res = self.jclient.vpc.describe_security_groups()
items = utils.get_item(('DescribeSecurityGroupsResponse', 'securityGroupInfo', 'item'), res)
if isinstance(items, list):
if include_default_group:
return [item['groupId'] for item in items if item.get('vpcId') == vpc_id]
else:
return [item['groupId'] for item in items if item.get('vpcId') == vpc_id if item.get('groupName') != 'default']
elif isinstance(items, dict):
if include_default_group:
if items['vpcId'] == vpc_id:
return [items['groupId']]
else:
if items['vpcId'] == vpc_id and items.get('groupName') != 'default':
return [items['groupId']]
return ids
def update_vpc_resource_quota(self, resource, quota, account_id=None):
params = {}
params['Version'] = self.version
params['Action'] = 'UpdateQuota'
params['resource'] = resource
params['quota'] = quota
if account_id is not None:
params['account'] = 'acc-'+account_id
resp = requestify.make_request(self.url, self.verb,
self.headers, params)
if resp is not None:
try:
resp_dict = json.loads(resp.content)
except:
resp_dict = xmltodict.parse(resp.content)
resp_json = json.dumps(resp_dict, indent=4, sort_keys=True)
resp_dict = json.loads(resp_json)
return utils.get_item(('UpdateQuotaResponse', 'quota-update'),
resp_dict)
def get(self,**kwargs):
result_id = kwargs.get('wiki_id')
related_news = []
related_tweets = []
wiki_article = dict()
news_articles = []
nearby = False;
wiki_article_solr = get_item(wiki, result_id)
if wiki_article_solr:
wiki_article = wiki_article_solr
query_terms = []
twitter_query = "";
keywords = wiki_article.get('keywords',[])
#TODO: For large documents, get keywords for random parts of the document only, to keep the kw list short enough
# try:
# keywords = get_keywords(wiki_article['wiki_body'][0])
# except:
# keywords = get_keywords(wiki_article['wiki_body'][0].decode())
# logger.info(keywords)
# if not application.config.get('INDEX_KEYWORD_GENERATION'):
# keywords = extract_keywords(wiki_article['wiki_body'][0].encode('utf-8')).get('keywords')
# logger.info(keywords)
twitter_query = wiki_article["title"][0];
#since we are favoring precision over recall
query_terms = ["\""+t+"\"" for t in keywords]
query_terms = wiki_article['title'][0].split()
query_term = "+".join(query_terms)
if query_term:
news_articles = search(news, query_term, defType="edismax", mm='2<-25%25' , ps=3,
qf="title^20.0+keywords^20.0+body^2.0", pf="title^20.0+keywords^20.0+body^20.0")[0]
related_tweets = search_twitter(twitter_query, nearby) ;
related_tweets = [html_parser.unescape(tweet) for tweet in related_tweets]
return dict(related_news=news_articles[:3], wiki_article=wiki_article, related_tweets=related_tweets), 200
def run_instances(image_id,
instance_type_id,
subnet_id,
key_name=None,
timeout=300,
logger=None):
resp = self.jclient.compute.run_instances(
image_id=image_id,
instance_type_id=instance_type_id,
subnet_id=subnet_id,
key_name=key_name)
if self.get_status_code(resp):
logger and logger.info(resp)
instance_id = utils.get_item(
('RunInstancesResponse', 'instancesSet', 'item', 'instanceId'),
res)
self.check_instance_state(instance_id,
timeout=timeout,
logger=logger)
return instance_id
else:
logger and logger.error(resp)
def find_item(hunt_id, item_id):
logger.info('Participant is visiting route: /hunts/%s/items/%s', hunt_id,
item_id)
admin_settings = get_settings(g.db, hunt_id=hunt_id)
# admin_settings found through hunt_id means hunt exists
logger.info("Settings retrieved for hunt with id, %s", hunt_id)
if finished_setting(admin_settings):
logger.info(
"Settings are complete. Preparing to retrieve item with id, %s",
item_id)
item = get_item(g.db, item_id, hunt_id)
if item:
logger.info("Item found. Preparing to retrieve hunt with id, %s ",
hunt_id)
hunt = Hunt.find_by_id(g.db, hunt_id)
if participant_registered(g.db, session.get('email'), hunt_id):
logger.info(
"Participant, %s, has registered. Preparing to"
" retrieve data from the state api.", session.get('email'))
lrs = WaxCommunicator(admin_settings,
request.host_url,
hunt,
item,
scavenger_info={
'email': session.get('email'),
'name': session.get('name')
})
state = lrs.get_state()
found_again = str(item_id) in state
lrs.send_found_item_statement(found_again=found_again)
updated_state = {str(item.item_id): True}
hunt_previously_completed = state.get('hunt_completed')
# TODO: Don't send the whole state object, as discussed
state.update(updated_state)
if hunt_requirements_completed(state, hunt):
logger.info(
'Requirements for hunt, "%s", have been completed.',
hunt.name)
if not hunt_previously_completed:
lrs.send_completed_hunt_statement()
updated_state['hunt_completed'] = True
state.update(updated_state)
lrs.update_state_api_doc(updated_state)
found_ids = found_ids_list(state)
return make_response(
render_template(
'items.html',
item=item,
hunt=hunt,
username=session.get('name'),
found_ids=found_ids,
hunt_now_completed=state.get('hunt_completed'),
num_found=len(found_ids),
num_items=len(hunt.items),
num_remaining=num_items_remaining(state, hunt.items),
found_again=found_again,
previously_completed=hunt_previously_completed))
else:
logger.info(
"Page visitor is not yet registered for this hunt."
" Preparing to redirect to the getting started page.")
session['intended_url'] = '/hunts/{}/items/{}'.format(
hunt_id, item_id)
return make_response(
render_template(
'welcome.html',
hunt=hunt,
welcome=hunt.welcome_message,
action_url="/get_started/hunts/{}".format(hunt_id)))
abort(404)
def reuters_news_page(page_id):
news_item = get_item(news, page_id)
return render_template('reuters.html', **locals())
def create_security_group(self, vpc_id, name, description):
res = self.jclient.vpc.create_security_group(vpc_id=vpc_id, group_name=name, group_description=description)
group_id = utils.get_item(('CreateSecurityGroupResponse', 'groupId'), res)
return group_id
def create_subnet(self, vpc_id, cidr_block):
res = self.jclient.vpc.create_subnet(vpc_id=vpc_id, cidr_block=cidr_block)
subnet_id = utils.get_item(('CreateSubnetResponse', 'subnet', 'subnetId'), res)
return subnet_id
def _play_video(self, item):
self._update_course(item)
user_id = get_item(item, 'context.user_id')
video_id = get_item(json.loads(get_item(item, 'event')), 'id')
self.users.view_content(user_id, video_id)
def _load_video(self, item):
self._update_course(item)
video_id = get_item(json.loads(get_item(item, 'event')), 'id')
page = get_item(item, 'page')
self.content.add_content('video', video_id)
self.modules.add_content(page, video_id)
def run_instances(image_id, instance_type_id, subnet_id, key_name):
res = self.jclient.compute.run_instances(image_id=image_id, instance_type_id=instance_type_id, subnet_id=subnet_id, key_name=key_name)
instance_id = utils.get_item(('RunInstancesResponse', 'instancesSet', 'item', 'instanceId'), res)
return instance_id
def create_vpc(self, cidr_block):
res = self.jclient.vpc.create_vpc(cidr_block=cidr_block)
vpc_id = utils.get_item(('CreateVpcResponse', 'vpc', 'vpcId'), res)
return vpc_id
def find_item(hunt_id, item_id):
logger.info(
'Participant is visiting route: /hunts/%s/items/%s', hunt_id, item_id)
admin_settings = get_settings(g.db, hunt_id=hunt_id)
# admin_settings found through hunt_id means hunt exists
logger.info("Settings retrieved for hunt with id, %s", hunt_id)
if finished_setting(admin_settings):
logger.info(
"Settings are complete. Preparing to retrieve item with id, %s",
item_id)
item = get_item(g.db, item_id, hunt_id)
if item:
logger.info(
"Item found. Preparing to retrieve hunt with id, %s ", hunt_id)
hunt = Hunt.find_by_id(g.db, hunt_id)
if participant_registered(g.db, session.get('email'), hunt_id):
logger.info(
"Participant, %s, has registered. Preparing to"
" retrieve data from the state api.", session.get('email'))
lrs = WaxCommunicator(
admin_settings, request.host_url, hunt, item,
scavenger_info={
'email': session.get('email'),
'name': session.get('name')
})
state = lrs.get_state()
found_again = str(item_id) in state
lrs.send_found_item_statement(found_again=found_again)
updated_state = {str(item.item_id): True}
hunt_previously_completed = state.get('hunt_completed')
# TODO: Don't send the whole state object, as discussed
state.update(updated_state)
if hunt_requirements_completed(state, hunt):
logger.info(
'Requirements for hunt, "%s", have been completed.',
hunt.name)
if not hunt_previously_completed:
lrs.send_completed_hunt_statement()
updated_state['hunt_completed'] = True
state.update(updated_state)
lrs.update_state_api_doc(updated_state)
found_ids = found_ids_list(state)
return make_response(render_template(
'items.html', item=item, hunt=hunt,
username=session.get('name'), found_ids=found_ids,
hunt_now_completed=state.get('hunt_completed'),
num_found=len(found_ids), num_items=len(hunt.items),
num_remaining=num_items_remaining(state, hunt.items),
found_again=found_again,
previously_completed=hunt_previously_completed))
else:
logger.info(
"Page visitor is not yet registered for this hunt."
" Preparing to redirect to the getting started page.")
session['intended_url'] = '/hunts/{}/items/{}'.format(
hunt_id, item_id)
return make_response(render_template(
'welcome.html', hunt=hunt, welcome=hunt.welcome_message,
action_url="/get_started/hunts/{}".format(hunt_id)))
abort(404)