def test_info(self): self.assertEqual(list(self.repo.info()), [ 'id', 'uid', 'user_id', 'namespace', 'name', 'slug', 'scm', 'git_http_url', 'git_ssh_url', 'link', 'default_branch', 'private', 'visibility', 'active', 'config_path', 'trusted', 'protected', 'ignore_forks', 'ignore_pull_requests', 'auto_cancel_pull_requests', 'auto_cancel_pushes', 'timeout', 'counter', 'synced', 'created', 'updated', 'version', 'permissions']) with self.assertRaises(requests.HTTPError) as err: Drone.Repo('tinvaan', 'foobar').info() self.assertEqual(err.response.status_code, 404) Drone.Repo('foobar', 'barfoo').info() self.assertEqual(err.response.status_code, 404)
def setUp(self): self.cron = Drone.Cron('tinvaan', 'drone-test-ci') self.cron.create(**{ 'name': 'nightly', 'expr': '0 0 1 * * *', 'branch': 'master' })
def make_drone(move_strategy, topology_sensors, destination=ExtractionPoint()): """ Makes a drone (factory method). Accepts either objects or Enums as arguments. We can use a variety of sensors, navigation strategies, and rules, and then we pass the chosen ones the dependencies they need, For example, the topology map is needed by everyone. :param destination: The Destination we're looking for, such as an ExtractionPoint :param move_strategy: either a MoveStrategy, a function, or Enum NavigationStrategyType :param topology_sensors: a list containing elements of either TopologySensor, or Enum TopologySensorType :return: """ # Map of known areas of the topology. In the future, we could persist this map and then # reuse it for this or any drone on subsequent missions topology_map = TopologyMap() # convert the passed-in sensor list to actual sensors in case enums were passed in sensors = [s if isinstance(s, TopologySensor) else DroneFactory.make_sensor(s) for s in topology_sensors] navigator = NavigatorFactory.make_navigator(topology_map=topology_map, move_strategy=move_strategy, destination=destination) return Drone(navigator, topology_sensors=sensors)
scores[idx] = score times[idx] = flight_time def thread_error_prompt(err): traceback.print_exception(type(err), err, err.__traceback__) raise type(err)(err) if __name__ == "__main__": # drone = Drone(visualize=False, n_servers=0) # sleep(2) # fly(drone) # exit() execution_time = int(time()) drones = [Drone(visualize=False, n_servers=0) for _ in range(n_drones)] scores = [0] * n_drones times = [0] * n_drones global_best_score = -np.Infinity global_best_drone = None thread_pool = ThreadPool(1) start_time = time() for gen in range(n_generations): generation_time = time() - start_time print(f"Time elapsed for last generation: {generation_time}") start_time = time() # TODO: find a way to do this in separate threads
def setUp(self): self.repo = Drone.Repo('tinvaan', 'drone-test-ci')
def test_all(self): self.assertGreater(len(self.repo.all()), 1) self.assertGreater(len(Drone.Repo('tinvaan', 'foobar').all()), 1) self.assertGreater(len(Drone.Repo('foobar', 'drone-ci-test').all()), 1)
def setUp(self): self.last = 1 self.build = Drone.Build('tinvaan', 'drone-test-ci') for build in self.build.all(): self.last = max(self.last, build.get('number'))
def fly( drone: Drone, timesteps: int = 2500, delta_t: float = 0.01, visualize=False, n_servers=0, punish_time=False, reward_time=True, idx=None, ): # print(f"flying in PID: {os.getpid()}") # initialize coin coin = Coin(np.array([[5], [5], [10]]), 2, 2000) # initialize drone position wind_speed = initial_wind_speed # set targets rot_targets = np.zeros((3, 1)) lin_targets = coin.position # initialize acceleration; drone should be free falling for now lab_lin_acc, lab_rot_acc = drone.quadcopter.calculate_accelerations( drone.angle, wind_speed, drone.thrust, lin_acc_drone_2_lab=True) for time in range(timesteps): real_time = time * delta_t if punish_time: drone.reward -= REWARD_TIME_PASSED if reward_time: drone.reward += REWARD_TIME_PASSED drone.flight_time += 1 collected_coin = coin.is_in_vicinity(drone.position) if collected_coin: drone.reward += coin.value drone.coins += 1 coin = Coin(coin.position + np.array([[5.0], [2.5], [0.0]]), 1, value=1000) # coin = Coin( # coin.position + (10 * np.random.random_sample(coin.position.shape)), # 1, # value=1000 # ) lin_targets = coin.position if visualize: drone.dh.new_setpoints(rot_targets, lin_targets) drone.dh.new_setpoints(rot_targets, lin_targets) drone.dh.new_setpoints(rot_targets, lin_targets) changed_setpoint = False if time % 10 == 0: changed_setpoint = True if visualize and changed_setpoint: drone.dh.new_setpoints(rot_targets, lin_targets) try: if not visualize and n_servers < 2: pass else: sleep(0.1) except KeyboardInterrupt: drone.dh.finish() is_crashed = drone.measure(wind_speed=wind_speed) if is_crashed: if visualize: drone.dh.finish(drone.reward, quit_program=False) drone.reward += REWARD_COIN_DISTANCE( coin.distance_drone_to_coin(drone.position)) drone.distance_to_coin = coin.distance_drone_to_coin( drone.position) return drone.reward, real_time, idx drone.translate_input_to_thrust(coin.position) if visualize: drone.status_update(real_time, lin_targets=coin.position) drone.new_data(real_time, wind_speed) if visualize: drone.dh.finish(drone.reward, quit_program=False) drone.reward += REWARD_COIN_DISTANCE( coin.distance_drone_to_coin(drone.position)) drone.distance_to_coin = coin.distance_drone_to_coin(drone.position) return drone.reward, real_time, idx