def detect_handlers(self): if config.VM == 'vmp' or config.VM == 'cv': dispatcher = self.sorted_blocks('loop_count')[0] # find the hottest block. print '[+] Dispatcher found at %#x.' % dispatcher.addr for loop in dispatcher.loops: loop_blocks = list(loop.list_nodes(self)) assert loop_blocks[0] == dispatcher h = handler.Handler() for b in loop_blocks[1:]: if not h.add_block(b): break # if add failed, we stop. if h.is_valid: self.add_handler(h) self.dispatcher = dispatcher elif config.VM == 'vmp3': jmp_edi_blocks = [] for addr in self.blocks: b = self.blocks[addr] if b.ends_with_jmp_edi and b.ins_count < 10: # short block jmp_edi_blocks.append(addr) for addr in self.blocks: if addr in jmp_edi_blocks: continue b = self.blocks[addr] if b.ends_with_jmp_edi: # block ends with "jmp edi" patten h = handler.Handler() h.add_block(b) self.add_handler(h) else: # block jump to `jmp_edi_block` if len(b.nexts) != 1: continue next_addr = b.nexts.keys()[0] if next_addr in jmp_edi_blocks: next_b = self.blocks[next_addr] h = handler.Handler() h.add_block(b) h.add_block(next_b) self.add_handler(h) else: raise NotImplementedError('unsupported VM type %s' % config.VM) print '[+] %s %s-handlers found.' % (len(self.handlers), config.VM)
def test_api(self): test_handler = handler.Handler('http://numbersapi.com/', self.loop, 'GET') async def go(): async with aiohttp.ClientSession(loop=self.loop) as session: await test_handler.download_json_coroutine(session, 100, test_handler.url) self.loop.run_until_complete(go()) self.assertTrue(test_handler.output.pop()['found'])
def __init__(self, room, nickname="", account=None, password=None, solve_captchas=False): self.room_name = room self.nickname = nickname self.account = account self.password = password self.client_id = 0 self.is_client_mod = False self.is_client_owner = False self._init_time = time.time() self.handler = handler.Handler() self.is_green_room = False self.is_connected = False self.active_user = None self.users = user.Users() # JSON string from tinychat.get_connect_info(), contains room token and ws address self.connect_info = {} self._ws = None self._req = 1 self.is_published = False self.solve_captchas = solve_captchas self.ice_servers = None if solve_captchas: if len(CONFIG.API_KEY) > 0: self.captcha = captcha.AntiCaptcha(CONFIG.API_KEY) else: self.solve_captchas = False
def run(): start_query = query.Api() results = start_query.query() if results: handler.Handler().pipeline(results) else: pass
def decorator(procedure): """Create a new handler from the decorated function.""" nonlocal name if not name: name = procedure.__name__ new_handler = handler.Handler(self, procedure, name, max_retries) if new_handler.name in self.handlers: err = "Conflict: handler for task '{}' already exists." raise RuntimeError(err.format(new_handler.name)) self.handlers[new_handler.name] = new_handler return new_handler
def __init__(self): self.cookies = hangups.get_auth_stdin("token.txt", True) self.client = hangups.Client(self.cookies) with open("reply_data.json", "r") as replies_file: self.reply_data = json.load(replies_file) self.handler = handler.Handler(self, self.reply_data) self.connected = asyncio.Event() # to prevent replying to self self.recent_meeper_messages = [] self.sending_lock = asyncio.Lock()
def run(self): event_handler = handler.Handler() self.observer.schedule(event_handler, self.watch_directory, recursive=True) self.observer.start() try: while True: time.sleep(5) except: self.observer.stop() print("\nERROR: Stopping watcher.\n") self.observer.join()
def __init__(self): super(Mapper, self).__init__() self.handler = handler.Handler() self._clear() f = Figlet() intro_text = """============================================\n""" intro_text += """Welcome to the Loadsheet Builder. \n""" intro_text += """Use this tool to build and review loadsheets. \n""" intro_text += """For help with functions, type 'help' or view README. \n""" intro_text += """OnboardingTool Copyright (C) 2020 DB Engineering""" intro_text += """To view license information, type 'license'\n""" intro_text += """============================================""" self.intro = f.renderText('LoadBoy2000')+intro_text self.prompt = '>>> '
def parse_js_obj(self,message_data): print message_data self.decoded = json.loads(message_data) print 'DECODED:', self.decoded print self.decoded[0]['data'] # write in a file to cache data fob = open('dwrite' ,'w') for item in self.decoded: fob.write("%s\n" % item) # A call to an handler class to pass the received message to the appropriate class object to run #handle = handler.Handler(item[0]) fob.close() # A call to an handler class to pass the received message to the appropriate class object to run handle = handler.Handler(self.decoded ) """
def detect_handlers(self): dispatcher = self.sorted_blocks('loop_count')[ 0] # find the hottest block. print '[+] Dispatcher found at %#x.' % dispatcher.addr for loop in dispatcher.loops: loop_blocks = list(loop.list_nodes(self)) assert loop_blocks[0] == dispatcher h = handler.Handler() for b in loop_blocks[1:]: if not h.add_block(b): break # if add failed, we stop. if h.is_valid: self.add_handler(h) self.dispatcher = dispatcher print '[+] %s handlers found.' % len(self.handlers)
def main(): parser = argparse.ArgumentParser() parser.add_argument("-w", "--weather", action="store_true", help="weather display function") args = parser.parse_args() arg_list = [] if args.weather: arg_list.append("weather") handler_object = handler.Handler(arg_list) try: for event in longpoll.listen(): # new message income if event.type == VkEventType.MESSAGE_NEW: # if this has mark for me(for bot) if event.to_me: # message from user request = event.text print(request) handler_object.handle(event.user_id, request) except KeyboardInterrupt: print("Goodbye...") sys.exit()
def data(): output = handler.Handler('/home/likewise-open/LOCAL/joao.garcia/Workplace/' '1.INPE/Data/Radar/BR_PP/2014/06/') return output
import random, handler, display # win_0 = Combat Calculator obj = handler.Handler() display.display_win("win_0")
def __init__(self): super().__init__() self.db = db.DB() self.handler = handler.Handler() self.initUI()
import os import handler import sys from flask import Flask, request import pandas as pd from sessionHandler import SessionHandler import redis import fbApi app = Flask(__name__) DATA_LOC = 'Data/' PRODUCTS = pd.read_csv(DATA_LOC + 'Lengow.csv').fillna('') SHOPS = pd.read_csv(DATA_LOC + 'Shops2.csv').fillna('') hdl = handler.Handler(opt_list=handler.ALL_OPT, shops=SHOPS, products=PRODUCTS) # Test setting TEST_MODE = True if len(sys.argv) > 1 and sys.argv[1] == 'test' else False if TEST_MODE: FB_URL = "http://localhost:9999/" ACCESS_TOKEN = "" REDIS_HOST = 'localhost' REDIS_PORT = 6379 r = redis.StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=0) else: FB_URL = "https://graph.facebook.com/v2.6/me/" ACCESS_TOKEN = os.environ["PAGE_ACCESS_TOKEN"] REDIS_URL = os.getenv('REDISTOGO_URL', 'redis://localhost:6379') r = redis.from_url(REDIS_URL)
import config import telebot import datetime import keyboards as kb import handler import sql bot = telebot.TeleBot(config.TOKEN) hd = handler.Handler(bot) print("Start") print(bot.get_me()) @bot.message_handler(commands=['start']) def handle_command(message): #Проверяем команды от пользователя hd.start_handler(message) @bot.message_handler(content_types=['text']) def handle_message(message): hd.handle_text(message) bot.polling(none_stop=True, interval=0)
import handler if __name__ == "__main__": hand = handler.Handler() hand.print_info() while True: command = str(input()) try: hand.get_command(command) except (ValueError, handler.InputException): print('Try one more time') except handler.AdderException: print('Already added') print('Try tomorrow') except handler.ForecastException: print('Firstly add current weather') except handler.APIException: print('Problems with servers, try later') except handler.DecodingException: print('Problems with decoding data, try later')
output_text += ' portd = %' + ''.join(d) + '\n' output_text += ' portc = %' + ''.join(c) + '\n' output_text += ' pause 1\n' output_text += '\n' output.insert(tkinter.END, output_text) output_text = '' output.insert(tkinter.END, ' next x\n') #create cube cube = Cube([],[],400,500,15, 150, 4) cube.generate() cube.rotate(220,1) cube.rotate(190,2) cube.draw_points() cube.draw_edges() h = handler.Handler(root,cube,screen) generate_button = tkinter.Button(root, text='generate', command = cube.create_frame) generate_button.grid(row = 2, column = 1) lock_button = tkinter.Button(root, text='lock', command = h.lock) lock_button.grid(row = 4, column = 1) screen.bind('<B1-Motion>',h.motion_handler) screen.bind('<Button-1>',h.click_handler) root.mainloop()
the top topics. Each has their own call to the handler class to retrieve the data. """ import dash from dash.dependencies import Input, Output, State import dash_core_components as dcc import dash_html_components as html import pandas as pd import numpy as np import handler app = dash.Dash() my_handler = handler.Handler() # Reusable def make_dash_table(data_frame): ''' Return a dash definition of an HTML table for a Pandas dataframe ''' table = [] for _, row in data_frame.iterrows(): html_row = [] for i in range(len(row)): html_row.append(html.Td([row[i]])) table.append(html.Tr(html_row)) return table # Main layout
def main(entry, depth): print("Entry: {w}, depth: {d}".format(w=entry, d=depth)) hdlr = handler.Handler(config) hdlr.crawl(entry ,int(depth))
import multiprocessing import Library.interfaz import Library.config import handler import server try: config = Library.config.read() except: import sys print("FAILED TO OPEN CONFIG FILE, EXITING") sys.exit() man = multiprocessing.Manager() adios = man.Value(bool, False) interfaz = Library.interfaz.Interfaz(lang=config["lang"]) hand = handler.Handler(interfaz, adios) hand.pantalla("INIT", prompt=False) input("") key_bits = int(config["key_length"]) hand.pantalla("GENERATING_KEY", args=(key_bits, ), prompt=False) server = server.Server(adios, hand, Library.Encriptacion.genera(key_bits), ip=config["host"], port=int(config["port"])) g = multiprocessing.Process(target=server.listen) p = multiprocessing.Process(target=server.server_handler) p2 = multiprocessing.Process(target=hand.listen, args=(server, )) p.start() g.start() hand.listen(server)
def run_handler(): global handler handler = handler.Handler(debug_mode=True) handler.start()
def __init__(self, host, port, controllers_prefix, logger_name=None): self.logger = Logger.get_logger(logger_name) self.controllers_prefix = controllers_prefix self.handler = handler.Handler(controllers_prefix) self.host = str(host) self.port = int(port)
# # Copyright 2017 Alsanium, SAS. or its affiliates. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # import sys import dl sys.setdlopenflags(sys.getdlopenflags() | dl.RTLD_NOW | dl.RTLD_GLOBAL) import shim shim.open(__name__) import handler sys.modules[__name__] = handler.Handler()
log('[MAIN] Connecting to database') database_connection = database.Database() log('[MAIN] Starting WebApp Server') webapp_server = threaded_server.ThreadedServer(ip_addr, 51030, database_connection, webapp_socket.WebAppSocket) webapp_server.start() log('[MAIN] Starting Wearable Server') wearable_server = threaded_server.ThreadedServer( ip_addr, 24192, database_connection, wearable_socket.WearableSocket) wearable_server.start() log('[MAIN] Setting up handlers') server_handler = handler.Handler(webapp_server, wearable_server, database_connection) while True: try: if not webapp_server.queue.empty(): server_handler.webapp() if not wearable_server.queue.empty(): server_handler.wearable() time.sleep(1) except KeyboardInterrupt: sys.exit(0) except: log(traceback.format_exc())
def setUp(self): self.handler = handler.Handler() self.query_article = 'SpaceX Launches Rocket' self.path = 'news_analyzer/libraries'
import time import problem, store, phone, handler, paras store = store.Store("./store") phone = phone.Phone() entryHandler = handler.Handler("entry", "pics/entrySign.jpg", phone) endHandler = handler.Handler("end", "pics/endSign.jpg", phone) retryHandler = handler.Handler("retry", "pics/retrySign.jpg", phone) exitHandler = handler.Handler("exit", "pics/exitSign.jpg", phone) backHandler = handler.Handler("back", "pics/backSign.jpg", phone) wrongHandler = handler.Handler("wrong", "pics/wrongSign.jpg", phone) problemHandler = problem.ProblemHandler("pics/problemSign.jpg", phone, store) inputFile = "inputs/a.png" if __name__ == '__main__': while True: phone.screencast(inputFile, paras.SCALE) if entryHandler.check(inputFile): entryHandler.handle() elif endHandler.check(inputFile): endHandler.handle() elif exitHandler.check(inputFile): exitHandler.handle() elif retryHandler.check(inputFile): retryHandler.handle() elif problemHandler.check(inputFile): problemHandler.handle() elif wrongHandler.check(inputFile): break backHandler.check(inputFile)
def __init__(self, title="Map Simulator"): self.master = Tk() self.master.title(title) self.handler = handler.Handler(self) self.map = self.handler.map self.algo = self.handler.algo t = Toplevel(self.master) t.title("Control Panel") t.geometry('180x360+1050+28') # left side map panel self.map_pane = ttk.Frame(self.master, borderwidth=0, relief="solid") self.map_pane.grid(column=0, row=0, sticky=(N, S, E, W)) # right side control panel self.control_pane = ttk.Frame(t, padding=(12, 10)) self.control_pane.grid(column=1, row=0, sticky=(N, S, E, W)) # robot size self.robot_size = config.robot_detail['size'] # stores instances of widgets on the map self.map_widget = [[None]*self.map.width]*self.map.height # photo instances self.robot_n = [] self.robot_s = [] self.robot_e = [] self.robot_w = [] for i in range(9): self.robot_n += [PhotoImage(file=config.icon_path['north'][i]).subsample(config.icon_path['size'])] self.robot_s += [PhotoImage(file=config.icon_path['south'][i]).subsample(config.icon_path['size'])] self.robot_w += [PhotoImage(file=config.icon_path['west'][i]).subsample(config.icon_path['size'])] self.robot_e += [PhotoImage(file=config.icon_path['east'][i]).subsample(config.icon_path['size'])] self.map_free1 = PhotoImage(file=config.icon_path['free']) self.map_free_explored1 = PhotoImage(file=config.icon_path['explored_free']) self.map_obstacle1 = PhotoImage(file=config.icon_path['obstacle']) self.map_obstacle_explored1 = PhotoImage(file=config.icon_path['explored_obstacle']) self.map_start1 = PhotoImage(file=config.icon_path['start']) self.map_end1 = PhotoImage(file=config.icon_path['end']) self.map_free = self.map_free1.subsample(config.icon_path['size']) self.map_free_explored = self.map_free_explored1.subsample(config.icon_path['size']) self.map_obstacle = self.map_obstacle1.subsample(config.icon_path['size']) self.map_obstacle_explored = self.map_obstacle_explored1.subsample(config.icon_path['size']) self.map_start = self.map_start1.subsample(config.icon_path['size']) self.map_end = self.map_end1.subsample(config.icon_path['size']) # map initialization. self.currentMap = deepcopy(self.map.get_map()) self.robot_location = self.map.get_robot_location() self.robot_direction = self.map.get_robot_direction() self.update_map(init=True) control_pane_window = ttk.Panedwindow(self.control_pane, orient=VERTICAL) control_pane_window.grid(column=0, row=0, sticky=(N, S, E, W)) parameter_pane = ttk.Labelframe(control_pane_window, text='Parameters') action_pane = ttk.Labelframe(control_pane_window, text='Action') control_pane_window.add(parameter_pane, weight=4) control_pane_window.add(action_pane, weight=1) explore_button = ttk.Button(action_pane, text='Explore', width=16, command=self.algo.explore) explore_button.grid(column=0, row=0, sticky=(W, E)) fastest_path_button = ttk.Button(action_pane, text='Fastest Path', command=self.algo.run) fastest_path_button.grid(column=0, row=1, sticky=(W, E)) move_button = ttk.Button(action_pane, text='Move', command=self.move) move_button.grid(column=0, row=2, sticky=(W, E)) left_button = ttk.Button(action_pane, text='Left', command=self.left) left_button.grid(column=0, row=3, sticky=(W, E)) right_button = ttk.Button(action_pane, text='Right', command=self.right) right_button.grid(column=0, row=4, sticky=(W, E)) step_per_second = StringVar() step_per_second_label = ttk.Label(parameter_pane, text="Step Per Second:") step_per_second_label.grid(column=0, row=0, sticky=W) step_per_second_entry = ttk.Entry(parameter_pane, textvariable=step_per_second) step_per_second_entry.grid(column=0, row=1, pady=(0, 10)) coverage_figure = StringVar() coverage_figure_label = ttk.Label(parameter_pane, text="Coverage Figure(%):") coverage_figure_label.grid(column=0, row=2, sticky=W) coverage_figure_entry = ttk.Entry(parameter_pane, textvariable=coverage_figure) coverage_figure_entry.grid(column=0, row=3, pady=(0, 10)) time_limit = StringVar() time_limit_label = ttk.Label(parameter_pane, text="Time Limit(s):") time_limit_label.grid(column=0, row=4, sticky=W) time_limit_entry = ttk.Entry(parameter_pane, textvariable=time_limit) time_limit_entry.grid(column=0, row=5, pady=(0, 10)) # self.root.columnconfigure(0, weight=1) # self.root.rowconfigure(0, weight=1) self.control_pane.columnconfigure(0, weight=1) self.control_pane.rowconfigure(0, weight=1) # for i in range(10): # map_pane.rowconfigure(i, weight=1) # for j in range(15): # map_pane.columnconfigure(j, weight=1) self.master.bind("<Left>", lambda e: self.left()) self.master.bind("<Right>", lambda e: self.right()) self.master.bind("<Up>", lambda e: self.move()) self.master.bind("<Down>", lambda e: self.back()) self.master.mainloop()