def __init__(self, config):
self.config = config
if config.LOAD_PATH:
self.model = None
self.load_model(self.config.LOAD_PATH)
else:
with open('{}.dict.c2s'.format(config.TRAIN_PATH), 'rb') as file:
subtoken_to_count = pickle.load(file)
node_to_count = pickle.load(file)
target_to_count = pickle.load(file)
max_contexts = pickle.load(file)
self.num_training_examples = pickle.load(file)
print('Num training samples: {0}'.format(
self.num_training_examples))
print('Dictionaries loaded.')
if self.config.DATA_NUM_CONTEXTS <= 0:
self.config.DATA_NUM_CONTEXTS = max_contexts
self.subtoken_to_index, self.index_to_subtoken, self.subtoken_vocab_size = \
Common.load_vocab_from_dict(subtoken_to_count, add_values=[Common.PAD, Common.UNK],
max_size=config.SUBTOKENS_VOCAB_MAX_SIZE)
print('Loaded subtoken vocab. size: %d' % self.subtoken_vocab_size)
self.target_to_index, self.index_to_target, self.target_vocab_size = \
Common.load_vocab_from_dict(target_to_count, add_values=[Common.PAD, Common.UNK, Common.SOS],
max_size=config.TARGET_VOCAB_MAX_SIZE)
print('Loaded target word vocab. size: %d' %
self.target_vocab_size)
self.node_to_index, self.index_to_node, self.nodes_vocab_size = \
Common.load_vocab_from_dict(node_to_count, add_values=[Common.PAD, Common.UNK], max_size=None)
print('Loaded nodes vocab. size: %d' % self.nodes_vocab_size)
self.model = Model(self.config, self.subtoken_vocab_size,
self.target_vocab_size, self.nodes_vocab_size,
self.target_to_index)
if self.config.TRAIN_PATH:
self.train_dataset_reader = reader.Reader(
subtoken_to_index=self.subtoken_to_index,
node_to_index=self.node_to_index,
target_to_index=self.target_to_index,
config=self.config,
is_evaluating=False)
else:
self.train_dataset_reader = None
self.test_dataset_reader = reader.Reader(
subtoken_to_index=self.subtoken_to_index,
node_to_index=self.node_to_index,
target_to_index=self.target_to_index,
config=self.config,
is_evaluating=True)
def test():
x_image = tf.placeholder(tf.float32, [None, 66, 200, 3])
y = tf.placeholder(tf.float32, [None, 1])
keep_prob = tf.placeholder(tf.float32)
model = Nivdia_Model(x_image, y, keep_prob, FLAGS, False)
# dataset reader
dataset = reader.Reader(FLAGS.data_dir, FLAGS)
# model saver used to resore model from model dir
saver = tf.train.Saver()
with tf.Session() as sess:
path = tf.train.latest_checkpoint(FLAGS.model_dir)
if not (path is None):
saver.restore(sess, path)
else:
print("There is not saved model in the directory of model.")
loss = batch_eval(model.loss, dataset.test, x_image, y, keep_prob, 500,
sess)
print("Loss (MSE) in test dataset:", loss)
mae = batch_eval(model.mae, dataset.test, x_image, y, keep_prob, 500,
sess)
print("MAE in test dataset: ", mae)
def __init__(self):
self.rd = reader.Reader()
self.bridge=CvBridge()
self.register()
self.left_features = Image()
self.process()
def extractcurve(self):
a_setparam = np.array([])
a_measparam = np.array([])
a_measparam1 = np.array([])
for file in self.files:
# print (file)
r = reader.Reader(file)
meas = r.getmeas()
if self.typeofsignal == 'clock':
setfall = float(meas.setvalues[1])
setrise = float(meas.setvalues[0])
measrise = float(meas.measvalue['Rise'])
measfall = float(meas.measvalue['Fall'])
# print ('measrise = ' , measrise, ' measfall = ' , measfall)
if self.scantype == 'fall':
a_setparam = np.append(a_setparam, setfall)
a_measparam = np.append(a_measparam, measfall)
if self.scantype == 'rise':
a_setparam = np.append(a_setparam, setrise)
a_measparam = np.append(a_measparam, measrise)
if self.typeofsignal == 'bias':
setval = float(meas.setvalues[0])
measmean = float(meas.measvalue['Mean'])
measrms = float(meas.measvalue['RMS'])
a_setparam = np.append(a_setparam, setval)
a_measparam = np.append(a_measparam, measmean)
a_measparam1 = np.append(a_measparam1, measrms)
return [a_setparam, a_measparam, a_measparam1]
def read_ClintYaleAccentedTischendorf_write_linear():
dir = ClintYaleAccentedTischbasedir
suffix = ""
rd = reader.Reader(dir, suffix)
rd.read_NT(reader.read_AccentedTischendorf)
rd.write_Linear()
return rd
def execute(input_folder_name, output_folder_name, file_num, data_hash):
input_name = ('input%0{}d.txt'.format(len(
str(number_of_files)))) % file_num
output_name = ('output%0{}d.txt'.format(len(
str(number_of_files)))) % file_num
rd = reader.Reader(input_folder_name=input_folder_name)
writer = Writer(output_folder_name=output_folder_name)
simplifier = Simplifier()
execution_lt = [
(simplifier.tautoly, "tautoly"),
(simplifier.blocked_clause, "blocked_clause"),
(simplifier.subsumption_elimination, "subsumption_elimination"),
(simplifier.hidden_tautoly, "hidden_tautoly"),
(simplifier.hidden_blocked_clause, "hidden_blocked_clause"),
(simplifier.hidden_subsumption_elimination,
"hidden_subsumption_elimination"),
(simplifier.asymmetric_tautoly, "asymmetric_tautoly"),
(simplifier.asymmetric_blocked_clause, "asymmetric_blocked_clause"),
(simplifier.asymmetric_subsumption_elimination,
"asymmetric_subsumption_elimination"),
(simplifier.explicits, "explicits"),
(simplifier.hiddens, "hiddens"),
(simplifier.asymmetrics, "asymmetrics"),
(simplifier.complete, "Complete"),
]
for function, function_name in execution_lt:
execution(function, rd, writer, input_name, output_name, function_name,
data_hash)
def freeze_graph_test():
dataset = reader.Reader(FLAGS.data_dir, FLAGS)
pb_path = './tools/pbmodel.pb'
with tf.Graph().as_default():
output_graph_def = tf.GraphDef()
with open(pb_path, "rb") as f:
output_graph_def.ParseFromString(f.read())
tf.import_graph_def(output_graph_def, name="")
with tf.Session() as sess:
sess.run(tf.global_variables_initializer())
# 定义输入的张量名称,对应网络结构的输入张量
input_image_tensor = sess.graph.get_tensor_by_name("Placeholder:0")
input_keep_prob_tensor = sess.graph.get_tensor_by_name(
"Placeholder_2:0")
# 定义输出的张量名称
output_tensor_name = sess.graph.get_tensor_by_name("output/add:0")
batch_size = 10
batch_num = 50
for i in range(batch_num):
batch_x, batch_y = dataset.test.next_batch(batch_size,
shuffle=False)
res = sess.run(output_tensor_name,
feed_dict={
input_image_tensor: batch_x,
input_keep_prob_tensor: 1.0
})
print(i, res)
def run(self):
ax = plt.axes()
rd = reader.Reader('elink.data.log','Data Logs')
while(True):
data, total_rows = rd.get_unread_logs()
#if not new data
if total_rows == 0:
plt.pause(3)
continue
for data_row in data:
data_array = data_row.split(',')
try:
time = data_array[self.time_index]
self.gond_x = float(data_array[self.index_x])
self.gond_y = float(data_array[self.index_y])
self.antenna_theta = float(data_array[self.angle_index])
except:
continue
min_x = min(self.gond_x , self.ground_x)
max_x = max(self.gond_x , self.ground_x)
distance_x = max_x - min_x
min_y = min(self.gond_y, self.ground_y)
max_y = max(self.gond_y, self.ground_y)
#pause
plt.pause(0.000001)
self.arrow_length = distance_x * 0.1
r_s , theta_s = self.cart2pol(0,self.arrow_length)
theta_s = math.radians(self.antenna_theta)
x_s , y_s = self.pol2cart(r_s, theta_s)
ax.clear()
padding = distance_x * 0.15
ax.set_xlim(min_x - padding , max_x + padding)
ax.set_ylim(min_y - padding , max_y + padding)
ax.grid(True)
ax.title.set_text('Antenna at {time}'.format(time=self.format_time(time)))
ax.arrow(self.gond_x, self.gond_y, x_s, y_s,head_starts_at_zero=True, width=0.0003, head_width=0.0009, head_length=0.0004, fc='lightblue', ec='red')
ax.plot(self.ground_x , self.ground_y, 'o', color='black')
ax.plot([self.ground_x,self.gond_x], [self.ground_y, self.gond_y], '-.k') # dashdot black
plt.show()
def __init__(self, path):
self.path = path
self.reader = reader.Reader()
self.abspath = os.path.join(self.root_path, path)
self.content = None
self._meta = None
self._body = None
self.initialize()
def create_new_reader(self):
"""
Create all reader
:return:
"""
self.reader_list.clear()
for i in range(1, 4):
self.reader_list.append(reader.Reader(i))
def test2():
"""Running v1 using only the WebCrawler class"""
webcrawler = crawler.WebCrawler(url="debeukenhuisartsen.praktijkinfo.nl")
webcrawler.crawl()
entry = webcrawler.html[0]
print('html\'s:', len(webcrawler.html))
r = reader.Reader(entry['html'], entry['url'])
r.test()
def graph_average(onBoolean,subList,graphData,refresh,days):
if subList is None:
logger.debug("cant graph 24hr b/c there are no streams selected")
raise PreventUpdate
logger.debug(refresh)
if graphData is not None and refresh is None:
return graphData,graphData
if onBoolean:
graphs = []
#start averaging over 24hrs
window = 60*60
hours = 24
start = time.time()-24*60*60*days
stop = time.time()-window - 24*60*60*days
read = reader.Reader(config,logger)
for stream in subList:
figure = {
'data':[],
'layout':{'title':'Graph of {} averaged over 24hrs'.format(stream),'uirevision':stream},
}
#get the averages
data = []
logger.debug("starting read for stream {}".format(stream))
for i in range(hours):
start = start - window
stop = stop - window
r = read.get_stream_stat_data(stream,start=start,stop=stop)
data.append(r)
logger.debug("done with read {}/{} for stream {}".format(i+1,24,stream))
#now format the data
xx = []
yy = {}
for val in data:
xx.append(pd.to_datetime(val['measurement_time']['start']/(2**32),
unit='s',utc=True).dt.tz_convert("US/Central"))
for keys in val:
if keys != 'measurement_time':
if keys not in yy.keys():
yy[keys] = []
yy[keys].append(val[keys]['average'])
for key in yy:
figure['data'].append({'x':xx,'y':yy[key],'type':'scatter','name':key})
graphs.append(dcc.Graph(
id='graph-{}'.format(stream),
figure = figure))
read.close()
return html.Div(graphs),html.Div(graphs)
else:
raise PreventUpdate
def predict(self, predict_data_lines):
if self.predict_queue is None:
self.predict_queue = reader.Reader(subtoken_to_index=self.subtoken_to_index,
node_to_index=self.node_to_index,
target_to_index=self.target_to_index,
config=self.config, is_evaluating=True)
self.predict_placeholder = tf.placeholder(tf.string)
reader_output = self.predict_queue.process_from_placeholder(
self.predict_placeholder)
reader_output = {key: tf.expand_dims(
tensor, 0) for key, tensor in reader_output.items()}
self.predict_top_indices_op, self.predict_top_scores_op, _, self.attention_weights_op = \
self.build_test_graph(reader_output)
self.predict_source_string = reader_output[reader.PATH_SOURCE_STRINGS_KEY]
self.predict_path_string = reader_output[reader.PATH_STRINGS_KEY]
self.predict_path_target_string = reader_output[reader.PATH_TARGET_STRINGS_KEY]
self.predict_target_strings_op = reader_output[reader.TARGET_STRING_KEY]
self.initialize_session_variables(self.sess)
self.saver = tf.train.Saver()
self.load_model(self.sess)
results = []
for line in predict_data_lines:
predicted_indices, top_scores, true_target_strings, attention_weights, path_source_string, path_strings, path_target_string = self.sess.run(
[self.predict_top_indices_op, self.predict_top_scores_op, self.predict_target_strings_op,
self.attention_weights_op,
self.predict_source_string, self.predict_path_string, self.predict_path_target_string],
feed_dict={self.predict_placeholder: line})
top_scores = np.squeeze(top_scores, axis=0)
path_source_string = path_source_string.reshape((-1))
path_strings = path_strings.reshape((-1))
path_target_string = path_target_string.reshape((-1))
predicted_indices = np.squeeze(predicted_indices, axis=0)
true_target_strings = Common.binary_to_string(
true_target_strings[0])
if self.config.BEAM_WIDTH > 0:
predicted_strings = [[self.index_to_target[sugg] for sugg in timestep]
for timestep in predicted_indices] # (target_length, top-k)
# (top-k, target_length)
predicted_strings = list(map(list, zip(*predicted_strings)))
top_scores = [np.exp(np.sum(s)) for s in zip(*top_scores)]
else:
predicted_strings = [self.index_to_target[idx]
for idx in predicted_indices] # (batch, target_length)
attention_per_path = None
if self.config.BEAM_WIDTH == 0:
attention_per_path = self.get_attention_per_path(path_source_string, path_strings, path_target_string,
attention_weights)
results.append((true_target_strings, predicted_strings,
top_scores, attention_per_path))
return results
def main():
with tf.Session() as session:
config = Config()
r = reader.Reader(vocab_size=config.vocab_size - 4,
num_steps=config.num_steps)
print "vocab_size", len(r.word_to_id)
dialogue = Dialogue(config, variational=False, forward_only=False)
summary_writer = tf.train.SummaryWriter('logdir', session.graph)
dialogue.fit(session, summary_writer, r, nb_epoch=555)
def main():
with tf.Session() as session:
config = Config()
r = reader.Reader(vocab_size=config.vocab_size - 4,
num_steps=config.num_steps)
print "vocab_size", len(r.word_to_id)
with tf.variable_scope("Model", reuse=None):
dialogue = Dialogue(config, variational=False, forward_only=False)
with tf.variable_scope("Model", reuse=True):
test_dialogue = Dialogue(config,
variational=False,
forward_only=True)
tf.global_variables_initializer().run()
for epoch in xrange(10):
r.batch_size = 128
for step, (x, y, x_early_steps,
y_early_steps) in enumerate(r.iterator()):
print("************ x: ", x.shape)
loss, weights = dialogue.step(session, x, y, x_early_steps)
if step % 10 == 1:
print "step {:<4}, loss: {:.4}".format(step, loss)
if loss < 0.2:
print "weights[0] : {}".format(weights[0])
print "weights[1] : {}".format(weights[1])
print "weights[-2] : {}".format(weights[-2])
print "weights[-1] : {}".format(weights[-1])
r.batch_size = 10
for ind, (x, y, x_early_steps,
y_early_steps) in enumerate(r.iterator()):
loss, indices = test_dialogue.step(session, x, y,
x_early_steps, True)
indices = np.array(indices)
for i in range(indices.shape[1]):
print "************"
print "post: ", ' '.join(
map(
lambda ind: r.id_to_word[ind],
filter(
lambda ind: ind != r.control_word_to_id[
'<PAD>'], x[i])))
print "response: ", ' '.join(
map(
lambda ind: r.id_to_word[ind],
filter(
lambda ind: ind != r.control_word_to_id[
'<PAD>'], indices[:, i])))
break # evaluate only one batch
def setupOBDReader():
obdReader = reader.Reader()
obdReader.connect()
availablePIDs = obdReader.checkAvailable()
if not obdReader.conn.is_connected():
exit(1)
obdReader.watch(availablePIDs, pidHandler, dtcHandler)
return obdReader
def predict(self, predict_data_lines):
if not self.model:
print('Model is not initialized')
exit(-1)
predict_reader = reader.Reader(subtoken_to_index=self.subtoken_to_index,
node_to_index=self.node_to_index,
target_to_index=self.target_to_index,
config=self.config,
is_evaluating=True)
results = []
for line in predict_data_lines:
input_tensors = predict_reader.process_from_placeholder(line)
path_source_string = input_tensors[reader.PATH_SOURCE_STRINGS_KEY]
path_strings = input_tensors[reader.PATH_STRINGS_KEY]
path_target_string = input_tensors[reader.PATH_TARGET_STRINGS_KEY]
true_target_strings = input_tensors[reader.TARGET_STRING_KEY]
batched_contexts = self.model.run_encoder(input_tensors, is_training=False)
outputs, final_states = self.model.run_decoder(batched_contexts, input_tensors, is_training=False)
if self.config.BEAM_WIDTH > 0:
predicted_indices = outputs.predicted_ids
top_scores = outputs.beam_search_decoder_output.scores
attention_weights = [tf.no_op()]
else:
predicted_indices = outputs.sample_id
top_scores = tf.constant(1, shape=(1, 1), dtype=tf.float32)
attention_weights = tf.squeeze(final_states.alignment_history.stack(), 1)
top_scores = np.squeeze(top_scores.numpy(), axis=0)
path_source_string = path_source_string.numpy().reshape((-1))
path_strings = path_strings.numpy().reshape((-1))
path_target_string = path_target_string.numpy().reshape((-1))
predicted_indices = np.squeeze(predicted_indices.numpy(), axis=0)
true_target_strings = Common.binary_to_string(true_target_strings.numpy()[0])
if self.config.BEAM_WIDTH > 0:
predicted_strings = [[self.index_to_target[sugg] for sugg in timestep]
for timestep in predicted_indices] # (target_length, top-k)
predicted_strings = list(map(list, zip(*predicted_strings))) # (top-k, target_length)
top_scores = [np.exp(np.sum(s)) for s in zip(*top_scores)]
else:
predicted_strings = [self.index_to_target[idx]
for idx in predicted_indices] # (batch, target_length)
attention_per_path = None
if self.config.BEAM_WIDTH == 0:
attention_per_path = self.get_attention_per_path(path_source_string, path_strings, path_target_string,
attention_weights.numpy())
results.append((true_target_strings, predicted_strings, top_scores, attention_per_path))
return results
def main():
filenames = ('a_example.in', 'b_should_be_easy.in', 'c_no_hurry.in',
'd_metropolis.in', 'e_high_bonus.in')
filename = filenames[1]
out_filename = '../output/{}_MCTS.out'.format(
filename[:filename.index('.')])
r = reader.Reader('../dataset/' + filename)
a = algorithm.MCTSAlgorithm(r.get_rides(), r.get_meta_info())
a.assign_rides()
w = writer.Writer(a.assigned_rides, out_filename)
def load(vidname):
import reader, trace, traj
vname, wname, mname = fnames(vidname)
v = reader.Reader(vname, adjuststipple=0)
w = trace.Load_Whiskers(wname)
try:
m = traj.MeasurementsTable(mname)
except:
traceback.print_exc(file=sys.stdout)
sys.stdout.flush()
m = None
return v, w, m
def handle_echo_client(ws):
while True:
#msg = ws.receive()
#if msg == "quit":
# ws.close_connection()
# break
nfc_reader = reader.Reader()
badge_id = nfc_reader.read_badge()
ws.send(badge_id)
nfc_reader.release_context()
del nfc_reader
time.sleep(1)
def engines():
user_login = request.form.get("username")
password = request.form.get("pass")
name = request.form.get("name")
writer = request.form.get("writer")
user = reader.Reader(user_login, password, name, writer)
if my_lib.check_login(user.login) == True:
flash("username already exist")
return render_template("registration.html")
my_lib.add_user(user)
flash("thank you for registering")
return render_template("index.html")
def login():
if current_user.is_authenticated:
return redirect(url_for('search'))
user = reader.Reader(request.form.get("usernamelog"),
request.form.get("passlog"), "any", "any")
if my_lib.check_user(user) == True:
print('this way')
reader1 = my_lib.get_reader(request.form.get("usernamelog"))
login_user(reader1)
#session['user']=request.form.get("usernamelog")
return redirect(url_for("search"))
else:
flash("incorrect username or password")
return render_template("index.html")
def main():
x_image = tf.placeholder(tf.float32, [None, 66, 200, 3])
keep_prob = tf.placeholder(tf.float32)
y = tf.placeholder(tf.float32, [None, 1])
model = Nivdia_Model(x_image, y, keep_prob, FLAGS, False)
# dataset reader
dataset = reader.Reader(FLAGS.data_dir, FLAGS)
saver = tf.train.Saver()
with tf.Session() as sess:
# initialize all varibales
sess.run(tf.global_variables_initializer())
# restore model
print(FLAGS.model_dir)
path = tf.train.latest_checkpoint(FLAGS.model_dir)
if path is None:
print("Err: the model does NOT exist")
exit(0)
else:
saver.restore(sess, path)
print("Restore model from", path)
batch_x, batch_y = dataset.train.next_batch(FLAGS.visualization_num,
False)
y_pred = sess.run(model.prediction,
feed_dict={
x_image: batch_x,
keep_prob: 1.0
})
masks = sess.run(model.visualization_mask,
feed_dict={
x_image: batch_x,
keep_prob: 1.0
})
if not os.path.exists(FLAGS.result_dir):
os.makedirs(FLAGS.result_dir)
for i in range(FLAGS.visualization_num):
image, mask, overlay = visualize(batch_x[i], masks[i])
cv2.imwrite(os.path.join(FLAGS.result_dir, "image_" + str(i) + ".jpg"),
image)
cv2.imwrite(os.path.join(FLAGS.result_dir, "mask_" + str(i) + ".jpg"),
mask)
cv2.imwrite(
os.path.join(FLAGS.result_dir, "overlay_" + str(i) + ".jpg"),
overlay)
def main():
reader1 = our_reader.Reader(cfg['vocab_size'], cfg['buckets'])
reader2 = cornell_reader.Reader(cfg)
reader1.build_dict(cfg['dictionary_name'], cfg['reversed_dictionary_name'], cfg['path']['train'])
reader1.read_data(cfg['path']['train'])
encoder_inputs_10 = [i for i in reader.dataset_enc if len(i) == 10]
decoder_inputs_10 = [i for i in reader.dataset_dec if len(i) == 10]
encoder_inputs__toks_10 = [i for i in reader.dataset_enc_tok if len(i) == 10]
decoder_inputs__toks_10 = [i for i in reader.dataset_dec_tok if len(i) == 10]
print("done")
model.create_placeholders()
def main():
if len(sys.argv) < 2:
sys.stderr.write("usage:\n\treader.py /dev/cu.{port}\n")
sys.exit(1)
th = reader.Reader(sys.argv[1])
garden = GardenServer(th)
httpd = make_server('', 8000, garden)
print("Serving on port 8000...")
# Serve until process is killed
#httpd.serve_forever()
serve_thread = threading.Thread(target=httpd.serve_forever)
sensor_thread = threading.Thread(target=th.run)
serve_thread.start()
sensor_thread.start()
def main():
"""Program Starts here."""
parser = argparse.ArgumentParser(prog='sync_ghs.py')
parser.add_argument("-f",
nargs=1,
required=True,
help="File with the input data.")
args = parser.parse_args()
log_file = "logs/sync_ghs_%s.log" % time.strftime("%Y%m%d_%H%M%S")
setup_log(log_file, logging.INFO)
input_parser = reader.Reader(args.f[0])
if not input_parser.read_data():
logging.error("Parsing of input file failed.")
sys.exit(-1)
def encode(self, predict_data_lines):
if not self.model:
print('Model is not initialized')
exit(-1)
predict_reader = reader.Reader(subtoken_to_index=self.subtoken_to_index,
node_to_index=self.node_to_index,
target_to_index=self.target_to_index,
config=self.config,
is_evaluating=True)
results = []
for line in predict_data_lines:
input_tensors = predict_reader.process_from_placeholder(line)
batched_contexts = self.model.run_encoder(input_tensors, is_training=False)
results.append(batched_contexts)
return results
def __init__(self, sess, learning_rate, data_sets_path, batch_size, canvas_size, window_size, threads, max_steps,
save_path, optimizer, kwidth, stride, is_train, beta1, summary_step, saver_step):
self.bach_size = batch_size
self.saver_step = saver_step
self.summary_step = summary_step
self.canvas_size = canvas_size
self.beta1 = beta1
self.is_train = is_train
self.stride = stride
self.kwidth = kwidth
self.sess = sess
self.optimizer = optimizer
self.save_path = save_path
self.max_step = max_steps
self.learning_rate = learning_rate
self.window_size = window_size
self.wav_data, self.label_data = reader.Reader(data_sets_path, canvas_size, batch_size, window_size,
threads).get_batch()
def download_all(self):
"""すべて（総理大臣の情報を記したCSVファイル・画像ファイル群・縮小画像ファイル群）をダウンロードし、テーブルを応答する。"""
if os.path.isdir(self._base_directory + "/images"):
shutil.rmtree(self._base_directory + "/images")
os.makedirs(self._base_directory + "/images")
if os.path.isdir(self._base_directory + "/thumbnails"):
shutil.rmtree(self._base_directory + "/thumbnails")
os.makedirs(self._base_directory + "/thumbnails")
self.download_csv()
a_reader = reader.Reader(self._base_directory + "/PrimeMinisters.csv")
a_table = a_reader.table()
image_names = a_table.image_filenames()
self.download_images(image_names)
thumbnails_names = a_table.thumbnail_filenames()
self.download_images(thumbnails_names)
return a_table
def setupUi(self):
#self.setStyleSheet("QWidget {border-image: url(/home/pi/guiPythonLABFAB/images/Baned.png)}")
self.setVisible(False)
self.imageCase = {'enrollIn':'/home/pi/guiPythonLABFAB/images/Enroll.png',
'nonEnroll':'/home/pi/guiPythonLABFAB/images/NonEnroll.png',
'nonSystemEnroll':'/home/pi/guiPythonLABFAB/images/NonSystemEnroll.png',
'enrollOut':'/home/pi/guiPythonLABFAB/images/EnrollOut.png',
'visit':'/home/pi/guiPythonLABFAB/images/Visit.png',
'baned':'/home/pi/guiPythonLABFAB/images/Baned',
'enrolling': 'images/Enrrolling.png',
'waiting': 'Wait.png'}
self.labeltext = QLabel(self)
self.labeltext.setStyleSheet("border-image: none; font: 80pt; color: white;")
self.labeltext.setVisible(False)
self.thread = reader.Reader()
self.thread.sig1.connect(self.screenResponse)
self.thread.sig2.connect(self.screenResponse)
self.thread.start()
self.lab_id = 1
