def get_fragment(self, root):
"""
Returns the path fragment of this directory starting with the given
directory.
"""
return PathUtil.get_path_fragment(str(root), self.path)
def trainRecommend():
data = json.loads(request.data.decode('utf-8'))
with open(PathUtil.get_path() + "proval/train.txt", "a+") as file:
for i in range(data.__len__()):
file.write('\n')
file.write(str(data[i]))
tag.train()
return "success"
def initialize(self, root, template=None, force=False):
if not template:
template = "default"
root_folder = Folder(root)
template_dir = root_folder.child_folder("templates", template)
if not template_dir.exists:
raise ValueError("Cannot find the specified template[%s]." % template_dir)
if self.site_path.exists:
files = os.listdir(self.site_path.path)
PathUtil.filter_hidden_inplace(files)
if len(files) and not force:
raise ValueError("The site_path[%s] is not empty." % self.site_path)
else:
self.site_path.delete()
self.site_path.make()
self.site_path.copy_contents_of(template_dir)
def __main__():
for language in ["English", "Chinese"]:
agenda = Agenda(language, "test theme")
session = Session(datetime(2020, 11, 5, 16, 40))
session.append_event(duration=20,
role_name="Sergeant at Arms (SAA)",
role_taker=MemberInfo({
"English Name": "Bonnie Wang",
"Chinese Name": "Baoni",
"Speech Records": [],
"Role Records": [],
}),
event="Registration/Greeting",
show_duration=False)
session.append_event(duration=4,
role_name="Toastmaster",
role_taker=MemberInfo({
"English Name": "Elliot Zhang",
"Chinese Name": "Xingzhi",
"Speech Records": [],
"Role Records": [],
}),
event="Meeting Opening & Welcome Guests (20s/P)")
session = Session(agenda.append_session(session).current_datetime,
title="Table Topic Session")
session.append_event(duration=25,
role_name="Table Topic Master",
role_taker=MemberInfo({
"English Name": "Kay",
"Chinese Name": "Li Kang",
"Speech Records": [],
"Role Records": [],
}),
event="Theme Introduction & Table Topic Session")
session.append_event(duration=6,
role_name="Table Topic Evaluator",
role_taker=MemberInfo({
"English Name": "Raymond Lu",
"Chinese Name": "Raymond",
"Speech Records": [],
"Role Records": [],
}),
event="Table Topic Evaluation")
session.append_event(duration=1,
role_name="Toastmaster",
role_taker=MemberInfo({
"English Name": "Elliot Zhang",
"Chinese Name": "Xingzhi",
"Speech Records": [],
"Role Records": [],
}),
event="Return control to Toastmaster")
agenda.append_session(session)
agenda.dump(PathUtil().get_output_path("{}.html".format(language)))
def trainRecommend():
data = json.loads(request.data.decode('utf-8'))
with open(PathUtil.get_path() + "proval/train_aliyun.txt", "a+") as file:
with open(PathUtil.get_path() + "proval/train_baidu.txt",
"a+") as file_baidu:
for i in range(data.__len__()):
aliyun_data = {}
aliyun_data["url"] = data[i]["url"]
aliyun_data["tags"] = data[i]["tags"]
aliyun_data["response"] = data[i]["response"]
baidu_data = {}
baidu_data["url"] = data[i]["url"]
baidu_data["tags"] = data[i]["tags"]
baidu_data["response"] = data[i]["baiduResponse"]
file.write('\n')
file.write(str(aliyun_data))
file_baidu.write('\n')
file_baidu.write(str(baidu_data))
tag.train()
return "success"
def __init__(self, language, theme, speech_count=3):
self._template_str = Agenda.template_localization(
PathUtil().get_template("default.html"), language, {
"theme": {
"default": theme,
},
"speech_count": {
"default": str(speech_count),
}
})
self._sessions = [] # type: List[Session]
def initialize(self, root, template=None, force=False):
if not template:
template = "default"
root_folder = Folder(root)
template_dir = root_folder.child_folder("templates", template)
if not template_dir.exists:
raise ValueError("Cannot find the specified template[%s]." %
template_dir)
if self.site_path.exists:
files = os.listdir(self.site_path.path)
PathUtil.filter_hidden_inplace(files)
if len(files) and not force:
raise ValueError("The site_path[%s] is not empty." %
self.site_path)
else:
self.site_path.delete()
self.site_path.make()
self.site_path.copy_contents_of(template_dir)
def __init__(self, month: int, day: int, is_english: bool, year=None):
self._function_role_taker = {} # type: Dict[str, MemberInfo]
self._info = {} # type: Dict[str, str]
self._year = year if year is not None else datetime.datetime.now().year
self._month = month
self._day = day
self._is_english = is_english
self._theme = "TBD"
self._speakers = [] # type: List[MemberInfo]
self._new_member_count = -1
self._skip_dict = set() # special hacks to skip events
self._special_events = {} # hacks to get special events
with open(PathUtil().get_config_path("time_dict"),
"r",
encoding="utf-8") as time_dict_file:
self._time_dict = json.load(time_dict_file)
time_dict_file.close()
with open(PathUtil().get_config_path("roles"), "r",
encoding="utf-8") as roles_file:
self._roles = json.load(roles_file)
roles_file.close()
def __init__(self, member_info_path=None):
self._path_util = PathUtil()
self._member_info_path = path.join(self._path_util.current_dir, "data", "member_info.json") \
if member_info_path is None else member_info_path
with open(self._member_info_path, "r", encoding="utf-8") as member_info_file:
member_info_list = json.load(member_info_file)
self._member_info_list = []
for member_info_json in member_info_list:
self._member_info_list.append(MemberInfo(member_info_json))
member_info_file.close()
for i, member_info_json in enumerate(member_info_list):
if "Mentor Name" in member_info_json and member_info_json["Mentor Name"] is not None:
self._member_info_list[i].set_mentor(member_info_json["Mentor Name"], self)
with open(self._path_util.get_config_path("learning_path"), "r", encoding="utf-8") as in_file:
learning_path = json.load(in_file)
in_file.close()
self._pathway_path = learning_path["pathway"] # type: List[str]
self._cc_path = learning_path["CC"]
def load_test_data():
test_data = []
with open(PathUtil.get_path() + "proval/test.txt", "r") as file:
all_data = file.readlines()
for j in range(all_data.__len__()):
data = json.loads(all_data[j].replace('\n',
"").replace('\'', '\"'))
tags = data["response"]
targets = data["tags"]
tag = []
for i in range(n_size):
if i < tags.__len__():
if tags[i]["tag"] in targets:
tag.append([tags[i]["confidence"], 1])
else:
tag.append([tags[i]["confidence"], 0])
else:
tag.append([0, 0])
sorted(tag, reverse=True)
test_data.append(tag)
return test_data
def get_mirror_folder(self, root, mirror_root, ignore_root=False):
"""
Returns a Folder object that reperesents if the entire fragment of this
directory starting with `root` were copied to `mirror_root`. If ignore_root
is True, the mirror does not include `root` directory itself.
Example:
Current Directory: /usr/local/hyde/stuff
root: /usr/local/hyde
mirror_root: /usr/tmp
Result:
if ignore_root == False:
Folder(/usr/tmp/hyde/stuff)
if ignore_root == True:
Folder(/usr/tmp/stuff)
"""
path = PathUtil.get_mirror_dir(
self.path, str(root), str(mirror_root), ignore_root)
return Folder(path)
def get_mirror_folder(self, root, mirror_root, ignore_root=False):
"""
Returns a Folder object that reperesents if the entire fragment of this
directory starting with `root` were copied to `mirror_root`. If ignore_root
is True, the mirror does not include `root` directory itself.
Example:
Current Directory: /usr/local/hyde/stuff
root: /usr/local/hyde
mirror_root: /usr/tmp
Result:
if ignore_root == False:
Folder(/usr/tmp/hyde/stuff)
if ignore_root == True:
Folder(/usr/tmp/stuff)
"""
path = PathUtil.get_mirror_dir(self.path, str(root), str(mirror_root),
ignore_root)
return Folder(path)
def template_localization(
cls,
template_path,
language,
additional_dict: Optional[Dict[str, Dict[str, str]]] = None):
with open(template_path, "r", encoding="utf-8") as html_file:
html_template = html_file.read()
html_file.close()
with open(PathUtil().get_config_path("localization"),
"r",
encoding="utf-8") as localization_file:
localization_dict = json.load(
localization_file) # type: Dict[str, Dict[str, str]]
localization_file.close()
if additional_dict is not None:
localization_dict.update(additional_dict)
for key, v_dict in localization_dict.items():
value = v_dict["default"] if language not in v_dict else v_dict[
language]
html_template = html_template.replace("{{" + key + "}}", value)
return html_template
def init_api_table(self):
api_graph: GraphData = GraphData.load(PathUtil.linking_graph_path())
api_node_ids = api_graph.get_node_ids_by_label("class")
api_node_ids.update(api_graph.get_node_ids_by_label("method"))
api_node_ids.update(api_graph.get_node_ids_by_label("interface"))
for node_id in api_node_ids:
api_node = api_graph.get_node_info_dict(node_id)
qualified_name = api_node["properties"]["qualified_name"]
long_name, short_name, parameter_list = self.process_api(qualified_name)
self.qualified_name_2_process_api_result[qualified_name] = {"long_name": long_name,
"short_name": short_name,
"parameter_list": parameter_list}
self.qualified_name_set.add(qualified_name)
if long_name not in self.long_name_dic.keys():
self.long_name_dic[long_name] = {qualified_name}
else:
self.long_name_dic[long_name].add(qualified_name)
if short_name not in self.short_name_dic.keys():
self.short_name_dic[short_name] = {qualified_name}
else:
self.short_name_dic[short_name].add(qualified_name)
def path_util(self):
return PathUtil()
def load_models(self):
self.saver.restore(self.sess,
PathUtil.get_path() + "trainmodels/model.ckpt")
def save_models(self):
self.saver.save(self.sess,
PathUtil.get_path() + "trainmodels/model.ckpt")
class MemberInfoLibrary:
def __init__(self, member_info_path=None):
self._path_util = PathUtil()
self._member_info_path = path.join(self._path_util.current_dir, "data", "member_info.json") \
if member_info_path is None else member_info_path
with open(self._member_info_path, "r", encoding="utf-8") as member_info_file:
member_info_list = json.load(member_info_file)
self._member_info_list = []
for member_info_json in member_info_list:
self._member_info_list.append(MemberInfo(member_info_json))
member_info_file.close()
for i, member_info_json in enumerate(member_info_list):
if "Mentor Name" in member_info_json and member_info_json["Mentor Name"] is not None:
self._member_info_list[i].set_mentor(member_info_json["Mentor Name"], self)
with open(self._path_util.get_config_path("learning_path"), "r", encoding="utf-8") as in_file:
learning_path = json.load(in_file)
in_file.close()
self._pathway_path = learning_path["pathway"] # type: List[str]
self._cc_path = learning_path["CC"]
def dump(self, member_info_path=None):
with open(self._member_info_path if member_info_path is None else member_info_path, "w", encoding="utf-8"
) as member_info_file:
json.dump(list(map(
lambda x: x.to_dict(),
self._member_info_list
)), member_info_file, indent=2)
def find(self, role_taker_name) -> MemberInfo:
if role_taker_name is not None and len(role_taker_name) is not 0:
for member_info in self._member_info_list:
for name in [
member_info.english_name,
member_info.chinese_name,
*member_info.nick_names
]:
if name.lower().find(role_taker_name.lower()) is 0:
return member_info
else:
return MemberInfo({
"English Name": "TBD",
"Chinese Name": "TBD",
"Speech Records": [],
"Role Records": [],
})
role_taker = MemberInfo({
"English Name": role_taker_name,
"Chinese Name": role_taker_name,
"Speech Records": [],
"Role Records": [],
})
self._member_info_list.append(role_taker)
return role_taker
def clear_records(self, date_str):
for member in self._member_info_list:
member.clear_records(date_str)
def next_level(self, current_level: str):
if current_level in self._pathway_path:
return "pathway", self._pathway_path[self._pathway_path.index(current_level) + 1]
elif current_level in self._cc_path:
return "CC", self._cc_path[self._cc_path.index(current_level) + 1]
def assign_role(self, role_taker_name: str, role_name: str, date_str, topic) -> MemberInfo:
role_taker = self.find(role_taker_name)
if role_name.find("Speaker") is 0:
speech_type, next_level = self.next_level(role_taker.current_level)
role_taker.append_speech(next_level, date_str, topic, speech_type)
else:
role_taker.take_function_role(role_name, date_str, topic)
return role_taker
@app.route('/separateSentence', methods=['POST'])
def separateSentence():
data = json.loads(request.data.decode('utf-8'))
result = pickup.separate(data['content'])
return jsonify({'words': result})
@app.route('/getRecommendTag', methods=['POST'])
def getRecommendTag():
data = json.loads(request.data.decode('utf-8'))
result = tag.recommend(data['recommendTagItemList'])
return json.dumps({'recommendTagItemList': result}, cls=MyEncoder)
@app.route('/trainRecommend', methods=['POST'])
def trainRecommend():
data = json.loads(request.data.decode('utf-8'))
with open(PathUtil.get_path() + "proval/train.txt", "a+") as file:
for i in range(data.__len__()):
file.write('\n')
file.write(str(data[i]))
tag.train()
return "success"
if __name__ == '__main__':
PathUtil.init_path()
app.run(port=8888)
