def __init__(self, robot_pose, robot_info, options = None):
"""Initialize internal variables"""
Supervisor.__init__(self, robot_pose, robot_info)
# initialize memory registers
self.left_ticks = robot_info.wheels.left_ticks
self.right_ticks = robot_info.wheels.right_ticks
def __init__ (self, inQueue, outQueue, planStr, startEvent, stopEvent, agent = None, pddlFiles=None):
if agent is None:
logger.error("Cannot repair with ROS without an agent name")
sys.exit(1)
self.repair_sub = rospy.Subscriber("hidden/repair/in", RepairMsg, self.repairCallback)
self.repair_pub = rospy.Publisher("hidden/repair/out", RepairMsg, queue_size=10)
self.stnvisu_pub = rospy.Publisher('/hidden/stnvisu', StnVisu, queue_size=10)
self.mastn_pub = rospy.Publisher('hidden/mastnUpdate/out', MaSTNUpdate, queue_size=10)
self.mastn_sub = rospy.Subscriber('hidden/mastnUpdate/in', MaSTNUpdate, self.mastnUpdate)
self.stnupdate_pub = rospy.Publisher('hidden/stnupdate', String, queue_size=10)
self.stnupdate_pub_latched = rospy.Publisher('hidden/stnupdate', String, queue_size=10, latch=True)
self.alea_srv = rospy.Service("alea", AleaAction, self.aleaReceived)
Supervisor.__init__(self, inQueue, outQueue, planStr, startEvent, stopEvent, agent, pddlFiles)
self.repairRos = True
self.lastPlanSyncRequest = time.time()
self.lastPlanSyncResponse = time.time()
if rospy.has_param("/hidden/ubForCom"):
f = float(rospy.get_param("/hidden/ubForCom"))
logger.info("Setting ubForCom to %s from the parameter server" % f)
self.ubForCom = f
if rospy.has_param("/hidden/ubForTrack"):
f = float(rospy.get_param("/hidden/ubForTrack"))
logger.info("Setting ubForTrack to %s from the parameter server" % f)
self.ubForTrack = f
def __init__(self, robot_pose, robot_info):
Supervisor.__init__(self, robot_pose, robot_info)
#Create conrollers
# initialize memory registers
self.left_ticks = robot_info.wheels.left_ticks
self.right_ticks = robot_info.wheels.right_ticks
def say(self,e):
"""
Canvia l'estat del node per un de nou, a més a més notifica al supervisor utilitzant la funcio notify_change(). Per canviar l'estat iguala la variable self._estat amb el estat nou.
"""
supervi= Supervisor()
if self._e != e:
self._e=e
supervi.notify_change()
def __init__(self, robot_pose, robot_info):
"""Initialize internal variables"""
Supervisor.__init__(self, robot_pose, robot_info)
# initialize memory registers
self.left_ticks = robot_info.wheels.left_ticks
self.right_ticks = robot_info.wheels.right_ticks
# Let's say the robot is that big:
self.robot_size = robot_info.wheels.base_length
def main():
match_results = {
'W' : 0,
'B' : 0
}
for i in range(100):
game_supervisor = Supervisor(BotBase('B'), SampleBot('W'),
datetime.datetime.now())
match_results[game_supervisor.play_game()] += 1
print(match_results)
def __init__(self, robot_pose, robot_info):
"""Initialize internal variables"""
Supervisor.__init__(self, robot_pose, robot_info)
# initialize memory registers
self.prev_left_ticks = robot_info.wheels.left_ticks
self.prev_right_ticks = robot_info.wheels.right_ticks
# Create tracker
self.tracker = Path(robot_pose, 0)
# Create & set the controller
self.current = self.create_controller("GoToAngle", self.parameters)
def setTimePoint(self, tp, value):
Supervisor.setTimePoint(self, tp, value)
l = self.plan.getMastnMsg()
#rospy.logdebug("Updated constraints: %s" % str(l))
#only send a MaSTN update if the stn is consistent
if self.plan.stn.isConsistent():
arcs = []
for a in l:
arcs.append(StnArc(a[0], a[1], a[2], a[3]))
self.sendMastnUpdate(arcs)
def execute(self, robot_info, dt):
"""Inherit default supervisor procedures and return unicycle model output (vl,vr)"""
if not self.at_goal():
output = Supervisor.execute(self, robot_info, dt)
return self.ensure_w(self.uni2diff(output))
else:
return 0,0
def init_connection(self):
self.conn = Supervisor(
host=self.config["HOST"],
port=self.config["PORT"],
user=self.config["USER"],
password=self.config["PASSWORD"],
)
def setUp(self):
self.socket_pub = ctx.socket(zmq.PUB)
self.socket_rr = ctx.socket(zmq.REP)
self.socket_pub.bind(config['uri_pub'])
self.socket_rr.bind(config['uri_rr'])
self.supervisor = Supervisor(ctx, config['uri_pub'], config['uri_rr'])
self.supervisor_handlers = self.supervisor.initialize()
gevent.sleep(0.01)
def main():
parser = argparse.ArgumentParser(
description='Run the queue client',
)
# Parse args
args = parser.parse_args()
logger.info("Starting queue client...")
# Create and run supervisor
supervisor = Supervisor()
supervisor.run()
try:
# Run until keyboard exit
while True:
# Display supervisor status
supervisor.status()
sleep(config.QUEUE_MONITOR_INTERVAL)
except KeyboardInterrupt:
# Call stop on all workers
supervisor.stop()
logger.info("Exiting...")
# Kill the queue
sys.exit(0)
def __init__(self):
Supervisor.__init__(self)
self._controllers = [
AvoidObstacles(),
GoToGoal(),
AOAndGTG()
]
self.set_current_controller(2)
self._prev_ticks = {
'left': 0,
'right': 0
}
self.goal = (0, 0)
self.reached_goal = False
def execute(self, robot_info, dt):
"""K3Supervisor procedures and converts unicycle output into differential drive output for the Khepera3"""
#You should use this code verbatim
output = Supervisor.execute(self, robot_info, dt)
#Convert to differntial model parameters here
vl, vr = self.uni2diff(output)
#Return velocities
return (vl, vr)
def execute(self, robot_info, dt):
"""Inherit default supervisor procedures and return unicycle model output (x, y, theta)"""
output = Supervisor.execute(self, robot_info, dt)
return self.ensure_w(self.uni2diff(output))
class SupervisorEntryTests(unittest.TestCase):
def setUp(self) -> None:
self.exchange_mock = Mock()
self.exchange_mock.get_open_orders_ws.return_value = []
self.exchange_mock.get_position_size_ws.return_value = 0
self.supervisor = Supervisor(interface=self.exchange_mock)
def tearDown(self) -> None:
self.supervisor.exit_cycle()
def test_market_position_enter_while_running_cycle(self):
self.supervisor.run_cycle()
self.supervisor.stop_cycle()
self.supervisor.enter_by_market_order(qty=20)
self.exchange_mock.get_position_size_ws.return_value = 20
self.supervisor.run_cycle()
sleep(1)
# assert that Supervisor change position only once
self.exchange_mock.place_market_order.assert_called_once_with(qty=20)
def test_fb_last_position_enter_while_running_cycle(self):
self.exchange_mock.get_last_price_ws.return_value = 1000
self.exchange_mock.get_order_status_ws.return_value = 'Filled'
self.exchange_mock.conn.get_tick_size.return_value = 0.5
self.supervisor.run_cycle()
self.supervisor.stop_cycle()
self.supervisor.enter_fb_method(qty=20,
price_type='last',
timeout=5,
max_retry=3)
self.exchange_mock.get_position_size_ws.return_value = 20
self.supervisor.run_cycle()
sleep(1)
order = Order(order_type='Limit',
qty=20,
price=1000,
side='Buy',
passive=True)
# assert that Supervisor change position only once with limit order
self.exchange_mock.place_order.assert_called_once_with(order)
def test_fb_first_ob_position_enter_while_running_cycle(self):
self.exchange_mock.get_first_orderbook_price_ws.return_value = 1000
self.exchange_mock.get_order_status_ws.return_value = 'Filled'
self.exchange_mock.conn.get_tick_size.return_value = 0.5
self.supervisor.run_cycle()
self.supervisor.stop_cycle()
self.supervisor.enter_fb_method(qty=20,
price_type='first_ob',
timeout=5,
max_retry=3)
self.exchange_mock.get_position_size_ws.return_value = 20
self.supervisor.run_cycle()
sleep(1)
order = Order(order_type='Limit',
qty=20,
price=1000,
side='Buy',
passive=True)
# assert that Supervisor change position only once with limit order
self.exchange_mock.place_order.assert_called_once_with(order)
def test_fb_third_ob_position_enter_while_running_cycle(self):
self.exchange_mock.get_third_orderbook_price_ws.return_value = 1000
self.exchange_mock.get_order_status_ws.return_value = 'Filled'
self.exchange_mock.conn.get_tick_size.return_value = 0.5
self.supervisor.run_cycle()
self.supervisor.stop_cycle()
self.supervisor.enter_fb_method(qty=20,
price_type='third_ob',
timeout=5,
max_retry=3)
self.exchange_mock.get_position_size_ws.return_value = 20
self.supervisor.run_cycle()
sleep(1)
order = Order(order_type='Limit',
qty=20,
price=1000,
side='Buy',
passive=True)
# assert that Supervisor change position only once with limit order
self.exchange_mock.place_order.assert_called_once_with(order)
def test_fb_positive_deviant_position_enter_while_running_cycle(self):
self.exchange_mock.get_last_price_ws.return_value = 1000
self.exchange_mock.get_order_status_ws.return_value = 'Filled'
self.exchange_mock.conn.get_tick_size.return_value = 0.5
self.supervisor.run_cycle()
self.supervisor.stop_cycle()
self.supervisor.enter_fb_method(qty=20,
price_type='deviant',
timeout=5,
max_retry=3,
deviation=15)
self.exchange_mock.get_position_size_ws.return_value = 20
self.supervisor.run_cycle()
sleep(1)
order = Order(order_type='Limit',
qty=20,
price=1150,
side='Buy',
passive=True)
# assert that Supervisor change position only once with limit order
self.exchange_mock.place_order.assert_called_once_with(order)
def test_fb_negative_deviant_position_enter_while_running_cycle(self):
self.exchange_mock.get_last_price_ws.return_value = 1000
self.exchange_mock.get_order_status_ws.return_value = 'Filled'
self.exchange_mock.conn.get_tick_size.return_value = 0.5
self.supervisor.run_cycle()
self.supervisor.stop_cycle()
self.supervisor.enter_fb_method(qty=20,
price_type='deviant',
timeout=5,
max_retry=3,
deviation=-15)
self.exchange_mock.get_position_size_ws.return_value = 20
self.supervisor.run_cycle()
sleep(1)
order = Order(order_type='Limit',
qty=20,
price=850,
side='Buy',
passive=True)
# assert that Supervisor change position only once with limit order
self.exchange_mock.place_order.assert_called_once_with(order)
def setUp(self) -> None:
self.exchange_mock = Mock()
self.exchange_mock.get_open_orders_ws.return_value = []
self.exchange_mock.get_position_size_ws.return_value = 0
self.supervisor = Supervisor(interface=self.exchange_mock)
class OrdersCallbacksTests(unittest.TestCase):
def setUp(self) -> None:
self.exchange_mock = Mock()
self.exchange_mock.get_open_orders_ws.return_value = []
self.exchange_mock.get_position_size_ws.return_value = 0
self.supervisor = Supervisor(interface=self.exchange_mock)
def tearDown(self) -> None:
self.supervisor.exit_cycle()
def test_filled_callback_will_be_called(self):
order = Order(order_type='Limit', side='Sell', qty=228, price=1000)
order.order_id = 123456
callback = Mock()
order._on_fill = callback
self.supervisor.add_order(order)
self.exchange_mock.get_order_status_ws.return_value = 'Filled'
self.supervisor.run_cycle()
sleep(1)
callback.assert_called_once()
self.assertListEqual([], self.supervisor.orders)
def test_rejected_callback_will_be_called(self):
order = Order(order_type='Limit', side='Sell', qty=228, price=1000)
order.order_id = 123456
callback = Mock()
order._on_reject = callback
self.supervisor.add_order(order)
self.exchange_mock.get_order_status_ws.return_value = 'Rejected'
self.supervisor.run_cycle()
sleep(1)
callback.assert_called_once()
self.assertListEqual([], self.supervisor.orders)
def test_several_filled_orders_at_the_same_time(self):
order_1 = Order(order_type='Limit', side='Sell', qty=228, price=1000)
order_1.order_id = 123456
order_2 = Order(order_type='Limit', side='Sell', qty=229, price=1001)
order_2.order_id = 123457
order_3 = Order(order_type='Limit', side='Sell', qty=2210, price=1002)
order_3.order_id = 123458
order_4 = Order(order_type='Limit', side='Sell', qty=2211, price=1003)
order_4.order_id = 123459
callback_1 = Mock()
callback_2 = Mock()
callback_3 = Mock()
callback_4 = Mock()
order_1._on_fill = callback_1
order_2._on_fill = callback_2
order_3._on_fill = callback_3
order_4._on_fill = callback_4
self.supervisor.add_order(order_1)
self.supervisor.add_order(order_2)
self.supervisor.add_order(order_3)
self.supervisor.add_order(order_4)
self.exchange_mock.get_order_status_ws.return_value = 'Filled'
self.supervisor.run_cycle()
sleep(1)
callback_1.assert_called_once()
callback_2.assert_called_once()
callback_3.assert_called_once()
callback_4.assert_called_once()
self.assertListEqual([], self.supervisor.orders)
from constants import HParamKey, DATA_PATH, EncoderType
from constants import DefaultConfig as config
from supervisor import Supervisor
import util
# config logger
logger = logging.getLogger('__main__')
util.init_logger()
# tuning sets
hidden_sets = [50, 100, 200, 500]
lr_sets = [0.01, 0.005, 0.001]
# dropout_sets = [0, 0.1, 0.2, 0.3, 0.5]
spv = Supervisor(config)
spv.load_data()
spv.get_dataloader()
record_save_path = util.get_results_folder() # or base_path=DATA_PATH
logger.info(
"Output directory (loss history, accuracy history, checkpoints): {}".
format(record_save_path))
tuning_records = []
for hidden in hidden_sets:
for lr in lr_sets:
# new parameters
conf_update = {
HParamKey.ENCODER_TYPE: EncoderType.RNN,
HParamKey.HIDDEN_SIZE: hidden,
class SyncOrdersTests(unittest.TestCase):
"""All methods that associated with placing and cancelling orders in cycle."""
def setUp(self) -> None:
self.exchange_mock = Mock()
self.exchange_mock.get_open_orders_ws.return_value = []
self.exchange_mock.get_position_size_ws.return_value = 0
self.supervisor = Supervisor(interface=self.exchange_mock)
def tearDown(self) -> None:
self.supervisor.exit_cycle()
def test_cancel_needless_order(self):
order1 = Order()
self.exchange_mock.get_open_orders_ws.return_value = [order1]
expected_orders = [order1]
self.supervisor.cancel_needless_orders()
# assert that Supervisor try to cancel needless order
self.exchange_mock.bulk_cancel_orders.assert_called_once_with(expected_orders)
def test_move_changed_order(self):
"""Test that Supervisor will amend order, not cancel it."""
order1 = Order(order_type='Limit', qty=228, price=1000, side='Buy')
order1_copy = Order(order_type='Limit', qty=228, price=1000, side='Buy')
self.supervisor.add_order(order1)
self.exchange_mock.get_open_orders_ws.return_value = [order1_copy]
order1.move(to=1001)
self.supervisor.cancel_needless_orders()
self.exchange_mock.bulk_cancel_orders.assert_not_called()
self.exchange_mock.move_order.assert_called_once_with(order=order1)
def test_cancel_several_needless_orders(self):
order1 = Order()
order2 = Order()
order3 = Order()
self.exchange_mock.get_open_orders_ws.return_value = [order1, order2, order3]
expected_orders = [order1, order2, order3]
self.supervisor.cancel_needless_orders()
# assert that Supervisor try to cancel needless order
self.exchange_mock.bulk_cancel_orders.assert_called_once_with(expected_orders)
def test_cancel_duplicates(self):
order1 = Order(order_type='Limit', qty=228, price=1000, side='Buy')
order2 = Order(order_type='Limit', qty=229, price=1001, side='Buy')
self.exchange_mock.get_open_orders_ws.return_value = [order1, order2, order2]
self.supervisor.add_order(order1)
self.supervisor.add_order(order2)
expected_orders = [order2]
self.supervisor.cancel_needless_orders()
# assert that Supervisor try to cancel needless order
self.exchange_mock.bulk_cancel_orders.assert_called_once_with(expected_orders)
def test_cancel_two_same_needed_orders(self):
order1 = Order(order_type='Limit', qty=228, price=1000, side='Buy')
order2 = Order(order_type='Limit', qty=228, price=1000, side='Buy')
order3 = Order(order_type='Limit', qty=229, price=1001, side='Buy')
self.exchange_mock.get_open_orders_ws.return_value = [order1, order2]
self.supervisor.add_order(order1)
self.supervisor.add_order(order2)
self.supervisor.add_order(order3)
self.supervisor.cancel_needless_orders()
self.exchange_mock.bulk_cancel_orders.assert_not_called()
def test_check_unplaced_order(self):
order = Order(order_type='Limit', qty=228, price=1000, side='Buy')
self.supervisor.add_order(order)
self.supervisor.check_needed_orders()
self.exchange_mock.place_order.assert_called_once_with(order)
def test_check_several_unplaced_orders(self):
order1 = Order(order_type='Limit', qty=228, price=1001, side='Buy')
order2 = Order(order_type='Limit', qty=229, price=1002, side='Buy')
order3 = Order(order_type='Limit', qty=2210, price=1003, side='Buy')
self.supervisor.add_order(order1)
self.supervisor.add_order(order2)
self.supervisor.add_order(order3)
self.supervisor.check_needed_orders()
self.exchange_mock.bulk_place_orders.assert_called_once_with([order1, order2, order3])
def test_check_rejected_order(self):
def order_status_mock(_order):
if _order == order:
return 'Rejected'
on_reject_mock = Mock()
self.exchange_mock.get_order_status_ws.side_effect = order_status_mock
order = Order(order_type='Limit', qty=228, price=1000, side='Buy')
order.order_id = '1234'
order._on_reject = on_reject_mock
self.supervisor.add_order(order)
self.supervisor.check_needed_orders()
# assert that we didn`t place this order
self.exchange_mock.place_order.not_called(order)
# assert that Supervisor forget this order
self.assertNotIn(order, self.supervisor._orders)
# assert that Supervisor call matching callback
on_reject_mock.assert_called_once()
def test_check_filled_order(self):
def order_status_mock(_order):
if _order == order:
return 'Filled'
on_filled_mock = Mock()
self.exchange_mock.get_order_status_ws.side_effect = order_status_mock
order = Order(order_type='Limit', qty=228, price=1000, side='Buy')
order.order_id = '1234'
order._on_fill = on_filled_mock
self.supervisor.add_order(order)
self.supervisor.check_needed_orders()
# assert that we didn`t place this order
self.exchange_mock.place_order.not_called(order)
# assert that Supervisor forget this order
self.assertNotIn(order, self.supervisor._orders)
# assert that Supervisor call matching callback
on_filled_mock.assert_called_once()
def test_check_filled_stop_order(self):
def order_status_mock(_order):
if _order == order:
return 'Triggered'
on_filled_mock = Mock()
self.exchange_mock.get_order_status_ws.side_effect = order_status_mock
order = Order(order_type='Stop', qty=228, stop_px=1000, side='Buy')
order.order_id = '1234'
order._on_fill = on_filled_mock
self.supervisor.add_order(order)
self.supervisor.check_needed_orders()
# assert that we didn`t place this order
self.exchange_mock.place_order.not_called(order)
# assert that Supervisor forget this order
self.assertNotIn(order, self.supervisor._orders)
# assert that Supervisor call matching callback
on_filled_mock.assert_called_once()
def test_validation_error_while_placing_order(self):
validation_error = requests.HTTPError()
validation_error.response = Mock()
validation_error.response.text = 'Order price is above the liquidation price of current'
self.exchange_mock.place_order.side_effect = validation_error
order = Order(order_type='Limit', qty=228, price=1000, side='Buy')
self.supervisor.add_order(order)
self.supervisor.check_needed_orders()
# assert that method has been called
self.exchange_mock.place_order.assert_called_once_with(order)
# assert that we catch the exception and forget the order
self.assertNotIn(order, self.supervisor._orders)
def pdf_report(training_data_name,
training_data_X,
training_data_y,
attack_training_set,
test_set,
kernel_type,
prediction_type,
attack_type,
bf_alpha,
budget_factor_alpha_list,
test_set_y=None):
dimension = len(training_data_X[0])
print(
"---------------------------------------------------------------------------"
)
print("[*] Initiating Experiment")
print("Parameters:")
print("Training set: ", training_data_name)
print("Training data count: ", len(training_data_X))
print("Attack data count: ", len(attack_training_set))
print("Data dimension: ", dimension)
print("Test set size: ", len(test_set))
if kernel_type is not None:
print("Kernel: ", kernel_type)
print("Prediction type: ", prediction_type)
print("Attack type: ", attack_type)
if budget_factor_alpha_list:
print("Budget Factor Alpha List: ", budget_factor_alpha_list[0], "..",
budget_factor_alpha_list[-1])
print("----------------------------------------------------")
s = Supervisor()
name = training_data_name
print("[*] Training Server Model...")
s.add_model(name, training_data_X, training_data_y, prediction_type,
kernel_type)
print("[*] Starting Test Attack...")
query_budget = math.ceil(bf_alpha * (dimension + 1))
if attack_type == "agnostic":
kernel_type = None
if True:
run_time, queries, model = s.attack_with_metrics(name,
kernel_type,
attack_type,
dimension,
query_budget,
attack_training_set,
roundsize=160,
test_set=test_set)
print("[*] Attack took ", run_time, " seconds and ", queries,
" queries.")
print("[*] Starting Prediction Comparison for test Attack... ")
a = s.compare_predictions(name,
test_set,
correct_results=test_set_y,
verbose=True)
if attack_type == "lowd-meek":
return a[0], queries, run_time
if not budget_factor_alpha_list:
return a[0], queries, run_time
if attack_type not in ["extraction", "lowd-meek", "agnostic"]:
print("[*] Running query mapping")
s.plot_error_on_queries("mse", name, kernel_type, attack_type,
dimension, budget_factor_alpha_list,
attack_training_set, test_set, 16)
class Test(unittest.TestCase):
def generateScenario(self):
slots = dict((i,Slot(i,1.0,120)) for i in range(3))
bidderInfos = dict([
(0,BidderInfo(0,1000,100,1,{0:0,1:0,2:1})),
(1,BidderInfo(1,1000,100,1,{0:1,1:1,2:0})),
(2,BidderInfo(2,1000,100,1,{0:1,1:0,2:0})),
(3,BidderInfo(3,1800,100,3,{0:1,1:1,2:2})),
])
return slots, bidderInfos
def setUp(self):
self.socket_pub = ctx.socket(zmq.PUB)
self.socket_rr = ctx.socket(zmq.REP)
self.socket_pub.bind(config['uri_pub'])
self.socket_rr.bind(config['uri_rr'])
self.supervisor = Supervisor(ctx, config['uri_pub'], config['uri_rr'])
self.supervisor_handlers = self.supervisor.initialize()
gevent.sleep(0.01)
def tearDown(self):
gevent.killall(self.supervisor_handlers)
self.supervisor.shutdown()
self.socket_rr.close()
self.socket_pub.close()
def testIsFree(self):
def send():
self.socket_pub.send(serialize(['is_free']))
def handle():
data = json.decode(self.socket_rr.recv())
self.assertEquals(['is_free', None, True], data)
self.socket_rr.send('{"ui":2}')
gevent.joinall((
gevent.spawn(handle),
gevent.spawn(send)
), timeout=1.0, raise_error=True)
def testIsNotFree(self):
self.supervisor.isFree = lambda *a: False
def send():
self.socket_pub.send(serialize(['is_free']))
def handle():
data = json.decode(self.socket_rr.recv())
self.assertEquals(['is_free', None, False], data)
self.socket_rr.send('')
gevent.joinall((
gevent.spawn(handle),
gevent.spawn(send)
), timeout=1.0, raise_error=True)
def testSendEvenIfNotFree(self):
self.supervisor.isFree = lambda *a: False
def send():
self.socket_pub.send(serialize(['is_free']))
def handle():
data = json.decode(self.socket_rr.recv())
self.assertEquals(['is_free', None, False], data)
self.socket_rr.send('{"ui":2}')
data = json.decode(self.socket_rr.recv())
self.assertEquals(['solve', 'in_use', None], data)
gevent.joinall((
gevent.spawn(handle),
gevent.spawn(send)
), timeout=1.0, raise_error=True)
def testSendInvalidData(self):
def send():
self.socket_pub.send(serialize(['is_free']))
def handle():
self.socket_rr.recv()
self.assertTrue(self.supervisor.isFree())
self.socket_rr.send('["invalid"]')
data = unserialize(self.socket_rr.recv())
self.assertIsNotNone(data[1])
gevent.joinall((
gevent.spawn(handle),
gevent.spawn(send)
), timeout=1.0, raise_error=True)
def testSendValidData(self):
def send():
self.socket_pub.send(serialize(['is_free']))
def handle():
self.socket_rr.recv()
scenario_data = [self.generateScenario(), {}]
self.socket_rr.send(serialize(scenario_data))
data = unserialize(self.socket_rr.recv())
self.assertIsNone(data[1])
gevent.joinall((
gevent.spawn(handle),
gevent.spawn(send)
), timeout=1.0, raise_error=True)
def testSendWhileRunning(self):
class SleepyWorker(SupervisorTask):
def _solve(self, scenario, options):
import time
time.sleep(0.2)
return {}
self.supervisor.worker_class = SleepyWorker
def send():
self.socket_pub.send(serialize(['is_free']))
def handle():
# first is_free
data = unserialize(self.socket_rr.recv())
self.assertEquals(['is_free',None,True],data)
self.socket_rr.send(serialize([[{},{}], {}]))
# second is free
data = unserialize(self.socket_rr.recv())
self.assertEquals(['is_free',None,False],data)
self.socket_rr.send('{}')
# result
data = unserialize(self.socket_rr.recv())
self.assertEquals(['solve',None,{}],data)
self.socket_rr.send('{}')
gevent.joinall((
gevent.spawn(handle),
gevent.spawn(send),
gevent.spawn_later(0.1, send)
), timeout=10.0, raise_error=True)
async def test_ip_address_get(event_loop):
s = Supervisor(loop=event_loop)
res = await s.ip_address_get()
assert res
await s.stop()
class SupervisorEntryTests(unittest.TestCase):
def setUp(self) -> None:
self.exchange_mock = Mock()
self.exchange_mock.get_open_orders_ws.return_value = []
self.exchange_mock.get_position_size_ws.return_value = 0
self.supervisor = Supervisor(interface=self.exchange_mock)
def tearDown(self) -> None:
self.supervisor.exit_cycle()
def test_market_entry(self):
self.supervisor.enter_by_market_order(228)
self.exchange_mock.place_market_order.assert_called_once_with(qty=228)
def test_fb_entry_last_price(self):
self.exchange_mock.get_last_price_ws.return_value = 1000
self.exchange_mock.get_order_status_ws.return_value = 'Filled'
self.exchange_mock.conn.get_tick_size.return_value = 0.5
self.supervisor.enter_fb_method(
qty=228,
price_type='last',
max_retry=5,
timeout=3
)
order = Order(order_type='Limit', qty=228, price=1000, side='Buy', passive=True)
self.exchange_mock.place_order.assert_called_once_with(order)
def test_fb_entry_last_price_timedout(self):
self.exchange_mock.get_last_price_ws.return_value = 1000
self.exchange_mock.get_order_status_ws.return_value = 'New'
self.exchange_mock.conn.get_tick_size.return_value = 0.5
self.supervisor.enter_fb_method(
qty=228,
price_type='last',
max_retry=3,
timeout=1
)
order = Order(order_type='Limit', qty=228, price=1000, side='Buy', passive=True)
expected_calls = [call(order)] * 3
self.exchange_mock.place_order.assert_has_calls(expected_calls)
self.exchange_mock.place_market_order.assert_called_once_with(qty=228)
def test_fb_entry_first_orderbook_price(self):
self.exchange_mock.get_first_orderbook_price_ws.return_value = 1000
self.exchange_mock.get_order_status_ws.return_value = 'Filled'
self.exchange_mock.conn.get_tick_size.return_value = 0.5
self.supervisor.enter_fb_method(
qty=228,
price_type='first_ob',
max_retry=5,
timeout=1
)
order = Order(order_type='Limit', qty=228, price=1000, side='Buy', passive=True)
self.exchange_mock.place_order.assert_called_once_with(order)
def test_fb_entry_third_orderbook_price(self):
self.exchange_mock.get_third_orderbook_price_ws.return_value = 1000
self.exchange_mock.get_order_status_ws.return_value = 'Filled'
self.exchange_mock.conn.get_tick_size.return_value = 0.5
self.supervisor.enter_fb_method(
qty=228,
price_type='third_ob',
max_retry=5,
timeout=1
)
order = Order(order_type='Limit', qty=228, price=1000, side='Buy', passive=True)
self.exchange_mock.place_order.assert_called_once_with(order)
def test_fb_entry_with_deviation(self):
self.exchange_mock.get_last_price_ws.return_value = 1000
self.exchange_mock.get_order_status_ws.return_value = 'Filled'
self.exchange_mock.conn.get_tick_size.return_value = 0.5
self.supervisor.enter_fb_method(
qty=228,
price_type='deviant',
max_retry=5,
timeout=1,
deviation=-10
)
order = Order(order_type='Limit', qty=228, price=900, side='Buy', passive=True)
self.exchange_mock.place_order.assert_called_once_with(order)
def set_parameters(self,params):
Supervisor.set_parameters(self,params.pid)
self.gtg.set_parameters(params.pid.gains)
def get_parameters(self):
params = Struct()
params.pid = Supervisor.get_parameters(self)
return params
async def test_device_register(event_loop):
s = Supervisor(loop=event_loop)
s.application = test_app
res = await s.device_register()
assert res
await s.stop()
from supervisor import Supervisor
from WindowsSleepInhibitor import WindowsSleepInhibitor
import sys
osSleep = None
# in Windows, prevent the OS from sleeping while we run
if sys.platform == 'win32':
osSleep = WindowsSleepInhibitor()
osSleep.inhibit()
supervisor = Supervisor(dev=True, archive=False)
supervisor.run()
# Remove sleep inhibition
if osSleep:
osSleep.uninhibit()
def execute(self, robot_info, dt):
"""Peforms K3Supervisor procedures and converts unicycle output into differential drive output for the Khepera3"""
output = Supervisor.execute(self, robot_info, dt)
vl, vr = self.uni2diff(output)
return (vl, vr)
def execute(self, robot_info, dt):
"""Inherit default supervisor procedures and return unicycle model output (x, y, theta)"""
output = Supervisor.execute(self, robot_info, dt)
self.tracker.add_point(self.pose_est)
return self.uni2diff(output)
def main():
qb1 = [1, 5, 10, 25, 50, 100, 250, 500, 1000]
qb2 = range(1, 100)
qb3 = range(10, 100)
qb4 = range(10, 200, 5)
qb5 = range(1, 250)
qb6 = range(6, 500, 2)
qb7 = range(5, 500)
print("SVM Model extractor")
print("Version ", version)
"""
x = []
y = []
for i in range(0, 1000):
datum = [i, random.choice([1, 3])]
x.append([datum[0], datum[1] + 0.5*datum[0]])
if datum[1] == 3:
y.append(0)
else:
y.append(1)
"""
s = Supervisor()
X = []
y = []
m = 3
b = 12
for i in range(0, 1000):
n = random.randrange(-50, 50, 1) / 100
y.append(m * i + b + n)
X.append([i])
line_training_data = {"x": X, "y": y}
line_training = "line-training-svr"
line_trained_model = s.create_trained_model_from_training_data(
line_training_data["x"][:500], line_training_data["y"][:500], "SVR",
"linear")
s.add_model(line_training, line_training_data, line_trained_model, "SVR")
s.attack_model(line_training, "SVR", "linear", "adaptive retraining", 1, 0,
100, 100, line_training_data["x"][500:600])
#s.compare_predictions(line_training, False, line_training_data["x"][600:700], "SVR")
s.plot_mse_on_queries_with_dataset(line_training, "SVR", "linear",
"adaptive retraining", 1, 0, 100, qb4,
line_training_data["x"][500:1000])
return
X, y = sklearn.datasets.make_blobs(n_samples=60, centers=2, random_state=7)
flat_training_data = {"x": X, "y": y}
firstclass = y[0]
for index, classf in enumerate(y):
if classf != firstclass:
secondindex = index
posneg = [X[0], X[secondindex]]
plt.scatter(X[:, 0], X[:, 1], c=y, s=30, cmap=plt.cm.Paired)
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()
xx = numpy.linspace(xlim[0], xlim[1], 30)
yy = numpy.linspace(ylim[0], ylim[1], 30)
YY, XX = numpy.meshgrid(yy, xx)
xy = numpy.vstack([XX.ravel(), YY.ravel()]).T
s = Supervisor()
"""
s.add_random_model("test_regression_linear", "SVR", "linear", 2, 100)
s.attack_model("test_regression_linear", "SVR", "linear", "retraining", 2, 100)
print(s.get_models())
s.compare_random_predictions("test_regression_linear", 50, 2, 0)
s.plot_mse_on_queries("test_regression_linear", "SVR", "linear", "retraining", 2, range(1, 101))
"""
flat_trained_model = s.create_trained_model_from_training_data(
flat_training_data["x"], flat_training_data["y"], "SVM", "linear")
s.add_model("flat-linear-svm", flat_training_data, flat_trained_model,
"SVM")
print(s.get_models()["flat-linear-svm"]["original_model"].coef_[0])
s.attack_model("flat-linear-svm", "SVM", "linear", "lowd-meek", 2, 0, 7,
100, posneg)
#s.compare_predictions("flat-linear-svm", False, flat_training_data["x"][800:1000], "SVM")
Z = s.get_models()["flat-linear-svm"]["original_model"].decision_function(
xy).reshape(XX.shape)
# plot decision boundary and margins
ax.contour(XX,
YY,
Z,
colors='k',
levels=[-1, 0, 1],
alpha=0.5,
linestyles=['--', '-', '--'])
# plot support vectors
ax.scatter(s.get_models()["flat-linear-svm"]
["original_model"].support_vectors_[:, 0],
s.get_models()["flat-linear-svm"]
["original_model"].support_vectors_[:, 1],
s=100,
linewidth=1,
facecolors='none',
edgecolors='k')
p, w, oneoff, doob, lastdoob, doox = s.get_models(
)["flat-linear-svm"]["extracted_model"]
wr = s.get_models()["flat-linear-svm"]["original_model"].coef_[0]
a = -w[0] / w[1]
intercept = p[1] - a * p[0]
inter = s.get_models()["flat-linear-svm"]["original_model"].intercept_
print("correct a", -wr[0] / wr[1])
print("correct intercept", inter)
print("calculated with correct", p[1] - (-wr[0] / wr[1]) * p[0])
print("with correct", (-wr[0] / wr[1]) * p[0] + inter)
print("a", a, "intercept", intercept)
print("p", p)
#xx = numpy.linspace(min_x - 5, max_x + 5) # make sure the line is long enough
yy = a * xx + intercept #/ w[1]
plt.plot(xx, yy, 'k-', label='extracted')
plt.plot(p[0], p[1], marker='o', color='r')
plt.plot(oneoff[0], oneoff[1], marker='o', color='b')
#for doo in doob:
# plt.plot(doo[0], doo[1], marker='o', color='g')
plt.plot(lastdoob[0], lastdoob[1], marker='o', color='y')
#plt.plot(doox[0], doox[1], marker='o', color='b')
print("pred",
s.get_models()["flat-linear-svm"]["original_model"].predict([doox]))
print(
"pred",
s.get_models()["flat-linear-svm"]["original_model"].predict([oneoff]))
plt.show()
return
krebs = sklearn.datasets.load_breast_cancer()
krebs_training_data = {"x": krebs.data, "y": krebs.target}
krebs_trained_model = s.create_trained_model_from_training_data(
krebs_training_data["x"], krebs_training_data["y"], "SVM", "rbf")
print(krebs_training_data["x"][18:20])
s.add_model("krebs-rbf", krebs_training_data, krebs_trained_model, "SVM")
s.attack_model("krebs-rbf",
"SVM",
"rbf",
"lowd-meek",
30,
0,
2000,
10,
dataset=krebs_training_data["x"][18:20])
#print(s.get_models())
s.compare_predictions("krebs-rbf", False,
krebs_training_data["x"][100:200], "SVM")
#s.plot_mse_on_queries_with_dataset("krebs-rbf", "SVM", "rbf", "retraining", 30, 0, 2000, qb7,
# krebs_training_data["x"][0:500])
#boston = sklearn.datasets.load_boston()
#boston_training_data = {"x": boston.data, "y": boston.target}
#boston_trained_model = s.create_trained_model_from_training_data(boston_training_data["x"], boston_training_data["y"],
# "SVR", "rbf")
#s.add_model("boston-svr-rbf", boston_training_data, boston_trained_model, "SVR")
#s.attack_model("boston-svr-rbf", "SVR", "rbf", "adaptive retraining", 13, 5, 50, 120, dataset=boston_training_data["x"][200:320])
#s.compare_predictions("boston-svr-rbf", False, boston_training_data["x"][000:500], "SVR")
#s.plot_mse_on_queries("boston-svr-rbf", "SVR" , "rbf", "adaptive retraining", 13, 5, 50, qb2)
#print(boston.DESCR)
return
with open(
r"C:\Users\Kolja\Documents\Uni\Bachelor\BA\STEALING SVM MODELS\Resources\Datasets\Alcala Tutorial 2017\1490779198_4046512_alc2017_training_set.csv"
) as csvfile:
reader = csv.reader(csvfile, delimiter=',')
line = 1
X = []
y1 = []
y2 = []
for row in reader:
if line == 1:
line += 1
continue
integered = list(map(lambda x: int(x), row[:-2]))
floated = list(map(lambda x: float(x), row[-2:]))
X.append(integered)
y1.append(floated[0])
y2.append(floated[1])
line += 1
print(len(X))
location_training_data = {"x": X, "y": y1}
#print(y1[500:])
svr = svm.SVR(kernel="rbf")
print(X[500:502])
print(y1[500:502])
svr.fit(X, y1)
j = 12
#for j in range(0, 100):
# print(svr.predict([X[j]]), y1[j])
location_trained_model = s.create_trained_model_from_training_data(
location_training_data["x"], location_training_data["y"], "SVR", "rbf")
s.add_model("location-svr-rbf", location_training_data,
location_trained_model, "SVR")
#for j in range(0, 100):
# print(svr.predict([X[j]]), y1[j], s.get_models()["location-svr-rbf"]["original_model"].predict([X[j]]))
s.attack_model("location-svr-rbf",
"SVR",
"rbf",
"retraining",
13,
5,
50,
100,
dataset=location_training_data["x"][200:400])
s.compare_predictions("location-svr-rbf", False,
location_training_data["x"][100:200], "SVR")
s.plot_mse_on_queries_with_dataset("location-svr-rbf", "SVR", "rbf",
"adaptive retraining", 13, 5, 50, qb4,
location_training_data["x"][0:500])
class SupervisorView(BaseView):
can_start = True
can_stop = True
can_restart = True
can_start_all = True
can_restart_all = True
can_stop_all = True
can_restart_supervisor = True
can_stop_supervisor = True
def __init__(self, **data):
self.config = data["config"]
del data["config"]
super(SupervisorView, self).__init__(**data)
self.init_connection()
def init_connection(self):
self.conn = Supervisor(
host=self.config["HOST"],
port=self.config["PORT"],
user=self.config["USER"],
password=self.config["PASSWORD"],
)
@expose("/")
def index(self):
try:
list_processes = self.conn.get_all_process_info()
except Exception as e:
print(e)
list_processes = []
flash("PROBLEM IN CONNECTION", "error")
return self.render("supervisor.html", list_processes=list_processes)
@expose("/start_all_processes")
def start_all_processes(self):
self.conn.start_all_processes()
return redirect(url_for(".index"))
@expose("/stop_all_processes")
def stop_all_processes(self):
self.conn.stop_all_processes()
return redirect(url_for(".index"))
@expose("/restart_all_processes")
def restart_all_processes(self):
return "{}"
@expose("/restart_supervisor")
def restart_supervisor(self):
self.conn.restart()
return redirect(url_for(".index"))
@expose("/stop_supervisor")
def stop_supervisor(self):
self.conn.shutdown()
return redirect(url_for(".index"))
@expose("/start_process")
def start_process(self):
name = request.values.get("id")
self.conn.start_process(name)
return redirect(url_for(".index"))
@expose("/stop_process")
def stop_process(self):
name = request.values.get("id")
self.conn.stop_process(name)
return redirect(url_for(".index"))
@expose("/restart_process")
def restart_process(self):
name = request.values.get("id")
self.conn.restart_process(name)
return redirect(url_for(".index"))
@expose("/get_log")
def get_log(self):
try:
name = request.values.get("id")
html = self.conn.get_log_process(name, 0, 1500)
return html.replace("\n", "<br>")
except Exception as e:
print(e)
return "PROBLEM WITH METHOD OF LOG"
return "{}"
states = {
0: {"name": "STOPPED", "class": "", "style": ""},
10: {"name": "STARTING", "class": "", "style": ""},
20: {"name": "RUNNING", "class": "", "style": "color: green;"},
30: {"name": "BACKOFF", "class": "", "style": ""},
40: {"name": "STOPPING", "class": "", "style": ""},
100: {"name": "EXITED", "class": "", "style": ""},
200: {"name": "FATAL", "class": "", "style": ""},
1000: {"name": "UNKNOWN", "class": "", "style": ""},
}
def init(self, plan, agent):
Supervisor.init(self, plan, agent)
async def test_settings_save(event_loop):
s = Supervisor(loop=event_loop)
res = await s.settings_save()
assert res == True
await s.stop()
#!/usr/bin/env python3
import anyio
import asks
import bs4
from supervisor import Supervisor
from nettirely import IrcBot
bot = IrcBot(state_path="factoid_state.json")
supervisor = Supervisor("8Banana/nettirely")
async def create_termbin(contents):
if isinstance(contents, str):
contents = contents.encode("utf-8")
socket = await anyio.connect_tcp("termbin.com", 9999)
async with socket:
await socket.send_all(contents)
url = await socket.receive_some(4096)
return url.decode("utf-8").strip()
@bot.on_regexp(r"^\$(\S+)(?:\s*(.+))?")
async def factoid_handler(self, sender, recipient, match):
factoid = match.group(1)
args = match.group(2).split() if match.group(2) else []
nick = sender.nick
admins = bot.state.setdefault("admins", ["tycoon177", "darkf", "__Myst__"])
lastfm_api_key = bot.state.setdefault("lastfm_api_key", None)
async def test_register(event_loop):
s = Supervisor(loop=event_loop)
res = await s.device_register()
assert res == True
await s.stop()
class SupervisorCycleTests(unittest.TestCase):
def setUp(self) -> None:
self.exchange_mock = Mock()
self.exchange_mock.get_open_orders_ws.return_value = []
self.exchange_mock.get_position_size_ws.return_value = 0
self.supervisor = Supervisor(interface=self.exchange_mock)
def tearDown(self) -> None:
self.supervisor.exit_cycle()
def test_run_cycle(self):
self.supervisor.run_cycle()
self.assertTrue(self.supervisor._run_thread.is_set())
self.assertFalse(self.supervisor._exit_sync_thread.is_set())
self.assertFalse(self.supervisor._stopped.is_set())
self.assertTrue(self.supervisor.sync_thread.is_alive())
def test_exit_cycle(self):
self.supervisor.run_cycle()
self.assertTrue(self.supervisor.sync_thread.is_alive())
self.supervisor.exit_cycle()
self.assertFalse(self.supervisor.sync_thread.is_alive())
def test_stop_cycle(self):
self.supervisor.run_cycle()
self.supervisor.stop_cycle()
self.assertTrue(self.supervisor._stopped.is_set())
self.assertFalse(self.supervisor._run_thread.is_set())
def test_continue_cycle(self):
self.supervisor.run_cycle()
self.supervisor.stop_cycle()
self.supervisor.run_cycle()
# assert that events conditions are the same as in just-created supervisor
self.assertTrue(self.supervisor._run_thread.is_set())
self.assertFalse(self.supervisor._exit_sync_thread.is_set())
self.assertFalse(self.supervisor._stopped.is_set())
# cycle should also be alive of course :)
self.assertTrue(self.supervisor.sync_thread.is_alive())
def test_exit_from_exited_cycle(self):
self.supervisor.run_cycle()
self.supervisor.exit_cycle()
self.assertFalse(self.supervisor.sync_thread.is_alive())
self.supervisor.exit_cycle() # must not raise anything
self.assertFalse(self.supervisor.sync_thread.is_alive())
def test_reset(self):
self.supervisor.run_cycle()
self.supervisor.reset()
self.assertEqual(0, self.supervisor.position_size)
self.assertListEqual([], self.supervisor._orders)
def execute(self, robot_info, dt):
"""Inherit default supervisor procedures and return unicycle model output (x, y, theta)"""
output = Supervisor.execute(self, robot_info, dt)
self.tracker.add_point(self.pose_est)
return self.uni2diff(output)
async def test_service_stop(event_loop):
s = Supervisor(loop=event_loop)
s.application = test_app
res = await s.service_stop(service_id=2)
assert res
await s.stop()
def process_state_info(self, state):
"""Update state parameters for the controllers and self"""
Supervisor.process_state_info(self,state)
self.parameters.pose = self.pose_est
from pessoa import Pessoa
from funcionario import Funcionario
from supervisor import Supervisor
from datetime import datetime as dt
data_nascimento = dt.strptime('2000-01-01', '%Y-%m-%d')
data_admissao = dt.strptime('2005-01-01', '%Y-%m-%d')
funcionario = Funcionario('Josh', '793.253.125-92', data_nascimento,
data_admissao, 2000, 'Setor 1')
supervisor = Supervisor('Nicole', '589.365.182-21', data_nascimento,
data_admissao, 2000, 'Setor 1', 500)
print('---Funcionario---')
print(funcionario)
print('Salário mensal: {}'.format(funcionario.calcula_salario_mensal()))
print('---Supervisora---')
print(supervisor)
print('Salário mensal: {}'.format(supervisor.calcula_salario_mensal()))
def process_state_info(self, state):
"""Update state parameters for the controllers and self"""
Supervisor.process_state_info(self, state)
self.parameters.pose = self.pose_est
tester.run_test(test, iterations)
elif test_file:
tester = Tester(output_file)
test_params = TestParams.load_test(test_file)
test = TestCase.create_test_case(test_params, tester.rand_gen)
tester.run_test(test, iterations)
else: # I'm the child process :D
test = pickle.loads("".join(sys.stdin.readlines()))
watchdog = Timer(interval=test.timeout,
function=Tester.timer_fn,
args=(test.crt_iteration, test.num_iterations))
watchdog.start()
supervisor = Supervisor(test)
supervisor.register_banned_thread(watchdog)
supervisor.register_banned_thread()
return_code = supervisor.run_testcase()
watchdog.cancel()
sys.stdout.flush()
sys.stderr.flush()
sys.exit(return_code)
if __name__ == "__main__":
main()
def start_test(self, test, iteration, total, timer):
"""
Starts the execution of a given test. It generates the nodes and
creates threads that send tasks to the cluster's nodes and wait for
the result. We have only 1 type of tasks, for obtaining the result.
@type test: a dictionary, its keys are defined in util.py
@param test: a Test object containing the test's parameters
@type iteration: Integer
@param iteration: the index of the current iteration
@type total: Integer
@param total: the total number of iterations
@type timer: Timer
@param timer: the timer used for timeout detection
"""
supervisor = Supervisor()
supervisor.register_banned_thread(timer)
supervisor.register_banned_thread(current_thread())
if test[MAT_SIZE] != test[NUM_NODES]:
print "Wrong test format, matrix size must be the same as the\
number of nodes"
os._exit(0)
# contains all the Node objects, ordered by index (ascending)
nodes = []
datastores = []
n = test[MAT_SIZE] # NUM_NODES = MAT_SIZE !
for i in range(n):
requests = 0
if test[MAX_PENDING_REQUESTS] != 0:
requests = self.test_generator.rand_gen.randint(1, test[MAX_PENDING_REQUESTS])
datastores.append(Datastore(test[A][i][:], # matrix row
test[B][i], # vector element
requests,
test[MIN_DATASTORE_DELAY],
test[MAX_DATASTORE_DELAY],
test[SEED_DS],
supervisor))
nodes.append(Node(i, n))
supervisor.register_node(datastores[-1], nodes[-1])
for node in nodes:
# set the node's datastore
node.set_datastore(datastores[nodes.index(node)])
# the nodes need to know about each other
node.set_nodes(nodes[:])
self.result = {}
# sends tasks to nodes
# we need threads because get_x() is blocking
threads = []
for node in nodes:
threads.append(Thread(target=Tester.start_node, args=(self, node)))
supervisor.register_banned_thread(threads[-1])
threads[-1].start()
for t in threads:
t.join()
for node in nodes:
node.shutdown()
supervisor.check_termination()
if self.bonus is None:
self.bonus = supervisor.check_bonus()
else:
self.bonus = self.bonus and supervisor.check_bonus()
errors = supervisor.status()
errors.extend(self.check_result(test))
if len(errors) == 0:
self.passed_tests += 1
else:
self.bonus = False
print test_errors_msg % (iteration, total)
for error in errors:
self.print_error(error)
async def test_service_status(event_loop):
s = Supervisor(loop=event_loop)
s.application = test_app
res = await s.service_status(service_id=1)
assert res == 'starting'
await s.stop()
