def pre_output(argv): """ This function will create new file (.hack file), and will output the compiled assembley file to it. :param argv: the users input :return: None """ BOOT_STRAP = [["call", "Sys.init", "0"]] # bootstrap initialization boot_strap_code = coder.Coder(BOOT_STRAP, "") boot_strap_coded_lines = boot_strap_code.get_list() for i in range(1, len(argv)): # This loop iterates over the user's inputs (or arguments). if os.path.isdir(argv[i]): if argv[i][-1] != "/": dir_name = argv[i].split("/")[-1] else: dir_name = argv[i].split("/")[-2] asm_file = open(argv[i] + "/" + dir_name + ".asm", "w") asm_file.writelines(["@256\n", "D=A\n", "@SP\n", "M=D\n"]) asm_file.writelines(boot_strap_coded_lines[0]) for file in os.listdir(argv[i]): if file.endswith(".vm"): # This if statement verifies that the argument is actually a dir. final_output(argv[i] + "/" + file, asm_file) asm_file.close() elif argv[i].endswith(".vm"): asm_file = open(argv[i][:-2] + "asm", "w") asm_file.writelines(["@256\n", "D=A\n", "@SP\n", "M=D\n"]) asm_file.writelines(boot_strap_coded_lines[0]) # Enter's if the specific argument is an assembly file only. final_output(argv[i], asm_file) asm_file.close()
def testCreateTargetImage(self): img = Image.open("samples/crop.jpg") encoder = coder.Coder() # Create a crop and resize it layerConf = LayerConfig(img, {"imgwidth": 200, "crop":(0, 0, 300, 300)}) target = encoder.createTargetImage(img, layerConf) target.save("/tmp/target1.webp", "WEBP", quality=95)
def test_most_likely_set(self): print("Most likely set test") src = source.DiscreteSource(mocks.get_stationary_src_desc()) coder_ = coder.Coder(src, 1, 0.01, 4) most_likely_set = coder_._Coder__create_most_likely_set() print("|T| =", len(most_likely_set)) print("n =", len(most_likely_set[0])) print(100 * "=")
def test_coder(self): print("Coder test") src = source.DiscreteSource(mocks.get_stationary_src_desc()) coder_ = coder.Coder(src, 1, 0.01, 4) code = coder_.get_code() for word, word_code in code.items(): print(word, word_code) print(100 * "=")
def tree_search(request, omega_id): decoder = coder.Coder() result = [] goto_docid = 1 while goto_docid is not None and goto_docid <= omega_id: request.goto(goto_docid) (docid, goto_docid) = request.evaluate() if docid is not None and docid <= omega_id: result.append(docid) return result
def encode(self, filename, configname): img = Image.open(filename) basename=filename.split("/")[1] config = json.load(open(configname, "rb")) layers = coder.Coder().encode(img, config) i = 0 layers2 = [] for layer in layers: i += 1 layerFileName = "/tmp/" + basename + "_layer" + str(i) + ".webp" layer[0].save(layerFileName, "WEBP", quality=90) #layer[0].save(layerFileName+".png", "PNG", quality=95) # TODO: Run ssim test to see that the image we got is correct layer2 = Image.open(layerFileName) layers2.append(layer2)
def __init__(self, val): TreeNode.__init__(self, val, term=True) decoder = coder.Coder() hash_val = mmh3.hash64(val.encode('utf8'))[0] offset, count = term_search(hash_val) if offset is None or count is None: self.docs = [] self.pos = 0 else: bin_index.seek(offset) byte_str = bytearray() buf = bin_index.read(count) byte_str.extend(buf) self.docs = decoder.decode(byte_str) self.pos = 0
def final_output(file_name, asm_file): """ The input generator :param file_name: The VM file to be complied. :param asm_file: The asm file to be written on. :return: None """ # calling the vm file vm_file = open(file_name, "r") parsed_file = parser.Parser(vm_file) parsed_lines = parsed_file.get_list() code = coder.Coder(parsed_lines, file_name.split("/")[-1][:-2]) coded_lines = code.get_list() vm_file.close() for command in coded_lines: # writing the complied lines into the new file (.hack) asm_file.writelines(command)
def final_output(file_name): """ This function will create new file (.hack file), and will output the compiled assembley file to it. :param file_name: the file to be complied :return: None """ # calling the asm file asm_file = open(file_name, "r") parsed_file = parser.Parser(asm_file) parsed_lines = parsed_file.get_list() code = coder.Coder(parsed_lines) coded_lines = code.get_list() asm_file.close() # writing the complied lines into the new file (.hack) new_file = open(file_name[:-3] + "hack", "w") new_file.writelines(coded_lines) new_file.close()
import iodeux as IODeux import lib as Lib import coder as Coder if __name__ == '__main__': io = IODeux.IODeux() coder = Coder.Coder() stringRead = io.readFile(Lib.FILENAME_READ) encodedVectors = coder.encode(stringRead) print("ENCODED VECTORS:") print(encodedVectors) decodedTuple = coder.decode(encodedVectors) decodedString = decodedTuple[1] print("DECODED STRING:") print(decodedString) if (decodedTuple[0]): io.writeFile(Lib.FILENAME_WRITE, decodedString) print("Same string? - " + repr(stringRead == decodedString)) else: print(decodedTuple[1])
def run(): path = os.getcwd() filename = "/test.asm" # c-command tuple in list, format: (comp, dest, jump) code = [] # program counter pc = -1 first = True RAM = 16 # load each line to a list f = open(path + filename, 'r') f_data = f.read() def is_in_dict(symbols): if t.get(symbols) is None: t.update({symbols: RAM}) return False else: return True # two-pass: 1. process symbol table # 2. generate binary code for i in range(2): p = parser.Parser(copy.deepcopy(f_data)) while p.has_more_commands(): current = p.advance() command_type = p.command_type(current) if command_type == "A_COMMAND": if first: symbols_a = current[1:] if p.is_symbol( symbols_a) and is_in_dict(symbols_a) is False: RAM += 1 pc += 1 else: code.append(p.symbol(current)) if command_type == "L_COMMAND": if first: # pseudo-command processing symbols_l = current[1:-1] if is_in_dict(symbols_l) is False: RAM += 1 t.update({symbols_l: pc + 1}) else: code.append(p.symbol(current)) if command_type == "C_COMMAND": comp, dest, jump = "", "", "" if "=" in current: part = current.split("=") dest = p.dest(part[0]) if ";" in part[-1]: comp = p.comp(part[1:].split(";")[0]) jump = p.jump(part[1:].split(";")[-1]) else: comp = p.comp(part[-1]) elif ";" in current: part2 = current.split(";") comp = p.comp(part2[0]) jump = p.comp(part2[-1]) if first: pc += 1 else: code.append(tuple([comp, dest, jump])) first = False if first is False: logg("pass {} ....".format(i + 1)) # translate to binary if len(code) > 0: logg(t) logg("".join([str(x) + "\n" for x in code])) bcode = coder.Coder(code) logg(pc)