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 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 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 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 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())
