def __init__(self, ser, default = RGBState.STATE_OFF): Controller.__init__(self) self.ser = ser self.default = default self.keepalive = False self.state = self.default self.lock = threading.Lock()
def test_TextSave_03(self, mock_isfile, mock_open): """ Add 2 Records, then expect the text save to produce 2 text lines """ def doText(): doText.theText = theTextStream.getvalue() theTextStream = StringIO() theTextStream.close = Mock(side_effect=doText) mock_isfile.return_value = False mock_open.return_value = theTextStream theController = Controller(TestView.TestView(), None) self._addSomeRecordsViaController(theController, 2) TestView.clearLog() theController.do_text_save("") # Part 1: Text data expectedData = "A000 M 0 0 Normal 0\nA001 M 0 0 Normal 0" actualData = doText.theText self.assertEqual(expectedData, actualData) # Part 2: Show expectedShow = "Saved As Text" actualShow = TestView.theLog[0] self.assertEqual(expectedShow, actualShow)
def test_SerialSave_01(self, mock_isfile, mock_open): """ Saving a RecordCollection with 10 Records """ def doDump(): doDump.theDump = theDumpStream.getvalue() theDumpStream = BytesIO() theDumpStream.close = Mock(side_effect=doDump) # So that it is know that file does not exist mock_isfile.return_value = False mock_open.return_value = theDumpStream theController = Controller(TestView.TestView(), None) # add 10 Records, reset view log, then serial save self._addSomeRecordsViaController(theController, 10) TestView.clearLog() theController.do_serial_save("") # Part 1: Check contents of theDumpStream # theDump = theDumpStream.getvalue() expectedRecords = 10 fromDump = pickle.load(BytesIO(doDump.theDump)) actualRecords = len(fromDump.getAllRecords()) self.assertEqual(expectedRecords, actualRecords) # Part 2: Check no show() messages on theLog expectedLog = 0 actualLog = len(TestView.theLog) self.assertEqual(expectedLog, actualLog)
def test_TextLoad_01(self, mockMeth): """ Load a record from text, test for correct attribute parsing - This test does not add coverage if test_TextLoad_02 is exercised - Asserted by expecting TestView().show() to get a message, representing the record in the same string format """ expID = "A001" expGender = "F" expAge = 36 expSales = 92 expBMI = "Normal" expIncome = 700 theData = "{} {} {} {} {} {}".format(expID, expGender, expAge, expSales, expBMI, expIncome) mockMeth.return_value = StringIO(theData) theController = Controller(TestView.TestView(), None) theController.do_text_load("") TestView.clearLog() expectedMessage = theData + "\n" theController.do_view_records("") actualMessage = TestView.theLog[0] self.assertEqual(expectedMessage, actualMessage)
def __init__(self, speed, min_altitude, max_altitudeGoal, height_diff, \ timeout, bbx, bby, pid_x, pid_y, pid_z, pid_theta, bounding_box=True): # Initialize the node and rate Mode.__init__(self, 'land_mode') Controller.__init__(self, pid_x, pid_y, pid_z, pid_theta, bounding_box) # Subscribers # self.sub_navdata = rospy.Subscriber('/ardrone/navdata', Navdata, self.navdata_cb) ##self.sub_state = rospy.Subscriber('/smach/state', String, self.state_cb) self.sub_state = rospy.Subscriber('/smach/state',String, self.handle_timer_cb) # Publishers self.pub_altitude = rospy.Publisher('/cmd_vel', Twist, queue_size=1) self.pub_land = rospy.Publisher('/ardrone/land', Empty, queue_size=100) #this turns off the motors # NOTE changed to passing transition and state info along # /smach/transition and /smach/state topics, respectively # self.pub_return_to_state = rospy.Publisher('qc_smach/transitions', String, queue_size=1) self.pub_transition = rospy.Publisher('smach/transition', String, queue_size=1) # Initialize member variables self.transition = String() self.state = 'nada' self.timer = rospy.Timer(rospy.Duration(timeout), self.goto_reacquisition) self.altitude_command = Twist() self.altitude_command.linear.z = speed self.min_altitude = min_altitude self.speed = speed self.max_altitudeGoal = max_altitudeGoal self.height_diff = height_diff
class Game(object): def __init__(self): self.TITLE = "TEST (by zeeisl)" self.WIDTH = 800 self.HEIGHT = 600 self.controller = Controller() # game things self.char = Player("res//hero.png") self.map = Map() self.char1 = Character("res//hero.png", 100, 100, 32, 32) def key_input(self, event): self.controller.getButtonStates(event) self.char.key_input(event) def update(self, delta): self.map.update() self.char.update(self.char1) self.char1.update() def render(self, screen): self.map.render(screen) self.char.render(screen) self.char1.render(screen)
class ControllerThread(threading.Thread): def __init__(self, group=None, target=None, name=None, args=(), kwargs=None, verbose=None): ''' Initialize class attributes. ''' threading.Thread.__init__(self, group=group, target=target, name=name, verbose=verbose) self.controller = Controller() self.state = True def stop_communication(self): ''' Change the state to False, this will finish the communication cylce. ''' self.state = False self.controller.quit_commands() def run(self): ''' Perform the joystick connection and get the bluetooth list. ''' try: while self.state: self.controller.send_commands() except: print str(traceback.format_exc())
class ControllerTest(unittest.TestCase): def setUp(self): self.clerk = MockClerk() self.clerk.store(Goal(name="Test Goal 1")) self.clerk.store(Goal(name="Test Goal 2")) self.clerk.store(Task(name="Test Task 1")) self.clerk.store(Task(name="Test Task 2")) self.clerk.store(User(name="Durran")) self.clerk.store(User(name="Michal")) self.clerk.store(Plan()) self.controller = Controller(self.clerk) # Test the listing of goals def testListGoals(self): g = self.controller.list_goal() assert len(g) == 2 # Test the listing of tasks def testListTasks(self): t = self.controller.list_task() assert len(t) == 2 # Test the user list def testListUsers(self): u = self.controller.list_user() assert len(u) == 2 # test the plan list def testListPlan(self): p = self.controller.list_plan() assert len(p) == 1
def test_SelectedRecord_EditBMI(self): """ A RecordCollection with one Record will be provided to Controller - Random ID, male, default attributes - New BMI will be Overweight """ theRC = self._getRecordColl_OneMaleRecord_RandomID() theRecord = theRC.getAllRecords()[0] theID = theRecord.getID() newBMI = "Overweight" theController = Controller(TestView.TestView(), theRC) # From here the record will be manipulated via theController # Successful calls will represent the record via show message expected_1 = self._getRecordStateMessage(theID) expected_2 = self._getRecordStateMessage(theID, bmi=newBMI) # Call 1, selecting the record. 3 show messages expectedList = [TestObjectSelectionClass._expRecordHeader, expected_1, TestObjectSelectionClass._expRecordFunctions] TestView.clearLog() theController.do_select_rec(theID) self.assertEqual(expectedList, TestView.theLog) # Call 2, editing the BMI. 3 show messages expectedList[1] = expected_2 TestView.clearLog() theController.do_edit_bmi(newBMI) self.assertEqual(expectedList, TestView.theLog)
def __init__(self, prefs): ''' Constructor ''' Controller.__init__(self) self.shared_prefs = prefs
def __init__(self, enemy, player, director): Controller.__init__(self, enemy, director) self.player = player self.enemy_speed = 0.10 self.ttl = 0 self.lastSpeedX = 0 self.lastSpeedY = 0
def __init__(self, model, view): Controller.__init__(self, model, view) self.choices = { 1: self._choice_insert_stop, 2: self._choice_insert_time, 3: self._choice_insert_local, "sair": self.finish}
def test_update_temperature_range(self): t_lower = 15 t_upper = 18 c = Controller(t_lower, t_upper) c.update_temperature_range(16,17) assert c.set_point_lower == 16 assert c.set_point_upper == 17
def test_SelectedRecord_EditIncome(self): """ A RecordCollection with one Record will be provided to Controller - Random ID, male, default attributes - Randomise an income - Methodology for picking a new income will be (original sales + 1) % 1000 """ theRC = self._getRecordColl_OneMaleRecord_RandomID() theRecord = theRC.getAllRecords()[0] theID = theRecord.getID() theRecord.setIncome(random.randrange(1000)) originalIncome = theRecord.getIncome() newIncome = (originalIncome + 1) % 1000 # 1000 is income limit theController = Controller(TestView.TestView(), theRC) # From here the record will be manipulated via theController # Successful calls will represent the record via show message expected_1 = self._getRecordStateMessage(theID, income=originalIncome) expected_2 = self._getRecordStateMessage(theID, income=newIncome) # Call 1, selecting the record. 3 show messages expectedList = [TestObjectSelectionClass._expRecordHeader, expected_1, TestObjectSelectionClass._expRecordFunctions] TestView.clearLog() theController.do_select_rec(theID) self.assertEqual(expectedList, TestView.theLog) # Call 2, editing the income. 3 show messages expectedList[1] = expected_2 TestView.clearLog() theController.do_edit_income(newIncome) self.assertEqual(expectedList, TestView.theLog)
def test_wrong_delimiter2(self): """ testet ob ein falscher delimiter verwendet wird """ c = Controller() c.delimiter = ',' self.assertEqual(c.delimiter, ',')
def test_delimiter(self): """ testet ob der richtige delimiter benutzt wird """ c = Controller() c.delimiter = ';' self.assertEqual(c.delimiter, ';')
def main(): parser = OptionParser() parser.add_option("-v", "--verbose", dest="verbose", help="verbose log output", default=False) parser.add_option("-l", "--label", dest="label", help="label of the agent", default=None) parser.add_option("--host", dest="host", help="AppMaster host", default=None) parser.add_option("--port", dest="port", help="AppMaster port", default=None) (options, args) = parser.parse_args() if not "AGENT_WORK_ROOT" in os.environ: parser.error("AGENT_WORK_ROOT environment variable must be set.") options.root_folder = os.environ["AGENT_WORK_ROOT"] if not "AGENT_LOG_ROOT" in os.environ: parser.error("AGENT_LOG_ROOT environment variable must be set.") options.log_folder = os.environ["AGENT_LOG_ROOT"] if not options.label: parser.error("label is required.") bind_signal_handlers() # Check for configuration file. agentConfig = AgentConfig(options.root_folder, options.log_folder, options.label) update_config_from_file(agentConfig) # update configurations if needed if options.host: agentConfig.set(AgentConfig.SERVER_SECTION, "hostname", options.host) if options.port: agentConfig.set(AgentConfig.SERVER_SECTION, "port", options.port) logFile = os.path.join(agentConfig.getResolvedPath(AgentConfig.LOG_DIR), logFileName) perform_prestart_checks(agentConfig) ensure_folder_layout(agentConfig) setup_logging(options.verbose, logFile) update_log_level(agentConfig, logFile) write_pid() logger.info("Using AGENT_WORK_ROOT = " + options.root_folder) logger.info("Using AGENT_LOG_ROOT = " + options.log_folder) server_url = SERVER_STATUS_URL.format( agentConfig.get(AgentConfig.SERVER_SECTION, "hostname"), agentConfig.get(AgentConfig.SERVER_SECTION, "port"), agentConfig.get(AgentConfig.SERVER_SECTION, "check_path"), ) print("Connecting to the server at " + server_url + "...") logger.info("Connecting to the server at: " + server_url) # Wait until server is reachable netutil = NetUtil() netutil.try_to_connect(server_url, -1, logger) # Launch Controller communication controller = Controller(agentConfig) controller.start() controller.join() stop_agent() logger.info("... agent finished")
def main(): # set up logging for the application logger.info("Starting BreakfastAlarm App for user: {}".format(user_id)) controller = Controller(user_id, logger) controller.set_profile(get_breakfast_profile()) controller.start()
def main(): app = QApplication(sys.argv) controller = Controller() controller.create() controller.show() sys.exit(app.exec_())
def __init__( self ): # ui self._tl_label = "tl" self._tm_label = "tm" self._tr_label = "tr" self._bl_label = "bl" self._bm_label = "bm" self._br_label = "br" Controller.__init__( self, view=PrototypeController.PrototypeView(self) )
def main(): global config parser = OptionParser() parser.add_option("-v", "--verbose", dest="verbose", action="store_true", help="verbose log output", default=False) parser.add_option("-e", "--expected-hostname", dest="expected_hostname", action="store", help="expected hostname of current host. If hostname differs, agent will fail", default=None) (options, args) = parser.parse_args() expected_hostname = options.expected_hostname setup_logging(options.verbose) default_cfg = { 'agent' : { 'prefix' : '/home/ambari' } } config = ConfigParser.RawConfigParser(default_cfg) bind_signal_handlers() if (len(sys.argv) >1) and sys.argv[1]=='stop': stop_agent() # Check for ambari configuration file. config = resolve_ambari_config() # Starting data cleanup daemon data_cleaner = None if int(config.get('agent','data_cleanup_interval')) > 0: data_cleaner = DataCleaner(config) data_cleaner.start() perform_prestart_checks(expected_hostname) daemonize() # Starting ping port listener try: ping_port_listener = PingPortListener(config) except Exception as ex: err_message = "Failed to start ping port listener of: " + str(ex) logger.error(err_message); sys.stderr.write(err_message) sys.exit(1) ping_port_listener.start() update_log_level(config) server_url = 'https://' + config.get('server', 'hostname') + ':' + config.get('server', 'url_port') print("Connecting to the server at " + server_url + "...") logger.info('Connecting to the server at: ' + server_url) # Wait until server is reachable netutil = NetUtil() netutil.try_to_connect(server_url, -1, logger) # Launch Controller communication controller = Controller(config) controller.start() controller.join() stop_agent() logger.info("finished")
def __init__(self, model, view): Controller.__init__(self, model, view) self.choices = { 1: self._choice_list_location_schedule, 2: self._choice_lines_having_a_spot, 3: self._choice_list_line_schedule, 4: self._choice_list_itinerary_lines, 5: self._choice_list_bus_spot_near_location, 6: self._choice_list_available_schedules_of_initial_itinerary_bus_stop, "sair": self.finish}
def run(self,edit,toggle): print toggle #config = configig(self.view) #config.run(edit) self.edit = edit if (toggle == "on"): Controller.turnOn(self.view,edit,self) else: print self.ctrl Controller.turnOff()
def __init__(self, event_handler): Controller.__init__(self, event_handler) self.modifiers=set(map(str, ['RIGHT SHIFT','LEFT SHIFT','RIGHT CTRL', 'LEFT CTRL','RIGHT ALT', 'LEFT ALT'])) self.keys=set(['F'+str(x) for x in range(12)]) \ | set(map(chr, range(ord('A'), ord('Z')))) \ | set(['ESC', 'SPACE', 'ENTER']) \ | set(map(chr, range(ord('0'), ord('9')))) '''TODO: more keys''' self.registered_keys=dict() self.key_codes=dict()
def getController(self): Ki = self.getKi() Kp = self.getKp() Kd = self.getKd() controller_dummy = Controller(Ki=Ki, Kp=Kp, Kd=Kd) controller_dummy.setMax(self.editWindow.getMax()) controller_dummy.setMin(self.editWindow.getMin()) return controller_dummy
def test_DoesNotSelectOption(self): """ To successfully select an option, the correct code must be provided - No correct code provided would expect an alternative show message """ expected = "There is no option\n" incorrectCode = "" theController = Controller(TestView.TestView(), None) TestView.clearLog() # Call theController.do_select_option(incorrectCode) self.assertEqual(expected, TestView.theLog[0])
def test_DoesNotSelectRecord(self): """ To successfully select a record, the correct ID must be provided - No correct ID provided would expect an alternative show message """ expected = "There is no record with that ID\n" incorrectID = "" theController = Controller(TestView.TestView(), None) TestView.clearLog() # Call theController.do_select_rec(incorrectID) self.assertEqual(expected, TestView.theLog[0])
class GUI_main(tk.Tk): ''' classdocs ''' def __init__(self, parent): ''' Constructor ''' tk.Tk.__init__(self,parent) self.parent = parent self.name = "main" # if on linux, set the icon # if Utils.isLinux(): # os.path.join("..", "dcs.xbm") # self.iconbitmap('@../dcs.xbm') # instantiate the controller, register with the controller self.controller = Controller() self.controller.register(self, self.name) self.initialize() def initialize(self): # make the main window cover the entire screen if Utils.isLinux(): self.w, self.h = self.winfo_screenwidth(), self.winfo_screenheight() self.geometry("%dx%d+0+0" % (self.w, self.h)) if Utils.isWindows(): self.wm_state('zoomed') # bind exit command self.protocol("WM_DELETE_WINDOW", self.shutdown) #create menu self.menu = GUI_menubar(self, self.controller) self.config(menu=self.menu) # create frame structure self.big_frame = tk.Frame(self, bd=2, relief=tk.FLAT, background="grey") self.big_frame.pack(anchor=tk.NW, expand=tk.TRUE, fill=tk.BOTH) # display frame #self.graph_frame = GUI_graph_frame(self.big_frame, self.controller) #self.graph_frame.pack(side=tk.TOP, expand=tk.TRUE, fill=tk.BOTH) def shutdown(self): self.destroy() raise SystemExit
def __init__(self): ''' Constructor ''' Controller.__init__(self) self.controllers = [] self.zoom_controller = None self.manual_direction_controller = None self.sensor_orientation_controller = None #self.time_travel_clock = TimeTravelClock(); #self.transitioning_clock = TransitioningCompositeClock(timeTravelClock, RealClock()) self.teleporting_controller = None self.using_auto_mode = True
def __init__(self, view, world_model, event_handler): ''' Constructor ''' Controller.__init__(self, event_handler) self.view=view self.world=world_model #registers sprite on model and view. Grabs it to disallow physics modification ch_id=world_model.add_entity((0,0), (0,0)) view.add_entity(ch_id, shape='s') world_model.grab_entity(ch_id) self.ch_id=ch_id self.DAMAGE_EVENT=world_model.DAMAGE_EVENT
def main(heartbeat_stop_callback=None): global config parser = OptionParser() parser.add_option("-v", "--verbose", dest="verbose", action="store_true", help="verbose log output", default=False) parser.add_option( "-e", "--expected-hostname", dest="expected_hostname", action="store", help= "expected hostname of current host. If hostname differs, agent will fail", default=None) (options, args) = parser.parse_args() expected_hostname = options.expected_hostname logging_level = logging.DEBUG if options.verbose else logging.INFO setup_logging(logger, AmbariConfig.AmbariConfig.getLogFile(), logging_level) global is_logger_setup is_logger_setup = True setup_logging(alerts_logger, AmbariConfig.AmbariConfig.getAlertsLogFile(), logging_level) Logger.initialize_logger('resource_management', logging_level=logging_level) # use the host's locale for numeric formatting try: locale.setlocale(locale.LC_ALL, '') except locale.Error as ex: logger.warning( "Cannot set locale for ambari-agent. Please check your systemwide locale settings. Failed due to: {0}." .format(str(ex))) default_cfg = {'agent': {'prefix': '/home/ambari'}} config.load(default_cfg) if (len(sys.argv) > 1) and sys.argv[1] == 'stop': stop_agent() if (len(sys.argv) > 2) and sys.argv[1] == 'reset': reset_agent(sys.argv) # Check for ambari configuration file. resolve_ambari_config() # Add syslog hanlder based on ambari config file add_syslog_handler(logger) # Starting data cleanup daemon data_cleaner = None if config.has_option('agent', 'data_cleanup_interval') and int( config.get('agent', 'data_cleanup_interval')) > 0: data_cleaner = DataCleaner(config) data_cleaner.start() perform_prestart_checks(expected_hostname) # Starting ping port listener try: #This acts as a single process machine-wide lock (albeit incomplete, since # we still need an extra file to track the Agent PID) ping_port_listener = PingPortListener(config) except Exception as ex: err_message = "Failed to start ping port listener of: " + str(ex) logger.error(err_message) sys.stderr.write(err_message) sys.exit(1) ping_port_listener.start() update_log_level(config) if not OSCheck.get_os_family() == OSConst.WINSRV_FAMILY: daemonize() # # Iterate through the list of server hostnames and connect to the first active server # active_server = None server_hostnames = hostname.server_hostnames(config) connected = False stopped = False # Keep trying to connect to a server or bail out if ambari-agent was stopped while not connected and not stopped: for server_hostname in server_hostnames: try: server_ip = socket.gethostbyname(server_hostname) server_url = config.get_api_url(server_hostname) logger.info('Connecting to Ambari server at %s (%s)', server_url, server_ip) except socket.error: logger.warn( "Unable to determine the IP address of the Ambari server '%s'", server_hostname) # Wait until MAX_RETRIES to see if server is reachable netutil = NetUtil(config, heartbeat_stop_callback) (retries, connected, stopped) = netutil.try_to_connect(server_url, MAX_RETRIES, logger) # if connected, launch controller if connected: logger.info('Connected to Ambari server %s', server_hostname) # Set the active server active_server = server_hostname # Launch Controller communication controller = Controller(config, server_hostname, heartbeat_stop_callback) controller.start() while controller.is_alive(): time.sleep(0.1) # # If Ambari Agent connected to the server or # Ambari Agent was stopped using stop event # Clean up if not Windows OS # if connected or stopped: ExitHelper().exit(0) logger.info("finished") break pass # for server_hostname in server_hostnames pass # while not (connected or stopped) return active_server
from Ui import Console from Controller import Controller from Repository import Repo from Validators import Validate repoGame = Repo() validate = Validate() controller = Controller(repoGame, validate) console = Console(controller) console.run()
def setup(self): self.__bot__ = Controller() self.__ai__ = AIModule()
from Controller import Controller from GA_population import GA_population from NeuralNetworks import save_model import numpy as np import sys import torch #Instantiate genetic algorithm population = int(sys.argv[1]) n_father = int(sys.argv[2]) npermanent = int(sys.argv[3]) nH = int(sys.argv[4]) genetic = GA_population(population, n_father, npermanent, nH) #Instanciate Controller controller = Controller() controller.load_circuit() controller.register_genetic(genetic, GUI=False) n_change = 100 best_fitness = 0 for generation in range(10000): try: print('Generation:', generation) #if generation % n_change == 0: # controller.load_circuit() controller.reset() done = False while not done:
#app.py from Controller import Controller refactoring = True #while True: if refactoring: controller = Controller() refactoring = False #print("como era que se hacia?") #controller.listar_usuarios() #controller.agregar_usuario() #controller.listar_usuarios() #controller.buscarPorCedula()
from Parts import * from Controller import Controller powerSupply = PowerSupply() legs = Legs() arms = Arms() vision = Vision() speech = Speech() stats = Stats() leftArm = LeftArm() rightArm = RightArm() controller = Controller() controller.roboCopController(powerSupply)
homeTeamTag = 'team1' enemyTeamTag = 'team2' elif ROBOT_ID == team2.id: homeTeamTag = 'team2' enemyTeamTag = 'team1' else: print('Robot ne tekmuje.') sys.exit(0) print('Robot tekmuje in ima interno oznako "' + homeTeamTag + '"') # ------------------------------------------------------------------------------------------------------------------- # # GLOBAL VARIABLES gameData = GameData(gameState, homeTeamTag, enemyTeamTag) controller = Controller(initialState=State.GET_HEALTHY_HIVE) robotNearTargetOld = False target = None timeOld = time() # ------------------------------------------------------------------------------------------------------------------- # # MAIN LOOP print('Izvajam glavno zanko. Prekini jo s pritiskom na tipko DOL.') print('Cakam na zacetek tekme ...') doMainLoop = True while doMainLoop and not btn.down:
action='store_true', help='Change control mode manual') p.add_argument('-ud', '--uplinkdelay', help='Uplink delay: Set uplink delay [ms]') p.add_argument('-dd', '--downlinkdelay', help='Downlink delay: Set downlink delay [ms]') p.add_argument('-ip', help='IP address') config = {} #設定データは辞書で保持 args = p.parse_args() if args.manual: config['manual'] = args.manual else: config['manual'] = False if args.uplinkdelay: config['uplinkdelay'] = float(args.uplinkdelay) else: config['uplinkdelay'] = 0.0 if args.downlinkdelay: config['downlinkdelay'] = float(args.downlinkdelay) else: config['downlinkdelay'] = 0.0 if args.ip: config['ip'] = str(args.ip) else: config['ip'] = 'localhost' geme = Controller(config)
""" Created on Tue Apr 7 12:27:10 2020 @author: Bogdan """ ''' Decision Tree ''' from Repository import Repo from Controller import Controller import sys r = Repo('balance-scale.data') c = Controller(r) nrTests = 30 minv = sys.maxsize maxv = 0 sumv = 0 for i in range(nrTests): r.loadFromFile(0.8) c.train() val = c.test() sumv += val if val > maxv: maxv = val if val < minv:
from Controller import Controller import random def test(pos, n): a = "panda" left = a[max(0, pos - n):pos] right = a[pos + 1:pos + n + 1] pattern = (n - len(left)) * '_' + left + '*' + right + (n - len(right)) * '_' return pattern if __name__ == "__main__": controller = Controller() controller.run() '''for p in range(4): print(test(p, 3))'''
cost = tf.reduce_mean(cross_entropy) optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate).minimize( cost, global_step=global_step) correct_prediction = tf.equal(y_pred_cls, tf_y_train_cls) accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32)) tf.summary.scalar('Accuracy', accuracy) tf.summary.scalar('loss/cost', cost) merged = tf.summary.merge_all() saver = tf.train.Saver() tf.reset_default_graph() with tf.Session(graph=graph) as session: tf.global_variables_initializer().run() saver.restore(session, 'checkpoints/model.ckpt') cnt = Controller("127.0.0.1", 5003) #cnt.startController() controlsStr = "0:0:0:0" posInMatrixStr = "0:0:0" isRestarted = 0 posMatrixSize = [30, 30, 30] posMatrix = np.zeros( (posMatrixSize[0], posMatrixSize[1], posMatrixSize[2])) lastTime = time.time() posMatThread = Thread(target=updatePositionMatrix, args=[]) posMatThread.start() while True: data = None
def test_start_button(qtbot): root = Tk() command = Controller(master=root) qtbot.addWidget(command) qtbot.mouseClick(command.start_button, QtCore.Qt.LeftButton)
# -*- coding: utf-8 -*- """ Created on Fri May 15 11:39:52 2020 @author: tamas """ from Repository import Repository from Controller import Controller from UI import Console if __name__=="__main__": repo = Repository() contr = Controller(repo) console = Console(contr) console.run()
def __init__(self): Controller.__init__(self)
def __init__(self, path): self.myController = Controller(path)
def __init__(self): self.__controller = Controller(self) # do stuff self.__controller.start() atexit.register(self.stop)
''' Created on Feb 20, 2019 @author: Adrian ''' from Repository import Repository from Controller import Controller from Console import Console if __name__ == '__main__': repository = Repository("rooms.txt", "reservations.txt") controller = Controller(repository) console = Console(controller) console.start()
class MediaPlayer: __controller = None __playerType = 'shell' __playerCommand = 'mplayer' __playerProcess = None __playingFile = None __fileData = None def __init__(self): self.__controller = Controller(self) # do stuff self.__controller.start() atexit.register(self.stop) def __del__(self): self.stop() def play(self, file, name=None): if self.isPlaying: self.stop() shell = False if self.__playerType == 'shell': shell = True self.__playerProcess = subprocess.Popen(self.__playerCommand + ' ' + file, shell=shell, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, preexec_fn=os.setsid) self.__playingFile = file self.__fillFileData(file, name) def stop(self): os.killpg(os.getpgid(self.__playerProcess.pid), signal.SIGTERM) self.__fileData.close() self.__playingFile = None self.__playerProcess = None def __fillFileData(self, file, name=None): if file.lower().startswith('http://') or file.lower().startswith( 'https://'): self.__fileData = IcyData(r_url=file, onUpdate=self.__onIcyUpdate, name=name, onInit=self.sendStatus) def __onIcyUpdate(self, data): data['action'] = 'updateIcyData' self.__controller.sendMessage(json.dumps(data)) @property def isPlaying(self): return self.__playingFile is not None @property def playingFile(self): return self.__playingFile def sendStatus(self, peer=None): if peer is not None: self.__controller.sendMessage(self.status, peer.appType, peer.uid) else: self.__controller.sendMessage(self.status) @property def playing(self): return self.__playingFile is not None @property def status(self): data = { 'playing': self.playing, } if self.playing: data['fileData'] = self.__fileData.data return json.dumps(data)
with open(args.settings, 'r') as settingsfile: settings = json.load(settingsfile) with open(args.script, 'r') as sriptFile: script = sriptFile.readlines() #coms = ArduinoCommunicator(settings['COM'], settings['sensor']) coms = DebugCommunicator(settings['COM'], settings['sensor']) app = QtWidgets.QApplication(sys.argv) app.setStyle(QtWidgets.QStyleFactory.create('Fusion')) MainWindow = QtWidgets.QMainWindow() ui = gui.Ui_MainWindow() ui.setupUi(MainWindow) control = Controller(settings, coms, script, MainWindow) update_list(control.program) control.pump_changed.connect(update_pump) control.temp_changed.connect(update_temp) control.program_changed.connect(update_list) control.sensors_changed.connect(update_sensors) ui.PumpCheckBox.stateChanged.connect(lambda x: control.pump_toggle(bool(x))) ui.TempUpButton.clicked.connect(lambda x: control.shift_temp(0.5)) ui.TempDownButton.clicked.connect(lambda x: control.shift_temp(-0.5)) ui.TimeUpButton.clicked.connect(lambda x: control.shift_time(30)) ui.TimeDownButton.clicked.connect(lambda x: control.shift_time(-30)) ui.StepUpButton.clicked.connect(lambda x: control.shift_step(1))
import time from operator import attrgetter import matplotlib.pyplot as plt from numpy import average from Controller import Controller from domain.Ant import Ant from domain.Traces import Traces from domain.Traces2 import Traces2 traces = Traces(Controller().read_string(0)) ants_result = [] for i in range(1000): ants = [Ant() for i in range(10)] for ant in ants: while len(ant.solution) < len(traces.matrix): ant.step(traces) traces.leave_trace(max(ants, key=attrgetter("fitness"))) print(str(traces)) ants_result.append(average([i.fitness for i in ants])) plt.plot(ants_result) plt.show() print(min(ants_result))
from Controller import Controller from DiscordBot import Bot import yaml CONFIG_FILE = 'AdaptBot.yml' with open(CONFIG_FILE, 'r') as config_file: config = yaml.full_load(config_file) my_controller = Controller(config.get('controller')) my_client = Bot(config.get('discord'), my_controller) my_client.run(config.get('bot_id'))
def setUp(self): self.repository = Repository("Test_rooms.txt") self.controller = Controller(self.repository)
class Game(): __delegate__ = None __bot__ = None __ai__ = None __turn__ = None board = None finishGame = False count_muertas = 0 def __init__(self, delegate): print("init game") self.__delegate__ = delegate self.__turn__ = TurnUser.USER def setup(self): self.__bot__ = Controller() self.__ai__ = AIModule() def reset(self): self.__turn__ = TurnUser.USER def run(self): self.backupBoard() while self.shouldFinishGame() == False: if self.__turn__ == TurnUser.USER: self.makePlayer(self.board) else: self.makeRobot() self.backupBoard() self.changeTurn() def changeTurn(self): if self.__turn__ == TurnUser.USER: self.__turn__ = TurnUser.ROBOT self.speak_robot() else: self.__turn__ = TurnUser.USER self.speak_user() def backupBoard(self): self.board = self.__ai__.getTablero() def shouldFinishGame(self): #TODO: Mirar si finaliza pendiente return self.finishGame def makePlayer(self, tablero): self.__ai__.scanf(tablero) def makeRobot(self): tirada, muertas = self.__ai__.getMovimiento() self.accionMuertas(muertas) print("Tirada: "+str(tirada)) print("Muertas: "+str(muertas)) self.__bot__.move(tirada, muertas) def accionMuertas(self, muertas): if len(muertas) > 0: self.count_muertas += 1 if self.count_muertas == 1: self.__delegate__.doAction("Eres muy malo", "jaja") elif self.count_muertas == 2: self.__delegate__.doAction("No me estarás dejando ganar... eh", "pesimo") elif self.count_muertas == 3: self.__delegate__.doAction("No te lo quería decir pero...", "loser") else: self.__delegate__.doAction("¡Perdedor!", "lastima") count_muertas = 0 def getTurn(self): return self.__turn__ def doCheat(self): if self.__turn__ == TurnUser.USER: self.speakCheat() self.__delegate__.doAction("", "cheat") self.makeRobot() self.__delegate__.cheatFinished() def doAbort(self): self.__bot__.abort() def speak_user(self): gif = None text = "" value = random.randint(0,15) if value == 1: text = "Qué hace una abeja en el gimnasio...\n - zúmba" elif value == 3: text = "Qué conduce Papa Noel...\n un Renol" elif value == 5: text = "Sabes cual es la fruta más graciosa...\n - la naranjajajajajajajaja" gif = "naranja" elif value == 6: text = "Eres un pendejo!" gif = "pendejo" elif value == 8: text = "Aguanta -wey" gif = "wey" self.__delegate__.doAction(text, gif) def speak_robot(self): gif = None text = "" value = random.randint(0,8) if value == 1: text = "Mira y aprende del jefe" gif = "robocop" elif value == 4: text = "Alojomora" gif = "HarryPotter" elif value == 5: text = "Soy mago, -el mago pajas" gif = "Magic" elif value == 6: text = "emmh..." gif = "thinking" elif value == 2: text = "Si sabes como me pongo... -pa que me invitas?" gif = "si sabes como me pongo" self.__delegate__.doAction(text, gif) def speakCheat(self): gif = None text = "" value = random.randint(0,6) if value == 1: text = "" gif = "evil" elif value == 2: text = "" gif = "666" else: text = "" gif = "tricky" self.__delegate__.doAction(text, gif)
self.profile_listing.delete(0, tk.END) for profile in self.profiles: self.profile_listing.insert(tk.END, profile["name"]) if self.selected_profile is not None: nameVar = tk.StringVar(self.root) name = tk.Entry(self.root, textvariable=nameVar) name.pack() def run(self): self.profile_scrollbar = tk.Scrollbar(self.root) self.profile_scrollbar.pack(side=tk.LEFT, pady=30) self.profile_listing = tk.Listbox(self.root, yscrollcommand=self.profile_scrollbar.set) for profile in self.profiles: self.profile_listing.insert(tk.END, profile["name"]) self.profile_listing.bind("<<ListboxSelect>>", self.on_profile_select) self.profile_listing.pack(side=tk.LEFT, fill=tk.BOTH, pady=30) self.profile_scrollbar.config(command=self.profile_listing.yview) tk.Button(self.root, command=self.add_profile, text="+").place(x=20, y=0, width=27, height=27) tk.Button(self.root, command=self.remove_profile, text="-").place(x=52, y=0, width=27, height=27) self.root.mainloop() if __name__ == '__main__': c = Controller() c.start()
def __init__(self, id): Controller.__init__(self, id)
def main(): global config parser = OptionParser() parser.add_option("-v", "--verbose", dest="verbose", action="store_true", help="verbose log output", default=False) parser.add_option( "-e", "--expected-hostname", dest="expected_hostname", action="store", help= "expected hostname of current host. If hostname differs, agent will fail", default=None) (options, args) = parser.parse_args() expected_hostname = options.expected_hostname setup_logging(options.verbose) default_cfg = {'agent': {'prefix': '/home/ambari'}} config = ConfigParser.RawConfigParser(default_cfg) bind_signal_handlers() if (len(sys.argv) > 1) and sys.argv[1] == 'stop': stop_agent() # Check for ambari configuration file. config = resolve_ambari_config() # Starting data cleanup daemon data_cleaner = None if int(config.get('agent', 'data_cleanup_interval')) > 0: data_cleaner = DataCleaner(config) data_cleaner.start() perform_prestart_checks(expected_hostname) daemonize() # Starting ping port listener ping_port_listener = PingPortListener(config) ping_port_listener.start() update_log_level(config) server_url = 'https://' + config.get( 'server', 'hostname') + ':' + config.get('server', 'url_port') print("Connecting to the server at " + server_url + "...") logger.info('Connecting to the server at: ' + server_url) # Wait until server is reachable netutil = NetUtil() netutil.try_to_connect(server_url, -1, logger) # Launch Controller communication controller = Controller(config) controller.start() controller.join() stop_agent() logger.info("finished")
class GUI(object): def __init__(self): self.root = Tk() self.controller = Controller() self.images_extensions = (("Image files", ("*.jpg", "*.png")), ) self.guitar = "guitar.mp3" # Label del titulo #self.title = Label(self.root,text="Seleccione el archivo pickle para cargarlo") #self.title.grid(row=0,column=0) # Boton de elegir pickle self.choose = Button(self.root, text="Browse", command=self.load_file, width=30) self.choose.grid(row=1, column=0) # Mensaje de seleccionado self.choose_text = "Seleccione un archivo binario" self.choose_error = "Eso no es un archivo binario" self.choose_msg = Label(self.root, text=self.choose_text) self.choose_msg.grid(row=1, column=1) # Boton de clasificar self.classify = Button(self.root, text="Seleccionar imágen y clasificar", command=self.load_image, width=30) self.classify.grid(row=2, column=0) # Mensaje de clasificado self.classify_text = "Seleccione una imágen" self.classify_wait = "Clasificando imágen..." self.classify_msg = Label(self.root, text=self.classify_text) self.classify_msg.grid(row=2, column=1) #self.setup() self.root.mainloop() def classification(self, image): return self.controller.classify(image) def set_file(self, file): return self.controller.set_file(file) def load_file(self): file = askopenfilename(filetypes=(("Binary files", "*.*"), )) if file: extension = file.split("/")[-1] if not "." in extension: # selecciono un binary # todo text = self.set_file(file) self.choose_msg.config(text=text) else: # selecciono uno con extension self.choose_msg.config(text=self.choose_error) else: self.choose_msg.config(text=self.choose_error) def load_image(self): image = askopenfilename(filetypes=self.images_extensions) if image: # selecciono una img # todo self.classify_msg.config(text=self.classify_wait) text = self.classification(image) self.classify_msg.config(text=text) self.play(self.guitar) else: # selecciono uno con extension self.classify_msg.config(text=self.classify_text) def play(self, sound): mixer.init() mixer.music.load(sound) mixer.music.play()
# el arbol else: if contWait < 3: contWait += 1 else: wait = False contWait = 0 return trace_calls command = "from " + file + " import " + function + " as func" exec(command) tr = sys.gettrace() # Guardo la traza original del programa sys.settrace(trace_calls) # Traceo la ejecucion del programa try: func() except Exception: None sys.settrace(tr) # Cargo la traza original guardada if fusion: arbol.fusionNodos() arbol.calcularPeso() controller = Controller(arbol, graphics) controller.run()
import struct from Controller import Controller ctl = Controller(1) axis_ids = { 'x': 0x83, 'y': 0x84, 'z': 0x85, 'rx': 0x86, 'ry': 0x87, 'rz': 0x88, } axis_lookup = { 0x83: lambda ctl, v: ctl.set_x(v), 0x84: lambda ctl, v: ctl.set_y(v), 0x85: lambda ctl, v: ctl.set_z(v), 0x86: lambda ctl, v: ctl.set_rx(v), 0x87: lambda ctl, v: ctl.set_ry(v), 0x88: lambda ctl, v: ctl.set_rz(v), 0x89: lambda ctl, v: ctl.set_slider_0(v), 0x90: lambda ctl, v: ctl.set_slider_1(v), } def on_packet(packet): m = list(packet) h = m[0] if h == 0xff:
import logging from logging.handlers import TimedRotatingFileHandler from Controller import Controller logger = logging.getLogger(__name__) logger.setLevel(logging.DEBUG) # TODO: This should be configurable f_handler = TimedRotatingFileHandler("controller.log", when="d", interval=1, backupCount=7) f_handler.setLevel(logging.INFO) f_format = logging.Formatter("%(asctime)s:%(levelname)s: %(message)s") f_handler.setFormatter(f_format) logger.addHandler(f_handler) logger.info("Controller started") thisController = Controller(logger) # Never reach here! logger.info("Controller stopping") logging.shutdown()