def __init__(self, world_state: WorldState): super().__init__(world_state) self.type_of_pathfinder = ConfigService( ).config_dict["STRATEGY"]["pathfinder"] self.last_time_pathfinding_for_robot = {} self.last_frame = time.time() self.game_state = world_state.game_state
def setUp(self): super().setUp() test_utils.setup() authorizer = Authorizer([], ['admin_user'], EmptyGroupProvider()) self.admin_user = User('admin_user', {}) self.config_service = ConfigService(authorizer, test_utils.temp_folder)
def __init__(self, team_color: TeamColor): super().__init__(team_color) # It is our team so we use our player! for player_id in range(PLAYER_PER_TEAM): self.players[player_id] = OurPlayer(self, player_id) if (ConfigService().config_dict["GAME"]["type"] == "sim" and 0 <= player_id <= 5)\ or (ConfigService().config_dict["GAME"]["type"] == "real" and 1 <= player_id <= 6): self.available_players[player_id] = self.players[player_id]
def __init__(self, world_state: WorldState): super().__init__(world_state) self.type_of_pathfinder = ConfigService( ).config_dict["STRATEGY"]["pathfinder"] self.pathfinder = self.get_pathfinder(self.type_of_pathfinder) self.last_time_pathfinding_for_robot = {} self.last_frame = time.time() self.last_path = None self.last_raw_path = None self.last_pose_goal = None
def setUp(self): super().setUp() test_utils.setup() authorizer = Authorizer([], ['admin_user'], EmptyGroupProvider()) self.admin_user = User('admin_user', {}) self.config_service = ConfigService(authorizer, test_utils.temp_folder) for suffix in 'XYZ': _create_script_config_file('conf' + suffix, name='Conf ' + suffix)
class ConfigServiceLoadConfigForAdminTest(unittest.TestCase): def setUp(self): super().setUp() test_utils.setup() authorizer = Authorizer([], ['admin_user'], [], EmptyGroupProvider()) self.admin_user = User('admin_user', {}) self.config_service = ConfigService(authorizer, test_utils.temp_folder) def tearDown(self): super().tearDown() test_utils.cleanup() def test_load_config(self): _create_script_config_file('ConfX', script_path='my_script.sh', description='some desc') config = self.config_service.load_config('ConfX', self.admin_user) self.assertEqual( config, { 'filename': 'ConfX.json', 'config': { 'name': 'ConfX', 'script_path': 'my_script.sh', 'description': 'some desc' } }) def test_load_config_when_name_different_from_filename(self): _create_script_config_file('ConfX', name='my conf x') config = self.config_service.load_config('my conf x', self.admin_user) self.assertEqual( config, { 'filename': 'ConfX.json', 'config': { 'name': 'my conf x', 'script_path': 'echo 123' } }) def test_load_config_when_non_admin(self): _create_script_config_file('ConfX') user = User('user1', {}) self.assertRaises(AdminAccessRequiredException, self.config_service.load_config, 'ConfX', user) def test_load_config_when_not_exists(self): _create_script_config_file('ConfX', name='my conf x') config = self.config_service.load_config('ConfX', self.admin_user) self.assertIsNone(config)
def setUp(self) -> None: super().setUp() test_utils.setup() authorizer = Authorizer([], ['admin_user', 'admin_non_editor'], [], ['admin_user'], EmptyGroupProvider()) self.admin_user = User('admin_user', {}) self.config_service = ConfigService(authorizer, test_utils.temp_folder) for pair in [('script.py', b'123'), ('another.py', b'xyz'), ('binary 1.bin', bytes.fromhex('300000004000000a')), ('my_python', bytes.fromhex('7F454C46'))]: path = os.path.join(test_utils.temp_folder, pair[0]) file_utils.write_file(path, pair[1], byte_content=True)
def __init__(self): cfg = ConfigService() self.default_dt = cfg.config_dict["GAME"]["ai_timestamp"] ncameras = int(cfg.config_dict["IMAGE"]["number_of_camera"]) # Transition model self.F = np.array([ [1, 0, self.default_dt, 0, 0, 0], # Position x [0, 1, 0, self.default_dt, 0, 0], # Position y [0, 0, 1, 0, 0, 0], # Speed x [0, 0, 0, 1, 0, 0], # Speed y [0, 0, 0, 0, 1, self.default_dt], # Orientation [0, 0, 0, 0, 0, 1] ]) # Speed w # Observation model self.H = [[1, 0, 0, 0, 0, 0] for _ in range(ncameras)] # Position x self.H += [[0, 1, 0, 0, 0, 0] for _ in range(ncameras)] # Position y self.H += [[0, 0, 0, 0, 1, 0] for _ in range(ncameras)] # Orientation self.H = np.array(self.H) # Process covariance values = np.array([10**0, 10**0, 10**0, 10**0, 10**2, 10**(-1)]) self.Q = np.diag(values) # Observation covariance values = [10**0 for _ in range(ncameras)] values += [10**0 for _ in range(ncameras)] values += [10**(-3) for _ in range(ncameras)] self.R = np.diag(values) # Pose * ncameras # Initial state covariance self.P = 10**3 * np.eye(6) self.x = np.array([9999, 9999, 0, 0, 0, 0])
def __init__(self, p_world_state: WorldState): super().__init__(p_world_state) is_simulation = ConfigService().config_dict["GAME"]["type"] == "sim" self.robot_motion = [ RobotMotion(p_world_state, player_id, is_sim=is_simulation) for player_id in range(12) ]
def __init__(self): """ Initialise le coach de l'IA. :param mode_debug_active: (bool) indique si les commandes de debug sont actives :param pathfinder: (str) indique le nom du pathfinder par défault :param is_simulation: (bool) indique si en simulation (true) ou en vrai vie (false) """ cfg = ConfigService() self.mode_debug_active = cfg.config_dict["DEBUG"][ "using_debug"] == "true" self.is_simulation = cfg.config_dict["GAME"]["type"] == "sim" # init the states self.world_state = WorldState() # init the executors self.debug_executor = DebugExecutor(self.world_state) self.play_executor = PlayExecutor(self.world_state) self.module_executor = ModuleExecutor(self.world_state) self.motion_executor = MotionExecutor(self.world_state) self.robot_command_executor = CommandExecutor(self.world_state) # logging DebugInterface().add_log( 1, "\nCoach initialized with \nmode_debug_active = " + str(self.mode_debug_active) + "\nis_simulation = " + str(self.is_simulation))
def start_server(self, port, address, *, xsrf_protection=XSRF_PROTECTION_TOKEN): file_download_feature = FileDownloadFeature( UserFileStorage(b'some_secret'), test_utils.temp_folder) config = ServerConfig() config.port = port config.address = address config.xsrf_protection = xsrf_protection config.max_request_size_mb = 1 authorizer = Authorizer(ANY_USER, [], [], EmptyGroupProvider()) execution_service = MagicMock() execution_service.start_script.return_value = 3 server.init(config, None, authorizer, execution_service, MagicMock(), MagicMock(), ConfigService(authorizer, self.conf_folder), MagicMock(), FileUploadFeature(UserFileStorage(b'cookie_secret'), test_utils.temp_folder), file_download_feature, 'cookie_secret', None, self.conf_folder, start_server=False) self.start_loop()
def __init__(self): cfg = ConfigService() host = cfg.config_dict["COMMUNICATION"]["ui_debug_address"] port = int(cfg.config_dict["COMMUNICATION"]["ui_cmd_receiver_port"]) self.packet_list = deque(maxlen=DEBUG_RECEIVE_BUFFER_SIZE) handler = self.get_udp_handler(self.packet_list) self.server = ThreadedUDPServer(host, port, handler)
def setUp(self): super().setUp() test_utils.setup() self.user = User('ConfigServiceTest', {AUTH_USERNAME: '******'}) self.config_service = ConfigService(AnyUserAuthorizer(), test_utils.temp_folder)
def __init__(self): super().__init__() nb_cameras = int( ConfigService().config_dict["IMAGE"]["number_of_camera"]) self.last_camera_frame = [empty_camera for _ in range(nb_cameras)] self.last_new_packet = None self.new_image_flag = False self.time = time.time()
class PathfinderModule(Executor): def __init__(self, world_state: WorldState): super().__init__(world_state) self.type_of_pathfinder = ConfigService( ).config_dict["STRATEGY"]["pathfinder"] self.last_time_pathfinding_for_robot = {} self.last_frame = time.time() self.game_state = world_state.game_state def exec(self): callback = partial(pathfind_ai_commands, self.type_of_pathfinder.lower(), self.game_state) paths = [ callback(player) for player in list( self.ws.game_state.my_team.available_players.values()) ] for path in paths: if path is not None: self.draw_path(path) def draw_path(self, path, pid=0): points = [] for idx, path_element in enumerate(path.points): x = path_element.x y = path_element.y points.append((x, y)) if self.type_of_pathfinder.lower() == "path_part": if idx == 0: pass else: self.ws.debug_interface.add_line(points[idx - 1], points[idx], timeout=0.1) # print(points) #self.ws.debug_interface.add_multi_line(points) self.ws.debug_interface.add_multiple_points( points[1:], COLOR_ID_MAP[pid], width=5, link="path - " + str(pid), timeout=DEFAULT_PATH_TIMEOUT)
def __init__(self): """ Constructeur de la classe, établis les propriétés de bases et construit les objets qui sont toujours necéssaire à son fonctionnement correct. """ # config self.cfg = ConfigService() # time self.last_frame_number = 0 self.time_stamp = None # time.time() self.last_camera_time = time.time() self.time_of_last_loop = time.time() self.ai_timestamp = float(self.cfg.config_dict["GAME"]["ai_timestamp"]) # thread self.ia_running_thread = None self.thread_terminate = threading.Event() # Communication self.robot_command_sender = None self.vision = None self.referee_command_receiver = None self.uidebug_command_sender = None self.uidebug_command_receiver = None self.uidebug_vision_sender = None self.uidebug_robot_monitor = None # because this thing below is a callable! can be used without being set self.vision_redirection_routine = lambda *args: None self.vision_routine = self._sim_vision # self._normal_vision # self._test_vision self._redirected_vision self._choose_vision_routines() # Debug self.incoming_debug = [] self.debug = DebugInterface() self.outgoing_debug = self.debug.debug_state self._init_communication() # Game elements self.reference_transfer_object = None self.game = None self.ai_coach = None self.referee = None self.team_color_service = None self._create_game_world() # VISION self.image_transformer = ImageTransformerFactory.get_image_transformer( ) # ia couplage self.ia_coach_mainloop = None self.ia_coach_initializer = None # for testing purposes self.frame_number = 0
def __init__(self, team, id): self.id = id self.team = team self.pose = Pose() self.velocity = Pose() self.kf = EnemyKalmanFilter() self.update = self._update if ConfigService().config_dict["IMAGE"]["kalman"] == "true": self.update = self._kalman_update
def __init__(self): super().__init__() nb_cameras = int( ConfigService().config_dict["IMAGE"]["number_of_camera"]) self.last_new_packet = None self.new_image_flag = False self.time = time.time() self.cameras = [CameraPacket(cam_nb) for cam_nb in range(nb_cameras)] self.last_camera_frame = self._create_kalman_image()
def get_image_transformer(): type_of_image_transformer = ConfigService( ).config_dict["IMAGE"]["kalman"] if type_of_image_transformer == "true": return KalmanImageTransformer() elif type_of_image_transformer == "false": return SingularPacketImageTransformer() else: raise TypeError("Tentative de création d'un RobotCommandSender de " "mauvais type.")
def setUp(self): config_service = ConfigService().load_file("config/sim_standard.cfg") self.game_state = GameState() self.game = Game() self.game.set_referee(Referee()) self.game.ball = Ball() game_world = ReferenceTransferObject(self.game) game_world.set_team_color_svc(TeamColorService(TeamColor.YELLOW_TEAM)) self.game_state.set_reference(game_world) self.game_state.game.ball.set_position(Position(100, 0), 0)
def __init__(self, ball: 'Ball'): self.ball = ball self.debug_interface = DebugInterface() cfg = ConfigService() if cfg.config_dict["GAME"]["our_side"] == "positive": self.our_side = FieldSide.POSITIVE self.constant = positive_side_constant else: self.our_side = FieldSide.NEGATIVE self.constant = negative_side_constant
def __init__(self, id: int): assert 0 <= id <= int(ConfigService().config_dict["IMAGE"]["number_of_camera"]), "Creating CameraPacket " \ "class with wrong id!" self.camera_id = id self.timestamp = 0 self.t_capture = 0 self.frame_number = 0 self.ball = None self.robots_blue = [None for _ in range(PLAYER_PER_TEAM)] self.robots_yellow = [None for _ in range(PLAYER_PER_TEAM)] self.packet = None
def __init__(self, ball: Ball): self.ball = ball cfg = ConfigService() if cfg.config_dict["GAME"]["terrain_type"] == "normal": self.constant = normal elif cfg.config_dict["GAME"]["terrain_type"] == "small": self.constant = small else: print("ERREUR lors de la création de l'objet field\n Mauvais terrain_type en config - normal choisi\n") self.constant = normal
def main(): tool_utils.validate_web_imports_exist(os.getcwd()) logging_conf_file = os.path.join(CONFIG_FOLDER, 'logging.json') with open(logging_conf_file, 'rt') as f: log_config = json.load(f) file_utils.prepare_folder(os.path.join('logs')) logging.config.dictConfig(log_config) file_utils.prepare_folder(CONFIG_FOLDER) file_utils.prepare_folder(TEMP_FOLDER) migrations.migrate.migrate(TEMP_FOLDER, CONFIG_FOLDER) server_config = server_conf.from_json(SERVER_CONF_PATH) secret = get_secret(TEMP_FOLDER) config_service = ConfigService(CONFIG_FOLDER) alerts_service = AlertsService(server_config.get_alerts_config()) alerts_service = alerts_service execution_logs_path = os.path.join('logs', 'processes') log_name_creator = LogNameCreator( server_config.logging_config.filename_pattern, server_config.logging_config.date_format) execution_logging_service = ExecutionLoggingService( execution_logs_path, log_name_creator) existing_ids = [ entry.id for entry in execution_logging_service.get_history_entries() ] id_generator = IdGenerator(existing_ids) execution_service = ExecutionService(id_generator) execution_logging_initiator = ExecutionLoggingInitiator( execution_service, execution_logging_service) execution_logging_initiator.start() user_file_storage = UserFileStorage(secret) file_download_feature = FileDownloadFeature(user_file_storage, TEMP_FOLDER) file_download_feature.subscribe(execution_service) file_upload_feature = FileUploadFeature(user_file_storage, TEMP_FOLDER) alerter_feature = FailAlerterFeature(execution_service, alerts_service) alerter_feature.start() server.init(server_config, execution_service, execution_logging_service, config_service, alerts_service, file_upload_feature, file_download_feature, secret)
def setUp(self): config_service = ConfigService().load_file("config/sim_standard.cfg") self.game = Game() self.referee = Referee self.game.set_referee(self.referee) self.tcsvc = TeamColorService(TeamColor.BLUE_TEAM) self.game.set_our_team_color(self.tcsvc.OUR_TEAM_COLOR) self.game_world_OK = ReferenceTransferObject(self.game) self.game_world_OK.set_team_color_svc(self.tcsvc) self.GameStateManager1 = GameState() self.GameStateManager2 = GameState() self.GameStateManager1.set_reference(self.game_world_OK)
def setUp(self): super().setUp() self.socket = None application = tornado.web.Application( [(r'/scripts/([^/]*)', ScriptConfigSocket)], login_url='/login.html', cookie_secret='12345') application.auth = TornadoAuth(None) application.authorizer = Authorizer(ANY_USER, [], [], EmptyGroupProvider()) application.identification = IpBasedIdentification( TrustedIpValidator(['127.0.0.1']), None) application.config_service = ConfigService(application.authorizer, test_utils.temp_folder) server = httpserver.HTTPServer(application) socket, self.port = testing.bind_unused_port() server.add_socket(socket) test_utils.setup() for dir in ['x', 'y', 'z']: for file in range(1, 4): filename = dir + str(file) + '.txt' test_utils.create_file( os.path.join('test1_files', dir, filename)) test1_files_path = os.path.join(test_utils.temp_folder, 'test1_files') test_utils.write_script_config( { 'name': 'Test script 1', 'script_path': 'ls', 'parameters': [ test_utils.create_script_param_config('text 1', required=True), test_utils.create_script_param_config( 'list 1', type='list', allowed_values=['A', 'B', 'C']), test_utils.create_script_param_config( 'file 1', type='server_file', file_dir=test1_files_path), test_utils.create_script_param_config( 'list 2', type='list', values_script='ls ' + test1_files_path + '/${file 1}') ] }, 'test_script_1')
def __init__(self, p_world_state: WorldState): """ initialise le PlayExecutor :param p_world_state: (WorldState) instance du worldstate """ super().__init__(p_world_state) cfg = ConfigService() self.auto_play = SimpleAutoPlay(self.ws) self.ws.play_state.autonomous_flag = cfg.config_dict["GAME"][ "autonomous_play"] == "true" self.last_time = 0 self.last_available_players = {} self.goalie_id = -1
def __init__(self, team_color: TeamColor): assert isinstance(team_color, TeamColor) self.players = {} self.available_players = {} for player_id in range(PLAYER_PER_TEAM): self.players[player_id] = Player(self, player_id) if player_id < 6: self.players[player_id].in_play = True self.available_players[player_id] = self.players[player_id] self.team_color = team_color self.score = 0 self.update_player = self._update_player if ConfigService().config_dict["IMAGE"]["kalman"] == "true": self.update_player = self._kalman_update
def get_pathfinder(self, type_of_pathfinder): assert isinstance(type_of_pathfinder, str) assert type_of_pathfinder.lower() in ["rrt", "astar", "path_part"] if type_of_pathfinder.lower() == "astar": return AsPathManager( self.ws, ConfigService().config_dict["GAME"]["type"] == "sim") elif type_of_pathfinder.lower() == "rrt": return PathfinderRRT(self.ws) elif type_of_pathfinder.lower() == "path_part": return PathPartitionner(self.ws) else: raise TypeError("Couldn't init a pathfinder with the type of ", type_of_pathfinder, "!")
def _create_teams(self): cfg = ConfigService() if cfg.config_dict["GAME"]["our_color"] == "blue": self.our_team_color == TeamColor.BLUE self.blue_team = OurTeam(TeamColor.BLUE) self.friends = self.blue_team self.yellow_team = Team(TeamColor.YELLOW) self.enemies = self.yellow_team elif cfg.config_dict["GAME"]["our_color"] == "yellow": self.our_team_color == TeamColor.YELLOW self.yellow_team = OurTeam(TeamColor.YELLOW) self.friends = self.yellow_team self.blue_team = Team(TeamColor.BLUE) self.enemies = self.blue_team else: raise ValueError("Config file contains wrong colors!")