def Parse(conn, message):
global waitfor
if Brick.DEBUG and message:
print("\033[0;36mrecv\033[0m> \033[0;33m%s\033[0m" % (message))
"""General problems"""
if message == 'access denied':
print("\033[1;31mAccess denied.\033[0m")
return None
elif message == 'request invalid':
print("\033[1;33mInvalid request.\033[0m")
return None
elif message == 'no actions':
print("\033[1;33mNo actions.\033[0m")
return None
elif message == 'False' or message == 'True' or message == 'None':
return None
if not message:
"""Authorize after fresh connection"""
waitfor = 'auth_response'
return "auth slave %s imslave!" % (socket.gethostname())
else:
if waitfor == 'auth_response':
data = message.split(' ')
waitfor = None
if data[0] == 'ok':
print("Connected to \033[0;36m%s\033[0m \033[0;33m%s\033[0m at %s:%s" % (data[1], data[2], Brick.TCP_IP, Brick.TCP_PORT))
return 'task get'
elif message == 'fail':
print("\033[1;33mAuthorization failed!\033[0m")
return None
else:
"""We're not waiting for something specific?"""
"""Assume it's json going from Hub"""
data = json.loads(message)
if 'tasklist' in data:
if Worker.isFree():
return 'task get'
else:
return 'fail'
elif 'task' in data:
print("Starting task \033[0;36m%s\033[0m" % data['task']['name'])
conn.send('task started\n')
ret = Worker.start_task(conn, data['task']['cmd'])
return None
def connect():
global client, connected
try:
if connected == False:
sleep(5)
client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
client.connect((TCP_IP, TCP_PORT))
connected = True
except socket.error as err:
client = None
if connected or connected == None:
print("\033[1;31mCan't connect to %s:%s\033[0m: %s" % (TCP_IP, TCP_PORT, err[1]))
connected = False
Worker.setWorking(False)
def __init__(self, parent=None):
"""
ctor for the main tray widget. Initialises all the values properly and configures initial state.
:param parent: Parent to create from
:return: Sempy object
"""
self.config = SempyConfig()
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, "Sempy", "config")
QSystemTrayIcon.__init__(self, QIcon("res/semaphore.png"), parent)
if os.path.exists(self.settings.fileName()) and self.settings.value("token"):
self.current_info = {}
self.last_info = {}
self.enabled_repos = []
self.token = str(self.settings.value("token"))
self.interval = int(self.settings.value("interval"))
self.logger = Logger(os.path.dirname(self.settings.fileName()))
self.req_counter = 0
self.update_enabled_repos()
self.menu = self.create_menu(parent)
self.setContextMenu(self.menu)
logging.debug("Starting RequestThread")
self.req_thread = Worker(interval=self.interval, function=self.update_enabled_repos)
self.req_thread.done_signal.connect(self.update_menu)
self.req_thread.start()
def start(self,ipv4,ipv6):
# Creo il socket ipv4, imposto l'eventuale riutilizzo, lo assegno all'ip e alla
try:
self.server_socket4 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server_socket4.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.server_socket4.bind((ipv4, Utility.PORT))
# Gestisco l'eventuale exception
except socket.error as msg:
print('Errore durante la creazione del socket IPv4: ' + msg[1])
exit(0)
# Creo il socket ipv6, imposto l'eventuale riutilizzo, lo assegno all'ip e alla porta
try:
self.server_socket6 = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
self.server_socket6.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.server_socket6.bind((ipv6, Utility.PORT))
# Gestisco l'eventuale exception
except socket.error as msg:
print('Errore durante la creazione del socket IPv6: ' + msg[1])
exit(0)
# Metto il server in ascolto per eventuali richieste sui socket appena creati
self.server_socket4.listen(5)
self.server_socket6.listen(5)
# Continuo ad eseguire questo codice
while True:
# Per non rendere accept() bloccante uso l'oggetto select con il metodo select() sui socket messi in ascolto
print("server in ascolto")
input_ready, read_ready, error_ready = select.select([self.server_socket4, self.server_socket6,sys.stdin], [], [])
# Ora controllo quale dei due socket ha ricevuto una richiesta
for s in input_ready:
# Il client si è collegato tramite socket IPv4, accetto quindi la sua richiesta avviando il worker
if s == self.server_socket4:
client_socket4, address4 = self.server_socket4.accept()
client_thread = Worker(client_socket4, self.lock)
client_thread.start()
# Il client si è collegato tramite socket IPv6, accetto quindi la sua richiesta avviando il worker
elif s == self.server_socket6:
client_socket6, address6 = self.server_socket6.accept()
client_thread = Worker(client_socket6, self.lock)
client_thread.start()
else:
sel=sys.stdin.readline()
Menu.function(sel)
def run(self):
# Creo il socket ipv4, imposto l'eventuale riutilizzo, lo assegno all'ip e alla
try:
self.server_socket4 = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server_socket4.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.server_socket4.bind((self.ipv4, self.port))
# Gestisco l'eventuale exception
except socket.error as msg:
print('Errore durante la creazione del socket IPv4: ' + msg[1])
exit(0)
# Creo il socket ipv6, imposto l'eventuale riutilizzo, lo assegno all'ip e alla porta
try:
self.server_socket6 = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
self.server_socket6.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.server_socket6.bind((self.ipv6, self.port))
# Gestisco l'eventuale exception
except socket.error as msg:
print('Errore durante la creazione del socket IPv6: ' + msg[1])
exit(0)
# Metto il server in ascolto per eventuali richieste sui socket appena creati
self.server_socket4.listen(50)
self.server_socket6.listen(50)
#Ciclo continuo
while self.running:
# Per non rendere accept() bloccante uso l'oggetto select con il metodo select() sui socket messi in ascolto
print("server in ascolto")
input_ready, read_ready, error_ready = select.select([self.server_socket4, self.server_socket6], [], [])
# Ora controllo quale dei due socket ha ricevuto una richiesta
for s in input_ready:
# Il client si è collegato tramite socket IPv4, accetto quindi la sua richiesta avviando il worker
if s == self.server_socket4:
client_socket4, address4 = self.server_socket4.accept()
client_thread = Worker(client_socket4, self.database)
client_thread.run()
# Il client si è collegato tramite socket IPv6, accetto quindi la sua richiesta avviando il worker
elif s == self.server_socket6:
client_socket6, address6 = self.server_socket6.accept()
client_thread = Worker(client_socket6, self.database)
client_thread.run()
@author: andyh
'''
import Worker
import json
import numpy as np
from Util import Util
import Cluster
if __name__ == '__main__':
# nameList=["fenghuang321.json","xinhua321.json","sina321.json","sohu321.json","xinhua321.json"]
# nameList=["fenghuang322.json","xinhua322.json","sina322.json","sohu322.json","net322.json"]
# nameList=["fenghuang323.json","xinhua323.json","sina323.json","sohu323.json","net323.json"]
nameList=["fenghuang42.json","xinhua42.json","sina42.json","sohu42.json","net42.json"]
nameList=["fenghuang44.json","xinhua44.json","sina44.json","sohu44.json","net44.json"]
# nameList=["test2.json"]
worker=Worker.Worker()
for name in nameList:
filename=Util.getDataPath("testData\\44\\"+name)
data=worker.loadData(filename)
worker.addNews(data)
# worker.printAllNews()
keywordDict=worker.getKeyWordDict()
# print(keywordDict)
print("len(keywordDict):"+str(len(keywordDict)))
vectorSize=300
weightLimit=0
# vectorSize=len(worker.getKeyWordDict())-1
#keyword that will be used in encoding a news
globalKeywordList,globalValueList=worker.getTopKKeywordList(vectorSize)
def updateWorkers(): df = pd.read_excel(r'router/RiceHackathonFile.xlsx', sheet_name='Worker Details') for index, data in df.iterrows(): worker = Worker(data[0],data[1],data[2],None,None) workers.append(worker)
import socket, sys, re, os
sys.path.append("../lib") # for params
import params
import framedSocket
import myIO
import Worker
switchesVarDefaults = (
(('-l', '--listenPort'), 'listenPort', 50001),
(('-?', '--usage'), "usage", False), # boolean (set if present)
)
progname = "fileServer"
paramMap = params.parseParams(switchesVarDefaults)
listenPort = paramMap['listenPort']
listenAddr = '' # Symbolic name meaning all available interfaces
if paramMap['usage']:
params.usage()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((listenAddr, listenPort))
s.listen(1) # allow only one outstanding request
# s is a factory for connected sockets
while True:
conn, addr = s.accept(
) # wait until incoming connection request (and accept it)
Worker.Worker(conn, addr).start()
def testWorkerQueryTimeConstraint():
Worker.getUserPermission('', r'SA4SP\administrator')
def testWorkerQuery():
expect = '[{"url": "", "permission": "Design", "title": "RootSite"}, {"url": "SubSite2", "permission": "Full Control", "title": "SubSite2"}, {"url": "SubSite2/SSubSite2", "permission": "View Only", "title": "SSubSite2"}, {"url": "SubSite2/SSubSite1/SSSubSite1", "permission": "Full Control", "title": "SSSubSite1"}]'
eq_(expect, Worker.getUserPermission('', r'SA4SP\administrator'))
def __init__(self,worker = None):
self.host = None
self.player = None
self.lives = 3
self.worker = Worker.Worker()
trainable=False)
test_nodes = tf.Variable(0, dtype=tf.int32, name='test_nodes', trainable=False)
learning_rate = tf.train.polynomial_decay(Constants.LEARNING_RATE, train_nodes,
Constants.MAX_STEPS // 2,
Constants.LEARNING_RATE * 0.1)
"""
Initializes tensorflow variables
"""
with tf.Session(config=tf.ConfigProto(allow_soft_placement=True,
log_device_placement=False)) as session:
with tf.device("/cpu:0"):
summary_writer = tf.summary.FileWriter("./Summary/" +
Constants.SUMMARY_NAME)
summary = Summary(summary_writer, Constants.MODE)
master_worker = Worker('global', session, learning_rate, epochs,
epochs_test, total_graphs, train_nodes,
test_nodes, summary)
workers = []
for i in range(Constants.NUM_WORKER):
print(i)
workers.append(
Worker(i, session, learning_rate, epochs, epochs_test,
total_graphs, train_nodes, test_nodes, summary))
saver = tf.train.Saver(max_to_keep=1)
if Constants.LOAD:
print("Loading....")
c = tf.train.get_checkpoint_state(Constants.MODEL_PATH)
saver.restore(session, c.model_checkpoint_path)
print("Graph loaded!")
else:
config.worker_count, config.healer_count, config.mage_count, config.ranger_count, config.knight_count, config.factory_count \
, config.rocket_count = Utilities.census()
config.my_units = gc.my_units()
try:
for unit in config.my_units:
if unit.unit_type != bc.UnitType.Factory and not unit.location.is_in_garrison(
):
Utilities.global_enemy_scanner(unit.location.map_location())
if unit.unit_type == bc.UnitType.Worker:
# tick=time.clock()
Worker.worker_actions(unit.id)
# tock=time.clock()
# print("Worker",unit.id,"time to act",(tick-tock)*1000,"ms")
# if unit.unit_type == bc.UnitType.Healer:
# Healer.healer_actions(unit.id)
if unit.unit_type == bc.UnitType.Mage:
Mage.mage_actions(unit.id)
if unit.unit_type == bc.UnitType.Ranger:
# tick = time.clock()
Ranger.ranger_actions(unit.id)
# tock = time.clock()
# print("Ranger", unit.id, "time to act", (tick - tock) * 1000, "ms")
if unit.unit_type == bc.UnitType.Knight:
help='Mode: test, work.')
parser.add_argument('-f',
type=str,
default='pics/pic.png',
help='The file name of picture or .npy file.')
parser.add_argument('-n',
type=int,
default=1800,
help='Steps of stepping motor.')
args = parser.parse_args()
mode = args.m
filename = args.f
work_size = args.n
worker = wk.Worker(work_size)
if mode == 'test':
worker.test()
elif mode == 'work':
if filename[-3:] == 'npy':
worker.actions.load(filename)
else:
reader = ir.ImageReader(filename)
reader.set_mode(ir.MODE_CONTOURS)
contours = reader.get_contours()
worker.actions.add_contours(contours)
worker.eval()
def preview_or_clean(operations, really_clean):
"""Preview deletes and other changes"""
cb = CliCallback()
worker = Worker.Worker(cb, really_clean, operations).run()
while worker.next():
pass
print('''Are you still working at %s?''' % (workingPerson.job.name))
more = yes_or_no()
if not more:
prompt_new_job(workingPerson)
new_month = True
else:
print("Nice to meet you, %s. I will manage your finances" % inputName)
print('''
Since it's your first time here, we'll show you
the instructions!
Then, we'll need some infos about you.
''')
show_instructions()
workingPerson = Worker.Worker(workerName)
prompt_new_job(workingPerson)
while True:
inc: float = workingPerson.get_income
#See current month before starting
prompt_month_pretty(workingPerson)
#Add another day to the month?
prompt_new_day(workingPerson)
#Start a new Month?
prompt_new_month(workingPerson)
#Show the current month?
#Show income
class Sempy(QSystemTrayIcon):
message_queue = Queue()
def __init__(self, parent=None):
"""
ctor for the main tray widget. Initialises all the values properly and configures initial state.
:param parent: Parent to create from
:return: Sempy object
"""
self.config = SempyConfig()
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope, "Sempy", "config")
QSystemTrayIcon.__init__(self, QIcon("res/semaphore.png"), parent)
if os.path.exists(self.settings.fileName()) and self.settings.value("token"):
self.current_info = {}
self.last_info = {}
self.enabled_repos = []
self.token = str(self.settings.value("token"))
self.interval = int(self.settings.value("interval"))
self.logger = Logger(os.path.dirname(self.settings.fileName()))
self.req_counter = 0
self.update_enabled_repos()
self.menu = self.create_menu(parent)
self.setContextMenu(self.menu)
logging.debug("Starting RequestThread")
self.req_thread = Worker(interval=self.interval, function=self.update_enabled_repos)
self.req_thread.done_signal.connect(self.update_menu)
self.req_thread.start()
def update_menu(self):
"""
Update the context menu upon a thread job concluding
:return: Nothing, just modifies global state
"""
for index, val in enumerate(self.menu.actions()):
if not val.isSeparator() and val.text() != "Exit" and val.text() != "Config":
last_item = self.last_info.popitem()
val.setText(last_item[0])
val.setIcon(QIcon("res/" + last_item[1]['result'] + ".svg"))
def create_menu(self, parent=None):
"""
Create the initial context menu
:param parent: Parent widget
:return: A constructed menu
"""
menu = QMenu(parent)
for i in self.current_info.values():
if self.enabled_repos.__contains__(str(i['owner'] + "/" + i['name'])):
if i['result'] == 'stopped':
file_str = "res/failed.svg"
else:
file_str = "res/" + i['result'] + ".svg"
menu.addAction(QIcon(file_str), i['owner'] + "/" + i['name'])
menu.addSeparator()
config_action = menu.addAction("Config")
config_action.triggered.connect(self.config.exec)
exit_action = menu.addAction("Exit")
exit_action.triggered.connect(self.exit)
return menu
def update_current_info(self):
"""
Update the current JSON & swap current and last
:return: The updated JSON
"""
self.req_counter += 1
logging.debug("Request #{}".format(self.req_counter))
if self.token is not None:
self.last_info = self.current_info
return json_to_dict(json.loads(get_json(self.token)))
def update_enabled_repos(self):
""" Update the list of enabled repos & their status. """
self.current_info = self.update_current_info()
for i in self.current_info.values():
self.message_queue.put({str(i['owner'] + "/" + i['name']): i['result']})
self.do_notify(str(i['owner'] + "/" + i['name']))
self.settings.beginGroup("Repositories")
for i in self.settings.allKeys():
if i in self.current_info:
if self.settings.value(i).capitalize() == "True":
logging.debug("{} is enabled".format(i))
self.enabled_repos.append(i)
else:
logging.debug("Removing {}, not found in current_info".format(i))
self.settings.remove(i)
self.settings.endGroup()
def do_notify(self, repo):
"""
Handles notifications.
:param repo: Repo to generate a notification from
"""
last_status = None
current_status = None
for i in self.last_info.values():
last_status = i['result']
for i in self.current_info.values():
current_status = i['result']
if all(a is not None for a in [last_status, current_status]):
if last_status != current_status:
message = str("Build for %s %s." % (repo, current_status))
notification_dict = {'title': "Sempy",
'message': message,
'app_name': "Sempy",
'timeout': 3}
if platform == "win":
notification_dict['app_icon'] = join(dirname(realpath(__file__)), "res/" + current_status + ".ico")
else:
notification_dict['app_icon'] = join(dirname(realpath(__file__)), "res/" + current_status + ".png")
notification.notify(**notification_dict)
def exit(self):
self.req_thread.quit()
sys.exit(0)
Globals.updatePathMars = Navigation.BFS(mars_map, Globals.radar.get_enemy_center(bc.Planet.Mars), gc)
if Globals.radar.our_num_earth_rangers > 0:
Globals.updatePath = Navigation.BFS(earth_map, Globals.radar.get_enemy_center(bc.Planet.Earth), gc)
# print(Globals.pathToEnemy)
asteroid = None
if (round > 250 and Globals.radar.our_num_earth_rockets < 1) or round > 600:
Globals.factory_hold = True
else:
Globals.factory_hold = False
if Globals.asteroid_pattern.has_asteroid(round):
asteroid = Globals.asteroid_pattern.asteroid(round)
if asteroid is not None:
Globals.radar.update_karb_amount(gc, asteroid.location, asteroid.karbonite)
if Globals.radar.our_num_mars_workers > 0:
Worker.get_closest_workers(gc, asteroid.location, Globals.pathsToKarbMars)
for unit in gc.my_units():
Globals.radar.update_location(unit)
if Units.try_go_to_rocket(gc, unit):
continue
if unit.location.is_on_map():
if Globals.radar.check_if_enemies_gone(gc, unit):
Globals.everyone_to_mars = True
if unit.location.map_location().planet == bc.Planet.Mars and Globals.on_mars is False:
Globals.on_mars = True
Navigation.BFS(gc.starting_map(bc.Planet.Mars), Globals.radar.get_enemy_center(bc.Planet.Mars), gc)
if unit.unit_type == bc.UnitType.Worker:
s = time.time()
Worker.manage_worker(gc, unit)
Globals.wtime += (time.time() - s)
elif unit.unit_type == bc.UnitType.Rocket:
#import tkinter as tk
import Worker as wk
import CellState as cs
import Board as bd
import Player as pl
PLAYER_COUNT = 2
main = bd.BoardManager()
player1 = pl.Player("G")
for x in range(PLAYER_COUNT):
player1.workers.append(wk.Worker())
player2 = pl.Player("R")
for x in range(PLAYER_COUNT):
player2.workers.append(wk.Worker())
print(main)
print(player1.workers[0])
main.add_worker(player1.workers[0], 1, 1)
print(main)
main.add_worker(player1.workers[1], 1, 2)
print(main)
main.add_worker(player2.workers[0], 3, 4)
print(main)
main.add_worker(player2.workers[1], 5, 5)
# Main.py
# / \
# Board ---------- Player ---- God
# / /
# Echo server program
import socket, sys, re, os
sys.path.append("../lib") # for params
import params
from FramedSocket import *
import Worker
switchesVarDefaults = (
(('-l', '--listenPort'), 'listenPort', 50001),
(('-?', '--usage'), "usage", False), # boolean (set if present)
)
progname = "echoserver"
paramMap = params.parseParams(switchesVarDefaults)
listenPort = paramMap['listenPort']
listenAddr = '' # Symbolic name meaning all available interfaces
if paramMap['usage']:
params.usage()
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((listenAddr, listenPort))
s.listen(1) # allow only one outstanding request
# s is a factory for connected sockets
while (True):
connectedSock, addr = s.accept()
Worker.Worker(connectedSock, addr).start()
def testWorkerQuery():
expect = '[{"url": "", "permission": "Design", "title": "RootSite"}, {"url": "SubSite2", "permission": "Full Control", "title": "SubSite2"}, {"url": "SubSite2/SSubSite2", "permission": "View Only", "title": "SSubSite2"}, {"url": "SubSite2/SSubSite1/SSSubSite1", "permission": "Full Control", "title": "SSSubSite1"}]'
eq_(expect, Worker.getUserPermission('', r'SA4SP\administrator'))
def update(self):
'''
The main function that gets called every X contains all the child
table updating functions
Args:
None
Returns:
None
'''
def _success(worker):
#Called when one of the workers is successfully completed
return
def _error(worker):
#Called if there was an error
logging.error('~~~~ Error with the {} ~~~~'.format(worker))
def _midCheck():
'''
Monitors the middle man list for unfilled orders
Args:
None
Returns:
None
'''
headers = {
'Accept': 'application/json',
'Authorization': self.trader.headers['Authorization']
}
for tick in self.midTicks:
if tick.transID:
try:
url = 'https://api.robinhood.com/orders' + '/' + tick.transID[
1]
res = requests.get(url, headers=headers).json()
if tick.transID[0] == 'sell':
if res['state'] in [
'partially_filled', 'filled', 'confirmed'
]:
logging.info(
'---- {} Moved from Mid to Queue ----'.
format(tick.T))
self.sell(tick,
fromMidPrice=float(res['price']))
else:
if res['state'] in ['partially_filled', 'filled']:
self.purchase(tick,
fromMidPrice=float(res['price']))
except Exception as e:
logging.error(
'~~~~ Mid Check Error: {} ~~~~'.format(e))
def _tickUpdate(curList):
'''
Updates the tick objects in the respective list
Args:
curList (str): string name of list that is being updated
Returns:
None
'''
listDict = {'Hold': self.hTicks, 'Queue': self.qTicks}
tickData = robinTicks(self.trader,
[tick.T for tick in listDict[curList]],
self.afterHours())
if len(tickData) != len(listDict[curList]):
logging.error(
'~~~~ {} and Fetch Lengths Do Not Match ~~~~'.format(
curList))
return
else:
for tickDict in tickData:
try:
idx = [tick.T for tick in listDict[curList]
].index(tickDict['Sym'])
except ValueError:
return
listDict[curList][idx].update(
data=tickDict['Data'],
purPrice=self.purPrice.value(),
spy=self.spy)
def _queueCall():
'''
Performs all the necessaries for the Queue table, is put in a worker
and executes in the background
Args:
None
Returns:
None
'''
if len(self.qTicks):
_tickUpdate('Queue')
#If actually trading, iterate through Queue and if the projected cost doesn't exceed budget see if
#it meets purchasing criteria, else just update
if not self.startBut.isEnabled():
for tick in self.qTicks:
logging.info('Queue {}'.format(tick.T))
transPrice = tick.C * tick.PQ
try:
if self._dtCost + transPrice < self.budget and transPrice < float(
self.buyingPower.text(
)) and transPrice < float(self.cash.text()):
if tick.toBuy(purPrice=self.purPrice.value(),
spy=self.spy):
self._executeOrder(tick,
orderType='Buy',
transPrice=transPrice)
except TypeError:
pass
def _holdCall():
'''
Performs all the necessaries for the Holdings table, is put in a worker
and executes in the background
Args:
None
Returns:
None
'''
if len(self.hTicks):
_tickUpdate('Hold')
if not self.startBut.isEnabled():
for tick in self.hTicks:
if tick.tradeable:
logging.info('Hold {}'.format(tick.T))
if tick.toSell(purPrice=self.purPrice.value(),
spy=self.spy):
self._executeOrder(tick, 'Sell')
#Robinhood portfolio and account info, creates an empty one if an error is thrown
#such as having 0 in the portfolio
try:
self.portfolio = self.trader.portfolios()
self.account = self.trader.get_account()['margin_balances']
except IndexError:
logging.error('~~~~ Portfolio Empty ~~~~')
self.portfolio = {
'equity': 0,
'extended_hours_equity': 0,
}
self.account = {
'unsettled_funds': 0,
'start_of_day_dtbp': 0,
'unallocated_margin_cash': 0
}
except (requests.exceptions.ConnectionError,
requests.exceptions.HTTPError, TimeoutError) as e:
logging.error('~~~~ Connection Error: {} ~~~~'.format(e))
return
#Updates the market tracker bar
self.marketBar(fetchMarkets())
now = datetime.datetime.now(self.tz).time()
#Set the Equity to current value depending on if it's aH or not
if self.afterHours(now):
self.equity.setText(
'%.2f' % (float(self.portfolio['extended_hours_equity'])))
#Disable Trading aH
if not TESTING:
if not self.startBut.isEnabled():
self.tradeActs()
else:
self.equity.setText('%.2f' % (float(self.portfolio['equity'])))
if self.portfolio['equity']:
#Plt that stuff if it's during the trading day
self.graphData[0].append(now.strftime('%H:%M:%S'))
self.graphData[1].append(float(self.portfolio['equity']))
xdict = dict(enumerate(self.graphData[0]))
ax = self.graph.getAxis('bottom')
ax.setTicks([xdict.items()])
self.graph.plot(list(xdict.keys()),
self.graphData[1],
pen=self.ePen,
clear=False)
self.buyingPower.setText('%.2f' %
(float(self.account['start_of_day_dtbp'])))
self.cash.setText('%.2f' %
(float(self.account['unallocated_margin_cash'])))
self.uFund.setText('%.2f' % (float(self.account['unsettled_funds'])))
if not TESTING:
if not self.startBut.isEnabled():
#If end of day approaching, close out all positions regardless of profit
if now > datetime.time(hour=15, minute=58, second=0):
self.dump()
#Safety-net for SEC guideline of >25000 on Non-Margin for day trading
if self.marginSpin.value() < float(
self.equity.text()) < self.marginSpin.value() + 100:
if self.notYetWarned:
self.warn('Near Thresh')
self.notYetWarned = False
if float(self.equity.text()) < self.marginSpin.value():
logging.error('~~~~ Equity Fell Below Threshold ~~~~')
self.warn('Below Thresh')
self.tradeActs()
self.purPrice.setMaximum(float(self.cash.text()))
else:
#Allow for dumping of stocks at end of the day if just testing, if testing AH doesn't auto dump
if not self.startBut.isEnabled():
if self.startTime < datetime.time(
hour=16, minute=0, second=0, tzinfo=self.tz):
if now > datetime.time(
hour=15, minute=58, second=0, tzinfo=self.tz):
self.dump()
if len(self.hTicks) > 0:
holdWorker = Worker(_holdCall)
holdWorker.signals.finished.connect(lambda: _success('Hold'))
holdWorker.signals.error.connect(lambda: _error('Hold'))
self.pool.start(holdWorker)
self.hModel.layoutChanged.emit()
self.holding.viewport().update()
#Only calls the update function if there's stuff in the table, saves memory
if len(self.qTicks) > 0:
queueWorker = Worker(_queueCall)
queueWorker.signals.finished.connect(lambda: _success('Queue'))
queueWorker.signals.error.connect(lambda: _error('Queue'))
self.pool.start(queueWorker)
self.qModel.layoutChanged.emit()
self.queue.viewport().update()
if len(self.midTicks) > 0:
midWorker = Worker(_midCheck)
midWorker.signals.finished.connect(lambda: _success('Middle'))
midWorker.signals.error.connect(lambda: _error('Middle'))
self.pool.start(midWorker)
def testWorkerQueryTimeConstraint():
Worker.getUserPermission('', r'SA4SP\administrator')
import Host
import Player
import Game
import Worker
worker = Worker.Worker()
player = Player.Player('Neo', worker)
host = Host.Host('Amitabh Bachchan', worker)
host.getCards('movies.txt')
game = Game.Game(worker)
game.addHost(host)
game.addPlayer(player)
game.start()
def testWorkerOk():
ok_(Worker.getUserPermission('', r'SA4SP\administrator'))
def testWorkerOk():
ok_(Worker.getUserPermission('', r'SA4SP\administrator'))
def SA(imported: bool, save: bool, folder_path: str = None):
# ___________ save trasy __________
trasy_list = []
# ___________ metrics _______________
avg_time = []
difference = []
avg_work_time = []
how_much_better = []
total_how_much_better = []
avg_revisited = []
when_minimum_list = []
# _________ plots __________
all_costs = []
all_rejected = []
all_deltas = []
all_delta_rejected = []
all_delta_accepted = []
original_street = Street.Streets()
for batch in range(5):
print('Current batch = ', batch + 1)
tic = time.clock()
# ________parametry algorytmu____________
temperature = 3000
alfa = 0.99
beta = 1
workers = Worker.Workers()
streets = Street.Streets()
if imported:
streets.load_matrices(folder_path)
streets.n = len(streets.A)
streets.fw_graph = streets.Floyd_Warshall()
streets.update_r()
else:
streets = deepcopy(original_street)
if streets.n <= 16:
workers.w = [5, 7]
Functions.initialize(workers, streets)
workers.calculate_cost(streets)
current_cost = max(workers.cost)
first_cost = max(workers.cost)
first_sum_cost = sum(workers.cost)
cost_list = [current_cost]
delta_list = []
iteration = 0
when_minimum = 0
rejected_list = []
temp_list = []
delta_accepted_list = []
delta_rejected_list = []
while temperature > 1:
new_workers = deepcopy(workers)
Functions.adjacent_solution(new_workers, streets)
new_workers.calculate_cost(streets)
new_cost = max(new_workers.cost)
if new_cost + 1 < current_cost:
when_minimum = iteration
delta = current_cost - new_cost
delta_list.append(delta)
temp_list.append(temperature)
if delta >= 0:
workers = deepcopy(new_workers)
current_cost = deepcopy(new_cost)
else:
if random.random() < np.exp((beta * delta) / temperature):
workers = deepcopy(new_workers)
current_cost = deepcopy(new_cost)
delta_accepted_list.append(delta)
else:
rejected_list.append(iteration)
delta_rejected_list.append(delta)
pass
cost_list.append(current_cost)
#print('iteracja = ', iteration, 'koszt = ', current_cost)
iteration += 1
temperature *= alfa
toc = time.clock()
last_cost = max(workers.cost)
last_sum_cost = sum(workers.cost)
# _______ plot tray _______
if len(workers.trasy) < 3:
Functions.plot_path(workers)
# ________ append save trasy ____________
if save:
trasy_list.append(workers.trasy)
# _______ append metrics _____________
avg_time.append(toc - tic)
avg_revisited.append(Functions.mean_of_repeating_streets(workers))
avg_work_time.append(Functions.average_time(workers))
how_much_better.append((first_cost - last_cost) / first_cost * 100)
total_how_much_better.append(
(first_sum_cost - last_sum_cost) / first_sum_cost * 100)
difference.append(Functions.inequality(workers))
when_minimum_list.append(when_minimum)
# _______ append plots _______________
all_costs.append(cost_list)
all_delta_accepted.append(delta_accepted_list)
all_delta_rejected.append(delta_rejected_list)
all_deltas.append(delta_list)
all_rejected.append(rejected_list)
# ________________printy______________
'''
print('Czas trwania algorytmu to: ', toc - tic, 's')
Functions.print_time()
print("Funkcja celu zmalała o ", last_cost/first_cost * 100, '%')
print("Całkowity czas zmalał o ", last_sum_cost/first_sum_cost * 100, '%')
print('Ilość ulic w miescie = ', streets.r)
print("Średnio ulice powtarzają się", Functions.mean_of_repeating_streets(workers)) # to powinno byc w klasie worker
print('Average work time = ', Functions.average_time(workers)) # to powinno byc w klasie worker
print('Difference between longest and shortest work time', Functions.inequality(workers)) # to pownno byc w klasie worker
print("Minimum osiągnięto w iteracji:", when_minimum)
'''
if save:
df = pd.DataFrame(
data={
'Średni czas trwania algorytmu': avg_time,
'Średni czas pracy dla pracownika': avg_work_time,
'Średnia ilość ponownie odwiedzonych ulic': avg_revisited,
'Różnica między najdłużej a najkrócej pracującym pracownikiem':
difference,
'Poprawa w %': how_much_better,
'Lączna poprawa w %': total_how_much_better,
'Kiedy minimum': when_minimum_list
})
writer = pd.ExcelWriter('metrics.xlsx', engine='xlsxwriter')
df.to_excel(writer, sheet_name='data', index=False)
writer.save()
best_idx = how_much_better.index(np.max(how_much_better))
df2 = pd.DataFrame(data=trasy_list[best_idx])
writer = pd.ExcelWriter('trasy.xlsx', engine='xlsxwriter')
df2.to_excel(writer, sheet_name='data', index=False)
writer.save()
# ________________ploty_________________________
best_idx = how_much_better.index(np.max(how_much_better))
worst_idx = how_much_better.index(np.min(how_much_better))
mean_cost = np.mean(all_costs, axis=0)
max_cost = all_costs[best_idx]
min_cost = all_costs[worst_idx]
plt.plot(mean_cost)
plt.plot(max_cost)
plt.plot(min_cost)
plt.legend(('mean', 'best', 'worst'))
plt.title('Cost function')
plt.ylabel('time [minutes]')
plt.xlabel('number of iterations')
plt.show()
plt.plot(all_rejected[best_idx], 'ro')
plt.title('Rejected solutions')
plt.xlabel('Rejected solution')
plt.ylabel('Number of iteration')
plt.show()
plt.plot(all_deltas[best_idx])
plt.title('Delta')
plt.xlabel('Number of iteration')
plt.ylabel('Value of delta')
plt.show()
ax = plt.subplot(211)
ax.plot(all_delta_accepted[best_idx], 'o')
ax.set_title('accepted')
ax2 = plt.subplot(212)
ax2.plot(all_delta_rejected[best_idx], 'o')
ax2.set_title('rejected')
plt.show()
dtype=tf.int32,
name='global_episodes',
trainable=False)
total_frames = tf.Variable(0,
dtype=tf.int32,
name='total_frames',
trainable=False)
learning_rate = tf.train.polynomial_decay(LEARNING_RATE, total_frames,
MAX_ITERATION // 2,
LEARNING_RATE * 0.1)
with tf.device("/cpu:0"):
summary_writer = tf.summary.FileWriter("./train/" + SUMMARY_NAME)
summary = Summary(summary_writer)
master_worker = Worker('global', env, GAMMA, learning_rate,
global_episodes, total_frames, model_path, False,
False, num_workers, summary)
workers = []
for i in range(num_workers):
print(i)
workers.append(
Worker(i, env, GAMMA, learning_rate, global_episodes, total_frames,
model_path, render, save_img, num_workers, summary))
"""
Initializes tensorflow variables
"""
with tf.Session(config=tf.ConfigProto(
intra_op_parallelism_threads=1)) as session:
saver = tf.train.Saver(max_to_keep=5)
if load:
print("Loading....")
def queryUserPermission(request):
url = request.POST.get('url')
domainID = request.POST.get('domainID')
return HttpResponse(Worker.getUserPermission(url, domainID))
def update(self):
#The main update function, gets called every 5 seconds
#Contains the child call functions
def _success(worker):
#Called when one of the workers is successfully completed
return
def _error(worker):
#Called if there was an error
logging.error('~~~~ Error with the {} ~~~~'.format(worker))
def _holdCall():
'''
Performs all the necessaries for the Holdings table, is put in a worker
and executes in the background
Args:
None
Returns:
None
'''
if not self.startBut.isEnabled():
for tick in self.hTicks:
if tick.tradeable:
logging.info('Hold {}'.format(tick.T))
if tick.toSell(purPrice=self.purPrice.value(),
tradeStrat=self.currStrat,
ah=self.afterHours()):
self.sell(tick)
else:
for tick in self.hTicks:
tick.update(self.purPrice.value(), self.afterHours())
def _queueCall():
'''
Performs all the necessaries for the Queue table, is put in a worker
and executes in the background
Args:
None
Returns:
None
'''
#If actually trading, iterate through Queue and if the projected cost doesn't exceed budget see if
#it meets purchasing criteria, else just update
if not self.startBut.isEnabled():
for tick in self.qTicks:
logging.info('Queue {}'.format(tick.T))
if type(tick.C) == float:
if self.purchase(tick):
logging.info(
'---- Bought {} shares of {} at {}, SL: {} ----'
.format(tick.Q, tick.T, tick.AP, tick.SL))
else:
for tick in self.qTicks:
tick.update(self.purPrice.value(), self.afterHours())
#Determines the trading strategy, based on the time of day
now = datetime.datetime.now(self.tz).time()
opening = datetime.time(hour=9, minute=30, second=0, tzinfo=self.tz)
ten_fifteen = datetime.time(hour=10,
minute=15,
second=0,
tzinfo=self.tz)
if opening < now < ten_fifteen:
#Price Swing Strategy
self.currStrat = 'PS'
else:
#Short Trading
self.currStrat = 'ST'
#Robinhood portfolio, creates an empty one if an error is thrown
#such as having 0 in the portfolio
try:
self.portfolio = self.trader.portfolios()
except IndexError:
logging.info('~~~~ Portfolio Empty ~~~~')
self.portfolio = {
'equity': 0,
'extended_hours_equity': 0,
'withdrawable_amount': 0
}
except (requests.exceptions.ConnectionError,
requests.exceptions.HTTPError, TimeoutError) as e:
logging.info('~~~~ Connection Error: {} ~~~~'.format(e))
return
#Set the Equity to current value depending on if it's aH or not
if self.afterHours():
self.holdLabel.setText(
'%.2f' % (float(self.portfolio['extended_hours_equity'])))
#Disable Trading aH
if not TESTING:
if not self.startBut.isEnabled():
self.tradeActs()
else:
self.holdLabel.setText('%.2f' % (float(self.portfolio['equity'])))
if self.portfolio['equity']:
#Plt that stuff if it's during the trading day
self.graphData[0].append(now.strftime('%H:%M:%S'))
self.graphData[1].append(float(self.portfolio['equity']))
xdict = dict(enumerate(self.graphData[0]))
ax = self.graph.getAxis('bottom')
ax.setTicks([xdict.items()])
self.graph.plot(list(xdict.keys()),
self.graphData[1],
pen=self.ePen,
clear=False)
self.marginLabel.setText(
'%.2f' % (float(self.portfolio['withdrawable_amount'])))
if not TESTING:
if not self.startBut.isEnabled():
#If end of day approaching, close out all positions regardless of profit
if now > datetime.time(
hour=15, minute=58, second=0, tzinfo=self.tz):
if self.hModel.rowCount() > 0:
logging.info(
'---- Markets are about to close, selling all positions ----'
)
for ticker in self.hTicks:
if ticker.tradeable:
self.sell(ticker)
#Safety-net for SEC guideline of >25000 on Non-Margin for day trading
if self.marginSpin.value() < float(self.marginLabel.text(
)) < self.marginSpin.value() + 100:
self.warn('Near Thresh')
if float(self.marginLabel.text()) < self.marginSpin.value():
logging.info('~~~~ Non-Margin Fell Below Threshold ~~~~')
self.warn('Below Thresh')
self.tradeActs()
holdWorker = Worker(_holdCall)
holdWorker.signals.finished.connect(lambda: _success('Hold'))
holdWorker.signals.error.connect(lambda: _error('Hold'))
self.pool.start(holdWorker)
self.hModel.layoutChanged.emit()
self.holding.viewport().update()
#Only calls the update function if there's stuff in the table, saves memory
if self.qModel.rowCount() > 0:
queueWorker = Worker(_queueCall)
queueWorker.signals.finished.connect(lambda: _success('Queue'))
queueWorker.signals.error.connect(lambda: _error('Queue'))
self.pool.start(queueWorker)
self.queue.viewport().update()
reload(sys)
sys.setdefaultencoding('utf-8')
sys.stdout = codecs.getwriter('utf_8')(sys.stdout)
sys.stdin = codecs.getreader('utf_8')(sys.stdin)
if __name__ == '__main__':
argNames = ['command', 'task']
args = dict(zip(argNames, sys.argv))
tasks = ['publisher', 'consumer']
if 'task' not in args:
print('===> Not found task in tasks')
for vtask in tasks:
print('- ' + vtask)
exit()
task = args['task']
if task in tasks:
# words.Worker().sendqueue()
method_to_call = getattr(words.Worker(), task)
method_to_call()
else:
print('===> Not found task in tasks')
for vtask in tasks:
print('- ' + vtask)
exit()
class Sempy(QSystemTrayIcon):
message_queue = Queue()
def __init__(self, parent=None):
"""
ctor for the main tray widget. Initialises all the values properly and configures initial state.
:param parent: Parent to create from
:return: Sempy object
"""
self.config = SempyConfig()
self.settings = QSettings(QSettings.IniFormat, QSettings.UserScope,
"Sempy", "config")
QSystemTrayIcon.__init__(self, QIcon("res/semaphore.png"), parent)
if os.path.exists(
self.settings.fileName()) and self.settings.value("token"):
self.current_info = {}
self.last_info = {}
self.enabled_repos = []
self.token = str(self.settings.value("token"))
self.interval = int(self.settings.value("interval"))
self.logger = Logger(os.path.dirname(self.settings.fileName()))
self.req_counter = 0
self.update_enabled_repos()
self.menu = self.create_menu(parent)
self.setContextMenu(self.menu)
logging.debug("Starting RequestThread")
self.req_thread = Worker(interval=self.interval,
function=self.update_enabled_repos)
self.req_thread.done_signal.connect(self.update_menu)
self.req_thread.start()
def update_menu(self):
"""
Update the context menu upon a thread job concluding
:return: Nothing, just modifies global state
"""
for index, val in enumerate(self.menu.actions()):
if not val.isSeparator(
) and val.text() != "Exit" and val.text() != "Config":
last_item = self.last_info.popitem()
val.setText(last_item[0])
val.setIcon(QIcon("res/" + last_item[1]['result'] + ".svg"))
def create_menu(self, parent=None):
"""
Create the initial context menu
:param parent: Parent widget
:return: A constructed menu
"""
menu = QMenu(parent)
for i in self.current_info.values():
if self.enabled_repos.__contains__(
str(i['owner'] + "/" + i['name'])):
if i['result'] == 'stopped':
file_str = "res/failed.svg"
else:
file_str = "res/" + i['result'] + ".svg"
menu.addAction(QIcon(file_str), i['owner'] + "/" + i['name'])
menu.addSeparator()
config_action = menu.addAction("Config")
config_action.triggered.connect(self.config.exec)
exit_action = menu.addAction("Exit")
exit_action.triggered.connect(self.exit)
return menu
def update_current_info(self):
"""
Update the current JSON & swap current and last
:return: The updated JSON
"""
self.req_counter += 1
logging.debug("Request #{}".format(self.req_counter))
if self.token is not None:
self.last_info = self.current_info
return json_to_dict(json.loads(get_json(self.token)))
def update_enabled_repos(self):
""" Update the list of enabled repos & their status. """
self.current_info = self.update_current_info()
for i in self.current_info.values():
self.message_queue.put(
{str(i['owner'] + "/" + i['name']): i['result']})
self.do_notify(str(i['owner'] + "/" + i['name']))
self.settings.beginGroup("Repositories")
for i in self.settings.allKeys():
if i in self.current_info:
if self.settings.value(i).capitalize() == "True":
logging.debug("{} is enabled".format(i))
self.enabled_repos.append(i)
else:
logging.debug(
"Removing {}, not found in current_info".format(i))
self.settings.remove(i)
self.settings.endGroup()
def do_notify(self, repo):
"""
Handles notifications.
:param repo: Repo to generate a notification from
"""
last_status = None
current_status = None
for i in self.last_info.values():
last_status = i['result']
for i in self.current_info.values():
current_status = i['result']
if all(a is not None for a in [last_status, current_status]):
if last_status != current_status:
message = str("Build for %s %s." % (repo, current_status))
notification_dict = {
'title': "Sempy",
'message': message,
'app_name': "Sempy",
'timeout': 3
}
if platform == "win":
notification_dict['app_icon'] = join(
dirname(realpath(__file__)),
"res/" + current_status + ".ico")
else:
notification_dict['app_icon'] = join(
dirname(realpath(__file__)),
"res/" + current_status + ".png")
notification.notify(**notification_dict)
def exit(self):
self.req_thread.quit()
sys.exit(0)
def create_workers(drop_off_nodes):
return [Worker(node.id, node.coordinates) for node in drop_off_nodes]
def update(self):
#The main update function, gets called every 5 seconds
#Contains the child call functions
def _success(worker):
#Called when one of the workers is successfully completed
return
def _error(worker):
#Called if there was an error
logging.error('Error with the {}'.format(worker))
def _holdCall():
'''
Performs all the necessaries for the Holdings table, is put in a worker
and executes in the background
Args:
None
Returns:
None
'''
#I'm not happy with this yet so I'm leaving it out
'''
if not TESTING:
#Gathers all current Robinhood holdings, deems them untradable and is used just for visualization
#Can be set to tradeable if desired
for pos in self.trader.positions()['results']:
inst = self.trader.instrument(pos['instrument'].split('/')[-2])
if float(pos['quantity']) > 0:
ticker = Tick(inst['symbol'], self.purPrice.value())
ticker.purchase((pos['quantity'], pos['average_buy_price'], None))
self.hTicks.append(ticker)
self.hModel.layoutChanged.emit()
#self.holding.viewport().update()
'''
if not self.startBut.isEnabled():
for tick in self.hTicks:
if tick.tradeable:
logging.info('Hold {}'.format(tick.T))
if tick.sell(self.purPrice.value(), self.currStrat):
self.sell(tick)
else:
for tick in self.qTicks:
tick.update(self.purPrice.value())
def _queueCall():
'''
Performs all the necessaries for the Queue table, is put in a worker
and executes in the background
Args:
None
Returns:
None
'''
if not self.startBut.isEnabled():
for tick in self.qTicks:
logging.info('Queue {}'.format(tick.T))
if not TESTING:
if float(self.marginLabel.text()) - (
ticker.C * ticker.PQ) < self.purLimit.value():
logging.info(
'====Purhcase of {} will exceed budget, cancelling purchase===='
.format(ticker.T))
if tick.purchase(self.purPrice.value(),
self.currStrat):
if self.purchase(tick):
logging.info(
'----Bought {} shares of {} at {}, SL: {}----'
.format(tick.Q, tick.T, tick.AP,
tick.SL))
else:
if tick.purchase(self.purPrice.value(),
self.currStrat):
if self.purchase(tick):
logging.info(
'----Bought {} shares of {} at {}, SL: {}----'
.format(tick.Q, tick.T, tick.AP, tick.SL))
else:
for tick in self.qTicks:
tick.update(self.purPrice.value())
#Determines the trading strategy, based on the time of day
now = datetime.datetime.now(self.tz).time()
opening = datetime.time(hour=9, minute=30, second=0, tzinfo=self.tz)
ten_fifteen = datetime.time(hour=10,
minute=15,
second=0,
tzinfo=self.tz)
if opening < now < ten_fifteen:
#Price Swing Strategy
self.currStrat = 'PS'
else:
#Short Trading
self.currStrat = 'ST'
#Robinhood portfolio
self.portfolio = self.trader.portfolios()
#Set the Equity to current value depending on if it's aH or not
if self.afterHours():
self.holdLabel.setText(
'%.2f' % (float(self.portfolio['extended_hours_equity'])))
#Disable Trading aH
if not self.startBut.isEnabled():
self.tradeActs()
else:
self.holdLabel.setText('%.2f' % (float(self.portfolio['equity'])))
#Plt that stuff if it's during the trading day
self.graphData[0].append(now.strftime('%H:%M:%S'))
self.graphData[1].append(float(self.portfolio['equity']))
xdict = dict(enumerate(self.graphData[0]))
ax = self.graph.getAxis('bottom')
ax.setTicks([xdict.items()])
self.graph.plot(list(xdict.keys()),
self.graphData[1],
pen=self.ePen,
clear=False)
self.marginLabel.setText(
'%.2f' % (float(self.portfolio['withdrawable_amount'])))
if not self.startBut.isEnabled():
#If end of day approaching, close out all positions regardless of profit
#To keep them until tomorrow, just turn off trading before 1658 (03:58 PM)
if now > datetime.time(
hour=15, minute=58, second=0, tzinfo=self.tz):
if self.hModel.rowCount() > 0:
logging.info(
'----Markets are about to close, selling all positions----'
)
for ticker in self.hTicks:
if ticker.tradeable:
self.sell(ticker)
if not TESTING:
#Safety-net for SEC guideline of >25000 on Non-Margin for day trading
if self.marginSpin.value() < float(
self.marginLabel.text()) < self.marginSpin.value() + 100:
self.warn('Near Thresh')
if float(self.marginLabel.text()) < self.marginSpin.value():
logging.info('#### Non-Margin Fell Below Threshold ####')
self.warn('Below Thresh')
self.tradeActs()
holdWorker = Worker(_holdCall)
holdWorker.signals.finished.connect(lambda: _success('Hold'))
holdWorker.signals.error.connect(lambda: _error('Hold'))
self.pool.start(holdWorker)
self.hModel.layoutChanged.emit()
self.holding.viewport().update()
#Only calls the update function if there's stuff in the table, saves memory
if self.qModel.rowCount() > 0:
queueWorker = Worker(_queueCall)
queueWorker.signals.finished.connect(lambda: _success('Queue'))
queueWorker.signals.error.connect(lambda: _error('Queue'))
self.pool.start(queueWorker)
self.queue.viewport().update()
def repopulate(self, target):
assert len(
self.population
) >= 2, "There must be at least 2 workers in the self.population to repopulate!"
# print("Initial population of self.population: ",len(self.population))
# Set up local variables and loop through workers.
pop = len(self.population)
minFitness = self.population[0].fitness
maxFitness = self.population[0].fitness
averageFitness = 0
parentWorkers = []
for worker in self.population:
# Calculate average fitness, store min and max fitness values for normalization later.
averageFitness += worker.fitness
if worker.fitness < minFitness:
minFitness = worker.fitness
if worker.fitness > maxFitness:
maxFitness = worker.fitness
averageFitness /= len(self.population)
if minFitness - maxFitness == 0:
minFitness = -1
#print("Average fitness:",averageFitness,"\nMax fitness:",maxFitness,"\nMin fitness:",minFitness)
# Select part of the population to be parent candidates. Note that this is not guaranteed to select any parents.
# To combat this, there is a check performed at the end of the loop to ensure there will always be at least
# 2 parents.
for worker in self.population:
# Normalize current worker fitness.
if worker.age >= self.maxAge and worker.fitness < self.bestFitness:
fitness = -1
else:
fitness = abs(
(worker.fitness - minFitness) / (maxFitness - minFitness))
# random() returns a value in the range [0.0,1.0) which means that the higher the fitness value the
# higher the probability of parent selection.
if float(fitness) >= self.age / self.maxAge:
parentWorkers.append(worker)
if len(parentWorkers) >= len(self.population):
return parentWorkers
# Force parent population to be at least 2
idx = 0
while len(parentWorkers) < 2:
parentWorkers.append(self.population[idx])
idx += 1
# print("Selected", len(parentWorkers), "parent candidates.")
children = []
# Loop until we have re-filled the population.
while (len(children) + len(parentWorkers) < pop):
for i in range(len(parentWorkers)):
if len(children) + len(parentWorkers) >= pop:
break
# print(len(children),len(parentWorkers))
# Normalize the current worker fitness again.
fitness = 0.01 + abs((parentWorkers[i].fitness - minFitness) /
(maxFitness - minFitness))
# print("Rolling with fitness =",fitness)
# Give each worker a weighted chance to be a parent based on the fitness.
if np.random.random() < fitness:
# Repeat the above process for the second parent.
for j in range(len(parentWorkers)):
fitness = 0.01 + abs(
(parentWorkers[j].fitness - minFitness) /
(maxFitness - minFitness))
if np.random.random() < fitness and i != j:
# Create a child from both selected parents and add it to the current population.
newGenome = parentWorkers[i].create_genome(
parentWorkers[j])
child = Worker.Worker(target, genome=newGenome)
children.append(child)
break
# print(len(children),"children created.")
# Empty old population and re-fill it with newly bred population.
self.population = []
for worker in children:
worker.mutate_genome(0.2,
canAdd=target.canAdd,
canRemove=target.canRemove)
self.population.append(worker)
for worker in parentWorkers:
self.population.append(worker)
def repopulate(self):
assert len(
self.population
) >= 2, "There must be at least 2 workers in the self.population to repopulate!"
# print("Initial population of self.population: ",len(self.population))
# Set up local variables and loop through workers.
minFitness = self.population[0].fitness
maxFitness = self.population[0].fitness
averageFitness = 0
parentWorkers = []
for worker in self.population:
# Calculate average fitness, store min and max fitness values for normalization later.
averageFitness += worker.fitness
if worker.fitness < minFitness:
minFitness = worker.fitness
if worker.fitness > maxFitness:
maxFitness = worker.fitness
averageFitness /= len(self.population)
if minFitness - maxFitness == 0:
minFitness = 10
# Select part of the population to be parent candidates. Note that this is not guaranteed to select any parents.
# To combat this, there is a check performed at the end of the loop to ensure there will always be at least
# 2 parents.
for worker in self.population:
fitness = abs(
(worker.fitness - minFitness) / (maxFitness - minFitness))
# random() returns a value in the range [0.0,1.0) which means that the higher the fitness value the
# higher the probability of parent selection.
#print("fitness:",worker.fitness,"age:",self.age,"max:",self.maxAge)
if float(fitness) >= self.age / self.maxAge:
parentWorkers.append(worker)
if len(parentWorkers) >= len(self.population):
return
if len(parentWorkers) == 0:
print("species died through repopulation\n", self.age, "\n",
self.maxAge)
print("num workers:", len(self.population))
for worker in self.population:
print(worker.fitness)
self.completionFlag = True
return
if len(parentWorkers) == 1:
p1 = parentWorkers[0]
p2 = Worker.Worker(target=p1.target, genome=p1.genome)
p2.mutate_genome(self.age, 0.2, self.mutationRate)
parentWorkers.append(p2)
children = []
# Loop until we have re-filled the population.
while len(children) + len(parentWorkers) < self.populationPool:
p1, idx = self.select_random_worker(parentWorkers, minFitness,
maxFitness)
parentWorkers.pop(idx)
p2, idx = self.select_random_worker(parentWorkers, minFitness,
maxFitness)
parentWorkers.append(p1)
newGenome = p1.create_genome(p2)
child = Worker.Worker(p1.target, genome=newGenome)
children.append(child)
self.population = []
for worker in children:
worker.mutate_genome(self.age, 0.2, self.mutationRate)
self.population.append(worker)
for worker in parentWorkers:
self.population.append(worker)
import Worker
bob = Worker.Woker("bob smith", 4545)
sue = Worker.Woker("sue jones", 5456)
print bob.lastName()
print sue.lastName()
sue.giveRaise(0.454)
print sue.pay
print 3 + 34.45454
with tf.device("/cpu:0"):
global_episodes = tf.Variable(0,
dtype=tf.int32,
name='global_episodes',
trainable=False)
trainer = tf.train.AdamOptimizer(learning_rate=1e-4)
master_network = AC_Network(s_size, a_size, 'global',
None) # Generate global network
num_workers = multiprocessing.cpu_count(
) # Set workers ot number of available CPU threads
workers = []
# Create worker classes
for i in range(num_workers):
workers.append(
Worker(DoomGame(), i, s_size, a_size, trainer, model_path,
global_episodes))
saver = tf.train.Saver(max_to_keep=5)
with tf.Session() as sess:
coord = tf.train.Coordinator()
writer = tf.summary.FileWriter("graph", sess.graph)
if load_model == True:
print('Loading Model...')
ckpt = tf.train.get_checkpoint_state(model_path)
saver.restore(sess, ckpt.model_checkpoint_path)
else:
sess.run(tf.global_variables_initializer())
# This is where the asynchronous magic happens.
# Start the "work" process for each worker in a separate threat.
def setBest(self, species):
self.bestGenome = species.bestGenome
self.bestFitness = species.bestFitness
worker = Worker.Worker(self.target, genome=self.bestGenome)
self.bestSpecies = Basic_Species.Species(worker, self.maxAge)
futures.append(handler.add(Worker.scrape, url, blacklist))
add_visited(url['url'])
#print("Status: q:" + str(len(queue)) + " | eqt:" + str(empty_queue_tick))
time.sleep(.5)
"""
queue = Worker.scrape(Filehandler.getpage(), blacklist)
i = 0
while len(queue) > 0:
# Fetch url from queue
url = queue.pop()
# Scrape the url, and retrieve new urls
new_urls = Worker.scrape(url, blacklist)
# Add new URL's to the queue
queue.extend(new_urls)
# Mark this url as visited
add_visited(url['url'])
def queryUserPermission(request):
url = request.POST.get('url')
domainID = request.POST.get('domainID')
return HttpResponse(Worker.getUserPermission(url, domainID))
