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