def poke_lab(): print("You're in the famous Kanto Pokemon Laboratory. What would you like to do next? ") print("[A] Look around\n[B] Approach Lab Assistant\n[C] Approach Professor Oak\n[D] Exit Outside") ans = input("> ") if ans == "A": # Look around Actions.look() print("You see all sorts of machines and gadgets. You even see Pokemon relaxing and waddling around.") Actions.tap() print("After glancing around you go back to the task at hand.") Actions.tap() poke_lab() elif ans == "B": # Approach Lab Assistant print(" You find a man in lab coat that is busy at work") Actions.tap() dialouge.assistant_diag_1() poke_lab() elif ans == "C": # Approach Professor oak_intro(player_name) elif ans == "D": # Exit lab print("You turn around and exit back from where you entered.") Actions.tap() pallet_town() else: print(invalid) poke_lab()
def close_page(self, ensure=True): """ Close the current page. If the notebook becomes empty, and ensure is true, call new page upon exit to ensure that at least one page exists. Args: ensure: boolean """ if not self.page_to_be_closed: self.page_to_be_closed = self.get_page() #show the page if it has an executing flow graph or is unsaved if self.page_to_be_closed.get_proc() or not self.page_to_be_closed.get_saved(): self._set_page(self.page_to_be_closed) #unsaved? ask the user if not self.page_to_be_closed.get_saved() and self._save_changes(): Actions.FLOW_GRAPH_SAVE() #try to save if not self.page_to_be_closed.get_saved(): #still unsaved? self.page_to_be_closed = None #set the page to be closed back to None return #stop the flow graph if executing if self.page_to_be_closed.get_proc(): Actions.FLOW_GRAPH_KILL() #remove the page self.notebook.remove_page(self.notebook.page_num(self.page_to_be_closed)) if ensure and self.notebook.get_n_pages() == 0: self.new_page() #no pages, make a new one self.page_to_be_closed = None #set the page to be closed back to None
def Main(): try: lastColor = 'green' distanceActions = DistanceActions(trigger, echo) servoActions = Actions() while True: distance = distanceActions.TakeDistance() print(distance) if(distance <= minDistance): GPIO.output(ledRojo, GPIO.HIGH) GPIO.output(ledAmarillo, GPIO.LOW) GPIO.output(ledVerde, GPIO.LOW) if(lastColor != 'red'): servoActions.Deg0(servo) lastColor = 'red' else: if(distance >= minDistance and distance <= midDistance): GPIO.output(ledRojo, GPIO.LOW) GPIO.output(ledAmarillo, GPIO.HIGH) GPIO.output(ledVerde, GPIO.LOW) if(lastColor != 'yellow'): servoActions.Deg90(servo) lastColor = 'yellow' else: GPIO.output(ledRojo, GPIO.LOW) GPIO.output(ledAmarillo, GPIO.LOW) GPIO.output(ledVerde, GPIO.HIGH) if(lastColor != 'green'): servoActions.Deg180(servo) lastColor = 'green' time.sleep(0.3) except (KeyboardInterrupt, SystemExit): raise finally: GPIO.cleanup()
def __init__( self, parent ): Qt.QWidget.__init__( self, parent ) # Actions # Actions.createGraphEditorActions( self ) # Menus # #menuBar = Qt.QMenuBar( self ) # #fileMenu = menuBar.addMenu( 'File' ) #viewMenu = menuBar.addMenu( 'View' ) # #fileMenu.addAction( Actions.graphEditor.loadDynamicNode ) #viewMenu.addAction( Actions.graphEditor.frameAll ) # Graph editor # graphEditor = Cellule.appli.createGraphEditor( Cellule.fromSIP( self ) ) graphEditorSIP = Cellule.toSIP( graphEditor, Qt.QWidget ) # Layout # layout = Qt.QVBoxLayout( self ) #layout.addWidget( menuBar ) layout.addWidget( graphEditorSIP )
def createNodesForTransactions(transactions, position): if (TransactionsData[0][position] == 'n'): #if the attribute is nominal lists = Actions.createListsForNominal( transactions, position ) #call the method that creates lists for the nominal attribute lisPos = 0 #Initialize the lisPos to 0 for placing the value left or right in the node(0-left,1-right) for tranList in lists: result = Actions.checkAttributes( tranList, TransactionsData ) # method to check if the list is pure(0/1) or not(2) checkResult( result, tranList, position, lisPos ) #checking the result if we need recusion that is furthur split or not lisPos += 1 elif (TransactionsData[0][position] == 'c' ): #if the attribute is continuous lists = Actions.createListsForContinuous( transactions, position ) #call the method that creates lists for the continuous attribute lisPos = 0 #Initialize the lisPos to 0 for placing the value left or right in the node(0-left,1-right) for tranList in lists: result = Actions.checkAttributes( tranList, TransactionsData ) # method to check if the list is pure(0/1) or not(2) checkResult( result, tranList, position, lisPos ) #checking the result if we need recusion that is furthur split or not lisPos += 1
def actPlace(self, player, loc, value): self.logAction() piece = (-1) * ((-1)**player) * value if self.turnCount <= 2: piece = piece * (-1) // abs(piece) act.place(self.board, loc, piece) self.turnCount += 1
def make_post(sub, post, comment): try: #make post and comment post = Actions.make_post_url(sub, post.title, post.url) Actions.make_comment(post, comment) except Exception, e: print str(e)
def player_awake(): Actions.tap() print("You wake up in comfortable bed in room that Mom always keeps clean.You see 3 Options:\n[PC]\n[Door]\n[Bed].") ans = input("> ") if ans == "Bed": # Go to bed print("It's like 11AM are you sure you want to go back to bed?") Actions.tap() print("[A] Yes I am sad and I want to go back to bed. or [B] No I'm going to do something today.") ans = input("> ") if ans == "A": # I'm sure, Go to bed print("Congratulations you wasted an entire day!~~~") player_awake() elif ans == "B": # Don't go to bed print("That's the spirit!") player_room() else: print(invalid) player_room() elif ans == "PC": # open PC print("You walk and sit at your PC") player_pc() elif ans == "Door": # Exit to the living room print("You exit your room and walk out your room.") door() else: print(invalid) player_awake()
def update_mods(self, author=None): """ Update the internal mod-list (who can execute queries) :param author: if specified, the bot will respond to this user to let them know success/failure :return: None """ try: mlist = [mod.name for mod in Actions.get_mods(self.praw, self.sub)] if mlist is None or not len(mlist): return False # only update if it's valid self.mod_list = mlist self.last_mod_update = datetime.datetime.now() if author is not None: Actions.send_message(self.praw, author, u"RE: Modlist update", u"Success!") return True except Exception, e: if author is not None: Actions.send_message(self.praw, author, u"RE: Modlist update", u"Error encountered, please try again later.") logging.error(u"Could not update moderator list!") self.log_error() if __debug__: logging.exception(e) return False
def clear_sub(credentials, sub, num=20): """Removes all* old posts from a sub (use with care) * up to 900 :param credentials: :param sub: :return: """ num = min(num, 900) if num < 0: num = int(1e6) mypraw = create_multiprocess_praw(credentials) sub = get_subreddit(credentials, mypraw, sub) old_stream = p.helpers.submission_stream(mypraw, sub, limit=num) results = [] try: #delete all old posts for i in range(num): try: post = old_stream.next() Actions.remove_post(post, delete=True) print("# {} deleted...".format(i)) except AttributeError: # Post or Comment may have been deleted between retrieving it # and accessing its fields pass except AssertionError, e: logging.log(logging.DEBUG, str(e) + "\nNo Posts!")
def __info(self, author, subject, text): try: limit = 10 #first find a limit if it exists match = self.limit_match.search(subject) if match: limit = int(match.group(1)) #we must figure out the case if self.list_command.search(subject): return self.__info_list(author, subject, text) elif self.channel_command.search(subject): return self.__info_channels(author, subject, text, limit) elif self.user_command.search(subject): return self.__info_user(author, subject, text, limit) else: return Actions.send_message(self.praw, author, u'Message text not recognized', u'Message w/ \n' u'subject: {}\n'.format(subject) + u'and body: {}\n'.format(text) + u'not recognized, please consult documentation or help.') except Exception as e: logging.exception(e) Actions.send_message(self.praw, author, u'Re: {}'.format(subject), u'An error occured processing the following text, please file a bug report with' u' /u/arghdos: \n{}'.format(text))
def adjacent_moves(self): """ Determines which of the 4 directions the player can move in, i.e. where player can move Output: moves [<Actions>] """ moves = [] moves.append(Actions.MoveNorth()) moves.append(Actions.MoveSouth()) moves.append(Actions.MoveEast()) moves.append(Actions.MoveWest()) random.shuffle(moves) remove_move = random.randint(0, 3) for removed in range(0, remove_move): moves.pop() return moves
def adjacent_moves(self): """ Describes all actions for adjacent tiles, i.e. where player can move Shuffles the list for the movements and eliminates two of them to give the sense of walls Output: moves [<Actions>] """ moves = [] moves.append(Actions.MoveNorth()) moves.append(Actions.MoveSouth()) moves.append(Actions.MoveEast()) moves.append(Actions.MoveWest()) random.shuffle(moves) moves.pop() moves.pop() return moves
def __init__(self, file_paths, platform): """ ActionHandler constructor. Create the main window, setup the message handler, import the preferences, and connect all of the action handlers. Finally, enter the gtk main loop and block. Args: file_paths: a list of flow graph file passed from command line platform: platform module """ self.clipboard = None for action in Actions.get_all_actions(): action.connect('activate', self._handle_action) #setup the main window self.platform = platform self.main_window = MainWindow(platform) self.main_window.connect('delete-event', self._quit) self.main_window.connect('key-press-event', self._handle_key_press) self.get_page = self.main_window.get_page self.get_flow_graph = self.main_window.get_flow_graph self.get_focus_flag = self.main_window.get_focus_flag #setup the messages Messages.register_messenger(self.main_window.add_report_line) Messages.send_init(platform) #initialize self.init_file_paths = file_paths Actions.APPLICATION_INITIALIZE() #enter the mainloop gtk.main()
def pokedex(self): Actions.tap() print( f"This Pokemon is called {self.name} and it is a {self.poke_type} type from the {self.region} region." ) Actions.tap() print(f"This particular {self.name} is level {self.level}")
def set_available_actions(self): """ Appends actions to all_moves """ self.all_moves = self.adjacent_movements self.all_moves.append(Actions.ViewInventory()) self.all_moves.append(Actions.Equip()) self.all_moves.append(Actions.ViewCharacter())
def mom_intro_event(player_name): print("You gently open your eyes and you see a more than familiar face.") Actions.tap() print("You see your mother staring you straight in the face. gitty with excitement.") Actions.tap() dialouge.mom_diag_1(player_name) print("She sneaks out the room closing the door behind her.") player_awake()
def sort_function(cls, model, iter1, iter2, column): """ Overrides default sorting behaviour """ data1, data2 = [model.get_value(x, column) for x in (iter1, iter2)] try: first = Actions.MachineSortableDate(data1) second = Actions.MachineSortableDate(data2) except ValueError, err: print err return cmp(first, second)
def __info_user(self, author, subject, text, limit): # check that we have text lines = [l.strip() for l in self.line_splitter.split(text) if l is not None and len(l.strip())] if not len(lines): Actions.send_message(self.praw, author, u"RE: info user", u"No users specified in text: \n{}".format(text)) return False invalid_users = [] valid_users = [] #now go through the lines and make sure they're all usernames for line in lines: match = self.user_name_match.search(line) if not match: invalid_users.append(line) else: valid_users.append(match.group(1)) if not len(valid_users): if len(invalid_users): message = u'The following were not recognized as usernames: \n{}'.format(u', '.join(invalid_users)) else: message = u"No users specified in text: ".format(text) Actions.send_message(self.praw, author, u"RE: info user", message) return False valid_users = list(set(valid_users)) return_string = self.__create_table((u'Date', u'Link', u'Submitter', u'Channel', u'Domain', u'Deleted', u'Exception')) #with our list of usernames, query DB for submissions with DataBaseWrapper(self.owner.database_file, False) as db: for user in valid_users: #val is (short_url, channel_id, domain, date_added, processed, exception val = db.get_reddit(submitter=user, return_channel_id=True, return_domain=True, return_processed=True, return_exception=True, sort_by_new=True, limit=limit, return_dateadded=True) if val is not None and len(val): for submission in val: return_string += self.__table_entry(( str(submission[3]), u'http://redd.it/{}'.format(submission[0][submission[0].index('t3_')+ 3:]), user, submission[1], submission[2], u'True' if submission[4] == 1 else u'False', u'True' if submission[5] == 0 and submission[4] == 1 else u'False')) else: return_string += self.__table_entry((u'Not Found', user, u'N/A', u'N/A', u'N/A', u'N/A')) if invalid_users: return_string += u'\n\n' return_string += u"The following were not recognized as users:\n" return_string += u'\n'.join(invalid_users) return_string += u'\n\n' return_string += u'Note: Deletions and Exceptions are processed every {:.1} day(s),'.format( self.policy.Historial_Scan_Period / (24.0 * 60.0 * 60.0)) + \ u' and thus may not be updated within that time window.' return Actions.send_message(self.praw, author, u'Re: User Info query', return_string)
def tearDownClass(self): driver = self.driver print("Searching finished, waiting for all downloads to complete...") Actions.downloads_done() print("Test Two, number of downloaded beatmapsets: %s" % len(OsuAutomationTwo.downloaded_beatmapsets)) driver.switch_to.window(driver.window_handles[1]) driver.close() driver.switch_to.window(driver.window_handles[0]) driver.close()
def perimeter_detect(action): zymkey.client.set_perimeter_event_actions(1, action_notify=True, action_self_destruct=False) while True: try: logInfo = "" #detect perimeter breach every 2 seconds zymkey.client.wait_for_perimeter_event(timeout_ms=2000) perimeter_status = "" plst = zymkey.client.get_perimeter_detect_info() #print(plst) now = datetime.now() #print warning, date and time of the breach print("\nPerimeter event detected at (%s %s):" % (datetime.date(now), datetime.time(now))) logInfo += "\nPerimeter event detected at " + str( datetime.date(now)) + " " + str(datetime.time(now)) #Detect in which loop the perimeter has been detected. for z in range(len(plst)): p = plst[z] if p: #first loop is broken (inner loop) if z == 0: print(" Breach in the inner loop has been detected!") logInfo += "\n Breach in the inner loop has been detected!" #second loop is broken (outer loop) elif z == 1: print(" Breach in the outer loop has been detected!") logInfo += "\n Breach in the outer loop has been detected!" for j in range(len(plst)): p = plst[j] #log perimeter detection info perimeter_status = " perimeter[%d] timestamp = %d" % (j, p) logInfo += "\n perimeter[" + str( j) + "] timestamp = " + str(p) print(perimeter_status) misc.logInfo_perim(logInfo) if action == '1': subject = "Security Alert - Perimeter Breach Detected: " + str( datetime.date(now)) + " " + str(datetime.time(now)) act.send_email(subject, logInfo) elif action == '2': #add self destruct code here. Actions.selfDestruct() print("selfDestruct") zymkey.client.clear_perimeter_detect_info() except zymkey.exceptions.ZymkeyTimeoutError: logInfo = "" now = datetime.now() #no perimeter breach has been detected print("Nothing going on at (%s %s):" % (datetime.date(now), datetime.time(now))) logInfo += "\nNothing going on at " + str( datetime.date(now)) + " " + str(datetime.time(now)) misc.logInfo_perim(logInfo)
def __init__(self): Classe.__init__(self) self.name = "Mage" self.baseAP = 3 self.baseHP = 2 self.char = chr(244) self.type = 'mage' self.base_skills.append(Actions.Attack()) self.base_skills.append(Actions.Paralyse())
def adjacent_moves(self): """Returns all move actions for adjacent tiles.""" moves = [] if World.tile_exists(self.x + 1, self.y): moves.append(Actions.MoveEast()) if World.tile_exists(self.x - 1, self.y): moves.append(Actions.MoveWest()) if World.tile_exists(self.x, self.y + 1): moves.append(Actions.MoveNorth()) if World.tile_exists(self.x, self.y - 1): moves.append(Actions.MoveSouth()) return moves
def __init__(self): Classe.__init__(self) self.name = "Assasin" self.baseAP = 4 self.baseHP = 3 self.char = chr(105) self.type = 'stealth' self.base_skills.append(Actions.Attack()) self.base_skills.append(Actions.BackStab())
def update_selected_elements(self): """ Update the selected elements. The update behavior depends on the state of the mouse button. When the mouse button pressed the selection will change when the control mask is set or the new selection is not in the current group. When the mouse button is released the selection will change when the mouse has moved and the control mask is set or the current group is empty. Attempt to make a new connection if the old and ports are filled. If the control mask is set, merge with the current elements. """ selected_elements = None if self.mouse_pressed: new_selections = self.what_is_selected(self.get_coordinate()) #update the selections if the new selection is not in the current selections #allows us to move entire selected groups of elements if self.get_ctrl_mask() or not (new_selections and new_selections[0] in self.get_selected_elements()): selected_elements = new_selections if self._old_selected_port: self._old_selected_port.force_label_unhidden(False) self.create_shapes() self.queue_draw() elif self._new_selected_port: self._new_selected_port.force_label_unhidden() else: # called from a mouse release if not self.element_moved and (not self.get_selected_elements() or self.get_ctrl_mask()): selected_elements = self.what_is_selected( self.get_coordinate(), self.press_coor) #this selection and the last were ports, try to connect them if self._old_selected_port and self._new_selected_port: try: self.connect(self._old_selected_port, self._new_selected_port) Actions.ELEMENT_CREATE() except: Messages.send_fail_connection() self._old_selected_port = None self._new_selected_port = None return #update selected elements if selected_elements is None: return old_elements = set(self.get_selected_elements()) self._selected_elements = list(set(selected_elements)) new_elements = set(self.get_selected_elements()) #if ctrl, set the selected elements to the union - intersection of old and new if self.get_ctrl_mask(): self._selected_elements = list( set.union(old_elements, new_elements) - set.intersection(old_elements, new_elements)) Actions.ELEMENT_SELECT()
def __init__(self): Classe.__init__(self) self.name = "Archer" self.baseAP = 3 self.baseHP = 3 self.char = chr(68) self.type = 'range' self.base_skills.append(Actions.RangeAttack()) self.base_skills.append(Actions.Kick())
def __init__(self): self._pokename = "Electrode_" + str(random.randint(1, 100000)) self._max_health = 50 self.attack = 0.20 self.defence = 0.10 self.speed = 23 self.poketype = PokemonType.ELECTRIC self.actions = list([Actions.Attack("Electrospit", 1, 14, 0.7), Actions.Attack("Electroblow", 1, 22, 0.6), Actions.Defence("Electroshield", 1, 0.1), Actions.Defence("Electrobulb", 1, 0.3), Actions.Waiting()]) self.effects = list()
def __init__(self): Classe.__init__(self) self.name = "Warrior" self.baseAP = 3 self.baseHP = 4 self.char = chr(82) self.type = 'fight' self.base_skills.append(Actions.Attack()) self.base_skills.append(Actions.Lock())
def available_actions(self): """ Describes all methods Actions can call in this room Is default behavior, different tiles(subclasses) will specify more actions Output: moves [<Actions>] """ moves = self.adjacent_moves() moves.append(Actions.ViewInventory()) moves.append(Actions.Quit()) return moves
def poke_selection(): print("We have 3 Pokemon to adopt from.") Actions.tap() print("Please choose from either, \n[A] Cyndaquil\n[B] Totodile\n[C] Chikorita") ans = input("> ") if ans == "A": # choose Cyndaquil print(" This is Cyndiquil, a fire type! Are you sure this is who you want? [Y] or [N]") ans = input("> ") if ans == "Y": print("You Chose Cyndiquil!") Actions.tap() player_poke = poke_characters.cyndiquil_l5 return player_poke elif ans == "B": # choose Totodile print(" This is Totodile, a water type! Are you sure this is who you want? [Y] or [N]") ans = input("> ") if ans == "Y": print("You Chose Totodile!") Actions.tap() player_poke = poke_characters.totodile_l5 return player_poke elif ans == "C": # choose Chikorita print("This is Chikorita, a grass type! Are you sure this is who you want? [Y] or [N]") ans = input("> ") if ans == "Y": print("You chose Chikorita!") player_poke = poke_characters.chikorita_l5 Actions.tap() return player_poke print("No problem Take your time!") return None
def pallet_town(): print("You see gorgeous blue skies, the field of short green grass that surround your small town. You see..." "\n [A] The Pallet Town PokeLab" "\n [B] The Westward Ocean Coastline" "\n [C] You're House.") print("Which would you like to visit first?") ans = input("> ") if ans == "A": # For Pallet Town Poke Lab print("You make your way over to the Pallet Town PokeLab") Actions.tap() print("As you approach the building the automatic doors swing open and you find yourself in the lobby.") poke_lab() elif ans == "B": # For Westward Ocean Coastline print("You look left and you walk down the path to the Westward Ocean Coastline") Actions.tap() westward_coast() print(indev) pass # Add method for the "West Ward Ocean Coast line", and loop back to outside world elif ans == "C": # For Home print("You take a look front yard and the house you grew up in...") Actions.tap() print("You walk towards the door and enter your childhood home.") Actions.tap() door_2() else: print(invalid) pallet_town()
def without_breakfast(): print("You're really going to leave without eating Mom's famous breakfast? [Y] or [N]") ans = input("> ") if ans == "Y": # Leave with an empty stomach print("You leave at your own loss then...") Actions.tap() Actions.faint() player_awake() elif ans == "N": # go back to eat breakfast print("Good lad, Now go eat that breakfast.") door() else: print(invalid) without_breakfast()
def listen(txt): global flag txt.delete('1.0', END) txt.update() if flag: wish_me(txt) flag = False dictionary = dict([ ('play_media', ['play', 'music', 'mp3', 'song', 'video']), ('movie', ['play', 'movie', 'movies']), ('google', ['google', 'search', 'web', 'internet']), ('youtube', ['youtube', 'play', 'video', 'videos', 'entertainment']), ('wikipedia', ['wikipedia', 'encyclopedia', 'search', 'article', 'articles']), ('weather', ['weather', 'temperature', 'climate']), ('news', ['news', 'headlines']), ('day_date_time', ['day', 'date', 'time']), ('horoscope', ['horoscope', 'fortune', 'luck']), ('joke', ['joke', 'jokes', 'fun', 'funny']), ('note', ['note', 'notes', 'memorize']), ('email', ['mail', 'email']), ('repeat', ['repeat', 'sorry', 'pardon']), ('bye', ['goodbye', 'bye', 'exit', 'close']) ]) score = dict([('play_media', 0), ('movie', 0), ('google', 0), ('youtube', 0), ('wikipedia', 0), ('weather', 0), ('news', 0), ('day_date_time', 0), ('horoscope', 0), ('joke', 0), ('note', 0), ('email', 0), ('repeat', 0), ('bye', 0)]) query = take_command(txt).lower() words = query.split(' ') for word in words: for keyword in dictionary: for value in dictionary.get(keyword): if word == value: score[keyword] += 1 break max_score = max(score, key=score.get) if score.get(max_score) == 0: Actions.general_conversation(query, txt) else: getattr(Actions, max_score)(query, txt)
def __init__(self): self._pokename = "Krabby_" + str(random.randint(1, 100000)) self._max_health = 75 self.attack = 0.15 self._defence = 0.10 self.speed = 17 self.poketype = PokemonType.WATER self.actions = list([Actions.Attack("Claw Bite", 1, 12, 0.8), Actions.Attack("Claw Smash", 1, 17, 0.6, effects=[ Effects.Stun("Claw Smash", 100) ]), Actions.Defence("Crab Defence", 1, 0.2), Actions.Defence("Super Crab Defence", 1, 0.4), Actions.Waiting()]) self.effects = list()
def _level_up(self, level): if 2 == level: self._max_health = 100 self.attack = 0.20 self._defence = 0.15 self.speed = 21 self.actions.append(Actions.Attack("Claw Slash", 1, 14, 0.7, effects=[ Effects.Poisoning("Отравление", 150, 6) ])) if 3 == level: self._max_health = 130 self.attack = 0.30 self._defence = 0.20 self.speed = 25 self.actions.append(Actions.Attack("Mighty Smash", 1, 28, 0.8))
def available_actions(self): """ Changes the base available actions, if the enemy is alive only allow the player to attack or flee otherwise the default moves """ if self.enemy.is_alive(): return [Actions.Flee(tile=self), Actions.Attack(enemy=self.enemy)] else: moves = self.adjacent_moves() moves.append(Actions.ViewInventory()) moves.append(Actions.Quit()) return moves
def check_exception(self, post): try: #check for link flair if post.link_flair_css_class is None: return True except: pass try: #check for removal reason if post.removal_reason is not None: return True except: pass #check top level comments for specific keyword matches try: success = True #check comments for comment in post.comments: #test comment if not Actions.is_deleted(comment) and comment.distinguished == 'moderator': #test keyword for exception in self.policy.exception_list: if re.search(exception, comment.body): return True return False except Exception, e: success = False time.sleep(1)
def test_approve_post(post): print "Approve Post:" if a.approve_post(post): print "Passed" return True print "Failed" return False
def test_send_message(reddit, credentials): if a.send_message(reddit, credentials['ALTUSER'], "test", "testmessage"): print "Test Message Send: Passed" return True else: print "Test Message Send: Failed" return False
def __init__(self, file_paths, platform): """ ActionHandler constructor. Create the main window, setup the message handler, import the preferences, and connect all of the action handlers. Finally, enter the gtk main loop and block. @param file_paths a list of flow graph file passed from command line @param platform platform module """ self.clipboard = None for action in Actions.get_all_actions(): action.connect('activate', self._handle_action) #setup the main window self.main_window = MainWindow(platform) self.main_window.connect('delete-event', self._quit) self.main_window.connect('key-press-event', self._handle_key_press) self.get_page = self.main_window.get_page self.get_flow_graph = self.main_window.get_flow_graph self.get_focus_flag = self.main_window.get_focus_flag #setup the messages Messages.register_messenger(self.main_window.add_report_line) Messages.send_init(platform) #initialize self.init_file_paths = file_paths Actions.APPLICATION_INITIALIZE() #enter the mainloop gtk.main()
def run(self): while True: if not self.check_status(): break # see if we need to update mods if datetime.datetime.now() - self.last_mod_update > self.policy.Mod_Update_Period: if __debug__: logging.info(u"Blacklist Query updating mod list...") self.update_mods() if __debug__: logging.info(u"Modlist updated to: {}".format(u", ".join(self.mod_list))) # get unread unread = Actions.get_unread(self.praw, limit=self.policy.Unread_To_Load) try: messages = [message for message in unread] if __debug__: logging.info(u"Blacklist query processing {} messages...".format(len(messages))) for message in messages: self.process_message(message) if __debug__: logging.info(u"Blacklist query processing message from user {}.\nSubject:{}\nBody:{}". format(message.author.name if message.author.name is not None else u"DELETED", message.subject, message.body)) except Exception, e: logging.error(u"Error on retrieving unread messages") if __debug__: logging.exception(e) self.log_error() self.message_cache = [] # and wait (min of 30s to prevent return of cached answers on default PRAW install) time.sleep(max(self.policy.Blacklist_Query_Period, 30))
def scan(self, limit=None): """Scans the sub. :param limit: If None, the limit in the policy will be used :return: True if self.last_seen was reached, False otherwise """ lim = limit if limit else self.policy.Posts_To_Load # first ask for posts posts = self.get_posts(lim) if posts is None: return scan_result.Error found_old = False post_data = [] for post in posts: try: if not post.is_self: post_data.append(( post.created_utc, post.name, post.url, Actions.get_username(post), post)) except socket.error, e: if e.errno == 10061: logging.critical("praw-multiprocess not started!") else: logging.error(str(e)) return scan_result.Error except (HTTPError, NotFound) as e: # bad resolve logging.warn('Bad resolve for post {}'.format(post))
def historical_scan(self, goto): posts = self.get_historial_posts(goto) if posts is not None and len(posts): post_data = [(post.created_utc, post.name, post.url, Actions.get_username(post), post) for post in posts if not post.is_self] self.__process_post_list(post_data) return scan_result.FoundOld return scan_result.Error
def test_strike_counter(): try: os.remove("test_database.db") except: pass credentials = CRImport("TestCredentials.cred") mypraw = u.create_multiprocess_praw(credentials) pol = Policies.DebugPolicy(None) sub = u.get_subreddit(credentials, mypraw) cs = CentralScrutinizer.CentralScrutinizer(credentials, pol, "test_database.db") scount = cs.scount print "Simple strike count test:" #make post post = a.make_post_url(sub, "test", "https://www.youtube.com/watch?v=vmT0lCfybR4") with DataBase.DataBaseWrapper("test_database.db") as db: db.add_reddit([(post.name, "arghdos", "youtube", datetime.datetime.today())]) db.add_channels([("arghdos", "youtube", "http://www.youtube.com/user/arghdos", Blacklist.BlacklistEnums.NotFound, 2)]) post.set_flair("test") #delete post.delete() #run counter scount.scan() #check strikes with DataBase.DataBaseWrapper("test_database.db") as db: result = db.get_channels(id_filter="arghdos", return_strikes=True)[0][-1] if result != 3: print "Failed" return False with DataBase.DataBaseWrapper("test_database.db") as db: result = db.get_blacklist([("arghdos", "youtube")])[0] == Blacklist.BlacklistEnums.Blacklisted if not result: print "Failed" return False #set to non-blacklisted and run again to check deletion db.set_blacklist([("arghdos", "youtube")], Blacklist.BlacklistEnums.NotFound) #run counter scount.scan() #check strikes with DataBase.DataBaseWrapper("test_database.db") as db: result = db.get_channels(id_filter="arghdos", return_strikes=True)[0][-1] if result != 3: print "Failed" return False print "Passed"
def test_get_moderators(r, sub): print "Test Get Mods:" mods = a.get_mods(r, sub) if len([u for u in mods if any(name == u.name for name in ['arghdos', 'centralscruuutinizer'])]) == 2: print "Passed" return True print "Failed" return False
def test_get_by_id(praw, ids): list = a.get_by_ids(praw, ids) if list: list = [l for l in list] if len(list): print "Passed" return True print "Failed" return False
def get_posts(self, lim): # first ask for posts try: posts = self.sub.mod.log(action="removelink", limit=lim) posts = [posts.next().target_fullname for i in range(lim)] return Actions.get_by_ids(self.praw, posts) except Exception, e: logging.error(str(e)) if __debug__: logging.exception(e)
def test_xpost(post, credentials, praw, sub): mysub = u.get_subreddit(credentials, praw, sub) val = a.xpost(post, mysub, "test") print "Xpost:" if val: print "Passed" return True else: print "Failed" return False
def __init__(self, platform, action_handler_callback): """ MainWindow contructor Setup the menu, toolbar, flowgraph editor notebook, block selection window... """ self._platform = platform gen_opts = platform.get_block('options').get_param('generate_options') generate_mode_default = gen_opts.get_value() generate_modes = [ (o.get_key(), o.get_name(), o.get_key() == generate_mode_default) for o in gen_opts.get_options()] # load preferences Preferences.load(platform) #setup window gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL) vbox = gtk.VBox() self.hpaned = gtk.HPaned() self.add(vbox) #create the menu bar and toolbar self.add_accel_group(Actions.get_accel_group()) self.menu_bar = Bars.MenuBar(generate_modes, action_handler_callback) vbox.pack_start(self.menu_bar, False) self.tool_bar = Bars.Toolbar(generate_modes, action_handler_callback ) vbox.pack_start(self.tool_bar, False) vbox.pack_start(self.hpaned) #create the notebook self.notebook = gtk.Notebook() self.page_to_be_closed = None self.current_page = None self.notebook.set_show_border(False) self.notebook.set_scrollable(True) #scroll arrows for page tabs self.notebook.connect('switch-page', self._handle_page_change) #setup containers self.flow_graph_vpaned = gtk.VPaned() #flow_graph_box.pack_start(self.scrolled_window) self.flow_graph_vpaned.pack1(self.notebook) self.hpaned.pack1(self.flow_graph_vpaned) self.btwin = BlockTreeWindow(platform, self.get_flow_graph); self.hpaned.pack2(self.btwin, False) #dont allow resize #create the reports window self.text_display = TextDisplay() #house the reports in a scrolled window self.reports_scrolled_window = gtk.ScrolledWindow() self.reports_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.reports_scrolled_window.add(self.text_display) self.reports_scrolled_window.set_size_request(-1, DEFAULT_REPORTS_WINDOW_WIDTH) self.flow_graph_vpaned.pack2(self.reports_scrolled_window, False) #dont allow resize #load preferences and show the main window self.resize(*Preferences.main_window_size()) self.flow_graph_vpaned.set_position(Preferences.reports_window_position()) self.hpaned.set_position(Preferences.blocks_window_position()) self.show_all() self.reports_scrolled_window.hide() self.btwin.hide()
def test_get_message(credentials): r = praw.Reddit(user_agent=credentials['USERAGENT']) r.login(username=credentials['ALTUSER'], password=credentials['ALTPASS']) messages = a.get_unread(r) message = messages.next() success = message.author.name == 'centralscruuutinizer' and message.body == "testmessage" and message.subject == "test" if success: print "Test Get Message: Passed" return True print "Test Get Message: Failed" return True
def _handle_key_press(self, widget, event): """ Handle key presses from the keyboard and translate key combinations into actions. This key press handler is called prior to the gtk key press handler. This handler bypasses built in accelerator key handling when in focus because * some keys are ignored by the accelerators like the direction keys, * some keys are not registered to any accelerators but are still used. When not in focus, gtk and the accelerators handle the the key press. @return false to let gtk handle the key action """ if not self.get_focus_flag(): return False return Actions.handle_key_press(event)
def main(): from CredentialsImport import CRImport import utilitymethods as u import logging testbed = None saved_posts = {} # mark true if the script should remove all old posts from the testbed DELETE_OLD = True #import credentials credentials = CRImport("TestCredentials.cred") #create my reddit r = u.create_multiprocess_praw(credentials) #get testbed sub testbed = u.get_subreddit(credentials, r) #create datasource object datasource = u.get_subreddit(credentials, r, credentials["DATAMININGSUB"]) if DELETE_OLD: old_stream = praw.helpers.submission_stream(r, testbed, limit=POST_LIMIT) results = [] try: #delete all old posts for post in old_stream: try: Actions.remove_post(post, delete=True) print("deleted old post: %s..." % post.title[:20]) except AttributeError: # Post or Comment may have been deleted between retrieving it # and accessing its fields pass except AssertionError, e: logging.log(logging.DEBUG, str(e) + "\nNo Posts!")
def __init__(self): """ Parse the list of action names in the toolbar list. Look up the action for each name in the action list and add it to the toolbar. """ gtk.Toolbar.__init__(self) self.set_style(gtk.TOOLBAR_ICONS) for action_name in TOOLBAR_LIST: if action_name: #add a tool item action = Actions.get_action_from_name(action_name) self.add(action.create_tool_item()) #this reset of the tooltip property is required (after creating the tool item) for the tooltip to show action.set_property('tooltip', action.get_property('tooltip')) else: self.add(gtk.SeparatorToolItem())
def process_message(self, message): """ Handles the processing of unread messages :param message: the message to process """ result = None # valid author check if message.author and any(name == message.author.name for name in self.mod_list) and not self.is_cached(message.id): subject = message.subject text = message.body # check that it matches one of the basic commands matches = [bc for bc in self.base_commands if bc.search(subject)] if len(matches) == 1: # take care of add /removes if matches[0] == self.add_command: self.__add_remove(message.author.name, subject, text, True) elif matches[0] == self.remove_command: self.__add_remove(message.author.name, subject, text, False) # update mods elif matches[0] == self.update_command: self.update_mods(message.author.name) # print query elif matches[0] == self.info_command: result = self.__info(message.author.name, subject, text) # help query elif matches[0] == self.help_command: Actions.send_message(self.praw, message.author.name, u"RE:{}".format(message.subject), self.doc_string) if len(matches) != 1: Actions.send_message(self.praw, message.author.name, u"RE:{}".format(message.subject), u"Sorry, I did not recognize your query. \n".format(text) + self.short_doc_string) self.message_cache.append(message.id) # don't need to see this again message.mark_read() return result
def update_exec_stop(self): """ Update the exec and stop buttons. Lock and unlock the mutex for race conditions with exec flow graph threads. """ sensitive = self.get_flow_graph().is_valid() and not self.get_page().get_pid() Actions.get_action_from_name(Actions.FLOW_GRAPH_GEN).set_sensitive(sensitive) Actions.get_action_from_name(Actions.FLOW_GRAPH_EXEC).set_sensitive(sensitive) Actions.get_action_from_name(Actions.FLOW_GRAPH_KILL).set_sensitive(self.get_page().get_pid() != None)
def _handle_key_press(self, widget, event): """ Handle key presses from the keyboard and translate key combinations into actions. This key press handler is called prior to the gtk key press handler. This handler bypasses built in accelerator key handling when in focus because * some keys are ignored by the accelerators like the direction keys, * some keys are not registered to any accelerators but are still used. When not in focus, gtk and the accelerators handle the the key press. Returns: false to let gtk handle the key action """ # prevent key event stealing while the search box is active if self.main_window.btwin.search_entry.has_focus(): return False if not self.get_focus_flag(): return False return Actions.handle_key_press(event)
def get_historial_posts(self, goto): """Scans the sub with more intensive detection of previously found reddit posts Allows for mass processing of past posts """ last_id = None last_seen = datetime.datetime.now() posts = [] if self.policy.Use_Reddit_Analytics_For_Historical_Scan: while last_seen > goto: raise NotImplementedError if last_id: self.RA_params["after"] = last_id try: data = requests.get("http://api.redditanalytics.com/getPosts", params=self.RA_params, headers=self.RA_headers) json_data = json.loads(data.content) ids = [post["name"] for post in json_data["data"]] with DataBase.DataBaseWrapper(self.file) as db: exists = db.reddit_exists(ids) if exists is not None: ids = [ids[i] for i in range(len(ids)) if not exists[i]] else: return None if not len(ids): continue temp_posts = Actions.get_by_ids(self.praw, ids) if temp_posts is not None: posts.extend(temp_posts) else: return None last_id = json_data["metadata"]["oldest_id"] last_seen = datetime.datetime.fromtimestamp(json_data["metadata"]["oldest_date"]) except ValueError, e: if str(e).startswith("No JSON object"): logging.error("Reddit-Analytics is down, retrying historical scan after pause...") else: logging.error(str(e)) if __debug__: logging.exception(e) #temporary fix to avoid endless waiting while RA is down return [] except Exception, e: logging.error(str(e)) if __debug__: logging.exception(e) #temporary fix to avoid endless waiting while RA is down return []
def __init__(self, platform): """ MainWindow contructor Setup the menu, toolbar, flowgraph editor notebook, block selection window... """ self._platform = platform # setup window gtk.Window.__init__(self, gtk.WINDOW_TOPLEVEL) vbox = gtk.VBox() self.hpaned = gtk.HPaned() self.add(vbox) # create the menu bar and toolbar self.add_accel_group(Actions.get_accel_group()) vbox.pack_start(Bars.MenuBar(), False) vbox.pack_start(Bars.Toolbar(), False) vbox.pack_start(self.hpaned) # create the notebook self.notebook = gtk.Notebook() self.page_to_be_closed = None self.current_page = None self.notebook.set_show_border(False) self.notebook.set_scrollable(True) # scroll arrows for page tabs self.notebook.connect("switch-page", self._handle_page_change) # setup containers self.flow_graph_vpaned = gtk.VPaned() # flow_graph_box.pack_start(self.scrolled_window) self.flow_graph_vpaned.pack1(self.notebook) self.hpaned.pack1(self.flow_graph_vpaned) self.btwin = BlockTreeWindow(platform, self.get_flow_graph) self.hpaned.pack2(self.btwin, False) # dont allow resize # create the reports window self.text_display = TextDisplay() # house the reports in a scrolled window self.reports_scrolled_window = gtk.ScrolledWindow() self.reports_scrolled_window.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC) self.reports_scrolled_window.add_with_viewport(self.text_display) self.reports_scrolled_window.set_size_request(-1, DEFAULT_REPORTS_WINDOW_WIDTH) self.flow_graph_vpaned.pack2(self.reports_scrolled_window, False) # dont allow resize # load preferences and show the main window Preferences.load(platform) self.resize(*Preferences.main_window_size()) self.flow_graph_vpaned.set_position(Preferences.reports_window_position()) self.hpaned.set_position(Preferences.blocks_window_position()) self.show_all()
def _handle_key_press(self, widget, event): """ Handle key presses from the keyboard and translate key combinations into actions. This key press handler is called prior to the gtk key press handler. This handler bypasses built in accelerator key handling when in focus because * some keys are ignored by the accelerators like the direction keys, * some keys are not registered to any accelerators but are still used. When not in focus, gtk and the accelerators handle the the key press. @return false to let gtk handle the key action """ #dont allow key presses to queue up if gtk.events_pending(): return True #extract action name from this key press key_name = gtk.gdk.keyval_name(event.keyval) mod_mask = event.state action_name = Actions.get_action_name_from_key_name(key_name, mod_mask) #handle the action if flow graph is in focus if action_name and self.get_focus_flag(): self.handle_states(action_name) return True #handled by this method return False #let gtk handle the key press
def __init__(self): """ Parse the list of submenus from the menubar list. For each submenu, get a list of action names. Look up the action for each name in the action list and add it to the submenu. Add the submenu to the menu bar. """ gtk.MenuBar.__init__(self) for main_action,action_names in MENU_BAR_LIST: #create the main menu item main_menu_item = main_action.create_menu_item() self.append(main_menu_item) #create the menu main_menu = gtk.Menu() main_menu_item.set_submenu(main_menu) for action_name in action_names: if action_name: #append a menu item action = Actions.get_action_from_name(action_name) main_menu.append(action.create_menu_item()) else: main_menu.append(gtk.SeparatorMenuItem()) main_menu.show_all() #this show all is required for the separators to show