def main(): filename, algorithm, cut_off_sec, random_seed = format_check( ) # check input format city, dim, edge_weight_type, coord = parse_input( filename) # parse input information adj_mat = adjacency_mat(dim, edge_weight_type, coord) # input matrix write_adj_mat_file(adj_mat, city, dim) # save input matrix as csv if random_seed == None: random_seed = 0 else: random_seed = int(random_seed) if algorithm == 'Approx': output = Output(filename, algorithm, cut_off_sec, algorithm) # init output object start_MST = time.time() c, tour = compute(dim, adj_mat, cut_off_sec=cut_off_sec) total_time = time.time() - start_MST output.solution([c] + tour) # generate solution file output.sol_trace([('%.4f' % total_time, c) ]) # generate solution trace file elif algorithm == 'BnB': output = Output(filename, algorithm, cut_off_sec, algorithm) # init output object bnb = BranchNBound( adj_mat, dim, cut_off_sec) # param: dist_matrix, num_city, time_limit path, cost, trace_list = bnb.run_branch_and_bound() output.solution([cost] + path) # generate solution file output.sol_trace(trace_list) # generate solution trace file elif algorithm == 'LS1': # Iterated LocalSearch output = Output(filename, algorithm, cut_off_sec, algorithm, random_seed) # init output object ils = ILS(adj_mat, dim, cut_off_sec, random_seed ) # param: dist_matrix, num_city, time_limit, random_seed path, cost, trace_list = ils.iterated_local_search() output.solution([cost] + path) # generate solution file output.sol_trace(trace_list) # generate solution trace file elif algorithm == 'LS2': # Simulated Annealing output = Output(filename, algorithm, cut_off_sec, algorithm, random_seed) # init output object sa = SA(adj_mat, dim, 1e30, 1, 0.999, random_seed, cut_off_sec) path, cost, trace_list = sa.run_simulated_annealing() output.solution([cost] + path) # generate solution file output.sol_trace(trace_list) # generate solution trace file
class GetEnvVarAddrCommand(Command): command = "geva" usage = "[variable name]" output = Output() help = "\tGet address of an environment variable.\n\tex:\tgeva SHELL" def set_option(self, option, cmd): cm = "" for name, value in option.env.items(): cm += 'export ' + name + '=' + '`python -c \'print "' + value + '"\'`;' if option.binType == BinType.THIRTY_TWO: getenv = "../utils/getenv32" else: getenv = "../utils/getenv64" try: addr = int( subprocess.check_output(cm + getenv + ' ' + cmd[1], shell=True), 16) except Exception: self.output.write_error_message("Env variable " + cmd[1] + " not Found") return addr += len(getenv) - len(option.binPath) self.output.write_message("Env variable " + cmd[1] + " Found at " + Color.blue + hex(addr) + Color.reset)
def __exec(self, command, switches, args): cwd = os.path.abspath(os.curdir) if (not os.path.exists(self.path)): if (not command == "branch"): raise ProjectPathError( "Error executing bzr %s. The project path %s does not exist." % (command, self.path)) else: os.chdir(self.path) switchString = [it + "=" + switches[it] for it in switches] finalCommand = (" ").join([self.cmd, command] + switchString + args) p = subprocess.Popen(finalCommand, shell=True, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True) returnValue = Output(p.stdout, p.stderr) p.wait() os.chdir(cwd) if p.returncode != 0: raise BzrException(p.returncode, str(returnValue), finalCommand) return returnValue
class MainLoop: option = Option() quit = False userInput = UserInput() commandHandler = CommandHandler() output = Output() execInstrution = ExecInstruction() def __init__(self, option): self.option = option self.start_loop() def start_loop(self): while not self.quit: self.output.load_prompt() try: cmd = self.userInput.read_input() if cmd: self.option.payload = None self.commandHandler.command_handler(cmd, self.option) if self.option.payload: self.execInstrution.run(self.option) except KeyboardInterrupt: self.output.write_message("use " + Color.pink + "\"quit\"" + Color.reset + " to exit")
def transactionFromByteArray(trans_data): offset = 0 in_arr = [] out_arr = [] no_of_input = int.from_bytes(trans_data[:4], 'big') offset += 4 for i in range(no_of_input): trans_ID = trans_data[offset:offset + 32].hex() offset += 32 index = int.from_bytes(trans_data[offset:offset + 4], 'big') offset += 4 sign_len = int.from_bytes(trans_data[offset:offset + 4], 'big') offset += 4 sign = trans_data[offset:offset + sign_len].hex() offset += sign_len inp_obj = Input(trans_ID, index, sign) in_arr.append(inp_obj) no_of_output = int.from_bytes(trans_data[offset:offset + 4], 'big') offset += 4 for i in range(no_of_output): coins = int.from_bytes(trans_data[offset:offset + 8], 'big') offset += 8 key_len = int.from_bytes(trans_data[offset:offset + 4], 'big') offset += 4 key = trans_data[offset:offset + key_len].decode() offset += key_len out_obj = Output(coins, key) out_arr.append(out_obj) return [in_arr, out_arr]
class ExecInstruction: output = Output() def __init__(self): pass def run(self, option): if option: cmd = "" for name, value in option.env.items(): cmd += 'export ' + name + '=' + '`python -c \'print "' + value + '"\'`;' if option.execMode == Mode.PIPED: cmd += "(python -c 'print(" + option.payload + ")'; cat) | " + option.binPath elif option.execMode == Mode.ARG: cmd += option.binPath + " `python -c 'import sys; sys.stdout.write(" + option.payload + ")'`" if option.bruteforce: option.bruteforce = False try: while True: self.output.write_message(Color.yellow + "executing command: " + cmd + Color.reset) except KeyboardInterrupt: pass self.output.write_message(Color.pink + "executing command: " + cmd + Color.reset) system(cmd)
def get_points(self): final_score = 0 try: print("Raw input: " + str(self.raw_input)) print("Raw output: " + str(self.raw_output)) self.obj_in = Input(self.raw_input) self.obj_out = Output(self.raw_output) #self.obj_in.print() #self.obj_out.print() print("==================================================") for vehicle in self.obj_out.vehicles: print("----------------------------------------------") print("Calculating score for vehicle: {0}".format(vehicle.index)) for ride_index in vehicle.rides_indexes: ride = self.obj_in.rides[int(ride_index)] print("Taking ride {0}".format(ride_index)) ride_score = self.calculate_points(vehicle, ride, int(self.obj_in.bonus)) print("Adding {0} to the total score of {1}".format(ride_score, final_score)) final_score += ride_score print("Current step time {0}".format(vehicle.step_time)) print("------") except Exception as e: print("Something crashed: " + str(e)) #raise e return 0 return final_score
def extractTables(self, path, target): """ Starts the table extraction. Using only this method, nothing will be returned, but the HTML output Files will be created in the specified output folder. """ try: os.mkdir(target) except OSError: pass os.chdir(target) self.__dtdFile = open(target + "/pdf2xml.dtd", "w") self.buildDtd() self.__cmdLine = "pdftohtml -xml " + path print(self.__cmdLine) os.system(self.__cmdLine) xmlFile = os.path.basename(path).rstrip(".pdf") + ".xml" fileMover.moveXmlFile(path=path, target=target) #starting the extraction firstClassification = FirstClassification(target) self.__resultTuple = firstClassification.run(target + "/" + xmlFile) tableList = self.__resultTuple[0] fontsList = self.__resultTuple[1] path = self.__resultTuple[2] self.__outputObj = Output(tableList, fontsList, path) self.__outputObj.createOutput()
def send_external(self, csv_file, write_output=True): message = self.build() to_filter = ClientFilter(csv_file) to_contact = to_filter.filter_emails() output = Output(to_contact) print("\nClient list to be emailed:\n---------") for i in to_contact: print(i.name) print("-------") if write_output: output.write() proceed = input("Proceed with emailing? y/n ... ") if proceed == 'y': with smtplib.SMTP_SSL("smtp.gmail.com", 465, context=self.context) as server: server.login(self.sender_email, self.password) for each in to_contact: try: server.sendmail(self.sender_email, each.email, message.as_string()) except smtplib.SMTPRecipientsRefused as e: print(e) to_contact.pop(each) pass print("\n") else: print("Aborting the mission...")
def from_json(self, data): data_inp = data['input'] data_out = data['output'] for i in data_inp: self.inp_arr.append( Input(i['transactionID'], i['index'], i['signature'])) for i in data_out: self.out_arr.append(Output(i['amount'], i['recepient']))
def __init__(self): """ creates a new program """ self.input = Input() self.output = Output() self.inventory = Inventory() self.choice = None
def __init__(self): self.input = Input() pygame.init() pygame.display.set_mode( (Constants.SCREEN_WIDTH, Constants.SCREEN_HEIGHT)) pygame.display.set_caption("color-based-multi-person-id-tracker") screen = pygame.display.get_surface() self.output = Output(screen, self.input)
def lint(self): statusoutput = self.status() lintoutput = "" for line in str(statusoutput).split("\n"): if line.startswith("?"): lintoutput += line + "\n" lintoutput += str(self.__exec("conflicts", {}, [])) tmp = Output(StringIO.StringIO(lintoutput), StringIO.StringIO()) return tmp
def __init__(self, instruction_path, register_path, config_path, memory_path): pp = pprint.PrettyPrinter(indent=4) self.configuration = self.getconfig(config_path) self.arch = self.getArch(memory_path, register_path, self.configuration) self.instructions = self.getInstructions(instruction_path) print(self.instructions) self.labels = self.getLabels(instruction_path) self.instructionMapping = self.defineInstructions() self.OUT = Output()
class CommandHandler: commands = [] output = Output() def __init__(self): self.init_all_command() def init_all_command(self): self.commands.append(QuitCommand()) self.commands.append(ChangeBinaryCommand()) self.commands.append(ChangeModeCommand()) self.commands.append(ChangeShellcodeCommand()) self.commands.append(ListFilesCommand()) self.commands.append(ListFunctionsCommand()) self.commands.append(DisassFunctionsCommand()) self.commands.append(CheckASLRCommand()) self.commands.append(JumpToFunctionCommand()) self.commands.append(ChangeBufferSizeCommand()) self.commands.append(SetVariableValueCommand()) self.commands.append(FindFunctionsCommand()) self.commands.append(FindStringCommand()) self.commands.append(ChangeBinTypeCommand()) self.commands.append(JumpToShellcodeCommand()) self.commands.append(RunPayloadCommand()) self.commands.append(SetEnvCommand()) self.commands.append(UnSetEnvCommand()) self.commands.append(GetEnvVarAddrCommand()) self.commands.append(GDBCommand()) self.commands.append(GetBufferAddrCommand()) self.commands.append(NopSpreadCommand()) self.commands.append(FileCommand()) def command_handler(self, cmd, option): if cmd[0] == "help": for command in self.commands: self.output.write_message( Color.purple + command.get_command() + ":" + " " * (10 - len(command.get_command())) + Color.reset, end='') self.output.write_message(Color.pink + command.get_usage() + Color.reset) self.output.write_message(command.get_help(), end="\n\n") return for command in self.commands: if cmd[0] == command.get_command(): try: command.set_option(option, cmd) except Exception as ex: print(ex) self.output.write_error_message("usage: " + cmd[0] + ' ' + command.get_usage())
def run_join(givers: list, receiver: User, send_amounts: list, total_send_amount: float, prior_blocks: list): remaining_amounts = [0] * len(givers) actual_total_amount = 0 for giver in range(len(givers)): giver_total = 0 for pBlock in range(len(prior_blocks[giver])): giver_total += prior_blocks[giver][pBlock].get_value( givers[giver].sk) actual_total_amount += giver_total remaining_amounts[giver] = giver_total - send_amounts[giver] return Output(remaining_amounts + [total_send_amount], [giver.sk for giver in givers] + [receiver.sk])
def test_io(): filename = "DATA/Cincinnati.tsp" city, dim, edge_weight_type, coord = parse_input(filename) adj_mat = adjacency_mat(dim, edge_weight_type, coord) algorithm = "TwoOpt" cut_off_sec = 10 output = Output(filename, algorithm, cut_off_sec) to = TwoOpt(adj_mat, dim, cut_off_sec) path, cost, quality = to.two_opt() output.solution([cost] + path) output.sol_trace([(quality, cost)])
def get_log_time(self): """ get log time """ finish_string = datetime.now().strftime("%Y-%m-%d ") log_line = self.get_line() finish_line = finish_string + log_line try: finish = datetime.strptime(finish_line, "%Y-%m-%d %H:%M") except Exception as _e: Output(_e, 0, "Error in GetLogTime").call_result() return finish
class CheckASLRCommand(Command): command = "cASLR" output = Output() help = "\tCheck if ASLR is On or Off." def set_option(self, option, cmd): f = open("/proc/sys/kernel/randomize_va_space", "r") nb = int(f.read()) if nb == 2: self.output.write_message("ASLR is ON") else: self.output.write_message("ASLR is OFF")
def run_merge(giver: User, reciever: User, send_amount: float, prior_blocks: list): #print("in run merge __________") total_amount = 0 try: for i in range(len(prior_blocks)): #print("merge key length: "+str(len(prior_blocks[i].keys))) total_amount += prior_blocks[i].get_value(giver.sk) giver_output_amount = total_amount - send_amount #print('leave run merge__________') return Output([giver_output_amount, send_amount], [giver.sk, reciever.sk]) except Exception as e: pass
def executeFunction(self, output=True, parsingCriteria=None, default=False, unpack=True, **kargs): params = " ".join(list(map(lambda x: f"-{x[0]} {x[1]}", kargs.items()))) if parsingCriteria is None: parsingCriteria = self.defaultParsingCriteria parsingOp = ParsingCriteria().generateCriteria(parsingCriteria) if parsingOp is None: parsingOp = "" code = f"""{self.funcDef} $result = {self.funcName} {params} if($result -ne $null){{ $result = $result {parsingOp} return $result }} """ if output: powershell = sp.Popen(["powershell", code], stderr=sp.STDOUT, stdout=sp.PIPE) result = powershell.communicate() try: result = result[0].decode('utf-8') except: result = str(result[0]) result = result[2:-1] result = Output(result) if default: if self.defaultParsing is None: return result try: parser = result.feed(self.defaultParsing) parser.parsingArgs = self.parsingArgs output = parser.parse() if unpack: return output.unpack() else: return output except: return result else: return result else: sp.call(["powershell", code]) return None
def runProgram(self): # try: self.output = Output(sleepChar=self.sleepChar, sleepLine=self.sleepLine) self.write = self.output.write self.writeln = self.output.writeln self.canWrite = self.output.canWrite self.printHello() if not self.tryConnectToRemoteServer(): print "Closing.. bye." self.dbManager = DbManager(self.output) self.tryConnectDB() self.mainBOT() self.newEntry()
def check_log(self): """ check log """ log_time = self.get_log_time() now_time = self.get_now_time() if log_time.hour == 00 and log_time.minute != 00: if not log_time.hour == now_time.hour: log_time = log_time + timedelta(days=1) time = log_time - now_time if time.total_seconds() > 0: Output("a", 0, "Thread has already been searched.").call_result()
def test_ils(): # filename = "DATA/Cincinnati.tsp" filename = "DATA/UKansasState.tsp" city, dim, edge_weight_type, coord = parse_input(filename) adj_mat = adjacency_mat(dim, edge_weight_type, coord) algorithm = "IteratedLocalSearch" cut_off_sec = 600 output = Output(filename, algorithm, cut_off_sec) ils = IteratedLocalSearch(adj_mat, dim, cut_off_sec, 20) path, cost, quality, _ = ils.iterated_local_search() output.solution([cost] + path) output.sol_trace([(quality, cost)])
def create_outputs(self, outputs): try: outputs_dict = json.loads(outputs)['outputs'] outputs_arr = [i for i in outputs_dict] for i in outputs_arr: self.validate_output(i) self.outputs.append( Output(i['address'], i['value'], i['script_type'])) self.numb_outputs = struct.pack("<B", len(self.outputs)) except BadOutputData: print("Bad outputs data") raise BadOutputFormat except: print("Bad outputs json format") raise BadOutputFormat
def __init__(self, yml=None, variables=None, switch_expect=None): if yml is not None: self.__variables = variables self.__variables.set_vars(yml.get('vars', [])) self.__opts = Opts(yml.get('opts', []), variables) self.__set_input(yml['input']) self.__transform = Transform( yml.get('transform', ''), variables, self.__opts.get('delimiter', None)) self.__query = yml.get('query', '') self.__preview = yml.get('preview', '') self.__bind = Bind(yml.get('bind', {}), self.__variables, self.__transform) self.__output = Output(yml.get('output', {}), variables) self.__switch_expect = switch_expect
def missing(self, url, switches={}, revision=""): if self.pinnedPatchLevel != None: return Output( StringIO.StringIO("This branch is pinned to " + str(url) + " at revision " + str(self.pinnedPatchLevel)), StringIO.StringIO()) try: retval = self.__exec("missing", {"--log-format": "short"}, [url]) except BzrException, e: # If any patches are missing or you have any extra patches # Bazaar returns with errorcode 1. Output is on stdout. if not (e.errorcode == 1): raise BzrMissingException(e.errorcode, e.errormessage, e.command) return e.errormessage
def __init__(self, config, window): self._l = logging.getLogger("plugin.builder") self._l.debug("Entered") self._window = window self._config = config # Store last build/compile command run for each document # during this session self._prev_commands = {} # Map to record location of items found in the Output buffer # _item_locations[item number] -> # if file loaded : a GtkTextBuffer mark # else: a tuple of (path, line, col) self._item_locations = {} ui_builder = gtk.Builder() ui_builder.add_from_file( os.path.join(config.get_data_dir(), 'Builder.glade')) self._ui = ui_builder.get_object self._ui('dlg_unsaved_file').set_transient_for(window) self._ui('dlg_run_command').set_transient_for(window) # Add bottom panel console self._console = Output(config) self._console.set_item_selected_cb(self._goto) self._console.set_item_found_cb(self._record) bottom = self._window.get_bottom_panel() bottom.add_item(self._console.widget(), _('Build Output'), gtk.STOCK_EXECUTE) # Insert menu item Tools->Compile manager = self._window.get_ui_manager() self._action_group = gtk.ActionGroup("plugin_builder") self._action_group.add_actions([ ("plugin_builder_compile", None, _("_Compile"), "<control>F5", _("Compile the current document"), self._compile_doc), ("plugin_builder_build", None, _("_Build"), "<control>F6", _("Run the build command"), self._build) ]) manager.insert_action_group(self._action_group, -1) self._ui_id = manager.add_ui_from_string(ui_str) self._l.info(manager.get_ui()) self._save_action = manager.get_action( '/ui/MenuBar/FileMenu/FileSaveMenu') self._l.info(self._save_action)
def set_option(self, option, cmd): output = Output() if option.buffSize == 0: output.write_error_message( "Buffer size must be set to execute this command") return value = format_hex_value(cmd[1], option) if len(cmd) > 2 and cmd[2] == "after": option.payload = '"\\x90" * ' + str( option.buffSize ) + ' + "' + value + '" + "' + option.shellcode + '"' else: size = option.buffSize - (len(option.shellcode) / 4) option.payload = '"' + option.shellcode + '" + "\\x90" * ' + str( int(size)) + ' + "' + value + '"'
def run_all_data(): dir = "DATA/" for f in os.listdir(dir): if f[-3:] == "tsp": print dir + f filename = dir + f city, dim, edge_weight_type, coord = parse_input(filename) adj_mat = adjacency_mat(dim, edge_weight_type, coord) algorithm = "IteratedLocalSearch" cut_off_sec = 600 random_seed = 0 output = Output(filename, algorithm, cut_off_sec) ils = IteratedLocalSearch(adj_mat, dim, cut_off_sec, random_seed) path, cost, trace_list = ils.iterated_local_search() print path, cost, trace_list output.solution([cost] + path) output.sol_trace(trace_list)