def text_handler(update, context): tgid = update.message.from_user.id if not tgid in config.kernel_dict: update.message.reply_text('Kernel not running, please use command /start') else: (km, cl, t, kernel) = config.kernel_dict[tgid] if not km.is_alive(): update.message.reply_text('Kernel not running, please use command /restart') else: t.cancel() t = Timer(config.timer_value, stop_kernel, [tgid]) t.start() config.kernel_dict[tgid] = (km, cl, t, kernel) li = Listener(kernel) try: timeout = 5.0 if kernel == 'octave' and update.message.text[:11] == 'pkg install': timeout = 60.0 reply = cl.execute_interactive(update.message.text, allow_stdin=False, timeout=timeout, output_hook=li.output_cb) except TimeoutError: context.bot.send_message( chat_id=update.message.chat_id, text='Timeout waiting for reply' ) if li.text: text = li.escape_ansi_text() if len(text) <= 4096: context.bot.send_message( chat_id=update.message.chat_id, text=text ) else: context.bot.send_message( chat_id=update.message.chat_id, text=text[:4092]+'\n...' ) if li.img_data: image = base64.b64decode(li.img_data) bio = BytesIO() bio.name = 'image.png' bio.write(image) bio.seek(0) context.bot.send_photo(chat_id=update.message.chat_id, photo=bio)
def __init__(s, master, todo): #Dane: Listener.__init__(s) s.__master = master s.__todo = todo #Definicje: s.__draw() s.listen2(todo)
def rec(url): l = Listener(url) m = Monitor(l) print('start') while True: if l.DetectLiveStream(): m.Record() time.sleep(120)
def __init__(self,manager,world=None): eventTypes = [Event.UpdateEvent,Event.NewPlayerEvent,Event.GameLoadedEvent] Listener.__init__(self,manager,eventTypes) self.creator = Creator() #self.worldList = [] self.worldIDToWorld = {} self.entityIDToEntity = {} self.activeWorld = world
def set_threads(self, manager): self.ts = Sender(self.client.multicast_addr, self.client.port, self.client.pvt_port) self.ts.start() self.tr = Receiver(self.client.multicast_addr, self.client.port, manager) self.tr.start() self.trp = Receiver_pvt(manager) self.trp.start() self.tl = Listener(manager) self.tl.start()
def __init__(self,manager,world,networked=True,gameClientID=None): # registers the WorldManipulator as a Listener for the given # events with the event manager. eventTypes = [ Event.EventExecutionEvent,Event.WorldManipulationEvent,Event.StartedEvent,Event.LoadGameEvent,Event.GameLoadedEvent] Listener.__init__(self,manager,eventTypes) self.networked=networked self.world=world self.gameClientID = gameClientID print 'WorldManipulator thinks the gameID is',gameClientID
def __init__(s,C,note): #Dane: Listener.__init__(s) s.__C=C s.__note=note s.__tag=s.__genTag() s.__font=Font(family="Monaco",size=14) #Definicje: s.__draw() s.__bind() s.listen2(note)
def __init__(self, username="******", plugin=False, live_debug=False): start = time.time() self.debug = debug(live_debug=live_debug) self.debug.addEvent("Starting DOC...", "SYSTEM") self.debug.addEvent("Create Variables...", "SYSTEM") # init names self.username = username self.user = "******" + self.username self.plugin = "PLUGIN" self.consoleGeneral = "CONSOLE" self.system = "SYSTEM" self.consoleGeneral = "CONSOLE" self.consoleInput = "CONSOLE IN" self.consoleOutput = "CONSOLE OUT" self.installed = [] instance = self self.debug.addEvent("Create Variables...Finished", self.system) self.debug.addEvent("Listener Build...", self.system) self.Listener = Listener() self.Listener.ConsoleStart() self.debug.addEvent("Listener Build... Finished", self.system) self.debug.addEvent("Interpret Build...", self.system) self.interpret = interpret(instance) self.debug.addEvent("Interpret Build... Finished", self.system) self.pluginMode = plugin if self.pluginMode == True: self.sender = self.plugin elif __name__ == "system": self.sender = self.system else: self.sender = self.user self.debug.addEvent("Starting DOC... Finished", self.system) stop = time.time() starttime = round((stop - start) * 1000) / 1000 if starttime < 1: starttime = "under 1" self.debug.addEvent("DOC started in " + str(starttime) + " second(s)", self.system)
def __init__(self, op, caption, post_id, file_format, addr): self.likes = 0 self.op = op self.caption = caption self.id = post_id self.liked_by = [] self.file_format = file_format self.link = 'users/' + str(int(post_id / lpn)) + '/' + str( post_id % lpn) + '.' + self.file_format self.list_sock = None listener = Listener(self.link, addr, self) listener.start()
def __init__(self): LogImplementer.__init__(self) Thread.__init__(self) self.listener = Listener(self.incomingMessages) self.createReceiverCallbacks() assert (self.callbackDict is not None ), f'Failed to create dictionary for callback functions!' self.initiaterFactory = InitiatorFactory() self.receiverFactory = ReceiverFactory(self.callbackDict) self.setName('Net-Man Thread')
def __init__(self): speaker = Speaker() listener = Listener() self.target = speaker.data # target self.dense_rep_target = speaker.data_encoder(self.target) # dense representation of target self.message = speaker.dense2message(self.dense_rep_target) # message self.all_candidate = listener.data # all candidates self.dense_rep_candidates = listener.data_encoder(self.all_candidate) # dense representation of all candidate self.encoded_message = listener.message2dense(self.message) # encoded message # sample from Gibbs self.likelihoods = tf.nn.softmax(tf.matmul(z, tf.transpose(self.dense_rep_candidate))) # Gibbs distribution of dot product of z and u in U self.dist = tf.distributions.Categorical(probs=self.likelihoods) self.prediction = self.dist.sample(1) # sample from Gibbs distribution to get target picked self.loss = (self.target == self.prediction)
def __init__(self,manager,clientID): eventTypes = [Event.NotificationEvent, Event.ResourceChangeEvent, Event.EntityFocusEvent, Event.SelectedEntityEvent] Listener.__init__(self,manager,eventTypes) self.descBox = DescriptionBox() self.resourceBar = ResourceBar((811,0)) self.selectedUnitBar = SelectedUnitBar() self.clientID = clientID #self.infoRect=pygame.Rect((0,20), (self.size[0], self.size[1]-20)) self.note=NotificationList()
async def process_file(self, file_path): print('processing {}'.format(file_path)) listener_output = Listener.read_wav_file(file_path) print('Listening completed') dispatcher_output = Dispatcher.offline(listener_output, self.config) print('Dispatching completed') return dispatcher_output
def __init__(self,manager,world,clientID): eventTypes = [ Event.RenderEvent, Event.MouseMovedEvent, \ Event.SelectionEvent, Event.SingleAddSelectionEvent, \ Event.InitiateActionEvent, \ Event.UpdateEvent, Event.WorldChangeEvent, \ Event.DisplaySurfaceCreatedEvent, Event.CompleteActionEvent, \ Event.DragBeganEvent, Event.DragEvent, \ Event.DragCompletedEvent, Event.AddDragCompletedEvent, \ Event.NumberKeyPressEvent, Event.GameOverEvent] Listener.__init__(self,manager,eventTypes) self.activeOverlay = None self.activeWorld = world self.activeScreen = None self.debugOverlay = None self.clientID = clientID self.TEST_interface()
def __init__(self, query): self.query = query self.tokens = json.load( open('./api/tokens.json', 'rb')) #This is dangerous, need to use better relative paths self.consumer_key = self.tokens['twitter']['consumer-key'] self.consumer_secret = self.tokens['twitter']['consumer-secret'] self.access_token = self.tokens['twitter']['oauth-token'] self.access_token_secret = self.tokens['twitter']['oauth-secret'] self.auth = tweepy.OAuthHandler(self.consumer_key, self.consumer_secret) self.auth.set_access_token(self.access_token, self.access_token_secret) self.stream = tweepy.Stream( self.auth, Listener('blank' if not self.query else '-'.join(self.query))) print 'Streaming started...' try: self.stream.filter(track=self.query, languages=['en']) except AttributeError as inst: print inst self.stream.disconnect() except: print 'here'
def appStarted(self): # Citation: this is a modified version of image from user BENL at link # https://www.chiefdelphi.com/t/top-down-orthographic-view-of-frcs-2019-playing-field/335397/9 self._fieldImage = self.loadImage("Skills-field.png") self.fieldImageScaled = ImageTk.PhotoImage(self._fieldImage) self._robotImage = self.scaleImage(self.loadImage("robot-blue2.png"), 0.57) self._WAYPOINT_RADIUS = 30 self.setAppDims() self.resetUserInputs() self.FIELD_REAL_WIDTH = 9.2 # meters self.FIELD_REAL_HEIGHT = 4.6 # 16.46 self.timerDelay = 30 # milliseconds self.waypoints = [] self.robot = RobotModel(1.0, 1.0, 0.0) self.time = 0.0 self.listener = Listener() self.UPDATE_RATE = 100 # odometryThread = threading.Thread( # target=self.odometryPeriodic, daemon=True) # odometryThread.start() self.logger = Logger() self.logger.registerLoggerDict(self.robot.logDict, "robot") # self.logger.registerLoggerDict(self.controls.logDict, "controls") yAxes = [ self.logger.dict["robot.heading"], self.logger.dict["robot.vel"] ] self.graph = StackedTimeGraph(self.logger.time, yAxes, (self.fieldImageWidth, self.width), (self.height, 0))
def main(argv): inp = FileStream(argv[1]) lexer = TinyLexer(inp) token_stream = CommonTokenStream(lexer) parser = TinyParser(token_stream) listener = Listener() tree = parser.program() walker = ParseTreeWalker().walk(listener, tree) lines = [] assembly_code = listener.assembly_code for i in range(len(assembly_code)): while assembly_code[i]: line = assembly_code[i].pop() l = convert(line) assert isinstance(l, list) assert len(l) == 2 lines.append(l[0]) if l[1]: lines.append(l[1]) for xyz in lines: print(xyz) print("sys halt")
def startListener(self): """ Starts a listener for incoming remote messages. The method will refuse to create a listener if there is already one """ if not self.listener: self.mylogger.info("Starting listener") self.listener = Listener(self.httpTree, self.myconfig) self.listener.start() else: msg = "Refusing to start listener (there is already one)." self.mylogger.info(msg)
def main(argv): inp = FileStream(argv[1]) lexer = TinyLexer(inp) token_stream = CommonTokenStream(lexer) parser = TinyParser(token_stream) listener = Listener() tree = parser.program() walker = ParseTreeWalker().walk(listener, tree) tables = listener.get_symbol_table() for t in tables: print("Symbol table %s" % t.name) for k, v in t.symbols.items(): if v[1]: print("name %s type %s value %s" % (k, v[0], v[1])) else: print("name %s type %s" % (k, v[0])) print("")
def start_listener(self): ''' Creates a new thread listening for an upstream connection from the ground station. ''' listenerThread = Listener(self.recievedQueue) listenerThread.setName('ISRU Listener') listenerThread.start() return listenerThread
async def replay_server(sockets, protocol, nursery): print("Testing", protocol) print(str(sockets)) try: for service in sockets: port = service.port print("Port", port) self.processList[port] = Listener( port, service, protocol, self.config.response_delay, nursery, ) nursery.start_soon(self.processList[port].handler) except Exception as ex: print("Replay_server exception", str(ex))
def start_watching (connection, configuration, utils): # Watchdog initialtion observer = Observer() observer.schedule(Listener(connection, configuration, utils), configuration.watch_dir, recursive=True) observer.start() print(Back.GREEN + Fore.BLACK + 'LemonSync is listening to changes for ' + connection["theme"] + ' in ' + configuration.watch_dir + Style.RESET_ALL) try: while True: time.sleep(1) except KeyboardInterrupt: observer.stop() observer.join() return
def main(self): self.twweeterObj = Twweeter() self.listenerObj = Listener(self.twweeterObj) self.check_data_dir_exists() print(('Press 99 to quit the Application')) while True: option = input('Enter \'twweet\' or \'get\' or \'edit\': ') if option == '99': break if option == 'twweet': tweet = input('Enter your twweet\n') self.twweeterObj.api.update_status(status=tweet) # Yes, tweet is called 'status' rather confusing elif option == 'get': check = True while check: check = self.home_select_action() elif option == 'edit': self.twweeterObj.createCreds() else: print(('Please choose any of the above options \n \n'))
class ClientApp(tk.Tk): def __init__(self, download_dir, source_dir): self.download_dir = download_dir tk.Tk.__init__(self) self.title("Torrent Sucks") self.geometry("500x500+300+100") self.resizable(False, True) self.config(bg="#474040") self.frame = tk.Frame(self, bg='#474040') self.frame.pack(side=tk.TOP, fill=tk.BOTH) self.search_bar = PlaceholderEntry(self.frame, "Please Enter the Filename", width=50) self.search_bar.pack(side=tk.LEFT, pady=20, padx=20) self.search_button = FocusButton(self.frame, text="Search", in_color="gray", out_color="black", fg="white", command=self.search) self.search_button.pack(side=tk.RIGHT, padx=20, pady=20) self.listbox_frame = tk.Frame(self, bg="#474040") self.listbox_frame.pack(side=tk.TOP, fill=tk.BOTH) self.listbox = tk.Listbox(self.listbox_frame, width=70, height=20) self.listbox.pack(side=tk.TOP, pady=20, padx=20) self.download_button = FocusButton(self.listbox_frame, text="Download", in_color="#52bf9c", out_color="#6ed1ff", fg="black", command=self.download) self.download_button.pack(side=tk.RIGHT, pady=20, padx=20) self.status_text = tk.Label(self.listbox_frame, text="", bg="#474040", font='Helvetica 10 bold') self.status_text.pack(side=tk.LEFT, pady=20, padx=20) #Start listener global host self.listener = Listener(host, source_dir) self.host, self.port = self.listener.get_self() print("Running On: {}:{}".format(self.host, self.port)) self.listen_thread = multiprocessing.Process( target=self.listener.listen) self.listen_thread.start() self.protocol("WM_DELETE_WINDOW", self.on_closing) self.search_file = "" #Start Sender self.sender = Sender(source_dir, self.host, self.port) global ft_server #Uncomment this if server is on print("Connecting to Server...") # print(ft_server[0]) # print(ft_server[1]) status = self.sender.start_conn(ft_server[0], ft_server[1]) if (status == 0): tkinter.messagebox.showerror( title="Error", message= "Couldn't correctly connect to FT server!\nCheck the ip configuration in Client.py, and restart the app!" ) # If server is not ready this will say "Could not connect to server" def search(self): filename = self.search_bar.get().strip() self.search_file = filename self.listbox.delete(0, tk.END) succ, status_message = self.sender.search(filename) if not succ: self.status_text.configure(text=status_message, fg="red") else: self.status_text.configure(text="") for result in self.sender.get_results(): self.listbox.insert(tk.END, result.strip()) def download(self): #<jpg, 54280, 07/30/2018, 127.0.0.1, 55682> data = self.listbox.get(tk.ACTIVE).strip()[1:-1].split(',') data = list(map(lambda str: str.strip(), data)) status_message = "Nothing happened" status_color = "gray" if (len(data) != 5): status_message = "Failed to download data format is not correct!" status_color = "red" else: req_file = { "name": self.search_file, #self.search_bar.get().strip() "type": data[0], "size": int(data[1]), "date": data[2], "ip": data[3], "port": int(data[4]), "dir": self.download_dir } succ, status_message = download_handler(req_file) if (succ): status_color = "green" else: status_color = "red" self.status_text.configure(text=status_message, fg=status_color) def on_closing(self): print("Closing!") self.sender.close() self.listen_thread.terminate() sys.exit()
def initListener(self): if self.listener == None: self.listener = Listener(self)
def _(*args, **kwargs): from Listener import Listener return Listener(TEST_PORT, args[0], args[1], args[2], args[3])
from Listener import Listener from dotenv import load_dotenv import logging from time import sleep import os logging.basicConfig(level=logging.INFO) current_dir = os.path.dirname(os.path.abspath(__file__)) load_dotenv(dotenv_path="{}/.env".format(current_dir)) l = Listener() l.start() def main(): while True: logging.info("*") sleep(1) if l.stop(): break if __name__ == '__main__': main()
def search(): #Gets text from search textbox userSearch = self.userSearch.get() #Wikipedia Checkbox if(self.chkVar1.get()): #webbrowser.open("http://en.wikipedia.org/w/index.php?title=" + str(userSearch)) #Displays Wikipedia hyperlink in label and binds it to left-click event and places in grid self.lblDisplayWikiURL.config(text="http://en.wikipedia.org/w/index.php?title=" + str(userSearch), font=("Times 10"), fg="Blue", cursor="hand2") self.lblDisplayWikiURL.bind('<Button-1>', self.wikicallback) #Flickr Checkbox if(self.chkVar2.get()): #sets the userSearchFlickr to the userSearch get method flickrPull = flickrSearch(userSearchFlickr=str(userSearch)) flickrPull.userSearch = userSearch #webbrowser.open("http://www.flickr.com/search/?q=" + str(userSearch)) #Opens the flickDB files and reads them for displaying in the lblDisplayFlickrData labels below, and then closes it saveFileFlickr = open('flickDB0.csv') readFileFlickr = saveFileFlickr.read() saveFileFlickr.close() saveFileFlickr = open('flickDB1.csv') readFileFlickr2 = saveFileFlickr.read() saveFileFlickr.close() saveFileFlickr = open('flickDB2.csv') readFileFlickr3 = saveFileFlickr.read() saveFileFlickr.close() saveFileFlickr = open('flickDB3.csv') readFileFlickr4 = saveFileFlickr.read() saveFileFlickr.close() saveFileFlickr = open('flickDB4.csv') readFileFlickr5 = saveFileFlickr.read() saveFileFlickr.close() saveFileFlickr = open('flickDB5.csv') readFileFlickr6 = saveFileFlickr.read() saveFileFlickr.close() saveFileFlickr = open('flickDB6.csv') readFileFlickr7 = saveFileFlickr.read() saveFileFlickr.close() saveFileFlickr = open('flickDB7.csv') readFileFlickr8 = saveFileFlickr.read() saveFileFlickr.close() saveFileFlickr = open('flickDB8.csv') readFileFlickr9 = saveFileFlickr.read() saveFileFlickr.close() saveFileFlickr = open('flickDB9.csv') readFileFlickr10 = saveFileFlickr.read() saveFileFlickr.close() #Displays Flickr hyperlink in label and binds it to left-click event and places in grid self.lblDisplayFlickrURL.config(text="http://www.flickr.com/search/?q=" + str(userSearch), fg="Blue", cursor="hand2") self.lblDisplayFlickrURL.bind('<Button-1>', self.flickrcallback) self.lblDisplayFlickrData.config(text=readFileFlickr, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT) self.lblDisplayFlickrData.bind('<Button-1>', self.flickrDisplayPhotocallback) self.lblDisplayFlickrData.grid(row=15, column=2, sticky=W) self.lblDisplayFlickrData2.config(text=readFileFlickr2, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT) self.lblDisplayFlickrData2.bind('<Button-1>', self.flickrDisplayPhotocallback2) self.lblDisplayFlickrData2.grid(row=16, column=2, sticky=W) self.lblDisplayFlickrData3.config(text=readFileFlickr3, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT) self.lblDisplayFlickrData3.bind('<Button-1>', self.flickrDisplayPhotocallback3) self.lblDisplayFlickrData3.grid(row=17, column=2, sticky=W) self.lblDisplayFlickrData4.config(text=readFileFlickr4, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT) self.lblDisplayFlickrData4.bind('<Button-1>', self.flickrDisplayPhotocallback4) self.lblDisplayFlickrData4.grid(row=18, column=2, sticky=W) self.lblDisplayFlickrData5.config(text=readFileFlickr5, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT) self.lblDisplayFlickrData5.bind('<Button-1>', self.flickrDisplayPhotocallback5) self.lblDisplayFlickrData5.grid(row=19, column=2, sticky=W) self.lblDisplayFlickrData6.config(text=readFileFlickr6, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT) self.lblDisplayFlickrData6.bind('<Button-1>', self.flickrDisplayPhotocallback6) self.lblDisplayFlickrData6.grid(row=20, column=2, sticky=W) self.lblDisplayFlickrData7.config(text=readFileFlickr7, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT) self.lblDisplayFlickrData7.bind('<Button-1>', self.flickrDisplayPhotocallback7) self.lblDisplayFlickrData7.grid(row=21, column=2, sticky=W) self.lblDisplayFlickrData8.config(text=readFileFlickr8, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT) self.lblDisplayFlickrData8.bind('<Button-1>', self.flickrDisplayPhotocallback8) self.lblDisplayFlickrData8.grid(row=22, column=2, sticky=W) self.lblDisplayFlickrData9.config(text=readFileFlickr9, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT) self.lblDisplayFlickrData9.bind('<Button-1>', self.flickrDisplayPhotocallback9) self.lblDisplayFlickrData9.grid(row=23, column=2, sticky=W) self.lblDisplayFlickrData10.config(text=readFileFlickr10, font=("Times 10"), fg="Blue", cursor="hand2", justify=LEFT) self.lblDisplayFlickrData10.bind('<Button-1>', self.flickrDisplayPhotocallback10) self.lblDisplayFlickrData10.grid(row=24, column=2, sticky=W) #Twitter Checkbox if(self.chkVar3.get()): #webbrowser.open("http://twitter.com/search?q=" + str(userSearch) + "&src=typd")1q #Streams the tweets using the Listener class and searches with the criteria of the userSearch twitterStream = Stream(authorize, Listener()) #Filters the twitter results with the user search input twitterStream.filter(track=[userSearch]) #Opens the tDB3 file and reads for displaying in the lblDisplayTwitterData below, and then closes it saveFile2 = open('tDB3.csv') readFile = saveFile2.read() saveFile2.close() #Displays Twitter hyperlink in label and binds it to left-click event and places in grid self.lblDisplayTwitterURL.config(text="http://twitter.com/search?q=" + str(userSearch) + "&src=typd", fg="Blue", cursor="hand2") self.lblDisplayTwitterURL.bind('<Button-1>', self.twittercallback) self.lblDisplayTwitterData.config(text=readFile, font=("Times 10"), justify=LEFT) self.lblDisplayTwitterData.grid(row=27, column=2, sticky=W) #Function that starts the thread def run(): while Listener.alive: multi = threading.Thread(target=search) multi.start()
def __init__(self, port=22000): Listener.__init__(self) self.port = port
print('[-] No arp spoof running at the moment.') else: print('[!] Hook injector already running.') elif command == 'vulnscan': vuln_scanner = VulnerabilityScanner.vulnscan_info() print("\n[+] Initializing Vulnerability Scanner...") try: vuln_scanner.crawl() vuln_scanner.run_scanner() except: print("[!] Something went wrong.") print("\n[+] Process finished...") elif command == 'backdoor': my_listener = Listener("10.0.2.10", 6217) service = multiprocessing.Process(target=my_listener.server) connections_status = multiprocessing.Process( target=my_listener.check_connections) service.start() connections_status.start() my_listener.shell() connections_status.terminate() service.terminate() elif command == 'portscan': tcp_ports = scan_ports() print("Open Ports: {}".format(str(tcp_ports).replace(' ', ''))) elif command == 'requestdns': my_ip = '10.0.2.10'
def handle_task(task, status, args): response = "Nothing happened" global running_tasks if status in [0, 1, 2] and task in known_tasks: # set index for corresponding listener object in array i = 0 for t in known_tasks: if t.partition("_")[0] in task: chosen_task = t print('task chosen:', chosen_task) if status == 2: response = chosen_task is_running_str = " is running" if running_tasks[ i].is_running() else " is not running" return response + is_running_str + "\n" if chosen_task in known_listeners: other_listeners = [ x for x in known_listeners if x != chosen_task ] for listener in running_tasks: if listener.get_name( ) in other_listeners and listener.is_running(): response = listener.get_name( ) + " is running, kill it before running " + chosen_task return response + "\n" # reinitialize Listener object with proper arguments if necessary, or quit early if nonesense request if chosen_task == "camera_stream": if running_tasks[i].is_running( ) and args != running_tasks[i].get_args(): response = "Camera stream already running on port " + running_tasks[ i].get_args() response += "\nTurn this stream of before starting or stopping a new one\n" return response # set appropriate usb port in args elif args and not running_tasks[i].is_running(): ports = glob.glob('/dev/tty[A-Za-z]*') if args in ports: running_tasks[i] = Listener( scripts[i], "bash", args, 1, True) else: response = "Requested port not available, is the camera properly plugged into the USB port?" return response + "\n" elif chosen_task == "arm_listener": if args and not running_tasks[i].is_running(): if args == 'usb' or args == 'uart': running_tasks[i] = Listener( scripts[i], "python", args) else: response = "Requested serial type is invalid" return response + '\n' elif chosen_task == "science_listener": if args and not running_tasks[i].is_running(): if args == 'usb' or args == 'uart': running_tasks[i] = Listener( scripts[i], "python", args) else: response = "Requested serial type is invalid" return response + '\n' break i += 1 if status == 1: if running_tasks[i].start(): response = "Started " + chosen_task else: response = "Failed to start " + chosen_task if running_tasks[i].is_running(): response += ", already running" else: # in this case it is worth trying to start the chosen_task if running_tasks[i].start(): response = "Started " + chosen_task else: if len(running_tasks) >= 1 and isinstance(running_tasks[i], Listener): if running_tasks[i].stop(): response = "Stopped " + chosen_task else: response = chosen_task + " not running, cannot terminate it" return response + "\n"
def __init__(self, download_dir, source_dir): self.download_dir = download_dir tk.Tk.__init__(self) self.title("Torrent Sucks") self.geometry("500x500+300+100") self.resizable(False, True) self.config(bg="#474040") self.frame = tk.Frame(self, bg='#474040') self.frame.pack(side=tk.TOP, fill=tk.BOTH) self.search_bar = PlaceholderEntry(self.frame, "Please Enter the Filename", width=50) self.search_bar.pack(side=tk.LEFT, pady=20, padx=20) self.search_button = FocusButton(self.frame, text="Search", in_color="gray", out_color="black", fg="white", command=self.search) self.search_button.pack(side=tk.RIGHT, padx=20, pady=20) self.listbox_frame = tk.Frame(self, bg="#474040") self.listbox_frame.pack(side=tk.TOP, fill=tk.BOTH) self.listbox = tk.Listbox(self.listbox_frame, width=70, height=20) self.listbox.pack(side=tk.TOP, pady=20, padx=20) self.download_button = FocusButton(self.listbox_frame, text="Download", in_color="#52bf9c", out_color="#6ed1ff", fg="black", command=self.download) self.download_button.pack(side=tk.RIGHT, pady=20, padx=20) self.status_text = tk.Label(self.listbox_frame, text="", bg="#474040", font='Helvetica 10 bold') self.status_text.pack(side=tk.LEFT, pady=20, padx=20) #Start listener global host self.listener = Listener(host, source_dir) self.host, self.port = self.listener.get_self() print("Running On: {}:{}".format(self.host, self.port)) self.listen_thread = multiprocessing.Process( target=self.listener.listen) self.listen_thread.start() self.protocol("WM_DELETE_WINDOW", self.on_closing) self.search_file = "" #Start Sender self.sender = Sender(source_dir, self.host, self.port) global ft_server #Uncomment this if server is on print("Connecting to Server...") # print(ft_server[0]) # print(ft_server[1]) status = self.sender.start_conn(ft_server[0], ft_server[1]) if (status == 0): tkinter.messagebox.showerror( title="Error", message= "Couldn't correctly connect to FT server!\nCheck the ip configuration in Client.py, and restart the app!" )
def __init__(self, controller): self.controller = controller listener = Listener(controller) listener.start()
class RemoteMsg(object): """ _RemoteMsg_ Main interface of the RemoteMsg module. Clients wishing to use the RemoteMsg should instantiate an object of this class and interface it using the public methods declared by it. """ def __init__(self, config, addresses=[], queue=True): """ Constructor. Requires a WMCore.Configuration object with configuration information. The addresses of recipients and the flag for queue/handling mode can be set with setAdress or setQueue methods also (have a look at their docstring for further help). The listener for messages needs to be started with the startListener method, meanwhile only publication capabilities are available. """ self.myconfig = config sections = self.myconfig.listSections_() if not "RemoteMsg" in sections: msg = "Cannot create RemoteMsg object without " msg += "RemoteMsg section in config file" raise Exception(msg) self.mylogger = None self.logMsg = None self.__setLogging__() self.mylogger.info("\n\n>>>>>RemoteMsg object being created <<<<<<\n") self.myComp = None if hasattr(self.myconfig.RemoteMsg, "inComponent"): self.myComp = self.myconfig.RemoteMsg.inComponent self.queueMode = queue self.addresses = addresses self.user = None self.passwd = None self.msgLock = threading.Lock() self.handlerLock = threading.Lock() self.factory = WMFactory("RemoteMsg") # If this is instantiated by a WMCore component, get its DB interface if self.myComp: # Get a reference to our invoking component's DB factory myThread = threading.currentThread() self.dbFactory = myThread.dbFactory self.dialect = myThread.dialect # TODO: Our msg queue is just in memo for now, but it might be in a DB # We already have the DB interface, but we would need our own Create # and Queries modules (in principle, different from those of the comp) # self.factory = WMFactory("threadPool", "WMCore.ThreadPool."+ \ # myThread.dialect) # self.queries = factory.loadObject(self.myComp+"Database"+ \ # myThread.dialect+"Queries") self.msgQueue = [] self.handlerMap = {} # Formatter for responses (change only if in synchronous mode) formatter = "RemoteMsgComp.DefaultFormatter" if hasattr(self.myconfig.RemoteMsg, "formatter"): formatter = self.myconfig.RemoteMsg.formatter formatterObj = self.factory.loadObject(formatter) params = { "msgQueue": self.msgQueue, "handlerMap": self.handlerMap, "msgLock": self.msgLock, "formatter": formatterObj, "queueMode": self.queueMode, } if self.myComp: params["component"] = self.myComp params["dbFactory"] = self.dbFactory params["dialect"] = self.dialect self.httpTree = HttpTree(params) self.sender = None self.__createSender__() self.listener = None def __del__(self): # Tell cherrypy to die self.mylogger.info("Asking listener to die") if self.listener: self.listener.terminate() self.listener.join() def __setLogging__(self): """ Initializes logging. Use by the constructor. """ compSect = self.myconfig.RemoteMsg # Logging if not hasattr(compSect, "logFile"): compSect.logFile = os.path.join(compSect.RemoteMsgDir, "remoteMsg.log") print("Log file is: " + compSect.logFile) if not hasattr(compSect, "listenerLogFile"): compSect.listenerLogFile = os.path.join(compSect.RemoteMsgDir, "listener.log") print("Listener log file is: " + compSect.listenerLogFile) logHandler = RotatingFileHandler(compSect.logFile, "a", 1000000, 3) logFormatter = logging.Formatter("%(asctime)s:%(levelname)s:%(filename)s:%(message)s") logHandler.setFormatter(logFormatter) self.mylogger = logging.getLogger("RemoteMsg") self.mylogger.addHandler(logHandler) self.mylogger.setLevel(logging.INFO) # map log strings to integer levels: self.logMsg = { "DEBUG": logging.DEBUG, "ERROR": logging.ERROR, "NOTSET": logging.NOTSET, "CRITICAL": logging.CRITICAL, "WARNING": logging.WARNING, "INFO": logging.INFO, } ## 'SQLDEBUG' : logging.SQLDEBUG } if hasattr(compSect, "logLevel") and compSect.logLevel in self.logMsg.keys(): self.mylogger.setLevel(self.logMsg[compSect.logLevel]) def __createSender__(self): """ Initializes the sender object. Used by the constructor. """ # Sender is not a new thread, so it does not need a lock params = {} params["addresses"] = self.addresses params["port"] = "8030" if hasattr(self.myconfig.RemoteMsg, "senderPort"): params["port"] = self.myconfig.RemoteMsg.senderPort params["service"] = "msg" if hasattr(self.myconfig.RemoteMsg, "senderService"): params["service"] = self.myconfig.RemoteMsg.senderService params["user"] = None if hasattr(self.myconfig.RemoteMsg, "senderUser"): params["user"] = self.myconfig.RemoteMsg.senderUser params["pwd"] = None if hasattr(self.myconfig.RemoteMsg, "senderPwd"): params["pwd"] = self.myconfig.RemoteMsg.senderPwd params["realm"] = "RemoteMsg" if hasattr(self.myconfig.RemoteMsg, "realm"): params["realm"] = self.myconfig.RemoteMsg.senderRealm self.sender = Sender(self.msgQueue, params) def startListener(self): """ Starts a listener for incoming remote messages. The method will refuse to create a listener if there is already one """ if not self.listener: self.mylogger.info("Starting listener") self.listener = Listener(self.httpTree, self.myconfig) self.listener.start() else: msg = "Refusing to start listener (there is already one)." self.mylogger.info(msg) def setAddress(self, addresses): """ Sets the addresses of the remote ends. Argument should be a list of IPs or hostnames. The publish method will send messages to all members of this list. """ self.addresses = addresses self.sender.setAddress(self.addresses) def setAuthentication(self, user, passwd): """ Sets the user/password for authentication with the remote application. Has to be done before sending a message. """ self.mylogger.debug("Setting user and passwd") self.user = user self.passwd = passwd def setQueue(self, value): """ This is an option that either allows messages that are being received to be put in a local queue (so a get method can retrieve them), or if set to False messages are handled directly through the handler framework. """ self.queueMode = value self.httpTree.setQueue(self.queueMode) def get(self): """ Gets messages from the local buffer (those not handled as explained in the setQueue method). The first message of the queue is retrieved and returned. This method is only used when the queue is set to True. If queue is set to False or there are no stored messages, None is returned. """ if self.queueMode: self.msgLock.acquire() if self.msgQueue: result = self.msgQueue.pop(0) else: result = None self.msgLock.release() return result else: return None def publish(self, msgType, payload, sync=False): """ Sends a message to the remote end. If sync is set to True, the remote server will complete the message handling before replying with some generated data. Otherwise, the remote end will immediately reply with some "Message received" indication and execute the handler asynchronously (if the remote end is in queue mode, there is no handler execution, so this flag is meaningless). In any case, the response of the message (e.g. a json string product of the handling of the HTTP request) is returned. Can throw an HTTP exception in case of error connecting with the remote end. """ return self.sender.send(msgType, payload, sync) def setHandler(self, msgType, handler): """ Maps the specified handler to the indicated message type. The handler must be the name of a class which can be called (e.g. RemoteMsg.SimpleHandler). The handler will only be called if queue mode is set to False. """ msg = "Setting new handler %s for msgType %s" % (handler, msgType) self.mylogger.debug(msg) # Factory to dynamically load handlers params = {} if self.myComp: params["component"] = self.myComp newHandler = self.factory.loadObject(handler, params) self.handlerLock.acquire() self.handlerMap[msgType] = newHandler self.handlerLock.release()
from Pagenator import Pagenator from Server import server import time import logging import os.path if __name__ == '__main__': currdir = os.path.abspath(os.getcwd()+'/../') try: logging.basicConfig(filename=os.path.normpath(currdir+'/logs/runlog.log'), level=logging.DEBUG) db = Database() listener = Listener(6969,256,db) listener.start() logging.info("Waiting 15 seconds for sensor data to populate the database...") time.sleep(15) serverdoc = Pagenator(db) #print serverdoc webpage = server(serverdoc,db) webpage.run() except SystemExit: print "Shutting Down..." logging.info("Shutting Down Main Thread...") webpage.stop()
label.setText('New Hotkey: Enter Keycombination') self.layout.addWidget(label) label = QLabel(self) label.setText('Delete Hotkey: Press DELETE') self.layout.addWidget(label) label = QLabel(self) label.setText('Cancel: Press ESC') self.layout.addWidget(label) self.setLayout(self.layout) if __name__ == '__main__': settings = Settings() listener = Listener(settings) app = QApplication(sys.argv) win = MainWindow(settings, listener) mw = windows.ModernWindow(win) stylesheet_path = os.path.join(wd, './Style/frameless.qss') icon_path = os.path.join(wd, './Compiled/owl.ico') with open(stylesheet_path) as stylesheet: mw.setStyleSheet(stylesheet.read()) mw.setWindowIcon(QIcon(icon_path)) mw.show() sys.exit(app.exec_())
from Listener import Listener from pynput.keyboard import Key, Controller import serial listener = Listener( serial.Serial(port="COM5", baudrate=115200, bytesize=8, timeout=2, stopbits=serial.STOPBITS_ONE)) keyboard = Controller() commands = listener.start() for command in commands: if (command == 'buttonA'): keyboard.press(Key.space) elif (command == 'buttonB'): keyboard.press(Key.down) else: keyboard.release(Key.down) keyboard.release(Key.space)
def __init__(self,manager,host = 'localhost',port = 51423): networking.Client.__init__(self,host,port) print self.socketThread eventTypes = [Event.WorldManipulationEvent,Event.LoadGameEvent] Listener.__init__(self,manager,eventTypes)
'stop_loss': None }] if __name__ == '__main__': trader = Trader(API_KEY, API_SECRET, SLACK_TOKEN) in_analyzers = [ InAnalyzer(trader, params=params_in[i]) for i in range(len(params_in)) ] out_analyzers = [ OutAnalyzer(trader, params=params_out[i]) for i in range(len(params_out)) ] trader.hire(in_analyzers, out_analyzers) follow_dict = csv_to_dict(FOLLOWED_USERS_FILE) listener = Listener(follow_dict, trader) auth = OAuthHandler(CONSUMER_KEY, CONSUMER_SECRET) auth.set_access_token(ACCESS_TOKEN, ACCESS_TOKEN_SECRET) try: followed_users_id = follow_dict.keys() tracked_words = [] # words you are looking for stream = Stream(auth, listener) stream.filter(follow=followed_users_id, track=tracked_words, async=True) trader.slackclient.api_call("chat.postMessage", channel='#bot-python', text="Bot init")
#!/usr/bin/env python3 import rospy import os from Listener import Listener from task_handler.srv import * current_dir = os.path.dirname(os.path.realpath(__file__)) + "/" print(current_dir) scripts = [ current_dir + "RoverCommandListener.py", current_dir + "ArmCommandListener.py", current_dir + "start_stream.sh" ] running_tasks = [ Listener(scripts[0], "python3"), Listener(scripts[1], "python3"), Listener(scripts[2], "bash", 1, True) ] known_tasks = ["rover_listener", "arm_listener", "camera_stream"] def handle_task_request(req): response = "\n" + handle_task(req.task, req.status) return response def handle_task(task, status): response = "Nothing happened"
#Reporter.log reporterlogger = logging.getLogger("reporter") reporterlogger.setLevel(logging.DEBUG) reporterfh = logging.handlers.RotatingFileHandler('logs/Reporter.log', maxBytes = 10*1024*1024, backupCount=2) reporterfh.setFormatter(formatter) reporterlogger.addHandler(reporterfh) ########initialize Listeners #first create server socket sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.bind(('192.168.1.222', 1060)) overseerlogger.info("(+) Listening socket created.") #create 5 Listeners and start them for i in range(5): t = Listener(sock, i+1) t.start() overseerlogger.info("(+) Listener "+str(i+1)+" started.") ########Initialize Alert Queue alertQueue = Queue() ########initialize Reporter reporter = Reporter(alertQueue, 0) reporter.start() overseerlogger.info("(+) Reporter started.") ########Initialize dict to hold phrases of active sessions and their states sessionsDict = dict() #Initialize list to hold SessionHanlder objects sessionHandlers = list()