def changeState(c, message):
header = message.header
if header.flagSet(Flag.F):
c.ackPackages(message.header.aNum + 1)
h = Header(c.streamID, c.sNum, c.aNum, Flags([Flag.A]), c.window)
m = Message(h)
c.send(m, True)
c.resetFinTimer()
return Time_Wait
return Closed
def changeState(c: Connection, message: Message):
header = message.header
if header.flagSet(Flag.A):
if header.sNum == c.aNum:
c.ackPackages(header.aNum)
#if it fits
if header.dataLength == 0:
if (c.lastReceivedAck == header.aNum):
c.duplicateAcks += 1
else:
c.lastReceivedAck = header.aNum
c.duplicateAcks = 0
if c.sendData():
return Fin_Wait_1
if c.duplicateAcks > 2:
c.resendInFlight()
if c.sendData():
return Fin_Wait_1
else:
#add data
c.lastReceivedAck = header.aNum
c.received += message.payload[:header.dataLength]
c.aNum = message.header.sNum + message.header.dataLength # update num
if c.sendData(True):
return Fin_Wait_1
else:
#duplicate Ack back - package did not fit
h = Header(c.streamID, c.sNum, c.aNum, Flags([Flag.A]),
c.window)
c.send(Message(h), True)
return Established
if header.flagSet(Flag.F):
h = Header(c.streamID, c.sNum, c.aNum, Flags([Flag.F]), c.window)
message = Message(h)
c.send(message)
c.sNum += 1
return Close_Wait
return Established
class PicklingFlagsCreatedAndStoredAtClassScope(
test_base.PicklingSuccessTestBase):
DynamicallyCreatedInnerFlags = Flags(
'DynamicallyCreatedInnerFlags',
'f0 f1 f2 f3',
module=__name__,
qualname=
'PicklingFlagsCreatedAndStoredAtClassScope.DynamicallyCreatedInnerFlags',
)
FlagsClass = DynamicallyCreatedInnerFlags
def main():
app = QCoreApplication([])
flags = Flags()
proc = subprocess.Popen([sys.executable, "subprogram.py"],
stdout=subprocess.PIPE,
shell=False)
thread = SubProgramWatcher(proc, flags, 55)
thread.finished.connect(app.exit)
thread.finished.connect(cleanup)
thread.start()
sys.exit(app.exec_())
def changeState(c, message):
header = message.header
if header.flagSet(Flag.S):
c.window = header.window
c.aNum += 1
h = Header(c.streamID, c.sNum, c.aNum, Flags([Flag.A, Flag.S]),
c.window)
message = Message(h)
c.send(message)
c.sNum += 1
return Syn_Rcvd
return Listen
def search_button(self, bot, query, chat_id):
"""
Кнопка поиска
Args:
bot (:class:`telegram.Bot`): хэндлер бота
query (:class:`telegram.CallbackQuery`): возвращаемое значение от inline клавиатуры
chat_id (:obj:`int`) id пользователя
"""
bot.edit_message_text(text="Please send me the name of the title: ",
chat_id=chat_id,
message_id=query.message.message_id)
flags[chat_id] = Flags()
flags[chat_id].set_flag_search(True)
def changeState(c, message):
header = message.header
if header.flagSet(Flag.S) and header.flagSet(Flag.A):
c.aNum = header.aNum
c.sNum += 1
h = Header(c.streamID, c.sNum, c.aNum, Flags([Flag.A]), c.window)
c.send(Message(h), True)
c.ackPackages(header.aNum)
if c.sendData():
return Fin_Wait_1
return Established
return Syn_Sent
def inference(config_file, image_file):
""" Run text recognition network on an image file.
"""
# Get config
FLAGS = Flags(config_file).get()
out_charset = load_charset(FLAGS.charset)
num_classes = len(out_charset)
net = get_network(FLAGS, out_charset)
if FLAGS.use_rgb:
num_channel = 3
mode = cv2.IMREAD_COLOR
else:
num_channel = 1
mode = cv2.IMREAD_GRAYSCALE
# Input node
image = tf.placeholder(tf.uint8,
shape=[None, None, num_channel],
name='input_node')
# Network
proc_image = net.preprocess_image(image, is_train=False)
proc_image = tf.expand_dims(proc_image, axis=0)
proc_image.set_shape(
[None, FLAGS.resize_hw.height, FLAGS.resize_hw.width, num_channel])
logits, sequence_length = net.get_logits(proc_image,
is_train=False,
label=None)
prediction, log_prob = net.get_prediction(logits, sequence_length)
prediction = tf.sparse_to_dense(sparse_indices=prediction.indices,
sparse_values=prediction.values,
output_shape=prediction.dense_shape,
default_value=num_classes,
name='output_node')
# Restore
restore_model = get_init_trained()
sess = tf.Session()
restore_model(sess, FLAGS.eval.model_path)
# Run
img = cv2.imread(image_file, mode)
img = np.reshape(img, [img.shape[0], img.shape[1], num_channel])
predicted = sess.run(prediction, feed_dict={image: img})
string = get_string(predicted[0], out_charset)
string = adjust_string(string, FLAGS.eval.lowercase,
FLAGS.eval.alphanumeric)
print(string)
return string
class PicklingFailure(TestCase):
DynamicInnerFlags = Flags('DynamicInnerFlags',
'f0 f1 f2 f3',
module=__name__)
def test_pickling_fails_with_dynamically_created_class_without_module_name(
self):
self.assertRaises(pickle.PicklingError, pickle.dumps,
DynamicModuleScopeFlagsWithoutModuleName.f0)
def test_pickling_fails_with_dynamically_created_inner_class_without_qualname(
self):
self.assertRaises(pickle.PicklingError, pickle.dumps,
self.DynamicInnerFlags.f0)
def test_subclassing_fails_if_at_least_one_flags_base_class_isnt_abstract(self):
class NonAbstract(Flags):
f0 = ()
class Abstract1(Flags):
pass
class Abstract2(Flags):
pass
with self.assertRaisesRegex(
RuntimeError, re.escape("You can't subclass 'NonAbstract' because it has already defined flag members")):
NonAbstract('MyFlags', 'flag1 flag2')
with self.assertRaisesRegex(
RuntimeError, re.escape("You can't subclass 'NonAbstract' because it has already defined flag members")):
NonAbstract('MyFlags', 'flag1 flag2', mixins=[Abstract1])
with self.assertRaisesRegex(
RuntimeError, re.escape("You can't subclass 'NonAbstract' because it has already defined flag members")):
Flags('MyFlags', 'flag1 flag2', mixins=[NonAbstract])
with self.assertRaisesRegex(
RuntimeError, re.escape("You can't subclass 'NonAbstract' because it has already defined flag members")):
Flags('MyFlags', 'flag1 flag2', mixins=[Abstract1, NonAbstract])
with self.assertRaisesRegex(
RuntimeError, re.escape("You can't subclass 'NonAbstract' because it has already defined flag members")):
Flags('MyFlags', 'flag1 flag2', mixins=[Abstract1, NonAbstract, Abstract2])
with self.assertRaisesRegex(
RuntimeError, re.escape("You can't subclass 'NonAbstract' because it has already defined flag members")):
Abstract1('MyFlags', 'flag1 flag2', mixins=[NonAbstract])
with self.assertRaisesRegex(
RuntimeError, re.escape("You can't subclass 'NonAbstract' because it has already defined flag members")):
Abstract1('MyFlags', 'flag1 flag2', mixins=[Abstract2, NonAbstract])
def sendData(self, ackIfNone=False):
if self.toSend is not None:
for _ in range(self.window - len(self.inFlight)):
if self.toSend.empty():
if len(self.inFlight) == 0:
h = Header(self.streamID, self.sNum, self.aNum,
Flags([Flag.F]), self.window)
m = Message(h)
self.send(m)
self.sNum += 1
return True
return False
payload = self.toSend.next(100)
h = Header(self.streamID, self.sNum, self.aNum,
Flags([Flag.A]), self.window)
m = Message(h, payload)
self.send(m)
self.sNum += len(payload)
elif ackIfNone:
h = Header(self.streamID, self.sNum, self.aNum, Flags([Flag.A]),
self.window)
self.send(Message(h), True)
return False
def __init__(self):
self.__dict__['_internals'] = dict(ax=0,
cx=0,
dx=0,
bx=0,
sp=0,
bp=0,
si=0,
di=0,
cs=0,
ds=0,
ss=0,
es=0,
ip=0,
flags=Flags())
def main():
# Load initial config
cfgList = {}
macroList = {}
flags = Flags()
loadConfig(flags.dir + 'pulautin.conf', flags)
# Parse command line arguments
parser = createArgParser()
parseArgs(parser, flags)
# Specify template directory, check for existence
templateDir = 'templates/projects/' + flags.cfgList['TEMPLATE'] + '/'
if not os.path.isdir(templateDir):
print('ERROR: project template from directory \'' + templateDir +
'\' not found')
printConfig(flags)
return 1
printConfig(flags) # TEMP
# Check for configuration errors
if flags.cfgList['PROJECT_NAME'] == '':
print("Error: Please provide project name (option -p)")
return 1
if flags.cfgList['DEST_ROOT'] == '':
print("Error: Please provide destination root directory (option -d)")
return 1
destDir = flags.cfgList['DEST_ROOT'] + '/' + flags.cfgList[
'PROJECT_NAME'] + '/'
if os.path.isdir(destDir):
if flags.force:
shutil.rmtree(destDir)
else:
print('Error: directory \'' + destDir + '\' already exists')
return 1
# Copy template to destination directory
copyTemplate(templateDir, destDir)
# Build the project according to the XML
buildProject(destDir, flags)
setupRemote(destDir, flags)
def main(argv):
printtime = False
i = 0
while i < len(argv):
if argv[i] == "--jit":
jitarg = argv[i + 1]
del argv[i:i + 2]
print jitarg, argv
jit.set_user_param(None, jitarg)
if argv[i] == "--time":
printtime = True
i += 1
patternfilename = argv[1]
inputfilename = argv[2]
patternfile = open(patternfilename, "r")
inputfile = open(inputfilename, "r")
pattern = patternfile.read()
patternfile.close()
inputstring = inputfile.read()
inputfile.close()
inputstring = inputstring.strip()
flags = Flags(optimize_char=True, optimize_testchar=True)
if not flags.optimize_choicepoints:
jit.set_param(
None, "enable_opts",
"intbounds:rewrite:virtualize:string:pure:earlyforce:heap")
if we_are_translated():
gct1 = rgc.get_stats(rgc.TOTAL_GC_TIME)
else:
gct1 = 0
t1 = time.time()
captures = runbypattern(pattern, inputstring, flags=flags).captures
output = processcaptures(captures, inputstring)
t2 = time.time()
if we_are_translated():
gct2 = rgc.get_stats(rgc.TOTAL_GC_TIME)
else:
gct2 = 0
print output
if printtime:
print "time:", t2 - t1
print "gc time:", (gct2 - gct1) / 1000.
return 0
def processcaptures(captures, inputstring, flags=Flags()):
#returnlist = []
out = rstring.StringBuilder()
if flags.debug:
print captures
while captures.prev is not None:
if isinstance(captures, SimpleCapture):
size = captures.get_size()
index = captures.index
newindex = index - size
assert newindex >= 0
assert index >= 0
out.append_slice(inputstring, newindex, index)
out.append("\n")
elif isinstance(captures, PositionCapture):
appendee = "POSITION:" + str(captures.index)
out.append(appendee + "\n")
captures = captures.prev # capturelist
return out.build() # returnlist
def create_data(self):
# Write variables
variables = ProjectVariables(self.data)
variables.define_variable()
files = ProjectFiles(self.data)
files.write_variables()
variables.define_project()
variables.define_target()
# Write Macro
macros = Macro()
macros.write_macro(self.data)
# Write Output Variables
variables.write_output()
# Write Include Directories
depends = Dependencies(self.data)
if self.data['includes']:
depends.write_include_dir()
else:
send('Include Directories is not set.', '')
# Write Dependencies
depends.write_dependencies()
# Add additional code or not
if self.data['additional_code'] is not None:
files.add_additional_code(self.data['additional_code'])
# Write Flags
all_flags = Flags(self.data)
all_flags.write_flags()
# Write and add Files
files.write_files()
files.add_artefact()
# Link with other dependencies
depends.link_dependencies()
# Close CMake file
self.data['cmake'].close()
def test_instantiation_of_abstract_flags_class_fails(self):
# A flags class is considered to be "abstract" if it doesn't define any members.
with self.assertRaisesRegex(RuntimeError, r"Instantiation of abstract flags class '.+\.Flags' isn't allowed."):
Flags()
class MyAbstractFlagsClass(Flags):
pass
with self.assertRaisesRegex(RuntimeError,
r"Instantiation of abstract flags class "
r"'.+\.MyAbstractFlagsClass' isn't allowed."):
MyAbstractFlagsClass()
# Subclassing MyAbstractFlagsClass by calling it:
MyAbstractFlagsClass_2 = MyAbstractFlagsClass('MyAbstractFlagsClass_2', '')
with self.assertRaisesRegex(RuntimeError,
r"Instantiation of abstract flags class "
r"'.+\.MyAbstractFlagsClass_2' isn't allowed."):
MyAbstractFlagsClass_2()
def main():
# Load initial config
flags = Flags()
loadConfig(flags.dir + 'pulautin.conf', flags)
# Parse command line arguments
parser = createArgParser()
parseArgs(parser, flags)
# Check for configuration errors
if flags.cfgList['PROJECT_PATH'] == '':
print("Error: Please provide project path")
return 1
destDir = flags.cfgList['PROJECT_PATH'] + '/'
if not os.path.isdir(destDir):
print('Error: directory \'' + destDir + '\' does not exist')
return 1
buildProject(destDir, flags)
printConfig(flags.cfgList, flags)
def parseArguments() -> Tuple[str, List[str], Flags]:
""" Process sys.argv to get command, arguments and flags """
# Ignore `sys.argv[0]` and empty args
argv: List[str] = [arg for arg in sys.argv[1:] if len(arg)]
# From argv, separate flags and arguments
args: List[str] = [v for v in argv if v[0] != '-']
flags: List[str] = [v for v in argv if v[0] == '-']
# Fixing args that start with an escaped hyphen
for i in range(len(args)):
if args[i].startswith(r'\-'):
args[i] = args[i][1:] # Ignore r'\' at [0]
# Safe equivalent to: `command = args.pop(0)`
command: str = args[0] if len(args) else ''
args = args[1:]
flags_object = Flags(flags) # `flags` parsing can cause termination
return (command, args, flags_object)
def delete_title_from_library_button(self, bot, query, chat_id):
"""
Кнопка для удаления фильма из библиотеки
Args:
bot (:class:`telegram.Bot`): хэндлер бота
query (:class:`telegram.CallbackQuery`): возвращаемое значение от inline клавиатуры
chat_id (:obj:`int`) id пользователя
"""
index = int(query.data.split("_")[1])
data = flags[chat_id].get_library()
logger.info("deleting %s" % data[index][1])
postgre = DataBase()
postgre.DeleteFilmFromLibrary(chat_id, data[index][1])
flags[chat_id] = Flags()
flags[chat_id].set_library(postgre.GetUserLibrary(chat_id))
dic = flags[chat_id].get_library()
print(dic)
if dic == {}:
bot.edit_message_text(text=Settings.EmptyLibraryTxt,
chat_id=chat_id,
message_id=query.message.message_id)
return
index = index % len(dic)
text_out = "http://imdb.com/title/tt%s" % dic[index][1]
series_info = postgre.GetSeriesInfo(dic[index][1])
if (series_info):
text_out += "\n *Season* - %s *Episode* - %s" % (
series_info['season'], series_info['episode'])
reply_markup = library_navigate_markup(len(dic), index)
bot.edit_message_text(text=text_out,
chat_id=chat_id,
message_id=query.message.message_id,
reply_markup=reply_markup,
parse_mode=ParseMode.MARKDOWN)
def test_get_z(self):
# testing using 1 everywhere
# thus z = sin 1 + cos 1 = 1.3817732906760363
T = 2
N = 3
new_flags = {'n_mc': 5, 'n_rff': 1, 'd': 1}
myflags = Flags(T, None, None, None)
myflags.set_flags(new_flags)
t = np.matrix([[1], [1]])
y = np.matrix([[1, 1, 1], [1, 1, 1]])
sess = tf.InteractiveSession()
self.myLatnet = ScalableLatnet(flags=myflags,
s=None,
d=1,
t=t,
y=y,
logger=None,
session=sess)
t_tf = tf.cast(t, self.myLatnet.FLOAT)
some_omega = tf.ones(
(myflags.get_flag('n_mc'), myflags.get_flag('n_rff'),
myflags.get_flag('d')),
dtype=self.myLatnet.FLOAT)
some_gamma = tf.ones(
(myflags.get_flag('n_mc'), N, 2 * myflags.get_flag('n_rff')),
dtype=self.myLatnet.FLOAT)
z = self.myLatnet.get_z(gamma=some_gamma,
omega=some_omega,
t=t_tf,
log_variance=tf.log(
tf.constant(1, dtype=self.myLatnet.FLOAT)))
assert z.shape[0] == myflags.get_flag('n_mc')
assert z.shape[1] == N
assert z.shape[2] == T
assert tf.reduce_max(z).eval() == 1.3817732906760363
assert tf.reduce_min(z).eval() == 1.3817732906760363
def main(config_file):
""" Train text recognition network
"""
# Parse configs
FLAGS = Flags(config_file).get()
# Set directory, seed, logger
model_dir = create_model_dir(FLAGS.model_dir)
logger = get_logger(model_dir, 'train')
best_model_dir = os.path.join(model_dir, 'best_models')
set_seed(FLAGS.seed)
# Print configs
flag_strs = [
'{}:\t{}'.format(name, value)
for name, value in FLAGS._asdict().items()
]
log_formatted(logger, '[+] Model configurations', *flag_strs)
# Print system environments
num_gpus = count_available_gpus()
num_cpus = os.cpu_count()
mem_size = virtual_memory().available // (1024**3)
log_formatted(logger, '[+] System environments',
'The number of gpus : {}'.format(num_gpus),
'The number of cpus : {}'.format(num_cpus),
'Memory Size : {}G'.format(mem_size))
# Get optimizer and network
global_step = tf.train.get_or_create_global_step()
optimizer, learning_rate = get_optimizer(FLAGS.train.optimizer,
global_step)
out_charset = load_charset(FLAGS.charset)
net = get_network(FLAGS, out_charset)
is_ctc = (net.loss_fn == 'ctc_loss')
# Multi tower for multi-gpu training
tower_grads = []
tower_extra_update_ops = []
tower_preds = []
tower_gts = []
tower_losses = []
batch_size = FLAGS.train.batch_size
tower_batch_size = batch_size // num_gpus
val_tower_outputs = []
eval_tower_outputs = []
for gpu_indx in range(num_gpus):
# Train tower
print('[+] Build Train tower GPU:%d' % gpu_indx)
input_device = '/gpu:%d' % gpu_indx
tower_batch_size = tower_batch_size \
if gpu_indx < num_gpus-1 \
else batch_size - tower_batch_size * (num_gpus-1)
train_loader = DatasetLodaer(
dataset_paths=FLAGS.train.dataset_paths,
dataset_portions=FLAGS.train.dataset_portions,
batch_size=tower_batch_size,
label_maxlen=FLAGS.label_maxlen,
out_charset=out_charset,
preprocess_image=net.preprocess_image,
is_train=True,
is_ctc=is_ctc,
shuffle_and_repeat=True,
concat_batch=True,
input_device=input_device,
num_cpus=num_cpus,
num_gpus=num_gpus,
worker_index=gpu_indx,
use_rgb=FLAGS.use_rgb,
seed=FLAGS.seed,
name='train')
tower_output = single_tower(net,
gpu_indx,
train_loader,
out_charset,
optimizer,
name='train',
is_train=True)
tower_grads.append([x for x in tower_output.grads if x[0] is not None])
tower_extra_update_ops.append(tower_output.extra_update_ops)
tower_preds.append(tower_output.prediction)
tower_gts.append(tower_output.text)
tower_losses.append(tower_output.loss)
# Print network structure
if gpu_indx == 0:
param_stats = tf.profiler.profile(tf.get_default_graph())
logger.info('total_params: %d\n' % param_stats.total_parameters)
# Valid tower
print('[+] Build Valid tower GPU:%d' % gpu_indx)
valid_loader = DatasetLodaer(dataset_paths=FLAGS.valid.dataset_paths,
dataset_portions=None,
batch_size=FLAGS.valid.batch_size //
num_gpus,
label_maxlen=FLAGS.label_maxlen,
out_charset=out_charset,
preprocess_image=net.preprocess_image,
is_train=False,
is_ctc=is_ctc,
shuffle_and_repeat=False,
concat_batch=False,
input_device=input_device,
num_cpus=num_cpus,
num_gpus=num_gpus,
worker_index=gpu_indx,
use_rgb=FLAGS.use_rgb,
seed=FLAGS.seed,
name='valid')
val_tower_output = single_tower(net,
gpu_indx,
valid_loader,
out_charset,
optimizer=None,
name='valid',
is_train=False)
val_tower_outputs.append(
(val_tower_output.loss, val_tower_output.prediction,
val_tower_output.text, val_tower_output.filename,
val_tower_output.dataset))
# Aggregate gradients
losses = tf.reduce_mean(tower_losses)
grads = _average_gradients(tower_grads)
with tf.control_dependencies(tower_extra_update_ops[-1]):
if FLAGS.train.optimizer.grad_clip_norm is not None:
grads, global_norm = _clip_gradients(
grads, FLAGS.train.optimizer.grad_clip_norm)
tf.summary.scalar('global_norm', global_norm)
train_op = optimizer.apply_gradients(grads, global_step=global_step)
# Define config, scaffold
saver = tf.train.Saver()
sess_config = get_session_config()
scaffold = get_scaffold(saver, FLAGS.train.tune_from, 'train')
restore_model = get_init_trained()
# Define validation saver, summary writer
summaries = tf.get_collection(tf.GraphKeys.SUMMARIES)
val_summary_op = tf.summary.merge(
[s for s in summaries if 'valid' in s.name])
val_summary_writer = {
dataset_name:
tf.summary.FileWriter(os.path.join(model_dir, 'valid', dataset_name))
for dataset_name in valid_loader.dataset_names
}
val_summary_writer['total_valid'] = tf.summary.FileWriter(
os.path.join(model_dir, 'valid', 'total_valid'))
val_saver = tf.train.Saver(max_to_keep=len(valid_loader.dataset_names) + 1)
best_val_err_rates = {}
best_steps = {}
# Training
print('[+] Make Session...')
with tf.train.MonitoredTrainingSession(
checkpoint_dir=model_dir,
scaffold=scaffold,
config=sess_config,
save_checkpoint_steps=FLAGS.train.save_steps,
save_checkpoint_secs=None,
save_summaries_steps=FLAGS.train.summary_steps,
save_summaries_secs=None,
) as sess:
log_formatted(logger, 'Training started!')
_step = 0
train_t = 0
start_t = time.time()
while _step < FLAGS.train.max_num_steps \
and not sess.should_stop():
# Train step
step_t = time.time()
[step_loss, _, _step, preds, gts, lr] = sess.run([
losses, train_op, global_step, tower_preds[0], tower_gts[0],
learning_rate
])
train_t += time.time() - step_t
# Summary
if _step % FLAGS.valid.steps == 0:
# Train summary
train_err = 0.
for i, (p, g) in enumerate(zip(preds, gts)):
s = get_string(p, out_charset, is_ctc=is_ctc)
g = g.decode('utf8').replace(DELIMITER, '')
s = adjust_string(s, FLAGS.train.lowercase,
FLAGS.train.alphanumeric)
g = adjust_string(g, FLAGS.train.lowercase,
FLAGS.train.alphanumeric)
e = int(s != g)
train_err += e
if FLAGS.train.verbose and i < 5:
print('TRAIN :\t{}\t{}\t{}'.format(s, g, not bool(e)))
train_err_rate = \
train_err / len(gts)
# Valid summary
val_cnts, val_errs, val_err_rates, _ = \
validate(sess,
_step,
val_tower_outputs,
out_charset,
is_ctc,
val_summary_op,
val_summary_writer,
val_saver,
best_val_err_rates,
best_steps,
best_model_dir,
FLAGS.valid.lowercase,
FLAGS.valid.alphanumeric)
# Logging
log_strings = ['', '-' * 28 + ' VALID_DETAIL ' + '-' * 28, '']
for dataset in sorted(val_err_rates.keys()):
if dataset == 'total_valid':
continue
cnt = val_cnts[dataset]
err = val_errs[dataset]
err_rate = val_err_rates[dataset]
best_step = best_steps[dataset]
s = '%s : %.2f%%(%d/%d)\tBEST_STEP : %d' % \
(dataset, (1.-err_rate)*100, cnt-err, cnt, best_step)
log_strings.append(s)
elapsed_t = float(time.time() - start_t) / 60
remain_t = (elapsed_t / (_step+1)) * \
(FLAGS.train.max_num_steps - _step - 1)
log_formatted(
logger, 'STEP : %d\tTRAIN_LOSS : %f' % (_step, step_loss),
'ELAPSED : %.2f min\tREMAIN : %.2f min\t'
'STEP_TIME: %.1f sec' %
(elapsed_t, remain_t, float(train_t) / (_step + 1)),
'TRAIN_SEQ_ERR : %f\tVALID_SEQ_ERR : %f' %
(train_err_rate, val_err_rates['total_valid']),
'BEST_STEP : %d\tBEST_VALID_SEQ_ERR : %f' %
(best_steps['total_valid'],
best_val_err_rates['total_valid']), *log_strings)
log_formatted(logger, 'Training is completed!')
def runARM(self):
""" Execute the program using the ARM instruction set. """
self.flags = Flags()
cur_line = 0
while cur_line < len(self.instructions):
instr = self.instructions[cur_line]
operation, condition, sets_flags = parse_arm_instr(instr.operation)
# check for presence of condition and that we DO NOT meet it, in which case we skip to the next instruction
if (cur_line in self.labels.values()) or \
(condition == "eq" and (not self.flags.Z)) or \
(condition == "ne" and self.flags.Z ) or \
(condition in ["cs", "hs"] and (not self.flags.C)) or \
(condition in ["cc", "lo"] and self.flags.C ) or \
(condition == "mi" and (not self.flags.N)) or \
(condition == "pl" and self.flags.N ) or \
(condition == "vs" and (not self.flags.V)) or \
(condition == "vc" and self.flags.V ) or \
(condition == "hi" and ((not self.flags.C) or self.flags.Z) ) or \
(condition == "ls" and ( self.flags.C and (not self.flags.Z))) or \
(condition == "ge" and (self.flags.N != self.flags.V)) or \
(condition == "lt" and (self.flags.N == self.flags.V)) or \
(condition == "gt" and ( self.flags.Z or (self.flags.N != self.flags.V))) or \
(condition == "le" and (not self.flags.Z and (self.flags.N == self.flags.V))):
cur_line += 1
continue
else: # we checked for all of our conditions and either there was none specified or there was one and we met its requirements
if operation == "add":
self.registers[instr.operand0] = self.registers[instr.operand1] + getval(self.registers, instr.operand2)
elif operation == "adc":
self.registers[instr.operand0] = self.registers[instr.operand1] + getval(self.registers, instr.operand2) + self.flags.C
elif operation == "sub":
self.registers[instr.operand0] = self.registers[instr.operand1] - getval(self.registers, instr.operand2)
elif operation == "sbc":
self.registers[instr.operand0] = self.registers[instr.operand1] - getval(self.registers, instr.operand2) + (self.flags.C - 1)
elif operation == "rsb":
self.registers[instr.operand0] = getval(self.registers, instr.operand2) - self.registers[instr.operand1]
elif operation == "rsc":
self.registers[instr.operand0] = getval(self.registers, instr.operand2) - self.registers[instr.operand1] + (self.flags.C - 1)
elif operation == "mul":
self.registers[instr.operand0] = self.registers[instr.operand1] * getval(self.registers, instr.operand2)
elif operation == "div":
self.registers[instr.operand0] = self.registers[instr.operand1] // getval(self.registers, instr.operand2)
# branching
elif operation == "b":
cur_line = self.labels[instr.operand0]
elif operation == "bl":
self.registers[15] = cur_line + 1
cur_line = self.labels[instr.operand0]
# comparisons for setting flags
elif operation == "cmp":
res = self.registers[instr.operand0] - self.registers[instr.operand1]
self.flags.update(N = int(res < 0), Z = int(res == 0))
elif operation == "cmn":
res = self.registers[instr.operand0] + self.registers[instr.operand1]
self.flags.update(N = int(res < 0), Z = int(res == 0), C = int(2**32-1 < res), V = int(2**31-1 < res < 2**32-1))
elif operation == "tst":
res = self.registers[instr.operand0] & self.registers[instr.operand1]
self.flags.update(Z = int(res == 0))
elif operation == "teq":
res = self.registers[instr.operand0] ^ self.registers[instr.operand1]
self.flags.update(Z = int(res == 0))
# logical operations
elif operation == "and":
self.registers[instr.operand0] = self.registers[instr.operand1] & self.registers[instr.operand2]
elif operation == "eor":
self.registers[instr.operand0] = self.registers[instr.operand1] ^ self.registers[instr.operand2]
elif operation == "orr":
self.registers[instr.operand0] = self.registers[instr.operand1] | self.registers[instr.operand2]
elif operation == "bic":
self.registers[instr.operand0] = self.registers[instr.operand1] & (~self.registers[instr.operand2] & 0xFFFFFFFF)
# data movement
elif operation == "mov":
self.registers[instr.operand0] = self.registers[instr.operand1]
elif operation == "mvn":
self.registers[instr.operand0] = (~self.registers[instr.operand1] & 0xFFFFFFFF)
else:
raise ValueError("Unrecognized operation: {0}".format(instr.operation))
if sets_flags:
N = int(self.registers[instr.operand0] < 0)
Z = int(self.registers[instr.operand0] == 0)
C = int(2**32-1 < self.registers[instr.operand0])
V = int(2**31-1 < self.registers[instr.operand0] < 2**32-1)
self.flags.update(N, Z, C, V)
cur_line += 1
return self
#!/usr/bin/python
import numpy as np
import time
from behaviour_exercise import Behaviour_exercise
from pynput.keyboard import Key, Listener
from flags import Flags
from time import time
timeStart = 0
timeEnd = 0
distance = 1
f = Flags()
behaviour = Behaviour_exercise(f)
def set_global():
global timeStart
global timeEnd
timeStart = 0
timeEnd = 0
######################### Jumping and Sound Tests ##############################
"""
print "Kubo says KuBo and jumps"
kubo.say('kuuu.mp3')
time.sleep(1)
kubo.say('bo.mp3')
# Frequency = 0 means kubo jumps only once and exits the thread automatically
def test_int_value_multiple_members(self):
MyFlags = Flags('MyFlags', 'f0 f1 f2')
flag = MyFlags(int(MyFlags.f1) | int(MyFlags.f2))
self.assertIsInstance(flag, MyFlags)
self.assertEqual(flag, MyFlags.f1 | MyFlags.f2)
def test_simple_str_value_zero(self):
MyFlags = Flags('MyFlags', 'f0 f1 f2')
flag = MyFlags(MyFlags.no_flags.to_simple_str())
self.assertIsInstance(flag, MyFlags)
self.assertEqual(flag, MyFlags.no_flags)
def setUp(self):
self.MyFlags = Flags('MyFlags', 'f0 f1 f2')
def test_bool_value_fails(self):
MyFlags = Flags('MyFlags', 'f0 f1 f2')
with self.assertRaisesRegex(TypeError, re.escape(r"Can't instantiate flags class 'MyFlags' from value False")):
MyFlags(False)
def test_simple_str_value_multiple_members(self):
MyFlags = Flags('MyFlags', 'f0 f1 f2')
flag = MyFlags((MyFlags.f1 | MyFlags.f2).to_simple_str())
self.assertIsInstance(flag, MyFlags)
self.assertEqual(flag, MyFlags.f1 | MyFlags.f2)
def test_simple_str_value_single_member(self):
MyFlags = Flags('MyFlags', 'f0 f1 f2')
flag = MyFlags(MyFlags.f1.to_simple_str())
self.assertIsInstance(flag, MyFlags)
self.assertEqual(flag, MyFlags.f1)
