def main(fragment_file, lead_file):
fragment_mols = read_file(fragment_file)
lead_mols = read_file(lead_file)
fragment_mols += lead_mols
logging.info("Read %s molecules for fragmentation library",
len(fragment_mols))
logging.info("Read %s lead moleculs", len(lead_mols))
fragments, used_mols = get_fragments(fragment_mols)
logging.info("Num fragments: %s", len(fragments))
logging.info("Total molecules used: %s", len(used_mols))
assert len(fragments)
assert len(used_mols)
encodings, decodings = get_encodings(fragments)
save_decodings(decodings)
logging.info("Saved decodings")
lead_mols = np.asarray(
fragment_mols[-len(lead_mols):])[used_mols[-len(lead_mols):]]
X = encode_list(lead_mols, encodings)
logging.info("Building models")
actor, critic = build_models(X.shape[1:])
X = clean_good(X, decodings)
logging.info("Training")
history = train(X, actor, critic, decodings)
logging.info("Saving")
np.save("History/history.npy", history)
def get_instructors(self, path):
"""A function that assigns instructor's information (cwid, name, dept) to instructor's cwid."""
try:
for cwid, name, dept in read_file(path, 3, sep = '\t', header=False):
self.instructors[cwid] = Instructor(cwid, name, dept)
except ValueError as e:
print(e)
def reading_students(self, path):
"""A function that assigns student's information (cwid, name, major) to his/her cwid."""
try:
for cwid, name, major in read_file(path, 3, '\t', header=False):
self.students[cwid] = Student(cwid, name, major)
except ValueError as e:
print(e)
def get_places():
"""Extracts entities from text and returns lists and links to wikipedia"""
text = file_reader.read_file(session['filepath'])
target_lang = session['target_lang']
source_lang = (session['source_lang']).encode('ascii', 'replace')
#Uses the NER tagger to get entities
if source_lang == 'de':
nouns = german.pos(text)
organizations, locations, people = german.ner(text)
elif source_lang == 'es':
nouns = spanish.pos(text)
organizations, locations, people = spanish.ner(text)
else:
nouns = text_processing.nouns_only(text_processing.preprocess(text))
organizations, locations, people = text_processing.ner_tagger(text)
#Checks the type of entity that is being requested
ent = request.form['ent']
if ent == "places":
if locations:
loclist = wikipedia.get_entity_info(locations, target_lang, source_lang)
downfile = file_reader.write_csv_file(loclist)
geocodes = geocoding.geocode(locations)
return render_template("places.html", locations = loclist, geocodes = json.dumps(geocodes), downfile=downfile)
else:
return render_template("places.html")
elif ent == "organizations":
if organizations:
orglist = wikipedia.get_entity_info(organizations, target_lang, source_lang)
downfile = file_reader.write_csv_file(orglist)
return render_template("orgs.html", organizations = orglist, downfile=downfile)
else:
return render_template("orgs.html")
elif ent == "people":
if people:
peoplelist = wikipedia.get_entity_info(people, target_lang, source_lang)
downfile = file_reader.write_csv_file(peoplelist)
return render_template("people.html", people = peoplelist, downfile=downfile)
else:
return render_template("people.html")
elif ent == "nouns":
if nouns:
nounlist = wikipedia.get_entity_info(nouns, target_lang, source_lang)
downfile = file_reader.write_csv_file(nounlist)
return render_template("other.html", nouns = nounlist, downfile=downfile)
else:
return render_template("other.html")
def main(fragment_file, lead_file):
fragment_mols = read_file(fragment_file)
lead_mols = read_file(lead_file)
fragment_mols += lead_mols
logging.info("Read %s molecules for fragmentation library",
len(fragment_mols))
logging.info("Read %s lead molecules", len(lead_mols))
fragments, used_mols = get_fragments(fragment_mols)
logging.info("Num fragments: %s", len(fragments))
logging.info("Total molecules used: %s", len(used_mols))
assert len(fragments)
assert len(used_mols)
# =============================================================================
# encodings, decodings = get_encodings(fragments)
# save_encodings(encodings)
# save_decodings(decodings)
# logging.info("Saved encodings and decodings")
# =============================================================================
lead_mols = np.asarray(
fragment_mols[-len(lead_mols):])[used_mols[-len(lead_mols):]]
decodings = read_decodings()
encodings = read_encodings()
logging.info("Loaded encodings and decodings")
X = encode_list(lead_mols, encodings)
#print(X.shape)
if X.shape[0] == 0:
return -1
logging.info("Building models")
actor, critic = build_models(X.shape[1:])
# X = clean_good(X, decodings)
# logging.info("Remaining molecules after clean good: %s",X.shape[0])
if X.shape[0] == 0:
return -1
logging.info("Training")
history = train(X, actor, critic, decodings)
logging.info("Saving")
np.save("History/history.npy", history)
actor.save('./saved_models/generation')
critic.save('./saved_models/critic')
def measure_spell_correction(path):
path = "/Users/anant/pythonWD/data_corrected 2/";
path += "spell_checking_task_v2/";
all_folders_to_train = ["graphics","medicine","motorcycles","religion","space","atheism","autos"];
count=0;
error = 0;
confusion_set = spell_checker.get_confusion_set(path);
for folder in all_folders_to_train:
dev_results_path = path+folder+"/dev_results/";
all_dev_op_files = file_reader.list_all_text_files(dev_results_path);
for file in all_dev_op_files:
devop = file_reader.read_file(file);
train_file = file.replace("dev_results", "train_docs");
devop_file_text = file_reader.read_file(file);
train_file_text = file_reader.read_file(train_file);
devop_list = nltk.word_tokenize(devop_file_text);
train_list = nltk.word_tokenize(train_file_text);
devop_confusion_list = [];
train_confusion_list = [];
for w in devop_list:
if(w in confusion_set):
devop_confusion_list.append(w);
for w in train_list:
if(w in confusion_set):
train_confusion_list.append(w);
if(len(train_confusion_list)!= len(devop_confusion_list)):
print("Number of confused words is not same in train and corrected data, this shouldn't have happen\n");
error_in_file = 0;
j = 0;
while j < len(train_confusion_list):
if(train_confusion_list[j] != devop_confusion_list[j]):
error_in_file += 1;
j=j+1;
if(len(train_confusion_list) == 0 ):
if(len(devop_confusion_list) == 0):
print("No confusion words found in:", file, "\n");
else:
count+=1;
error += error_in_file/len(train_confusion_list);
print("Mean error for the folder:", error/count, "\n");
def main(fragment_file, lead_file):
fragment_mols = read_file(fragment_file)
lead_mols = read_file(lead_file)
fragment_mols += lead_mols
fragments, used_mols = get_fragments(fragment_mols)
encodings, decodings = get_encodings(fragments)
save_decodings(decodings)
lead_mols = np.asarray(fragment_mols[-len(lead_mols):])[used_mols[-len(lead_mols):]]
X = encode_list(lead_mols, encodings)
actor, critic = build_models(X.shape[1:])
X = clean_good(X, decodings)
history = train(X, actor, critic, decodings)
np.save("History/history.npy", history)
def start_processing(data_file):
data = fr.read_file(data_file)
# Встановимо найбільше можливе значення для ваги
max_weight = sys.maxsize
optimum_path = None
path_common = []
path_common = pc.start_path_generator(data, path_common,
cg.weight_calculator)
while len(
list(
filter(
lambda path_dictionary_converted:
(path_dictionary_converted['alive'] == True) and
(len(path_dictionary_converted['path']) < len(data)),
path_common))) > 0:
short_path_dictionary_converted = sorted(
path_common, key=lambda path: path['weight'])[0]
path_common.remove(short_path_dictionary_converted)
removed_connections = [
i for i in range(len(data))
if short_path_dictionary_converted['path'].count(i) == 0
]
for connection in removed_connections:
path_common, max_weight, optimum_path = pu.path_inserter(
data, path_common, connection, short_path_dictionary_converted,
max_weight, optimum_path, cg.paths_calculator,
cg.weight_calculator, ds.duplicate_searcher)
maximum_solutions = math.factorial(len(data))
unexplored_percentage = (maximum_solutions -
len(path_common)) / maximum_solutions * 100
result = ""
paths_string = ""
for path in path_common:
result = result + 'Шлях: {}, Вага: {}, C: {}'.format(
[x + 1 for x in path['path']], path['weight'], path['C']) + "\n"
# for x in optimum_path:
result = result + '\nВага найкращого шляху: ' + str(max_weight)
result = result + '\nНайкращий шлях: ' + str([x + 1 for x in optimum_path])
result = result + '\n% Відсічення: ' + '{}%'.format(
int(unexplored_percentage))
return result
def get_grades(self, path):
"""A function that adds courses and grades to students and instructors."""
try:
for student_cwid, course, grade, instructor_cwid in read_file(path, 4, sep = '\t', header=False):
if student_cwid in self.students:
self.students[student_cwid].add_course(course, grade)
else:
print("unknown student")
if instructor_cwid in self.instructors:
self.instructors[instructor_cwid].add_course(course)
else:
print("instructor not found")
except ValueError as e:
print (e)
def get_entities(): """Loads all entity names into a JSON for highlighting""" text = file_reader.read_file(session['filepath']) session['text'] = (text) source_lang = session['source_lang'] if source_lang == 'de': fullset =text_processing.single_set(german.ner(text)) elif source_lang == 'es': fullset =text_processing.single_set(spanish.ner(text)) else: fullset = text_processing.single_set(text_processing.ner_tagger(text)) return json.dumps(fullset)
def test_reading_file_succeeds(self):
path_to_test_file = os.path.join(os.path.dirname(__file__), 'sample_1',
'routes.geojson')
expected_content = """{
"type": "FeatureCollection",
"name": "routes",
"crs": { "type": "name", "properties": { "name": "urn:ogc:def:crs:OGC:1.3:CRS84" } },
"features": [
]
}
"""
geojson = read_file(path_to_test_file)
self.assertIsNotNone(geojson)
self.assertEquals(geojson, expected_content)
def do_spell_correction(path, dev_set=1):
n_gram = 2
path += "spell_checking_task_v2/"
print("***Running spell correction at: ", path, " \n ***")
confusion_set = get_confusion_set(path)
all_folders_to_train = [
"graphics", "medicine", "motorcycles", "religion", "space", "atheism",
"autos"
]
''' BUILD LANGUAGE MODELS FOR ALL THE FOLDERS '''
folder_index = 0
probability_table = [dict() for x in range(7)]
while (folder_index < len(all_folders_to_train)):
print("\n Processing folder ", all_folders_to_train[folder_index])
#read all text files
all_text_files = []
folder_path = path + all_folders_to_train[folder_index] + "/train_docs/"
all_text_files += file_reader.list_all_text_files(folder_path)
#preprocess each file
all_preprocessed_text = ""
for file in all_text_files:
file_text = file_reader.read_file(file)
all_preprocessed_text += " " + preprocessor.preprocess(file_text)
sent_end_chars = [".", "!", "?"]
token_dictionary = tokenizer.tokenize(all_preprocessed_text, n_gram,
sent_end_chars, 1)
probability_table[
folder_index] = probability_calculator.generate_probability_table(
token_dictionary, n_gram)
folder_index += 1
print("\n Done processing all the folders\n")
print("\n Done processing all the folders\n")
generate_fixed_files(all_folders_to_train, confusion_set,
probability_table, path, dev_set)
def post_process(text):
f = open('data/temp.txt', 'w')
f.write(text)
f.close()
command = 'sh ../pos_tagger.sh data/temp.txt 2> data/temp_info.txt > data/temp_tagged.txt'
subprocess.call(command, shell=True)
pos_lines = file_reader.read_file_lines('data/temp_tagged.txt')
pos_info_array = sanitize_pos(pos_lines)
# print(pos_info_array)
command = 'sh ../parser_dependencies.sh data/temp.txt 2> data/temp_info.txt > data/temp_dependencies.txt'
subprocess.call(command, shell=True)
dependencies_content = file_reader.read_file('data/temp_dependencies.txt')
dep_info_array = sanitize_dep(dependencies_content)
# print(dep_info_array)
knowledge.generate(pos_info_array, dep_info_array)
def main():
try:
user_option = int(
input("1- Create new instance \n2- Read a file\nOPTION: "))
except:
print("ERROR: USER INPUT")
if user_option == 1:
instance_generator()
elif user_option == 2:
clusters_amount, capacity, customers, weights, distance_matrix = read_file(
)
solved_clusters_hwe, solved_clusters_weights_hwe, objective_function_hwe = heaviest_weight_edge(
len(weights), clusters_amount, capacity, weights, distance_matrix)
solved_clusters_gch, solved_clusters_weights_gch, objective_function_gch = greedy_construction_heuristic(
len(weights), clusters_amount, capacity, weights, distance_matrix)
local_search(solved_clusters_hwe, solved_clusters_weights_hwe,
distance_matrix, objective_function_hwe)
local_search(solved_clusters_gch, solved_clusters_weights_gch,
distance_matrix, objective_function_gch)
def learn_and_answer(input_file):
info = read_file(input_file)
error_msgs = info['error_msgs']
if len(info['ref_words']) > 0:
# init the robot with default answer
robot = MerchantRobot(DEFAULT_ANSWER)
# build the robot's ref words book
result = robot.learn_knowledge(info['ref_words'], info['price_msgs'])
if result:
error_msgs.extend(result)
# use to robot to answer questions
result = robot.answer_questions(info['questions'])
if result:
print("\n".join(result))
if error_msgs:
print("\n".join(error_msgs))
else:
print("no ref words found")
import os
from file_reader import read_file
from file_writer import write_output
from problem_solver import ProblemSolver
# Input
files = [
'a_example.txt', 'b_lovely_landscapes.txt', 'c_memorable_moments.txt',
'd_pet_pictures.txt', 'e_shiny_selfies.txt'
]
# End Input
example_file = os.path.join('data', files[0])
example = read_file(example_file)
exampleSlicer = ProblemSolver(example['header'], example['rows'],
os.path.join('output', 'example.txt'))
exampleSlicer.output_solution()
small_file = os.path.join('data', files[1])
small = read_file(small_file)
smallSlicer = ProblemSolver(small['header'], small['rows'],
os.path.join('output', 'small.txt'))
smallSlicer.output_solution()
medium_file = os.path.join('data', files[2])
medium = read_file(medium_file)
mediumSlicer = ProblemSolver(medium['header'], medium['rows'],
os.path.join('output', 'medium.txt'))
mediumSlicer.output_solution()
def p_communication(p):
'''
communication : talk EXCLAMATION communication
| talk EXCLAMATION
'''
def p_talk(p):
'''
talk : SEND LB ID SEMICOLON ID SEMICOLON MESSAGE RB
'''
controller.send_message(p[3], p[5], p[7])
# Error rule for syntax errors
def p_error(p):
if p:
print("Syntax error in input at '%s', at line %s character %s." % (p.value, p.lineno, p.lexpos))
# Build the parser
parser = yacc.yacc()
if __name__ == '__main__':
file_name = input("Enter name of file to execute: ")
s = read_file("tests/%s.txt" % file_name)
parser.parse(s)
from optimizer_core import Optimizer
parser = argparse.ArgumentParser(description='Parallelize eBPF program')
parser.add_argument('-i',
'--input',
type=str,
required=True,
help='eBPF dump input file name')
parser.add_argument('-o',
'--output',
type=str,
help='parallelized bin file name')
args = parser.parse_args()
in_file = args.input
out_file = os.path.splitext(
args.input)[0] + ".bin" if args.output is None else args.output
program_bin, program_str = read_file(in_file)
parallelizer = Optimizer(program_bin,
program_str,
filename=os.path.splitext(args.input)[0],
branch_all_lanes=False,
lane_forward_constraint=True)
parallelizer.optimize()
write_program_to_file(filename=out_file + ".out",
parallel_program=parallelizer.resource_table)
import sys
import file_reader
import runner
def initialize_parking_lot(line):
command, arg = file_reader.parse_line(line)
return runner.create_parking_lot(command, arg)
if __name__ == '__main__':
"""
python -m main ABSOLUTE_FILE_PATH or RELATIVE_FILE_PATH or 'tests/mocks/input.txt'
"""
try:
input_file = sys.argv[1]
except (IndexError, NameError):
print("Please pass a valid file to see how can I run Parking lot.")
exit()
with file_reader.read_file(input_file) as file:
parking_lot = initialize_parking_lot(file.readline())
for line in file:
command, args = file_reader.parse_line(line)
runner.execute_command(parking_lot, command, args)
if original_struct_time.tm_zone == 'GMT': # original_struct_time is UTC based
return calendar.timegm(original_struct_time)
else: # original_struct_time is in local time zone
return time.mktime(original_struct_time)
def calculate_struct_time(time_float, zone):
if zone == 'GMT':
return time.gmtime(time_float)
else: # calculate local time based on time_float
return time.localtime(time_float)
if __name__ == '__main__':
dict_list = file_reader.read_file('timestamps.json')
print('dict_list = ', dict_list)
for d in dict_list:
original_struct_time = time.strptime(d['timestamp'],
d['format_string'])
time_float = get_time_float(original_struct_time)
calculated_struct_time = calculate_struct_time(
time_float, original_struct_time.tm_zone)
calculated_timestamp = time.strftime(d['format_string'],
calculated_struct_time)
print('********************************************')
print(f'Original timestamp: {d["timestamp"]} ')
print('Original struct_time: ', original_struct_time,
original_struct_time.tm_zone, original_struct_time.tm_gmtoff)
# Define a rule so we can track line numbers
def t_newline(t):
r'\n+'
t.lexer.lineno += len(t.value)
# Characters to ignore
t_ignore = ' \t'
# Error rule
def t_error(t):
print("ERROR: Illegal character '%s', at position %s, %s." %
(t.value[0], t.lineno, t.lexpos))
t.lexer.skip(1)
# Build the lexer
lexer = lex.lex()
if __name__ == '__main__':
# Read the input
lexer.input(read_file("tests/test.txt"))
while True:
tok = lexer.token()
if not tok:
break
print(tok)
folders_to_train = [folder];
n_gram = int( input("\n\nEnter n for n-gram: "));
#read all text files
all_text_files = [];
for folder in folders_to_train:
folder_path = path+"/classification task/"+folder+"/train_docs/";
all_text_files += file_reader.list_all_text_files(folder_path);
#preprocess each file
all_preprocessed_text = "";
for file in all_text_files:
file_text = file_reader.read_file(file);
all_preprocessed_text += " "+preprocessor.preprocess(file_text);
sent_end_chars = [".","?","!"];
#Tokenize the corpus
#last argument in the function call below is for lowercasing
token_dictionary = tokenizer.tokenize( all_preprocessed_text, n_gram, sent_end_chars, 1 );
#get cdf
cum_probability = probability_calculator.generate_cdf(token_dictionary, n_gram);
#
# Printing Cumulative probability table.
# Uncomment this block to print the Cumulative probability table.
#
attribute_types = {
"country": "categorical",
"year": "numeric",
"sex": "categorical",
"age": "categorical",
"suicides_no": "numeric",
"population": "numeric",
"suicides/100k pop": "numeric",
"country-year": "categorical",
"HDI for year": "numeric",
"gdp_for_year ($)": "numeric",
"gdp_per_capita ($)": "numeric",
"generation": "categorical"
}
data = read_file("data.csv", attribute_types)
# step 1 and 2
print_numeric_attribute_info(data)
print('\n')
print_categorical_attribute_info(data)
# step 4
plot_histograms(data)
# step 5
for attribute in data:
attribute.fill_missing_values()
def test_reading_nonexisting_file_fails(self):
content = read_file("nonexisting")
self.assertIsNone(content)
def get_file_content():
file_path = request.args.get("filePath")
return file_reader.read_file(file_path)
import os
from file_reader import read_file
from file_writer import write_output
from problem_solver import ProblemSolver
from Slide import Slide
# Input
files = [
'a_example.txt', 'b_loveley_landscapes.txt', 'c_memorable_moments.txt',
'd_pet_pictures.txt', 'e_shiny_selfies.txt'
]
# End Input
example_file = os.path.join('data', files[0])
example = read_file(example_file)
print(example)
' will change to slide from their function'
photos = example['rows']
slides = [] # they will pass this
for photo in photos:
if photo['orientation'] == 'H':
# print(photo['tags'])
slides.append(Slide(photo))
''''''
data_directory = '/media/ian/B2D61116D610DC831/8-7-18 Wavefronts/'
files = os.listdir(data_directory)
train_filelist, test_filelist = segment_files(files)
write_filelist('train_filelist.csv', train_filelist)
write_filelist('test_filelist.csv', test_filelist)
convlstm_model = model.get_model()
convlstm_model.compile(optimizer=tf.keras.optimizers.Adam(lr=0.001),
loss='mse')
num_epochs = 100
for epoch in range(num_epochs):
print('Epoch {}'.format(epoch))
for file in train_filelist:
if (file.startswith('wavefront')):
input_batch, output_batch = batch_data(
file_reader.read_file(data_directory + file))
convlstm_model.train_on_batch(input_batch, output_batch)
average_error = 0
for file in test_filelist:
input_batch, output_batch = batch_data(
file_reader.read_file(data_directory + file))
error = convlstm_model.test_on_batch(input_batch, output_batch)
average_error += error
average_error = average_error / len(test_filelist)
print('Average error: {}'.format(average_error))
convlstm_model.save('convlstm_model2.h5')
mean_speedup = 0
mean_unused_lanes = 0
def print_program(program):
print()
print("Program:")
for inst in range(len(program)):
print_unpkd(unpack_instruction(program[inst]), inst)
print()
for file in files:
print("====================================================")
program_bin, program_str = read_file("xdp_prog_dump/" + file)
print("File: " + file)
print(" ~ with constraints")
parallelizer = Optimizer(program_bin,
program_str,
filename=file,
branch_all_lanes=True,
lane_forward_constraint=True,
debug_print_blocks_pre_sched=True,
debug_print_blocks_pre_opt=False,
debug_draw_cfg=True)
parallelizer.optimize()
parser = argparse.ArgumentParser(
description='Mercury. Sends GeoJSON or TCX files to Polaris server.')
parser.add_argument('--file', dest='file', help='The file to send')
parser.add_argument('--type',
dest='type',
help='Type of file to send (geojson/tcx)',
default='geojson')
parser.add_argument('--server',
dest='server_address',
help='URL of the Polaris server where to send the data',
default='http://127.0.0.1:3000/')
args = parser.parse_args()
if not args.file:
parser.print_help()
exit()
logging.debug("Mercury starting.")
data = read_file(args.file)
if data is not None:
logging.debug("Sending " + args.file + " to Polaris server at " +
args.server_address)
if args.type == 'geojson':
endpoint = PolarisAPI.geojson.value
if args.type == 'tcx':
endpoint = PolarisAPI.tcx.value
client = PolarisClient(args.server_address)
client.send_data(data, endpoint)
logging.debug("Mercury finished.")
def generate_fixed_files(all_folders_to_train,
confusion_set,
probability_table,
path,
dev_set=1):
folder_index = 0
while (folder_index < len(all_folders_to_train)):
folder = all_folders_to_train[folder_index]
probability_model = probability_table[folder_index]
print("\n Processing folder ", folder)
if (dev_set):
bad_files_path = path + folder + "/train_modified_docs/"
fixed_files_path = path + folder + "/dev_results/"
else:
bad_files_path = path + folder + "/test_modified_docs/"
fixed_files_path = path + folder + "/test_docs/"
#folder_path = path+all_folders_to_train[folder_index]+"/train_docs/";
all_text_files = []
all_text_files += file_reader.list_all_text_files(bad_files_path)
#folder_path);
#count = 0;
for file in all_text_files:
file_text = file_reader.read_file(file)
file_text_list = nltk.word_tokenize(file_text)
i = 0
prev_word = ("<s>", )
file_list_len = len(file_text_list)
while i < file_list_len:
current_word = file_text_list[i]
if (prev_word in ['.', '!', "?"]):
prev_word = ("<s>", )
if (current_word in confusion_set):
#print("testing for ", current_word, "\n");
current_word1 = confusion_set[current_word]
if (not (prev_word in probability_model)):
# print("didn't find prev_word ", prev_word, " replacing it with <unk>\n");
prev_word = ("<unk>", )
# prev_word = file_text_list[i];
# i=i+1;
# continue;
probability_row = probability_model[prev_word]
prob = 0
prob1 = 0
if (not (current_word in probability_row)):
if (current_word1 in probability_row):
prob1 = probability_row[current_word1]
else:
prob1 = 0
prob = 1
# print("didn't find current_word ", current_word, " replacing it with <unk>\n");
else:
prob = probability_row[current_word]
if (current_word1 in probability_row):
prob1 = probability_row[current_word1]
else:
prob1 = 0
# current_word = "<unk>";
# if( not(current_word1 in probability_row) ):
# print("didn't find conf_word ", current_word1, " replacing it with <unk>\n");
# current_word1 = "<unk>";
# prob1 = probability_row[ current_word];
# prob2 = probability_row[current_word1];
if (prob < prob1):
new_word = confusion_set[file_text_list[i]]
if (file_text_list[i].isupper()):
new_word = new_word.capitalize()
# print("Replaced ", file_text_list[i], " with ", new_word, "\n");
file_text_list[i] = new_word
prev_word = (file_text_list[i], )
i = i + 1
corrected_file_text = " ".join(file_text_list)
##create a a file and write
corrected_file_name = file.split('/')[-1].replace("_modified", "")
print(fixed_files_path + corrected_file_name)
wfile = open(fixed_files_path + corrected_file_name, "w+")
wfile.write(corrected_file_text)
wfile.close()
#count +=1;
#if(count>10): break;
folder_index += 1
#coding=utf-8
'''
Created on 2016.10.13
@author: xiaoq
'''
import json
from file_reader import read_file
from user import *
from func import *
if __name__ == '__main__':
records = read_file("data.txt")
name2QQ_id = {}
users = {}
for record in records:
#循环处理聊天记录
#record是一个字典，包括QQ_id,name,timestamp,words等keys
QQ_id = record["QQ_id"]
#生成新用户，并不断更新用户name
if not users.has_key(QQ_id):
newUser = User(QQ_id, record["name"])
name2QQ_id[record["name"]] = QQ_id
newUser.addRecord(record)
users[QQ_id] = newUser
else:
users[QQ_id].name = record["name"]
name2QQ_id[record["name"]] = QQ_id
users[QQ_id].addRecord(record)
#建立QQ号和昵称之间的映射，以及index与QQ号之间的映射
def test_read_file(self):
for key, value in read_file('input.txt').items():
self.assertEqual(value, self.info[key])
return formatted_slices
def output_solution(self):
num_slices = self.get_num_slices()
formatted_slices = self.get_slices_formatted()
output = num_slices + formatted_slices
write_output(self.output_file, output)
example_file = os.path.join('data', 'a_example.in')
small_file = os.path.join('data', 'b_small.in')
medium_file = os.path.join('data', 'c_medium.in')
big_file = os.path.join('data', 'd_big.in')
example = read_file(example_file,
['rows', 'cols', 'minIngredients', 'maxCellsPerSlice'],
['row'])
small = read_file(small_file,
['rows', 'cols', 'minIngredients', 'maxCellsPerSlice'],
['row'])
medium = read_file(medium_file,
['rows', 'cols', 'minIngredients', 'maxCellsPerSlice'],
['row'])
big = read_file(big_file,
['rows', 'cols', 'minIngredients', 'maxCellsPerSlice'],
['row'])
exampleSlicer = PizzaSlicer(example['header'], example['rows'], 'example.out')
smallSlicer = PizzaSlicer(small['header'], small['rows'], 'small.out')
mediumSlicer = PizzaSlicer(medium['header'], medium['rows'], 'medium.out')
bigSlicer = PizzaSlicer(big['header'], big['rows'], 'big.out')
#coding=utf-8
'''
Created on 2016.10.13
@author: xiaoq
'''
import json
from file_reader import read_file
from user import *
from func import *
if __name__ == '__main__':
records = read_file("data.txt")
name2QQ_id = {}
users = {}
for record in records:
#循环处理聊天记录
#record是一个字典，包括QQ_id,name,timestamp,words等keys
QQ_id = record["QQ_id"]
#生成新用户，并不断更新用户name
if not users.has_key(QQ_id):
newUser = User(QQ_id, record["name"])
name2QQ_id[record["name"]] = QQ_id
newUser.addRecord(record)
users[QQ_id] = newUser
else:
users[QQ_id].name = record["name"]
name2QQ_id[record["name"]] = QQ_id
users[QQ_id].addRecord(record)
