def __reorder_edges(l, item):
if not l:
return []
for elem in l:
if elem[0] == item[-1]:
return [elem] + __reorder_edges(utils.remove_from_list(l, elem), elem)
elif elem[-1] == item[-1]:
return [elem[::-1]] + __reorder_edges(utils.remove_from_list(l, elem), elem[::-1])
return []
def __reorder_edges(l, item):
if not l:
return []
for elem in l:
if elem[0] == item[-1]:
return [elem] + __reorder_edges(utils.remove_from_list(l, elem),
elem)
elif elem[-1] == item[-1]:
return [elem[::-1]] + __reorder_edges(
utils.remove_from_list(l, elem), elem[::-1])
return []
def collide(self, other_obj, moved_center=(None, None), from_container_obj=False):
''' Collision handler for any type of obj'''
# todo: handle game_class=="all"
# todo: point class
if not hasattr(other_obj, "__class__"):
raise AttributeError(
"other_obj must be a class or instance")
# Handle instances
if isinstance(other_obj, Circle):
return self.collide_circle(other_obj, moved_center, from_container_obj)
elif isinstance(other_obj, sprite_types.Rect):
return self.collide_rect(other_obj, moved_center, from_container_obj)
elif isinstance(other_obj, sprite_types.Img):
return self.collide_img(other_obj, moved_center, from_container_obj)
else:
pass
# Handle classes
if inspect.isclass(other_obj):
if issubclass(other_obj, Circle):
return self.collide_list_circle(other_obj.list_instance, moved_center, from_container_obj)
elif issubclass(other_obj, sprite_types.Rect):
return self.collide_list_rect(other_obj.list_instance, moved_center, from_container_obj)
elif issubclass(other_obj, sprite_types.Img):
return self.collide_list_img(other_obj.list_instance, moved_center, from_container_obj)
else:
pass
# Handle fun_Game and fun_Class or their instances
if isinstance(other_obj, base.fun_Game) or (inspect.isclass(other_obj) and issubclass(other_obj, base.fun_Game)):
def instance_collide(other_obj):
return self.collide(other_obj.sprite, moved_center, from_container_obj=True)
to_return = other_obj.for_all_instance(
instance_collide, flatten="level-class")
remove_from_list(to_return, self.container_obj)
remove_from_list(to_return, None, recursive=True)
remove_from_list(to_return, False, recursive=True)
return to_return
if inspect.isclass(other_obj) and issubclass(other_obj, base.fun_Class):
def instance_collide(other_obj):
return self.collide(other_obj.sprite, moved_center, from_container_obj=True)
to_return = other_obj.for_all_instance(
instance_collide, flatten=False)
remove_from_list(to_return, self.container_obj)
remove_from_list(to_return, None, recursive=True)
remove_from_list(to_return, False, recursive=True)
return to_return
if isinstance(other_obj, base.fun_Class):
other_obj_sprite = other_obj.sprite
to_return = self.collide(
other_obj_sprite, moved_center, from_container_obj=True)
# doesnt return list, so prev. case operations not done
return to_return
def run(self):
parser = etree.HTMLParser()
tree = etree.parse(StringIO(self.content), parser)
#job title
title = tree.xpath('//td[@class=\'sr_bt\']/text()')
for t in title:
print "job title: %s" % t
self.extract_content += "%s\n" % t
#job detail
detail = tree.xpath('//td[contains(@class, \'txt_4 wordBreakNormal job_detail\')]/div/text()')
print "job detail: "
job_detail = ""
for d in detail:
print d
job_detail += "%s\t" % d
self.extract_content += "%s\n" % job_detail
#welfare
welfare = tree.xpath('//span[contains(@class, \'Welfare_label\')]/text()')
#print "job welfare %s " % welfare
print "job welfare :"
welfare_info = ""
for w in welfare:
print w
welfare_info += "%s\t" % w
self.extract_content += "%s\n" % welfare_info
#l = tree.xpath('//table[contains(@class, \'jobs_1\')]')
txt1 = tree.xpath('//table[contains(@class, \'jobs_1\')]/tr/td[contains(@class, \'txt_1\')]')
txt2 = tree.xpath('//table[contains(@class, \'jobs_1\')]/tr/td[contains(@class, \'txt_2\')]')
#txt1_tag = ['发布日期：', '工作地点：', '招聘人数：', '工作年限：', '薪水范围：' ]
txt1_tag = ['发布日期：', '工作地点：', '薪水范围：' ]
print "job info:"
job_info = ''
for i, e in enumerate(txt1):
if len(e.text.lstrip()) == 0:
break
if txt1[i].text == '发布日期：':
job_info += "%s\t" % txt2[i].text
if txt1[i].text == '工作地点：':
job_info += "%s\t" % txt2[i].text
if txt1[i].text == '薪水范围：':
job_info += "%s\t" % txt2[i].text
print job_info
self.extract_content += "%s\n" % job_info
#company introduction
l = tree.xpath('//div[contains(@class, \'jobs_txt\')]/p')
print "company introduction:"
company_intro = ""
for i in l:
if not i.text is None:
print i.text
company_intro += "%s\t" % i.text
self.extract_content += "%s\n" % company_intro
#company name
print 'company name'
company_name = ""
l = tree.xpath('//td[@class=\'sr_bt\']')
for i in l:
tr = l[0].getparent()
iters = tr.itersiblings();
for it in iters:
a_list = it.xpath('//td/table/tr/td/a')
for i in a_list:
if not i.text is None:
print i.text
company_name = i.text
break
break
self.extract_content += "%s\n" % company_name
#company info
company_info = ""
l = tree.xpath('//td/strong')
txt1_tag = ['公司行业：', '公司性质：', '公司规模：' ]
remove_from_list(l, txt1_tag)
#print l
for i in l:
td = i.getparent()
iters = td.itertext()
index = 0
for it in iters:
it = it.lstrip()
#if it in txt1_tag:
print "[%s]" % it
company_info += "%s\t" % it
index += 1
break
self.extract_content += "%s\n" % company_info
def run(self):
self.slotsStartWatch.start()
self.slotsEndWatch.start()
while not self.stopped_thread():
self.check_timeouts()
new_timeout = self.get_next_timeout()
readable, writable, exceptional = select.select(
self.inputs, [], self.inputs, new_timeout)
for s in readable:
if s is self.sock_tcp:
(connection, address) = self.sock_tcp.accept()
connection.setblocking(False)
self.logger.info('TCP CON (%s, %d)' %
(address[0], address[1]))
self.inputs.append(connection)
else:
buffer = utils.read_data_from_socket(s)
if buffer:
self.logger.debug(
'Req_data = %s\t client = (%s, %d)' %
(buffer, s.getpeername()[0], s.getpeername()[1]))
action, data = utils.segment_packet(buffer)
if action == utils.GATEWAY_NODES_FLASH:
image_name = self.get_image_name(s)
result = []
for node in data[db_utils.NODES]:
if node['status'] == utils.FLASHED:
gateway_id = self.dbConnector.find_gateway_by_addr(
s.getpeername())
node_uid = self.dbConnector.get_node_uid_by_gateway_id_and_node_id(
gateway_id, node['node_id'])
self.dbConnector.node_update_flash_info(
node_uid, 'FINISHED', image_name)
_node = {
'_id': node_uid,
'status': node['status']
}
else: # node['status'] = utils.ERROR
gateway_id = self.dbConnector.find_gateway_by_addr(
s.getpeername())
node_uid = self.dbConnector.get_node_uid_by_gateway_id_and_node_id(
gateway_id, node['node_id'])
_node = {
'_id': node_uid,
'status': node['status']
}
result.append(_node)
self.handle_gateway_request(s, result)
self.inputs.remove(s)
s.close()
elif action == utils.GATEWAY_NODES_ERASE:
result = []
for node in data[db_utils.NODES]:
if node['status'] == utils.ERASED:
gateway_id = self.dbConnector.find_gateway_by_addr(
s.getpeername())
node_uid = self.dbConnector.get_node_uid_by_gateway_id_and_node_id(
gateway_id, node['node_id'])
self.dbConnector.node_update_flash_info(
node_uid, 'NOT_STARTED', None)
_node = {
'_id': node_uid,
'status': node['status']
}
else: # node['status'] = utils.ERROR
gateway_id = self.dbConnector.find_gateway_by_addr(
s.getpeername())
node_uid = self.dbConnector.get_node_uid_by_gateway_id_and_node_id(
gateway_id, node['node_id'])
_node = {
'_id': node_uid,
'status': node['status']
}
result.append(_node)
self.handle_gateway_request(s, result)
self.inputs.remove(s)
s.close()
elif action == utils.GATEWAY_NODES_RESET:
result = []
for node in data[db_utils.NODES]:
gateway_id = self.dbConnector.find_gateway_by_addr(
s.getpeername())
node_uid = self.dbConnector.get_node_uid_by_gateway_id_and_node_id(
gateway_id, node['node_id'])
_node = {
'_id': node_uid,
'status': node['status']
}
result.append(_node)
self.handle_gateway_request(s, result)
self.inputs.remove(s)
s.close()
elif action == utils.IMAGES_GET: # { token }
token = data[db_utils.TOKEN]
decoded_token = utils.decode_auth_token(token)
if not decoded_token:
utils.send_invalid_token_error(s)
else:
nodetypes_images = utils.get_nodetypes_images(
decoded_token[db_utils.USER])
pck = utils.create_response_packet(
json.dumps({
'data': nodetypes_images,
'status': 200
}).encode())
# OnSuccess: { data, status: 200 }
s.sendall(pck)
elif action == utils.IMAGE_SAVE: # { token, image_name, image_data, nodetype_id }
token = data[db_utils.TOKEN]
decoded_token = utils.decode_auth_token(token)
if not decoded_token:
utils.send_invalid_token_error(s)
else:
utils.save_image(decoded_token[db_utils.USER],
data[db_utils.NODETYPE_ID],
data[db_utils.IMAGE_NAME],
data[db_utils.IMAGE_DATA])
pck = utils.create_response_packet(
json.dumps({
'status': 200
}).encode())
# OnSuccess: { status: 200 }
s.sendall(pck)
elif action == utils.IMAGE_DELETE: # { token, image_name }
token = data[db_utils.TOKEN]
decoded_token = utils.decode_auth_token(token)
if not decoded_token:
utils.send_invalid_token_error(s)
else:
nodetype_id = utils.get_nodetype_by_user_and_image_name(
decoded_token[db_utils.USER],
data[db_utils.IMAGE_NAME])
res = utils.delete_image(
decoded_token[db_utils.USER],
data[db_utils.IMAGE_NAME], nodetype_id)
pck = utils.create_response_packet(
json.dumps(res).encode())
# OnSuccess: { status: 204 }
# OnError : { status: 404 }
s.sendall(pck)
elif action == utils.NODES_GET: # { token }
token = data[db_utils.TOKEN]
decoded_token = utils.decode_auth_token(token)
if not decoded_token:
utils.send_invalid_token_error(s)
else:
nodes = self.dbConnector.get_nodes()
pck = utils.create_response_packet(
json.dumps({
'nodes': nodes,
'status': 200
}).encode())
# OnSuccess: { nodes, status: 200 }
s.sendall(pck)
elif action == utils.NODES_FLASH: # { token, slot_id, image_name, node_uids}
token = data[db_utils.TOKEN]
slot_id = data[db_utils.TIMESLOT_ID]
decoded_token = utils.decode_auth_token(token)
if not decoded_token:
utils.send_invalid_token_error(s)
elif not self.dbConnector.get_slot_by_id(slot_id):
utils.send_invalid_slot_error(s)
else:
gateway_socks = self.send_flash_request(
decoded_token[db_utils.USER],
data[db_utils.IMAGE_NAME],
data[db_utils.NODE_UIDS])
self.inputs.extend(gateway_socks)
self.gateway_sockets.append(gateway_socks)
self.gateway_sockets_info.append({
'web_socket':
s,
'data': [],
db_utils.IMAGE_NAME:
data[db_utils.IMAGE_NAME]
})
elif action == utils.NODES_ERASE: # { token, slot_id, node_uids }
token = data[db_utils.TOKEN]
slot_id = data[db_utils.TIMESLOT_ID]
decoded_token = utils.decode_auth_token(token)
if not decoded_token:
utils.send_invalid_token_error(s)
elif not self.dbConnector.get_slot_by_id(slot_id):
utils.send_invalid_slot_error(s)
else:
gateway_socks = self.send_erase_request(
data[db_utils.NODE_UIDS])
self.inputs.extend(gateway_socks)
self.gateway_sockets.append(gateway_socks)
self.gateway_sockets_info.append({
'web_socket':
s,
'data': [],
db_utils.IMAGE_NAME:
''
})
elif action == utils.NODES_RESET: # { token, slot_id, node_uids }
token = data[db_utils.TOKEN]
slot_id = data[db_utils.TIMESLOT_ID]
decoded_token = utils.decode_auth_token(token)
if not decoded_token:
utils.send_invalid_token_error(s)
elif not self.dbConnector.get_slot_by_id(slot_id):
utils.send_invalid_slot_error(s)
else:
gateway_socks = self.send_reset_request(
data[db_utils.NODE_UIDS])
self.inputs.extend(gateway_socks)
self.gateway_sockets.append(gateway_socks)
self.gateway_sockets_info.append({
'web_socket':
s,
'data': [],
db_utils.IMAGE_NAME:
''
})
elif action == utils.TIMESLOTS_SAVE: # { token, slots: [{start, end}] }
token = data[db_utils.TOKEN]
decoded_token = utils.decode_auth_token(token)
if not decoded_token:
utils.send_invalid_token_error(s)
else:
slots = db_utils.convert_isoformat_to_datetime(
data[db_utils.SLOTS])
slots_saved = self.dbConnector.save_timeslots(
decoded_token[db_utils.USER], slots)
slots = db_utils.convert_datetime_to_isoformat(
slots_saved)
pck = utils.create_response_packet(
json.dumps({
'slots': slots,
'status': 200
}).encode())
# OnSuccess: { slots: [{start, end}], status: 200 }
s.sendall(pck)
elif action == utils.TIMESLOTS_GET_DAYSLOTS: # { token, date }
token = data[db_utils.TOKEN]
decoded_token = utils.decode_auth_token(token)
if not decoded_token:
utils.send_invalid_token_error(s)
else:
slots_day = self.dbConnector.get_day_slots(
data[db_utils.DATE])
slots = db_utils.convert_datetime_to_isoformat(
slots_day)
pck = utils.create_response_packet(
json.dumps({
'slots': slots,
'status': 200
}).encode())
# OnSuccess: { slots: [{start, end, user_id}], status: 200 }
s.sendall(pck)
elif action == utils.TIMESLOTS_GET_USERSLOTS: # { token }
token = data[db_utils.TOKEN]
decoded_token = utils.decode_auth_token(token)
if not decoded_token:
utils.send_invalid_token_error(s)
else:
user_slots = self.dbConnector.get_user_slots(
decoded_token[db_utils.USER])
slots = db_utils.convert_datetime_to_isoformat(
user_slots)
pck = utils.create_response_packet(
json.dumps({
'slots': slots,
'status': 200
}).encode())
# OnSuccess: { slots: [{slot_id, start, end}], status: 200 }
s.sendall(pck)
elif action == utils.NODETYPES_GET: # { token }
token = data[db_utils.TOKEN]
decoded_token = utils.decode_auth_token(token)
if not decoded_token:
utils.send_invalid_token_error(s)
else:
nodetypes = self.dbConnector.get_nodetypes()
pck = utils.create_response_packet(
json.dumps({
'nodetypes': nodetypes,
'status': 200
}).encode())
# OnSuccess: { nodetypes, status: 201 }
s.sendall(pck)
elif action == utils.USERS_SIGNUP: # { email, username, password }
res = self.dbConnector.create_user(data)
pck = utils.create_response_packet(
json.dumps(res).encode())
# OnSuccess: { status: 201 }
# OnError : { message, status: 403 }
s.sendall(pck)
elif action == utils.USERS_LOGIN: # { email, username }
res = self.dbConnector.login_user(data)
pck = utils.create_response_packet(
json.dumps(res).encode())
# OnSuccess: { token, status: 200}
# OnError : { message, status: 401 }
s.sendall(pck)
elif action == utils.DEBUG_START: # { token, slot_id }
token = data[db_utils.TOKEN]
slot_id = data[db_utils.TIMESLOT_ID]
decoded_token = utils.decode_auth_token(token)
if not decoded_token:
utils.send_invalid_token_error(s)
elif not self.dbConnector.get_slot_by_id(slot_id):
utils.send_invalid_slot_error(s)
else:
if self.sock_debug:
utils.remove_from_list(
self.inputs, self.sock_debug)
self.sock_debug.close()
log_data = [
'=== DEBUG CHANNEL START ===\n===========================\n'
]
pck = utils.create_response_packet(
json.dumps({
'data': log_data
}).encode())
self.sock_debug = s
self.sock_debug.sendall(pck)
elif action == utils.DEBUG_END: # { token, slot_id }
token = data[db_utils.TOKEN]
slot_id = data[db_utils.TIMESLOT_ID]
decoded_token = utils.decode_auth_token(token)
if not decoded_token:
utils.send_invalid_token_error(s)
elif not self.dbConnector.get_slot_by_id(slot_id):
utils.send_invalid_slot_error(s)
else:
log_data = [
'=== DEBUG CHANNEL END ===\n=========================\n'
]
if self.sock_debug:
self.experiment_info = {}
pck = utils.create_response_packet(
json.dumps({
'data': log_data,
'message': 'STOP DEBUG'
}).encode())
self.sock_debug.sendall(pck)
utils.remove_from_list(
self.inputs, self.sock_debug)
self.sock_debug.close()
self.sock_debug = None
# { status: 204 }
pck = utils.create_response_packet(
json.dumps({
'status': 204
}).encode())
s.sendall(pck)
elif action == utils.DEBUG_CLEAR_LOG: # { token, slot_id }
token = data[db_utils.TOKEN]
slot_id = data[db_utils.TIMESLOT_ID]
decoded_token = utils.decode_auth_token(token)
if not decoded_token:
utils.send_invalid_token_error(s)
elif not self.dbConnector.get_slot_by_id(slot_id):
utils.send_invalid_slot_error(s)
else:
self.clear_debug_log(
decoded_token[db_utils.USER], slot_id)
pck = utils.create_response_packet(
json.dumps({
'status': 204
}).encode())
# OnSuccess: { status: 204 }
s.sendall(pck)
elif action == utils.DEBUG_GET_LOG: # { token, slot_id }
token = data[db_utils.TOKEN]
slot_id = data[db_utils.TIMESLOT_ID]
decoded_token = utils.decode_auth_token(token)
if not decoded_token:
utils.send_invalid_token_error(s)
elif not self.dbConnector.get_slot_by_id(slot_id):
utils.send_invalid_slot_error(s)
else:
self.send_debug_log(
s, decoded_token[db_utils.USER], slot_id)
elif action == utils.DEBUG_GATEWAY: # [ TIMESTAMP, NODE_ID, DATA ]
print(data[0], '|', data[1], '|', data[2])
if self.experiment_info:
self.write_debug_log(data)
if self.sock_debug:
pck = utils.create_response_packet(
json.dumps({
'data': data
}).encode())
self.sock_debug.sendall(pck)
else:
self.logger.info(
'TCP DISCON (%s, %d)' %
(s.getpeername()[0], s.getpeername()[1]))
self.inputs.remove(s)
s.close()
for s in exceptional:
self.inputs.remove(s)
s.close()
for sock in self.inputs:
self.logger.debug('Exiting. . . Closing [%s]' % sock)
sock.close()
self.log_timer.cancel()
self.sock_tcp.close()
sys.exit('Exiting. . .')
