def test_divison(): interpreter = Interpreter('30/2') result = interpreter.expr() assert result == 15.0
def part1(program): return Interpreter(program, [1]).run()
def test_numbers(self): value = Interpreter().visit(NumberNode(51.2)) self.assertEqual(value, Number(51.2))
def __init__(self, configJSON): self.interpreter = Interpreter(configJSON) self.config = self.interpreter.getConfig() self.pluginTemplate = MuseUI(self.interpreter) pass
def get_interpreter(self): return Interpreter(self.lang_opts)
def test_interpreter(): assert Interpreter(Lexer("1 + (2 * 3) + (4 * (5 + 6))")).expr() == 51 assert Interpreter(Lexer("2 * 3 + (4 * 5)")).expr() == 46
(This time I did a compiler to Python) ''' from lexer import Lexer from astparser import Parser text = ''' PROGRAM hello; VAR hi : INTEGER BEGIN a := 1 + 1; {this is a comment} b := a END. ''' if __name__ == '__main__': #text = input('parse> ') ''' ll = Lexer('a := 1') print('Token', c) while c.type != 'EOF': print(c) c = ll.get_next_token() ''' l = Lexer(text) p = Parser(l) from interpreter import Interpreter i = Interpreter(p.program()) print(i.visit())
from cpu import Cpu from interpreter import Interpreter import struct if __name__ == "__main__": src = './code/factorial.asm' i = Interpreter() i.asm_decoder(src) vm = Cpu("./code/factorial.o") # print(vm.__get_data_from_memory(0)) # memory = 4 + 2 * 4 # pos = 0 vm.start() # vm.mm[0:4] = bytearray(struct.pack('I', 42)) # print(struct.unpack('I', vm.mm[pos:pos + 4])) vm.close()
def create_pdf(self, data): """Build, interpret, and distribute PDF award Arguments: self data: dictionary. POST request data, as well as data from the result of the post request keys = award_id, authorizing_user_id, receiving_user_id, awarded_datetime, type Returns: True if email was POST to database successful. False if unsuccessful. Does NOT Return the result of following handling of PDF. This is designed so that an admin could manually generate award & send out if there was an issue with PDF creation -- the user isn't prevented from creating the award if there IS a problem. """ # Set up instances of helper classes builder = Builder(self.connection_data, data['type']) interpreter = Interpreter() distributer = Distributer(data['award_id']) # Build the Award Contents logging.info('AwardDriver.create_pdf(): building award contents') award_data = builder.query_database_for_data(data) modified_award_tex = builder.generate_award_tex(award_data) image = builder.query_bucket_for_image(award_data['SignaturePath']) # Initialize boolean success/failure variables to None pdf, write_successful = (None, None) email_successful, deletion_successful, distributed_updated = (False, False, False) # Build PDF from TEX + JPG if building award contents was successful if image is not None and modified_award_tex is not None: logging.info('AwardDriver.create_pdf(): building PDF') pdf = interpreter.interpret(award_data['SignaturePath'], modified_award_tex, image) # Send email if we have a PDF generated, or just say we did if email_on is False (for testing) if pdf is not None: # Technically don't NEED to additionally write to storage bucket, but it allows for # us to not lose award PDF if something goes wrong in this function # Writing to storage bucket instead of a SQL database because # 1) this is transient / temporary data # 2) it is not best practice to store files in a SQL database. logging.info( 'AwardDriver.create_pdf(): saving PDF to storage bucket') write_successful = interpreter.write_award_to_bucket( data['award_id'], pdf) if self.email_on is True: logging.info('AwardDriver.create_pdf(): distributing email') email_successful = distributer.email_receiving_user( pdf, award_data['email_address'], data['type']) else: email_successful = True # Show we sent email in database -- even if we're using no-email if email_successful is True: logging.info( 'AwardDriver.create_pdf(): updating distributed in database' ) distributed_updated = distributer.update_distributed_in_database( self.connection_data) # Clean-up PDF from storage bucket if email_successful is True and write_successful is True: logging.info( 'AwardDriver.create_pdf(): deleting PDF from storage bucket') deletion_successful = distributer.delete_award_from_bucket() # Only returns true if email sent logging.info( 'AwardDriver.create_pdf(): returning {}'.format(email_successful)) return email_successful
def test_hello(self): sys.stdout = io.StringIO('') code = '++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.' Interpreter(code).run() self.assertEqual(sys.stdout.getvalue(), 'Hello World!\n')
def test_nested_loop(self): sys.stdout = io.StringIO('') code = '++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.' Interpreter(code).run() self.assertEqual(sys.stdout.getvalue(), 'Hello World!\n')
def test_A(self): sys.stdout = io.StringIO('') code = '+++++[>+++++++++++++<-]>.' Interpreter(code).run() self.assertEqual(sys.stdout.getvalue(), 'A')
def interact(): itp = Interpreter() while True: line = raw_input(">>") line = line.strip() itp.interpret(line)
def test_whitespace(): interpreter = Interpreter('3 + 5') result = interpreter.expr() assert result == 8
def __init__(self, debug=False): self.interpreter = Interpreter() self.history = [] self.debug = debug
def part2(): print(Interpreter(read_input(), 5).run())
from interpreter import Interpreter from astcompiler import Compiler from parser_ import Parser from lexer import Lexer kod = """ isim = oku("Adın ne? > ") yaz("Merhaba", isim + "!") """ bytecode = Compiler().compile_ast(Parser(Lexer()).parse(kod)) Interpreter().execute_bytecode(bytecode) print(bytecode)
def test_part1(): assert Interpreter([1002, 4, 3, 4, 33], [1]).run() == [] assert Interpreter([1101, 100, -1, 4, 0], [1]).run() == []
def init_dialog_manager(max_clients, dialog_manager_port): """ Dialog Manager process that listens to messages from the classifier :param max_clients: maximum number of clients that can connect to the dialog manager at a time :param dialog_manager_port: port the dialogue manager socket is running on :return: None """ global socket_conn host = socket.gethostname() dialog_manager_port = dialog_manager_port server_socket = socket.socket() server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1) server_socket.bind((host, dialog_manager_port)) server_socket.listen(max_clients) USER_MEMORY = OrderedDict() USER_TREES = OrderedDict() USER_SLOTS = OrderedDict() while True: try: socket_conn, address = server_socket.accept() data = socket_conn.recv(1024).decode() if data: message_data = json.loads(data) session_id = message_data['sessionid'] intent_name = message_data['intent'] slot_data = message_data['slots'] action_type = message_data['action_type'] user_message = message_data['message'] user_intent_slots = USER_SLOTS.get(session_id) if slot_data is not None: if user_intent_slots is None: user_intent_slots = slot_data USER_SLOTS[session_id] = user_intent_slots else: user_intent_slots.extend(slot_data) if action_type is not None: user_intent_memory = USER_MEMORY.get(session_id) user_intent_tree = USER_TREES.get(session_id) node_id = user_intent_tree[0] tree = user_intent_tree[1] interpreter = Interpreter(tree, user_message, user_intent_slots, user_intent_memory, node_id) response_data = interpreter.interpret() else: intent = get_intent(intent_name) lexer = Lexer(intent) parser = Parser(lexer) tree = parser.parse() interpreter = Interpreter(tree, user_message, user_intent_slots, OrderedDict(), -1) response_data = interpreter.interpret() print('') print('Run-time GLOBAL_MEMORY contents:') for k, v in sorted(interpreter.GLOBAL_MEMORY.items()): print('%s = %s' % (k, v)) interpreter = None if response_data is not None: response_text = response_data.response_text tree = response_data.tree node_id = response_data.node_id global_memory = response_data.global_memory action_type = response_data.action_type USER_MEMORY[session_id] = global_memory USER_TREES[session_id] = (node_id, tree) message_data = {} message_data['sessionid'] = session_id message_data['response_text'] = response_text message_data['action_type'] = action_type message_data['intent'] = intent_name message = json.dumps(message_data) socket_conn.send(message.encode()) if action_type == ACTION_EXIT: del USER_MEMORY[session_id] del USER_TREES[session_id] del USER_SLOTS[session_id] else: message_data = {} message_data['sessionid'] = session_id message_data['response_text'] = None message_data['action_type'] = None message_data['intent'] = None message = json.dumps(message_data) socket_conn.send(message.encode()) except KeyboardInterrupt: socket_conn.close() # intent = get_intent('PieceIntent') # lexer = Lexer(intent) # parser = Parser(lexer) # tree = parser.parse() # # # # semantic_analyser = SemanticAnalyser() # # try: # # semantic_analyser.visit(tree) # # except Exception as e: # # print(e) # # # interpreter = Interpreter(tree, 'test', USER_SLOTS) # response_data = interpreter.interpret() print('') print('Run-time GLOBAL_MEMORY contents:') for k, v in sorted(interpreter.GLOBAL_MEMORY.items()): print('%s = %s' % (k, v))
def part1(): print(Interpreter(read_input(), 1).run())
def run(): opt = parse_argument() if not os.path.isdir(opt.prog_save_path): os.makedirs(opt.prog_save_path) if not os.path.isdir(opt.imgs_save_path): os.makedirs(opt.imgs_save_path) print('========= arguments =========') for key, val in vars(opt).items(): print("{:20} {}".format(key, val)) print('========= arguments =========') # data loader test_set = ShapeNet3D(opt.data) test_loader = DataLoader( dataset=test_set, batch_size=opt.batch_size, shuffle=False, num_workers=opt.num_workers, ) # model ckpt = torch.load(opt.model) model = BlockOuterNet(ckpt['opt']) model.load_state_dict(ckpt['model']) if opt.is_cuda: model = model.cuda() cudnn.benchmark = True # test the model and evaluate the IoU ori_shapes, gen_shapes, pgms, params = test_on_shapenet_data( epoch=0, test_loader=test_loader, model=model, opt=opt, gen_shape=True) IoU = BatchIoU(ori_shapes, gen_shapes) print("Mean IoU: {:.3f}".format(IoU.mean())) # execute the generated program to generate the reconstructed shapes # for double-check purpose, can be disabled num_shapes = gen_shapes.shape[0] res = [] for i in range(num_shapes): data = execute_shape_program(pgms[i], params[i]) res.append(data.reshape((1, 32, 32, 32))) res = np.concatenate(res, axis=0) IoU_2 = BatchIoU(ori_shapes, res) assert abs(IoU.mean() - IoU_2.mean()) < 0.1, 'IoUs are not matched' # save results save_file = os.path.join(opt.save_path, 'shapes.h5') f = h5py.File(save_file, 'w') f['data'] = gen_shapes f['pgms'] = pgms f['params'] = params f.close() # Interpreting programs to understandable program strings if opt.save_prog: interpreter = Interpreter(translate, rotate, end) num_programs = gen_shapes.shape[0] for i in range(min(num_programs, opt.num_render)): program = interpreter.interpret(pgms[i], params[i]) save_file = os.path.join(opt.prog_save_path, '{}.txt'.format(i)) with open(save_file, 'w') as out: out.write(program) # Visualization if opt.save_img: data = gen_shapes.transpose((0, 3, 2, 1)) data = np.flip(data, axis=2) num_shapes = data.shape[0] for i in range(min(num_shapes, opt.num_render)): voxels = data[i] save_name = os.path.join(opt.imgs_save_path, '{}.png'.format(i)) visualization(voxels, threshold=0.1, save_name=save_name, uniform_size=0.9)
def vqahelper(app): if not vqahelper.interpreter: vqahelper.interpreter = Interpreter() return vqahelper.interpreter
def __init__(self, param): np.random.seed(1) torch.manual_seed(999) #if torch.cuda.is_available(): torch.cuda.manual_seed_all(999) self.param = param self.run_interpreter = True self.run_validation = False self.generate_data = False self.param = param if not self.generate_data and os.path.exists(self.param['model_dir'] + '/model_data.pkl'): self.pickled_train_data = pkl.load( open(self.param['model_dir'] + '/model_data.pkl')) else: self.pickled_train_data = {} if 'use_kb_emb' not in self.param: self.param['use_kb_emb'] = True #self.param['use_kb_emb'] = False self.starting_epoch = 0 self.starting_overall_step_count = 0 self.starting_validation_reward_overall = 0 self.starting_validation_reward_topbeam = 0 if 'dont_look_back_attention' not in self.param: self.param['dont_look_back_attention'] = False if 'concat_query_npistate' not in self.param: self.param['concat_query_npistate'] = False if 'query_attention' not in self.param: self.param['query_attention'] = False if self.param['dont_look_back_attention']: self.param['query_attention'] = True if 'single_reward_function' not in self.param: self.param['single_reward_function'] = False if 'terminate_prog' not in self.param: self.param['terminate_prog'] = False terminate_prog = False else: terminate_prog = self.param['terminate_prog'] if 'none_decay' not in self.param: self.param['none_decay'] = 0 if 'train_mode' not in self.param: self.param['train_mode'] = 'reinforce' self.qtype_wise_batching = self.param['questype_wise_batching'] self.read_data = ReadBatchData(param) if self.param['question_type'] == 'all': self.param['question_type'] = ','.join( self.read_data.all_questypes_inv.values()) print "initialized read data" if 'relaxed_reward_till_epoch' in self.param: relaxed_reward_till_epoch = self.param['relaxed_reward_till_epoch'] else: self.param['relaxed_reward_till_epoch'] = [-1, -1] relaxed_reward_till_epoch = [-1, -1] if 'params_turn_on_after' not in self.param: self.param['params_turn_on_after'] = 'epoch' if self.param['params_turn_on_after'] != 'epoch' and self.param[ 'params_turn_on_after'] != 'batch': raise Exception('params_turn_on_after should be epoch or batch') if 'print' in self.param: self.printing = self.param['print'] else: self.param['print'] = False self.printing = True if 'prune_beam_type_mismatch' not in self.param: self.param['prune_beam_type_mismatch'] = 0 if 'prune_after_epoch_no.' not in self.param: self.param['prune_after_epoch_no.'] = [ self.param['max_epochs'], 1000000 ] if self.param['question_type'] == 'verify': boolean_reward_multiplier = 1 else: boolean_reward_multiplier = 0.1 if 'print_valid_freq' not in self.param: self.param['print_valid_freq'] = self.param['print_train_freq'] if 'valid_freq' not in self.param: self.param['valid_freq'] = 100 if 'unused_var_penalize_after_epoch' not in self.param: self.param['unused_var_penalize_after_epoch'] = [ self.param['max_epochs'], 1000000 ] unused_var_penalize_after_epoch = self.param[ 'unused_var_penalize_after_epoch'] if 'epoch_for_feasible_program_at_last_step' not in self.param: self.param['epoch_for_feasible_program_at_last_step'] = [ self.param['max_epochs'], 1000000 ] if 'epoch_for_biasing_program_sample_with_target' not in self.param: self.param['epoch_for_biasing_program_sample_with_target'] = [ self.param['max_epochs'], 1000000 ] if 'epoch_for_biasing_program_sample_with_last_variable' not in self.param: self.param[ 'epoch_for_biasing_program_sample_with_last_variable'] = [ self.param['max_epochs'], 100000 ] if 'use_var_key_as_onehot' not in self.param: self.param['use_var_key_as_onehot'] = False reward_func = "f1" self.param['reward_function'] = "f1" if 'relaxed_reward_strict' not in self.param: relaxed_reward_strict = False self.param['relaxed_reward_strict'] = relaxed_reward_strict else: relaxed_reward_strict = self.param['relaxed_reward_strict'] if param['parallel'] == 1: raise Exception( 'Need to fix the intermediate rewards for parallelly executing interpreter' ) for k, v in param.items(): print 'PARAM: ', k, ':: ', v print 'loaded params ' self.train_data = [] if os.path.isdir(param['train_data_file']): self.training_files = [ param['train_data_file'] + '/' + x for x in os.listdir(param['train_data_file']) if x.endswith('.pkl') ] elif not isinstance(param['train_data_file'], list): self.training_files = [param['train_data_file']] else: self.training_files = param['train_data_file'] random.shuffle(self.training_files) self.valid_data = [] if os.path.isdir(param['test_data_file']): self.valid_files = [ param['test_data_file'] + '/' + x for x in os.listdir(param['test_data_file']) if x.endswith('.pkl') ] elif not isinstance(param['test_data_file'], list): self.valid_files = [param['test_data_file']] else: self.valid_files = param['test_data_file'] for file in self.valid_files: temp = pkl.load(open(file)) #temp = self.rectify_ques_type(temp) #temp = self.remove_bad_data(temp) temp = self.add_data_id(temp) self.valid_data.extend(temp) if self.qtype_wise_batching: self.valid_data_map = self.read_data.get_data_per_questype( self.valid_data) self.valid_batch_size_types = self.get_batch_size_per_type( self.valid_data_map) self.n_valid_batches = int( math.ceil( float(sum([len(x) for x in self.valid_data_map.values()]))) / float(self.param['batch_size'])) else: self.n_valid_batches = int( math.ceil( float(len(self.valid_data)) / float(self.param['batch_size']))) if not os.path.exists(param['model_dir']): os.mkdir(param['model_dir']) self.model_file = os.path.join(param['model_dir'], param['model_file']) learning_rate = param['learning_rate'] start = time.time() self.model = NPI(param, self.read_data.none_argtype_index, self.read_data.num_argtypes, \ self.read_data.num_progs, self.read_data.max_arguments, self.read_data.wikidata_rel_embed, self.read_data.wikidata_rel_date_embed, \ self.read_data.vocab_init_embed, self.read_data.program_to_argtype, \ self.read_data.program_to_targettype) self.checkpoint_prefix = os.path.join(param['model_dir'], param['model_file']) if os.path.exists(self.checkpoint_prefix): self.model.load_state_dict(torch.load(self.checkpoint_prefix)) fr = open(self.param['model_dir'] + '/metadata.txt').readlines() self.starting_epoch = int(fr[0].split(' ')[1].strip()) self.starting_overall_step_count = int(fr[1].split(' ')[1].strip()) self.starting_validation_reward_overall = float( fr[2].split(' ')[1].strip()) self.starting_validation_reward_topbeam = float( fr[3].split(' ')[1].strip()) print 'restored model' end = time.time() if torch.cuda.is_available(): self.model.cuda() self.optimizer = torch.optim.Adam(self.model.parameters(), lr=learning_rate, betas=[0.9, 0.999], weight_decay=1e-5) print self.model #self.printing = False print 'model created in ', (end - start), 'seconds' self.interpreter = Interpreter(self.param['freebase_dir'], self.param['num_timesteps'], \ self.read_data.program_type_vocab, self.read_data.argument_type_vocab, False, terminate_prog, relaxed_reward_strict, reward_function = reward_func, boolean_reward_multiplier = boolean_reward_multiplier, relaxed_reward_till_epoch=relaxed_reward_till_epoch, unused_var_penalize_after_epoch=unused_var_penalize_after_epoch) if self.param['parallel'] == 1: self.InterpreterProxy, self.InterpreterProxyListener = proxy.createProxy( self.interpreter) self.interpreter.parallel = 1 self.lock = Lock() self.rule_based_logs = json.load( open(self.param['freebase_dir'] + '/rulebased_program_jaccard_date_operation.json')) self.aggregated_results = {} print "initialized interpreter"
def test_none(self): number = Interpreter().evaluate(None) self.assertEqual(number, None)
def test_part1(): assert Interpreter([109, 1, 204, -1, 1001, 100, 1, 100, 1008, 100, 16, 101, 1006, 101, 0, 99]).run() == \ [109, 1, 204, -1, 1001, 100, 1, 100, 1008, 100, 16, 101, 1006, 101, 0, 99] assert len( str(Interpreter([1102, 34915192, 34915192, 7, 4, 7, 99, 0]).run()[0])) == 16 assert Interpreter([104, 1125899906842624, 99]).run()[0] == 1125899906842624 assert Interpreter([109, -1, 4, 1, 99]).run()[0] == -1 assert Interpreter([109, -1, 104, 1, 99]).run()[0] == 1 assert Interpreter([109, -1, 204, 1, 99]).run()[0] == 109 assert Interpreter([109, 1, 9, 2, 204, -6, 99]).run()[0] == 204 assert Interpreter([109, 1, 109, 9, 204, -6, 99]).run()[0] == 204 assert Interpreter([109, 1, 209, -1, 204, -106, 99]).run()[0] == 204 assert Interpreter([109, 1, 3, 3, 204, 2, 99]).run()[0] == 0 assert Interpreter([109, 1, 203, 2, 204, 2, 99]).run()[0] == 0
def test_numbers(self): number = Interpreter().evaluate(IntNode(2)) self.assertEqual(number, NumberValue(2)) number = Interpreter().evaluate(FloatNode(2.0)) self.assertEqual(number, NumberValue(2.0))
def part2(program): return Interpreter(program, [2]).run()
# The Pickle Programming Language. from lexer import Lexer from parse import Parser from interpreter import Interpreter from sys import argv from os import system from printf import printf from SymbolTable import global_symbol_table system("cls") system("@echo The Pickle Programming Language.") version = "0.0.1" system(f"@echo @{version}") line_number = 0 while True: text = input(f"pickle > ") lexer = Lexer(text) tokens = lexer.generate_tokens() parser = Parser(tokens) tree = parser.generate_tree() interpreter = Interpreter(global_symbol_table) if not tree: print(f"\u007b{line_number}\u007d => null") line_number += 1 continue else: print(f"\u007b{line_number}\u007d => {interpreter.visit(tree)}") line_number += 1
from interpreter import Interpreter from lexer import Lexer from parser_ import Parser from interpreter import Interpreter while True: try: text = input("clac >") lexer = Lexer(text) tokens = lexer.generate_tokens() parser = Parser(tokens) tree = parser.parse() if not tree: continue interpreter = Interpreter() value = interpreter.visit(tree) print(value) except Exception as e: print(e)
def test_addition(): interpreter = Interpreter('3+4') result = interpreter.expr() assert result == 7