def __init__(self): #procControllerAddr = '165.227.24.226' # I am client to HostController #procControllerPort = '5557' hostControllerPort = '5556' # I server to device print("Host Controller Starting\n") self.context = zmq.Context() # get context self.loop = IOLoop.instance() # self.clientSetup = ClientSetup(context) # instantiate the ClientSetup object self.serverSetup = ServerSetup(self.context) # instantiate the ServerSetup object # set up separate server and client sockets self.serverSocket = self.serverSetup.createServerSocket() # get a server socket self.serverSetup.serverBind(hostControllerPort, self.serverSocket) # bind to an address # self.clientSocket = self.clientSetup.createClientSocket() # get a client socket # NOTE: setIdentity() MUST BE CALLED BEFORE clientConnect or the identity will # not take effect # self.clientSetup.setIdentity(MasterId().getDevId()) # get the device id # self.clientSetup.clientConnect(hostControllerAddr, hostControllerPort, self.clientSocket) # connect to server using clientSocket self.serverSocket = ZMQStream(self.serverSocket) self.serverSocket.on_recv(self.onServerRecv) self.messages = Messages() # instantiate a Messages object self.inDict = {} self.outDict = {}
class Device: def __init__(self): deviceControllerAddr = 'localhost' deviceControllerPort = '5555' clientPort = '' print("Device Starting\n") self.context = zmq.Context() # get context self.loop = IOLoop.instance() self.clientSetup = ClientSetup(self.context) # instantiate the ClientSetup object #serverSetup = ServerSetup(context) # instantiate the ServerSetup object # set up separate server and client sockets self.clientSocket = self.clientSetup.createClientSocket() # get a client socket # NOTE: setIdentity() MUST BE CALLED BEFORE clientConnect or the identity will # not take effect self.clientSetup.setIdentity(MasterId().getDevId(), self.clientSocket) # get the device id self.clientSetup.clientConnect(deviceControllerAddr, deviceControllerPort, self.clientSocket) # connect to server using clientSocket self.clientSocket = ZMQStream(self.clientSocket) self.clientSocket.on_recv(self.onClientRecv) self.messages = Messages() # instantiate a Messages object def onClientRecv(self,msg): print("on_recv, msg=", msg) self.cmdFrmServer = msg[0] self.data = msg[1] print("Received from DeviceController: cmd=", self.cmdFrmServer, "data=", self.data) self.dataList = self.messages.bufferToDict(self.data) # create a list print("internal list, devType={}, cmd={}, data={}, returnList={}" .format(self.dataList['devType'], self.dataList['cmd'], self.dataList['data'], self.dataList['returnList'])) self.clientDevId = MasterId().getDevId() print("Device's id=", self.clientDevId) def start(self): # self.periodic.start() cmdToServer = "001".encode() outDict = self.messages.createMessageDict('00', '001', 'Hello HostServer', []) print("initial state, sending this dictionary:", outDict) dataToServer = self.messages.dictToBuffer(outDict).encode() print('sending this output message:\n', dataToServer) self.clientSocket.send_multipart([cmdToServer, dataToServer]) try: self.loop.start() except KeyboardInterrupt: pass
def __init__(self, mode, ip, port): self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.msg = Messages() self.missing_packages = [] self.keywords = ['setPyPy', 'pycross()'] self.Pycross = [] self.MainFile = None if mode: self.socket.connect((ip, port)) self.send = self.__client_send self.recv = self.__client_recv else: self.socket.bind((ip, port)) self.socket.listen(2) self.send = self.__server_send self.recv = self.__server_recv self.clinet = self.socket.accept()[0] self.msgToFunc = { "SF": self.sendFunc, "RF": self.readFunc, "RMF": self.readMainFile, "RP": self.readPackages, "SMF": self.sendMainFile, "SP": self.sendPackages, "RO": self.readOutput, "RE": self.readError, "end": None }
def get_message(sid): messages = Messages() msg = messages.getMessage(app.config['TWILIO_ACCOUNT_SID'], app.config['TWILIO_AUTH_TOKEN'], sid) return json.dumps({"sid": msg.sid, "body": msg.body, "date_sent": msg.date_sent, "from": msg.from_})
def __init__(self): deviceControllerAddr = 'localhost' deviceControllerPort = '5555' clientPort = '' print("Device Starting\n") self.context = zmq.Context() # get context self.loop = IOLoop.instance() self.clientSetup = ClientSetup(self.context) # instantiate the ClientSetup object #serverSetup = ServerSetup(context) # instantiate the ServerSetup object # set up separate server and client sockets self.clientSocket = self.clientSetup.createClientSocket() # get a client socket # NOTE: setIdentity() MUST BE CALLED BEFORE clientConnect or the identity will # not take effect self.clientSetup.setIdentity(MasterId().getDevId(), self.clientSocket) # get the device id self.clientSetup.clientConnect(deviceControllerAddr, deviceControllerPort, self.clientSocket) # connect to server using clientSocket self.clientSocket = ZMQStream(self.clientSocket) self.clientSocket.on_recv(self.onClientRecv) self.messages = Messages() # instantiate a Messages object
def sell_limit(symbol, quantity, sell_price): order = client.sell_limit(symbol, quantity, sell_price) if 'msg' in order: Messages.get(order['msg']) return order
def buy_limit(symbol, quantity, buy_price): order = client.buy_limit(symbol, quantity, buy_price) if 'msg' in order: Messages.get(order['msg']) # Buy order created. return order['orderId']
def sell_market(symbol, quantity): order = client.sell_market(symbol, quantity) if 'msg' in order: Messages.get(order['msg']) return order
def get_messages(): messages = Messages() messages=messages.list(app.config['TWILIO_ACCOUNT_SID'], app.config['TWILIO_AUTH_TOKEN']) ret_message = [] for msg in messages: if msg.direction == 'inbound': ret_message.append({"sid": msg.sid, "body": msg.body, "date_sent": str(msg.date_sent), "from": msg.from_}) return json.dumps(ret_message)
def vs_locus(input): msg = Messages() #msg.info("Welcome to vs_locus (version {})".format(vs.__version__)) msg.info("Welcome to vs_locus!") cluster_summary = ClusterSummary() cluster_summary.load_table(input) cluster_summary.add_centroids() cluster_summary.add_hits() pass
def get_message_sid_list(): messages = Messages() messages=messages.list(app.config['TWILIO_ACCOUNT_SID'], app.config['TWILIO_AUTH_TOKEN']) message_sid_list = [] for message in messages: if message.direction == 'inbound': message_sid_list.append(message.sid) return json.dumps(message_sid_list)
def buy_limit(symbol, quantity, buyPrice): order = client.buy_limit(symbol, quantity, buyPrice) if 'msg' in order: Messages.get(order['msg']) # Buy order created. return order['orderId']
def get_balance(symbol): coin_order, currency_order = client.get_balance(symbol) if 'msg' in coin_order: Messages.get(coin_order['msg']) if 'msg' in currency_order: Messages.get(currency_order['msg']) # Buy order created. return coin_order['free'], currency_order['free']
def get_order(symbol, orderId): try: order = client.query_order(symbol, orderId) if 'msg' in order: Messages.get(order['msg']) return order except Exception as e: print ('go: %s' % (e)) return False
def get_order_status(symbol, orderId): try: order = client.query_order(symbol, orderId) if 'msg' in order: Messages.get(order['msg']) return order['status'] except Exception as e: print('get_order_status Exception: %s' % e) return None
def get_order_status(symbol, orderId): try: order = client.query_order(symbol, orderId) if 'msg' in order: Messages.get(order['msg']) return order['status'] except Exception as e: print ('gos: %s' % (e)) return None
def get_order(symbol, orderId): try: order = client.query_order(symbol, orderId) if 'msg' in order: return False Messages.get(order['msg']) # TODO return order except Exception as e: print ('go: %s' % (e)) return False
def get_order(symbol, orderId): try: order = client.query_order(symbol, orderId) if 'msg' in order: #import ipdb; ipdb.set_trace() Messages.get(order['msg']) # TODO return False return order except Exception as e: print('get_order Exception: %s' % e) return False
def cancel_order(symbol, orderId): try: order = client.cancel(symbol, orderId) if 'msg' in order: Messages.get(order['msg']) print('Profit loss, called order, %s' % (orderId)) return True except Exception as e: print('cancel_order Exception: %s' % e) return False
def sell_limit(symbol, quantity, sell_price): order = client.sell_limit(symbol, quantity, sell_price) while (order is None): try: order = client.sell_limit(symbol, quantity, sell_price) except ValueError: order = None else: break # order = client.sell_limit(symbol, quantity, sell_price) if 'msg' in order: Messages.get(order['msg']) return order
def cancel_order(symbol, orderId): try: order = client.cancel(symbol, orderId) if 'msg' in order: Messages.get(order['msg']) print ('Profit loss, called order, %s' % (orderId)) return True except Exception as e: print ('co: %s' % (e)) return False
def buy_limit(symbol, quantity, buyPrice): order = client.buy_limit(symbol, quantity, buyPrice) while (order is None): try: order = client.sell_limit(symbol, quantity, buyPrice) except ValueError: order = None else: break # order = client.buy_limit(symbol, quantity, buyPrice) if 'msg' in order: Messages.get(order['msg']) # Buy order created. return order['orderId']
def initialize(self): self.msg = Messages(self) self.patterns = [] self.pattern = None self.currentDatFile = None self.initConfig() self.initializeUtilities() self.gui = Gui() self.gui.initializeMainWindow(self) self.updatePatternCanvasLastSize() self.patternListBox.bind('<<ListboxSelect>>', self.patternSelected) self.after_idle(self.canvasConfigured) self.deviceEntry.entryText.set(self.getConfig().device) self.datFileEntry.entryText.set(self.getConfig().datFile) self.initEmulator() self.after_idle(self.reloadPatternFile)
def start(self, event): self.send_presence() self.get_roster() self.send_message(mto=self.recipient, mbody="connect", mtype='chat') from Rss import Feeds from time import sleep from Messages import Messages i = 0 while True: i = i + 1 sleep(15) feed = Feeds().feedaki() #self.msg = "publish:face3 "+feed self.msg = "publish:face3 I am on my " + str(i) + " cycle!" self.send_message( mto=self.recipient, #mbody=self.msg, mbody=Messages().choose_message(), mtype='chat') # Using wait=True ensures that the send queue will be # emptied before ending the session. self.disconnect(wait=True)
def get_server_time(): time = client.get_server_time() if 'msg' in time: Messages.get(time['msg']) return datetime.datetime.fromtimestamp(time['serverTime'] / 1000.0)
class HostController: def __init__(self): #procControllerAddr = '165.227.24.226' # I am client to HostController #procControllerPort = '5557' hostControllerPort = '5556' # I server to device print("Host Controller Starting\n") self.context = zmq.Context() # get context self.loop = IOLoop.instance() # self.clientSetup = ClientSetup(context) # instantiate the ClientSetup object self.serverSetup = ServerSetup(self.context) # instantiate the ServerSetup object # set up separate server and client sockets self.serverSocket = self.serverSetup.createServerSocket() # get a server socket self.serverSetup.serverBind(hostControllerPort, self.serverSocket) # bind to an address # self.clientSocket = self.clientSetup.createClientSocket() # get a client socket # NOTE: setIdentity() MUST BE CALLED BEFORE clientConnect or the identity will # not take effect # self.clientSetup.setIdentity(MasterId().getDevId()) # get the device id # self.clientSetup.clientConnect(hostControllerAddr, hostControllerPort, self.clientSocket) # connect to server using clientSocket self.serverSocket = ZMQStream(self.serverSocket) self.serverSocket.on_recv(self.onServerRecv) self.messages = Messages() # instantiate a Messages object self.inDict = {} self.outDict = {} def onServerRecv(self,msg): print("msg=", msg) print("length of msg=", len(msg)) ident = msg[0] cmdFrmClient = msg[1] data = msg[2] # is it a message from a client? if (len(msg) == 3): print("Message received from device controller: ident=", ident,"cmd=", cmdFrmClient, "data=", data) self.inDict = self.messages.bufferToDict(data) # create a list from the message print("Internal list, devType={}, cmd={}, data={}, returnList={}\n" .format(self.inDict['devType'], self.inDict['cmd'], self.inDict['data'], self.inDict['returnList'])) # For testing purposes, now send the message back down the line self.inDict['data'] += ' host controller got it' self.outIdent = self.messages.popLastReturnId(self.inDict).encode() # get the device controller id print("Ident poped from returnId", self.outIdent) dataToClient = self.messages.dictToBuffer(self.inDict).encode() # create a buffer print("Data to Device Controller=", dataToClient) cmdToClient = self.inDict['cmd'].encode() print("Cmd to Device Controller=", cmdToClient) print("Sending to outIdent =", self.outIdent) self.serverSocket.send_multipart([self.outIdent, cmdToClient, dataToClient]) else: print("Message received from host proc: cmd=", cmdFrmClient, "data=", data) def start(self): # self.periodic.start() try: self.loop.start() except KeyboardInterrupt: pass
def display_sweetboard(): messages = Messages() return render_template('index.html', messages=messages.list(app.config['TWILIO_ACCOUNT_SID'], app.config['TWILIO_AUTH_TOKEN']))
def get_archive(): messages = Messages() return render_template('archive.html', messages=messages.list(app.config['TWILIO_ACCOUNT_SID'], app.config['TWILIO_AUTH_TOKEN']))
def dump(): messages = Messages() return render_template('dump.html', messages=messages.list(app.config['TWILIO_ACCOUNT_SID'], app.config['TWILIO_AUTH_TOKEN']))
def __init__(self, nick, addr, port): self.width, self.height = 750, 500 self.card_w, self.card_h = 43, 62 # initialize pygame pygame.init() # 2 # initialize the screen self.screen = pygame.display.set_mode((self.width, self.height)) pygame.display.set_caption('Poker') # 3 # initialize pygame clock self.clock = pygame.time.Clock() self.nick_color, self.money_color, self.text_color = (150, 150, 150), (255, 255, 0), (50, 50, 50) self.bg_color = (220, 220, 220) self.is_turn = False self.is_playing = True self.is_waiting_to_start = True self.player_id = None self.is_out = False self.pot_val = None self.money = None self.big_blind = self.small_blind = None self.id_big_blind = self.id_small_blind = None self.card1 = self.card2 = None self.back_card = pygame.image.load(f'images/back.png') self.table_img = pygame.image.load('images/table.png') self.table_img_x, self.table_img_y = self.width // 2 - 700 // 2, 20 # self.font = pygame.font.Font('freesansbold.ttf', 16) self.font = pygame.font.SysFont('Arial', 16, bold=True) self.text_font = pygame.font.SysFont('Arial', 12) self.nick = nick self.error_font = pygame.font.Font('freesansbold.ttf', 12) self.error_raise_msg = self.error_font.render('INVALID VALUE', True, (255, 0, 0), (255, 255, 255)) self.error_time = 0 # other players self.is_opp_out = defaultdict( bool) # True when out of money, default to False self.opp_cards_img = {} self.is_opp_playing = {} self.id_turn = None self.opp_bet = {} self.players_nick = {} self.opp_ids = [] self.opp_money = {} self.players_pos = [(self.width * 0.75 // 5, self.height * 3.1 // 5), (self.width * 0.75 // 5, self.height * 1.7 // 5), (self.width // 2, 75), (self.width * 4.25 // 5, self.height * 1.7 // 5), (self.width * 4.25 // 5, self.height * 3.1 // 5)] # cards on the table self.on_table = [None] * 5 self.bet = 0 self.bet_on_table = 0 self.fold_b = Button('fold', (self.width - 270, self.height - 20), self.screen) self.check_b = Button('check', (self.width - 180, self.height - 20), self.screen) self.raise_b = Button('raise to', (self.width - 90, self.height - 20), self.screen) self.raise_t = TextField((self.width - 90, self.height - 50), self.screen) # self.mess = Messages((0, self.height-115), self.screen) self.mess = Messages((5, 5), self.screen) self.actions_mess = Messages((5, self.height - 35), self.screen, size=(275, 25)) self.Connect((addr, int(port)))
def main(): ''' main entry point into the script ''' # store the start time # used for duration stats later start_time = datetime.now() global environment_options global messages environment_options = EnvironmentOptions() environment_options.get_options() messages = Messages().prefixes if environment_options.debug: print(f'{environment_options}\n') print(f'{messages.info} Evaluation script started at {pretty_time()}.') print(f'{messages.info} Checking environment.') # check the environment, first environment_options.check_environment(messages) print(f'{messages.ok} Environment OK.') # verify the specified blueprint directory exists if os.path.exists(environment_options.directory): print(f'{messages.info} Blueprint directory found. Continuing.') else: print(f'{messages.error} Blueprint directory not found. Exiting.') sys.exit() # verify the specified criteria file exists if os.path.exists(f'{environment_options.criteria}'): print(f'{messages.info} Evaluation criteria file found. Continuing.') # validate the specified criteria as valid JSON try: with open(f'{environment_options.criteria}', 'r') as criteria_file: json.loads(criteria_file.read()) print(f'{messages.info} Criteria file ' + f'{environment_options.criteria} successfully parsed ' + 'as JSON. Continuing.') criteria_file.close() except json.decoder.JSONDecodeError as e: print( f'{messages.error} The {environment_options.criteria} JSON ' + 'file could not be parsed. Is it valid JSON?') if environment_options.debug: print(f'{messages.error} Exception details: {e}') else: print(f'{messages.error} Evaluation criteria file not found. ' + 'Exiting.') sys.exit() # keep track of how many blueprints have been processed processed_ok = 0 ''' check to see if the user has indicated they want to parse all blueprints in the specified blueprint directory ''' if environment_options.blueprint.lower() == 'all': print(f'{messages.info} All blueprints in ' + f'{environment_options.directory} ' + 'will be processed.') bp_list = glob.iglob(f'{environment_options.directory}/*.json') for bp in bp_list: process_json(bp) processed_ok += 1 else: print(f'{messages.info} Only {environment_options.blueprint} in ' + f'{environment_options.directory} will be processed.') process_json(f'{environment_options.directory}/' + f'{environment_options.blueprint}') processed_ok += 1 # store the finish time finish_time = datetime.now() # calculate how long the script took to run duration = finish_time - start_time # clean up print(f'{messages.line}') print(f'{messages.info} Cleaning up.') print(f'{messages.info} Processed {processed_ok} blueprints.') print(f'{messages.info} Evaluation completed in ' + f'{humanize.precisedelta(duration, minimum_unit="seconds")}.') print(f'{messages.info} Evaluation script finished at {pretty_time()}.\n')
class KnittingApp(Tkinter.Tk): def __init__(self,parent=None): Tkinter.Tk.__init__(self,parent) self.parent = parent self.initialize() #self.startEmulator() def initialize(self): self.msg = Messages(self) self.patterns = [] self.pattern = None self.currentDatFile = None self.initConfig() self.initializeUtilities() self.gui = Gui() self.gui.initializeMainWindow(self) self.updatePatternCanvasLastSize() self.patternListBox.bind('<<ListboxSelect>>', self.patternSelected) self.after_idle(self.canvasConfigured) self.deviceEntry.entryText.set(self.getConfig().device) self.datFileEntry.entryText.set(self.getConfig().datFile) self.initEmulator() self.after_idle(self.reloadPatternFile) def initializeUtilities(self): self.patternDumper = PatternDumper() self.patternDumper.printInfoCallback = self.msg.showInfo self.patternInserter = PatternInserter() self.patternInserter.printInfoCallback = self.msg.showInfo self.patternInserter.printErrorCallback = self.msg.showError def initEmulator(self): self.emu = PDDemulator(self.getConfig().imgdir) self.emu.listeners.append(PDDListener(self)) #self.emu = lambda: 1 self.setEmulatorStarted(False) def emuButtonClicked(self): self.getConfig().device = self.deviceEntry.entryText.get() if self.emu.started: self.stopEmulator() else: self.startEmulator() def startEmulator(self): self.msg.showInfo('Preparing emulator. . . Please Wait') if self.getConfig().simulateEmulator: self.msg.showInfo('Simulating emulator, emulator is not started...') self.setEmulatorStarted(True) else: try: port = self.getConfig().device self.emu.open(cport=port) self.msg.showInfo('PDDemulate Version 1.1 Ready!') self.setEmulatorStarted(True) self.after_idle(self.emulatorLoop) except Exception, e: self.msg.showError('Ensure that TFDI cable is connected to port ' + port + '\n\nError: ' + str(e)) self.setEmulatorStarted(False)
class net: def __init__(self, mode, ip, port): self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.msg = Messages() self.missing_packages = [] self.keywords = ['setPyPy', 'pycross()'] self.Pycross = [] self.MainFile = None if mode: self.socket.connect((ip, port)) self.send = self.__client_send self.recv = self.__client_recv else: self.socket.bind((ip, port)) self.socket.listen(2) self.send = self.__server_send self.recv = self.__server_recv self.clinet = self.socket.accept()[0] self.msgToFunc = { "SF": self.sendFunc, "RF": self.readFunc, "RMF": self.readMainFile, "RP": self.readPackages, "SMF": self.sendMainFile, "SP": self.sendPackages, "RO": self.readOutput, "RE": self.readError, "end": None } def __del__(self): if self.MainFile is not None: os.remove('MainFile.py') for package in self.missing_packages: os.remove('%s' % package.py) def sendOutput(self, message): self.send("RO", message) def readOutput(self, message): print(message) def sendError(self, error): self.send("RE", error) def readError(self, error): sys.stderr.write(str(error)) def sendFunc(self, func): self.send("RF", func) def readFunc(self, func): if self.MainFile == None: self.send("SMF", "") return funcName, args, kargs = func func = getattr(self.MainFile, funcName) result = func(*args, **kargs) self.send('end', result) return True def readMainFile(self, code=None): if code is not None: code = preprocessing.filesetup(self.keywords, code) try: self.MainFile = import_module('MainFile') self.send('SF', '') except ModuleNotFoundError: packages = self.FindPackages(code) self.send('SP', packages) def readPackages(self, packages): for packageName, packageCode in packages: with open("%s.py" % packageName, "w") as file: file.write(packageCode) file.close() self.readMainFile() def sendMainFile(self, _=None): with open(sys.argv[0], 'r') as file: self.send('RMF', file.read()) file.close() def sendPackages(self, packages): packages_code = [] for package in packages: with open("%s.py" % package, "r") as file: packages_code.append((package, file.read())) file.close() self.send("RP", packages_code) def readResult(self, _=None): return self.recv() def recvall(self, scoket, msglen=4): buffer = b"" while len(buffer) < msglen: packet = scoket.recv(msglen - len(buffer)) if not packet: return None buffer += packet return buffer def __client_send(self, msg, data): data = self.msg.pack(msg, 12, 1, 0, data) # ID src dst self.socket.sendall(data) def __client_recv(self): header = self.recvall(self.socket, 24) if not header: return None _, ID, src, dst, msg, dataLength = self.msg.unpack(header) data = self.recvall(self.socket, dataLength) return msg, serializer.loads(data) # server def __server_send(self, msg, data): data = self.msg.pack(msg, 30, 0, 1, data) # ID src dst self.clinet.sendall(data) def __server_recv(self): header = self.recvall(self.clinet, 24) if not header: return None _, ID, src, dst, msg, dataLength = self.msg.unpack(header) data = self.recvall(self.clinet, dataLength) return msg, serializer.loads(data) def FindPackages(self, code): lines = code.split('\n') imports = [line for line in lines if 'import' in line] matches = [ re.search('(?<=from)\s*\w*', line) if 'from' in line else re.search('(?<=import)\s*\w*', line) for line in imports ] packages = [match.group(0).replace(' ', '') for match in matches] self.missing_packages = [] for pack in packages: try: exec('import %s' % pack) except ModuleNotFoundError as e: self.missing_packages.append(pack) return self.missing_packages
def deal(agent_one, agent_two, first_random=True, n_offers=1, corpus_path="./", save_corpus=False, show_offers=True, show_graphic_process=True, graphic_interactive=False): dealer_one, dealer_two = Utils.select_first_dealer( agent_one, agent_two, first_random) t = 0 offers_register = [] dealer_one.set_oponent(dealer_two.get_name()) dealer_two.set_oponent(dealer_one.get_name()) proposal_offers_one_x, proposal_offers_one_y = [], [] proposal_offers_two_x, proposal_offers_two_y = [], [] # Entrenar los modelos para cada agente # if dealer_one.get_using_knowledge(): dealer_one.load_oponent_knowledge(corpus_path + "/" + dealer_two.get_name() + ".dump") if dealer_two.get_using_knowledge(): dealer_two.load_oponent_knowledge(corpus_path + "/" + dealer_one.get_name() + ".dump") while True: print("Step ", t, "...", end="\r") dealer_one.set_t(t) dealer_two.set_t(t) if t % 2 == 0: offers = dealer_one.emit_n_offers(n_offers) offers_register.append((dealer_one.get_name(), offers)) offers_accepted = dealer_two.receive_offers(offers) for offer in offers: proposal_offers_one_x.append(agent_one.get_benefits(offer)) proposal_offers_one_y.append(agent_two.get_benefits(offer)) else: offers = dealer_two.emit_n_offers(n_offers) offers_register.append((dealer_two.get_name(), offers)) offers_accepted = dealer_one.receive_offers(offers) for offer in offers: proposal_offers_two_x.append(agent_one.get_benefits(offer)) proposal_offers_two_y.append(agent_two.get_benefits(offer)) if offers_accepted: dealer_accept = dealer_two if t % 2 == 0 else dealer_one dealer_proposal = dealer_two if t % 2 != 0 else dealer_one dealer_accept_name = dealer_two.get_name( ) if t % 2 == 0 else dealer_one.get_name() dealer_proposal_name = dealer_two.get_name( ) if t % 2 != 0 else dealer_one.get_name() print( Messages.accepted_deal_message( dealer_accept=dealer_accept_name, dealer_proposal=dealer_proposal_name, step=t, benefits_accept=dealer_accept.get_benefits( offers_accepted), benefits_proposal=dealer_proposal.get_benefits( offers_accepted), dealer_accept_s=dealer_accept.get_s(), dealer_proposal_s=dealer_proposal.get_s(), offer=offers_accepted)) break if not dealer_one.ready(t): print( Messages.deal_revoked(dealer=dealer_one.get_name(), step=t)) break if not dealer_two.ready(t): print( Messages.deal_revoked(dealer=dealer_two.get_name(), step=t)) break dealer_one.update_s(t) dealer_two.update_s(t) t += 1 if save_corpus: with open(corpus_path + "/" + dealer_one.get_name() + ".dump", "ab") as fd: pickle.dump(dealer_one.get_knowledge(), fd) with open(corpus_path + "/" + dealer_two.get_name() + ".dump", "ab") as fd: pickle.dump(dealer_two.get_knowledge(), fd) if show_offers: print(Messages.show_offers(offers_register)) if offers_accepted: if show_graphic_process: accepted_offer = 0 < len(offers_accepted) dealer_proposal = 2 if t % 2 != 0 else 1 if graphic_interactive: Graphics.draw_offers(proposal_offers_one_x, proposal_offers_one_y, proposal_offers_two_x, proposal_offers_two_y, accepted_offer, dealer_proposal, dealer_one.get_name(), dealer_two.get_name()) else: Graphics.draw_offers_all(proposal_offers_one_x, proposal_offers_one_y, proposal_offers_two_x, proposal_offers_two_y, accepted_offer, dealer_proposal, dealer_one.get_name(), dealer_two.get_name()) return { dealer_one.get_name(): dealer_one.get_benefits(offers_accepted), dealer_two.get_name(): dealer_two.get_benefits(offers_accepted) }
#!/usr/bin/env python # -*- coding: utf-8 -*- # Acceptance.py from os import system from sys import argv from Messages import Messages import urllib.request if __name__ == "__main__": if len(argv) == 2 and argv[1] == "install": print(Messages.installing("pip")) pip_file, headers = urllib.request.urlretrieve( "https://bootstrap.pypa.io/get-pip.py", filename="get-pip.py") pip_file = open(pip_file) system("python get-pip.py") print(Messages.installing("numpy")) system("pip install numpy") print(Messages.installing("scipy")) system("pip install scipy") print(Messages.installing("matplotlib")) system("pip install matplotlib") print(Messages.installing("scikit-learn")) system("pip install scikit-learn") print(Messages.installing("deap")) system("pip install deap") print(Messages.installing("hyperopt")) system("pip install hyperopt") print(Messages.all_installed())
#import time import random import math from NewSnake import NewSnake from CheckDirections import CheckDirections from Messages import Messages pygame.init() white = (255, 255, 255) red = (255, 0, 0) green = (0, 155, 0) check = CheckDirections() mySnake = NewSnake() message = Messages() display_width = 1056 display_height = 600 gameDisplay = pygame.display.set_mode((display_width, display_height)) pygame.display.set_caption('Snake') background = pygame.image.load("Snake-Game-py/src/Background.png") snakSheet = pygame.image.load("Snake-Game-py/src/snakeImage.png") AppleSprite = snakSheet.subsurface(pygame.Rect((0, 3 * 64, 64, 64))) gameDisplay.blit(background, (0, 0)) clock = pygame.time.Clock()
def main(): if len(argv) != 2: print(Messages.usage()) exit() else: config_fd = argv[1] with open(config_fd, "r") as fd: config_file = load(fd) version = config_file["project_info"]["version"] author = config_file["project_info"]["author"] agents = [] for agent_name in config_file["agents"]: agent = Agent(definition_json=config_file["agents"][agent_name]) err = agent.get_valid() if err != True: print(Messages.agent_definition_error(agent_name, err)) exit() agents.append(agent) corpus_path = config_file["knowledge"]["corpus_path"] save_corpus = config_file["knowledge"]["save_corpus"] n_offers = config_file["params"]["n_offers"] show_offers = config_file["params"]["show_offers"] first_random = config_file["params"]["first_random"] graphic_process = config_file["params"]["graphic_process"] graphic_interactive = config_file["params"]["graphic_interactive"] Messages.header() if len(agents) == 2: print(Messages.bilateral()) Exchange.deal(agents[0], agents[1], first_random=first_random, n_offers=n_offers, corpus_path=corpus_path, save_corpus=save_corpus, show_offers=show_offers, show_graphic_process=graphic_process, graphic_interactive=graphic_interactive) elif 2 < len(agents): print(Messages.tournament()) utilities = {} for agent in agents: utilities[agent.get_name()] = [] c = 0 for i in range(len(agents)): for j in range(min(len(agents) - 1, i + 1), len(agents)): if i != j: print( Messages.tournament_round(c, agents[i].get_name(), agents[j].get_name())) results = Exchange.deal( agents[i], agents[j], first_random=first_random, n_offers=n_offers, corpus_path=corpus_path, save_corpus=save_corpus, show_offers=show_offers, show_graphic_process=graphic_process, graphic_interactive=graphic_interactive) utilities[agents[i].get_name()].append( results[agents[i].get_name()]) utilities[agents[j].get_name()].append( results[agents[j].get_name()]) c += 1 print(Messages.tournament_statistics(Statistics.all(utilities))) else: print(Messages.less_two_agents())