def __init__(self, networkname, server_config, bot_config, joinlist, modules_config): self.alive = True self.connected = False self.hostname = server_config['hostname'] self.port = int(server_config.get('port', "6667")) self.nick = bot_config['nick'] self.altnick = bot_config.get('altnick', self.nick + "_") self.username = bot_config['username'] self.realname = bot_config['realname'] self.owner = bot_config['owner'] self.networkname = networkname self.joinlist = joinlist self._reader_thread = None self._parser = MessageParser() self._init_callback_table() self._socket = None self._channel_list = [] self._modules_config = modules_config self.dynamic_modules = [ DynamicModule(self, m, c) for m, c in modules_config.items() ] self._last_ping = time.time()
def __init__(self, message): self.message_parser = MessageParser(message) # hole, [['2c', '2d'],...] for 6 players self.hole = self.message_parser.hole # board ['2c', '2d', '2h', ...] for at most 5 board cards self.board = self.message_parser.board self.viewing_player = self.message_parser.get_position() self.betting_string = self.message_parser.get_betting_string(rd=None) self.board_string = self.message_parser.get_board_string(rd=None) # a two-dimension list, dim-1 is round, dim-2 is i-th action of a round self.betting_action = self.get_betting_action() # a one-dimension list, store each {action string} as an element self.action_list = [] # store each {action object} of all round actions in a one-dimension list for each_round_action in self.betting_action: for action in each_round_action: self.action_list.append(Action(action)) # set up basic data structure self.spent = [50, 100, 0, 0, 0, 0] self.active = [True] * 6 self.fold = [False] * 6 self.allin = [False] * 6 self.pot = 150 self.max_bet = 100 self.current_player = 2 # player at seat 2 is first player to act in PREFLOP round self.finished = False self.round = Round.PREFLOP self.boards = None # first round have no board cards self.holes = None # hole array for 6 players self.min_no_limit_raise_to = 2 * 100 self.max_no_limit_raise_to = 20000 self.next_round_flag = False self.call_number = 0 # update [hole] and [board] self.holes = self.message_parser.get_hole_card(position=None) self.boards = self.message_parser.get_board_card(rd=None) # after setting up basic data structure, start to do each action and update data structure cnt = 0 for action in self.action_list: cnt += 1 self.do_action(action)
def __init__(self, sock): self.__socket = sock self.__message_parser = MessageParser() self.__lobby_model = LobbyModel() # name of the game self.__game = None # player number (1 or 2) self.__player = None # player id lol self.__id = self.__get_own_player_id() # add client as player self.__lobby_model.add_player(self.__id) # register callbacks self.__lobby_model.register_callback(LobbyEvent.on_update, self.on_update_lobby) self.__lobby_model.register_callback(LobbyEvent.on_chat, self.on_chat)
def __init__(self, roverID, blockInfo): self.roverID = roverID self.blockInfo = blockInfo self.posY = 0 self.nextY = 0 if roverID == 0: self.posX = 0 self.nextX = 0 else: self.posX = -1 self.nextX = -1 # Declare test client and parser self.clientConnection = TestClient() self.parser = MessageParser(roverID) # Connect signals and slots self.clientConnection.messageFromServer.connect(self.parser.parse) self.parser.parsedMessageSignal.connect(self.messageFromServer) self.parser.constructedMessageSignal.connect( self.clientConnection.sendMessageToServer)
def cleanup(): print('cleanup') server.closeServer() # Make Qt happy app = QApplication(sys.argv) # Declare server server = team13Server('192.168.42.1', 2000) # Declare server GUI serverGui = MainWindow() # Declare parser for rover 0 rover0Parser = MessageParser(0) # Declare parser for rover 1 rover1Parser = MessageParser(1) # Central class holding positions of both rovers roverPositions = RoverPositions() # Declare controller for rover 0 rover0Controller = Rover0Control(roverPositions) # Declare controller for rover 1 rover1Controller = Rover1Control(roverPositions) # Connect server signals server.client0Message.connect(rover0Parser.parse) server.client1Message.connect(rover1Parser.parse) server.serverClosed.connect(rover0Parser.closeLog) server.startSelf.connect(server.runServer) # Connect GUI signals
# Please install the slackclient module either globally or into ./lib before running this bot # Additionally, you should fill in the config.json with all of the appropriate keys, tokens, and IDs import json, sys, socket, time sys.path.insert(0, 'lib') sys.dont_write_bytecode = True from rtmctl import SlackBotController from messageparser import MessageParser with open('config.json', 'r') as cfg: config = json.load(cfg) slackbot = SlackBotController(config=config, parser=MessageParser(config)) # Runs the bot and handles/retries on connection errors, # implements an exponential backoff up to 256 seconds. def retryLoop(func, sec): try: func() except Exception, e: sec = sec + 1 if sec < 8 else 1 print 'Connection error, retrying in ' + str(2**sec) + ' seconds...' time.sleep(2**sec) retryLoop(func, sec) retryLoop(slackbot.run, 0)
from messageparser import MessageParser mp = MessageParser() try: prefix, command, params = mp.parseMessage('USER oskar oskar 127.0.0.1 :realname\r\n') except ValueError as e: print(e) print("prefix: ", prefix) print("command:", command) print("parameters:", params) # try: # mp.parseMessage(':prefix 001 middle :this is a trailing parameter \r\n') # except ValueError as e: # print(e) # print("prefix: ", mp.prefix) # print("command:", mp.command) # print("parameters:", mp.parameters)
import json, sys, socket, time sys.path.insert(0, './lib') from irccontroller import SlackIRCController from messageparser import MessageParser with open('config.json', 'r') as cfg: config = json.load(cfg) slackbot = SlackIRCController(server=config['irc']['host'], port=config['irc']['port'], channel=config['irc']['channel'], master=config['master'], parser=MessageParser(config=config), username=config['irc']['username'], password=config['irc']['password']) # Runs the bot and handles/retries on connection errors, # implementing an exponential backoff up to 256 seconds. def retryLoop(func, sec): try: func() except socket.error: sec = sec + 1 if sec < 8 else 1 print 'Connection error, retrying in ' + str(2**sec) + ' seconds...' time.sleep(2**sec) retryLoop(func, sec) retryLoop(slackbot.run, 0)