def _build_single_scenario(clean: bool, allow_offset_map: bool, scenario: str): click.echo(f"build-scenario {scenario}") if clean: _clean(scenario) scenario_root = Path(scenario) scenario_root_str = str(scenario_root) scenario_py = scenario_root / "scenario.py" if scenario_py.exists(): _install_requirements(scenario_root) subprocess.check_call([sys.executable, scenario_py]) from smarts.core.scenario import Scenario traffic_histories = Scenario.discover_traffic_histories(scenario_root_str) shift_to_origin = not allow_offset_map or bool(traffic_histories) map_spec = Scenario.discover_map(scenario_root_str, shift_to_origin=shift_to_origin) road_map, _ = map_spec.builder_fn(map_spec) if not road_map: click.echo( "No reference to a RoadNetwork file was found in {}, or one could not be created. " "Please make sure the path passed is a valid Scenario with RoadNetwork file required " "(or a way to create one) for scenario building.".format( scenario_root_str)) return road_map.to_glb(os.path.join(scenario_root, "map.glb"))
def __init__(self, config): print(">>> ENV: ", config["eval_mode"]) self.scenario_info = config["scenario_info"] self.scenarios = self.get_task(self.scenario_info[0], self.scenario_info[1]) self._timestep_sec = config["timestep_sec"] self._seed = config["seed"] if not config["eval_mode"]: _scenarios = glob.glob(f"{self.scenarios['train']}") else: _scenarios = glob.glob(f"{self.scenarios['test']}") config["scenarios"] = _scenarios self.ultra_scores = BaselineAdapter.reward_adapter super().__init__(config=config) if config["ordered_scenarios"]: scenario_roots = [] for root in config["scenarios"]: if Scenario.is_valid_scenario(root): # The case that this is a scenario root scenario_roots.append(root) else: # The case that there this is a directory of scenarios: find each of the roots scenario_roots.extend(Scenario.discover_scenarios(root)) # Also see `smarts.env.HiwayEnv` self._scenarios_iterator = cycle( Scenario.variations_for_all_scenario_roots( scenario_roots, list(config["agent_specs"].keys())))
def spawn_sumo(worker_idx, batch_id): sumo_sim = SumoTrafficSimulation(headless=True) scenarios_iterator = Scenario.scenario_variations( ["scenarios/loop"], ["Agent007"], ) sumo_sim.setup(Scenario.next(scenarios_iterator, f"{batch_id}-{worker_idx}")) sumo_sim.teardown()
def main(scenarios, headless, seed): scenarios_iterator = Scenario.scenario_variations(scenarios, []) for _ in scenarios: scenario = next(scenarios_iterator) agent_missions = scenario.discover_missions_of_traffic_histories() for agent_id, mission in agent_missions.items(): scenario.set_ego_missions({agent_id: mission}) agent_spec = AgentSpec( interface=AgentInterface.from_type(AgentType.Laner, max_episode_steps=None), agent_builder=KeepLaneAgent, ) agent = agent_spec.build_agent() smarts = SMARTS( agent_interfaces={agent_id: agent_spec.interface}, traffic_sim=SumoTrafficSimulation(headless=True, auto_start=True), envision=Envision(), ) observations = smarts.reset(scenario) dones = {agent_id: False} while not dones[agent_id]: agent_obs = observations[agent_id] agent_action = agent.act(agent_obs) observations, rewards, dones, infos = smarts.step( {agent_id: agent_action})
def scenarios(): with temp_scenario(name="straight", map="maps/straight.net.xml") as scenario_root: traffic = t.Traffic(flows=[ t.Flow( route=t.Route( begin=("west", 1, 0), end=("east", 1, "max"), ), rate=50, actors={t.TrafficActor("car"): 1}, ) ]) missions = [ t.Mission( t.Route(begin=("west", 1, 10), end=("east", 1, "max")), entry_tactic=t.TrapEntryTactic( wait_to_hijack_limit_s=3, zone=t.MapZone(start=("west", 0, 1), length=100, n_lanes=3), ), ) ] scenario = t.Scenario( traffic={"all": traffic}, ego_missions=missions, ) gen_scenario(scenario, output_dir=scenario_root) yield Scenario.variations_for_all_scenario_roots([str(scenario_root)], [AGENT_ID])
def two_agent_capture_offset_tenth_of_second(): with temp_scenario(name="straight", map="maps/straight.net.xml") as scenario_root: missions = [ t.Mission( t.Route(begin=("west", 1, 20), end=("east", 1, "max")), entry_tactic=t.TrapEntryTactic( wait_to_hijack_limit_s=0, zone=t.MapZone(start=("west", 0, 1), length=100, n_lanes=3), ), ), t.Mission( t.Route(begin=("west", 2, 10), end=("east", 1, "max")), entry_tactic=t.TrapEntryTactic( wait_to_hijack_limit_s=0.1, zone=t.MapZone(start=("west", 0, 1), length=100, n_lanes=3), ), ), ] scenario = t.Scenario( traffic={}, ego_missions=missions, ) gen_scenario(scenario, output_dir=scenario_root) yield Scenario.variations_for_all_scenario_roots( [str(scenario_root)], [AGENT_ID, AGENT_ID_2])
def test_scenario_variations_of_social_agents(scenario_root): iterator = Scenario.variations_for_all_scenario_roots( [str(scenario_root)], [AGENT_ID] ) scenarios = list(iterator) assert len(scenarios) == 6, "3 social agents x 2 missions each " for s in scenarios: assert len(s.social_agents) == 4, "4 social agents" assert len(s.missions) == 5, "4 missions for social agents + 1 for ego" # Ensure correct social agents are being spawned all_social_agent_ids = set() for s in scenarios: all_social_agent_ids |= set(s.social_agents.keys()) groups = ["group-1", "group-2", "group-3", "group-4"] speeds = [10, 30, 80] expected_social_agent_ids = { SocialAgentId.new(f"non-interactive-agent-{speed}-v0", group=group) for group, speed in itertools.product(groups, speeds) } assert ( len(all_social_agent_ids - expected_social_agent_ids) == 0 ), "All the correct social agent IDs were used"
def __init__(self, config): seed = int(config.get("seed", 42)) # See https://rllib.readthedocs.io/en/latest/rllib-env.html#configuring-environments # for context. We combine worker_index and vector_index through the Cantor pairing # function (https://en.wikipedia.org/wiki/Pairing_function) into a unique integer # and then add that to seed to both differentiate environment instances and # preserve determinism. a = config.worker_index b = config.vector_index c = (a + b) * (a + b + 1) // 2 + b smarts.core.seed(seed + c) self._agent_specs = config["agent_specs"] self._scenarios_iterator = Scenario.scenario_variations( config["scenarios"], list(self._agent_specs.keys()), ) self._sim_name = config.get("sim_name", None) self._headless = config.get("headless", False) self._num_external_sumo_clients = config.get( "num_external_sumo_clients", 0) self._sumo_headless = config.get("sumo_headless", True) self._sumo_port = config.get("sumo_port") self._sumo_auto_start = config.get("sumo_auto_start", True) self._endless_traffic = config.get("endless_traffic", True) self._envision_endpoint = config.get("envision_endpoint", None) self._envision_record_data_replay_path = config.get( "envision_record_data_replay_path", None) self._timestep_sec = config.get("timestep_sec", 0.1) self._smarts = None # Created on env.setup() self._dones_registered = 0
def scenarios(): with temp_scenario(name="straight", map="maps/straight.net.xml") as scenario_root: ego_missions = [ # missions of laner and buddha t.Mission( t.Route( begin=("west", 0, 30), end=("east", 0, "max"), ) ), t.Mission( t.Route( begin=("west", 0, 40), end=("east", 0, "max"), ) ), ] gen_scenario( t.Scenario(ego_missions=ego_missions), output_dir=scenario_root, ) yield Scenario.variations_for_all_scenario_roots( [str(scenario_root)], [AGENT_1, AGENT_2] )
def main(scenarios, headless, seed): agent_spec = AgentSpec( interface=AgentInterface.from_type(AgentType.Laner, max_episode_steps=None), agent_builder=None, observation_adapter=None, ) smarts = SMARTS( agent_interfaces={}, traffic_sim=SumoTrafficSimulation(headless=True, auto_start=True), envision=Envision(), ) scenarios_iterator = Scenario.scenario_variations( scenarios, list([]), ) smarts.reset(next(scenarios_iterator)) for _ in range(5000): smarts.step({}) smarts.attach_sensors_to_vehicles( agent_spec, smarts.vehicle_index.social_vehicle_ids()) obs, _, _, _ = smarts.observe_from( smarts.vehicle_index.social_vehicle_ids())
def __init__(self, config): self._config = config # XXX: These are intentionally left public at PyMARL's request self.n_agents = config.get("n_agents", 1) self.episode_limit = config.get("episode_limit", 1000) self.observation_space = config.get("observation_space", DEFAULT_OBSERVATION_SPACE) self.action_space = config.get("action_space", DEFAULT_ACTION_SPACE) self.state_space = config.get("state_space", DEFAULT_STATE_SPACE) self._agent_ids = ["Agent %i" % i for i in range(self.n_agents)] self._reward_adapter = config.get("reward_adapter", default_reward_adapter) self._observation_adapter = config.get("observation_adapter", default_obs_adapter) self._action_adapter = config.get("action_adapter", default_action_adapter) self._done_adapter = config.get("done_adapter", lambda dones: list(dones.values())) self._state_adapter = config.get("state_adapter", default_state_adapter) self._headless = config.get("headless", False) self._timestep_sec = config.get("timestep_sec", 0.01) self._observations = None self._state = None self._steps = 0 seed = self._config.get("seed", 42) smarts.core.seed(seed) self._scenarios_iterator = Scenario.scenario_variations( config["scenarios"], self._agent_ids) agent_interfaces = { agent_id: AgentInterface.from_type( config.get("agent_type", AgentType.Laner), max_episode_steps=self.episode_limit, debug=config.get("debug", False), ) for i, agent_id, in enumerate(self._agent_ids) } envision = None if not self._headless: envision = Envision( endpoint=config.get("envision_endpoint", None), output_dir=config.get("envision_record_data_replay_path", None), ) self._smarts = SMARTS( agent_interfaces=agent_interfaces, traffic_sim=SumoTrafficSimulation( time_resolution=self._timestep_sec), envision=envision, timestep_sec=self._timestep_sec, )
def main(scenario): scenario_path = Path(scenario).absolute() agent_mission_count = Scenario.discover_agent_missions_count(scenario_path) assert agent_mission_count > 0, "agent mission count should larger than 0" agent_ids = [f"AGENT-{i}" for i in range(agent_mission_count)] agent_specs = { agent_id: AgentSpec( interface=AgentInterface.from_type(AgentType.Laner, max_episode_steps=None), agent_builder=RuleBasedAgent, ) for agent_id in agent_ids } agents = {aid: agent_spec.build_agent() for aid, agent_spec in agent_specs.items()} env = HiWayEnv(scenarios=[scenario_path], agent_specs=agent_specs) while True: observations = env.reset() done = False while not done: agent_ids = list(observations.keys()) actions = {aid: agents[aid].act(observations[aid]) for aid in agent_ids} observations, _, dones, _ = env.step(actions) done = dones["__all__"]
def __init__( self, scenarios: Sequence[str], agent_specs, shuffle_scenarios=True, headless=False, visdom=False, timestep_sec=0.1, seed=42, num_external_sumo_clients=0, sumo_headless=True, sumo_port=None, sumo_auto_start=True, endless_traffic=True, envision_endpoint=None, envision_record_data_replay_path=None, zoo_workers=None, auth_key=None, ): self._log = logging.getLogger(self.__class__.__name__) smarts.core.seed(seed) self._agent_specs = agent_specs self._dones_registered = 0 self._scenarios_iterator = Scenario.scenario_variations( scenarios, list(agent_specs.keys()), shuffle_scenarios, ) agent_interfaces = { agent_id: agent.interface for agent_id, agent in agent_specs.items() } envision_client = None if not headless: envision_client = Envision( endpoint=envision_endpoint, output_dir=envision_record_data_replay_path ) visdom_client = None if visdom: visdom_client = VisdomClient() self._smarts = SMARTS( agent_interfaces=agent_interfaces, traffic_sim=SumoTrafficSimulation( headless=sumo_headless, time_resolution=timestep_sec, num_external_sumo_clients=num_external_sumo_clients, sumo_port=sumo_port, auto_start=sumo_auto_start, endless_traffic=endless_traffic, ), envision=envision_client, visdom=visdom_client, timestep_sec=timestep_sec, zoo_workers=zoo_workers, auth_key=auth_key, )
def __init__( self, agent_specs, scenario_info, headless, timestep_sec, seed, eval_mode=False, ordered_scenarios=False, ): self.timestep_sec = timestep_sec self.headless = headless self.scenario_info = scenario_info self.scenarios = self.get_task(scenario_info[0], scenario_info[1]) if not eval_mode: _scenarios = glob.glob(f"{self.scenarios['train']}") else: _scenarios = glob.glob(f"{self.scenarios['test']}") self.smarts_observations_stack = deque(maxlen=_STACK_SIZE) super().__init__( scenarios=_scenarios, agent_specs=agent_specs, headless=headless, timestep_sec=timestep_sec, seed=seed, visdom=False, ) if ordered_scenarios: scenario_roots = [] for root in _scenarios: if Scenario.is_valid_scenario(root): # The case that this is a scenario root scenario_roots.append(root) else: # The case that there this is a directory of scenarios: find each of the roots scenario_roots.extend(Scenario.discover_scenarios(root)) # Also see `smarts.env.HiwayEnv` self._scenarios_iterator = cycle( Scenario.variations_for_all_scenario_roots( scenario_roots, list(agent_specs.keys()) ) )
def scenarios(bubble): with temp_scenario(name="straight", map="maps/straight.net.xml") as scenario_root: gen_scenario( t.Scenario(traffic={}, bubbles=[bubble]), output_dir=scenario_root, ) yield Scenario.variations_for_all_scenario_roots([str(scenario_root)], [])
def scenarios(): mission = Mission(start=Start((71.65, 63.78), Heading(math.pi * 0.91)), goal=EndlessGoal()) scenario = Scenario( scenario_root="scenarios/loop", route="basic.rou.xml", missions={"Agent-007": mission}, ) return cycle([scenario])
def smarts(): smarts_ = SMARTS( agent_interfaces={}, traffic_sim=mock.Mock(), ) scenario = next( Scenario.scenario_variations(["scenarios/intersections/4lane_t"], ["Agent-007"])) smarts_.reset(scenario) return smarts_
def scenarios(request): with temp_scenario(name="map", map=request.param[0]) as scenario_root: mission = t.Mission(route=t.Route(begin=("edge-west-WE", 0, 10), end=(request.param[1], 0, 40))) gen_scenario( t.Scenario(ego_missions=[mission]), output_dir=scenario_root, ) yield Scenario.variations_for_all_scenario_roots([str(scenario_root)], [AGENT_ID])
def _check_reset(self) -> Optional[Dict[str, Observation]]: with self._reset_lock: if self._reset_msg: self._scenario_path = self._reset_msg.scenario rospy.loginfo( f"resetting SMARTS w/ scenario={self._scenario_path}") self._reset_msg = None self._last_step_time = None self._recent_state = deque(maxlen=3) self._most_recent_state_sent = None self._warned_about_freq = False map_spec = self._get_map_spec() routes = Scenario.discover_routes( self._scenario_path) or [None] return self._smarts.reset( Scenario(self._scenario_path, map_spec=map_spec, route=routes[0])) return None
def __init__( self, scenarios: Sequence[str], agent_specs, visdom=False, headless=False, timestep_sec=0.1, seed=42, num_external_sumo_clients=0, sumo_headless=True, sumo_port=None, sumo_auto_start=True, endless_traffic=True, envision_endpoint=None, envision_record_data_replay_path=None, ): self._log = logging.getLogger(self.__class__.__name__) smarts.core.seed(seed) self._visdom_obs_queue = None if visdom: self._log.debug("Running with visdom") self._visdom_obs_queue = build_visdom_watcher_queue() self._agent_specs = agent_specs self._dones_registered = 0 self._scenarios_iterator = Scenario.scenario_variations( scenarios, list(agent_specs.keys()), ) agent_interfaces = { agent_id: agent.interface for agent_id, agent in agent_specs.items() } envision = None if not headless: envision = Envision(endpoint=envision_endpoint, output_dir=envision_record_data_replay_path) self._smarts = SMARTS( agent_interfaces=agent_interfaces, traffic_sim=SumoTrafficSimulation( headless=sumo_headless, time_resolution=timestep_sec, num_external_sumo_clients=num_external_sumo_clients, sumo_port=sumo_port, auto_start=sumo_auto_start, endless_traffic=endless_traffic, ), envision=envision, timestep_sec=timestep_sec, )
def scenario(): mission = Mission( start=Start(np.array([71.65, 63.78]), Heading(math.pi * 0.91)), goal=EndlessGoal(), ) scenario = Scenario( scenario_root="scenarios/loop", route="basic.rou.xml", missions={AGENT_ID: mission}, ) return scenario
def scenario(): with temp_scenario(name="map", map="maps/straight.net.xml") as scenario_root: mission = t.Mission(route=t.Route( begin=("west", 1, 99.9), end=("east", 1, 10.0), )) gen_scenario( t.Scenario(ego_missions=[mission]), output_dir=scenario_root, ) yield Scenario.variations_for_all_scenario_roots([str(scenario_root)], [AGENT_ID])
def gen_config(**kwargs): scenario_path = Path(kwargs["scenario"]).absolute() agent_missions_count = Scenario.discover_agent_missions_count( scenario_path) if agent_missions_count == 0: agent_ids = ["default_policy"] else: agent_ids = [f"AGENT-{i}" for i in range(agent_missions_count)] config = load_config(kwargs["config_file"], mode=kwargs.get("mode", "training")) agents = {agent_id: AgentSpec(**config["agent"]) for agent_id in agent_ids} config["env_config"].update({ "seed": 42, "scenarios": [str(scenario_path)], "headless": kwargs["headless"], "agent_specs": agents, }) obs_space, act_space = config["policy"][1:3] tune_config = config["run"]["config"] if kwargs["paradigm"] == "centralized": config["env_config"].update({ "obs_space": gym.spaces.Tuple([obs_space] * agent_missions_count), "act_space": gym.spaces.Tuple([act_space] * agent_missions_count), "groups": { "group": agent_ids }, }) tune_config.update(config["policy"][-1]) else: policies = {} for k in agents: policies[k] = config["policy"][:-1] + ({ **config["policy"][-1], "agent_id": k }, ) tune_config.update({ "multiagent": { "policies": policies, "policy_mapping_fn": lambda agent_id: agent_id, } }) return config
def main(scenarios: Sequence[str], headless: bool, seed: int): agent_spec = AgentSpec( interface=AgentInterface.from_type(AgentType.Laner, max_episode_steps=None), agent_builder=None, observation_adapter=None, ) smarts = SMARTS( agent_interfaces={}, traffic_sim=SumoTrafficSimulation(headless=headless, auto_start=True), envision=None if headless else Envision(), ) scenarios_iterator = Scenario.scenario_variations( scenarios, list([]), ) scenario = next(scenarios_iterator) obs = smarts.reset(scenario) collected_data = {} _record_data(smarts.elapsed_sim_time, obs, collected_data) # could also include "motorcycle" or "truck" in this set if desired vehicle_types = frozenset({"car"}) while True: smarts.step({}) current_vehicles = smarts.vehicle_index.social_vehicle_ids( vehicle_types=vehicle_types) if collected_data and not current_vehicles: print("no more vehicles. exiting...") break smarts.attach_sensors_to_vehicles(agent_spec, current_vehicles) obs, _, _, dones = smarts.observe_from(current_vehicles) _record_data(smarts.elapsed_sim_time, obs, collected_data) # an example of how we might save the data per car for car, data in collected_data.items(): outfile = f"data_{scenario.name}_{scenario.traffic_history.name}_{car}.pkl" with open(outfile, "wb") as of: pickle.dump(data, of) smarts.destroy()
def uturn_scenarios(): with temp_scenario(name="straight", map="maps/6lane.net.xml") as scenario_root: ego_missions = [ t.Mission( route=t.Route(begin=("edge-west-WE", 0, 30), end=("edge-west-EW", 0, "max")), task=t.UTurn(), ), ] gen_scenario( t.Scenario(ego_missions=ego_missions), output_dir=scenario_root, ) yield Scenario.variations_for_all_scenario_roots([str(scenario_root)], [AGENT_ID])
def main(scenarios, headless, seed): scenarios_iterator = Scenario.scenario_variations(scenarios, []) smarts = SMARTS( agent_interfaces={}, traffic_sim=None, envision=None if headless else Envision(), ) for _ in scenarios: scenario = next(scenarios_iterator) agent_missions = scenario.discover_missions_of_traffic_histories() for agent_id, mission in agent_missions.items(): agent_spec = AgentSpec( interface=AgentInterface.from_type(AgentType.LanerWithSpeed, max_episode_steps=None), agent_builder=KeepLaneAgent, agent_params=scenario.traffic_history_target_speed, ) agent = agent_spec.build_agent() # Take control of vehicle with corresponding agent_id smarts.switch_ego_agent({agent_id: agent_spec.interface}) # tell the traffic history provider to start traffic # at the point when this agent enters... traffic_history_provider = smarts.get_provider_by_type( TrafficHistoryProvider) assert traffic_history_provider traffic_history_provider.start_time = mission.start_time # agent vehicle will enter right away... modified_mission = replace(mission, start_time=0.0) scenario.set_ego_missions({agent_id: modified_mission}) observations = smarts.reset(scenario) dones = {agent_id: False} while not dones.get(agent_id, True): agent_obs = observations[agent_id] agent_action = agent.act(agent_obs) observations, rewards, dones, infos = smarts.step( {agent_id: agent_action}) smarts.destroy()
def main(scenarios, headless, seed): agent_spec = AgentSpec( interface=AgentInterface.from_type(AgentType.Laner, max_episode_steps=None), agent_builder=None, observation_adapter=None, ) smarts = SMARTS( agent_interfaces={}, traffic_sim=SumoTrafficSimulation(headless=headless, auto_start=True), envision=None if headless else Envision(), ) scenarios_iterator = Scenario.scenario_variations( scenarios, list([]), ) smarts.reset(next(scenarios_iterator)) prev_vehicles = set() done_vehicles = set() for _ in range(5000): smarts.step({}) current_vehicles = smarts.vehicle_index.social_vehicle_ids() # We explicitly watch for which agent/vehicles left the simulation here # since we don't have a "done criteria" that detects when a vehicle's # traffic history has played itself out. done_vehicles = prev_vehicles - current_vehicles prev_vehicles = current_vehicles smarts.attach_sensors_to_vehicles(agent_spec, current_vehicles) obs, _, _, dones = smarts.observe_from(current_vehicles) # The `dones` returned above should be empty for traffic histories # where all vehicles are assumed to stay on the road and not collide. # TODO: add the following assert once the maps are accurate enough that # we don't have any agents accidentally go off-road. # assert not done for v in done_vehicles: dones[f"Agent-{v}"] = True # TODO: save observations for imitation learning smarts.destroy()
def scenarios(): with temp_scenario(name="6lane", map="maps/6lane.net.xml") as scenario_root: actors = [ t.SocialAgentActor( name=f"non-interactive-agent-{speed}-v0", agent_locator="zoo.policies:non-interactive-agent-v0", policy_kwargs={"speed": speed}, ) for speed in [10, 30, 80] ] def to_mission(start_edge, end_edge): route = t.Route(begin=(start_edge, 1, 0), end=(end_edge, 1, "max")) return t.Mission(route=route) def fifth_mission(start_edge, end_edge): route = t.Route(begin=(start_edge, 0, 0), end=(end_edge, 0, "max")) return t.Mission(route=route) gen_scenario( t.Scenario( social_agent_missions={ "group-1": (actors, [to_mission("edge-north-NS", "edge-south-NS")]), "group-2": (actors, [to_mission("edge-west-WE", "edge-east-WE")]), "group-3": (actors, [to_mission("edge-east-EW", "edge-west-EW")]), "group-4": (actors, [to_mission("edge-south-SN", "edge-north-SN")]), "group-5": ( actors, [fifth_mission("edge-south-SN", "edge-east-WE")], ), }, ego_missions=[ t.Mission( t.Route( begin=("edge-west-WE", 0, 0), end=("edge-east-WE", 0, "max") ) ) ], ), output_dir=scenario_root, ) yield Scenario.variations_for_all_scenario_roots( [str(scenario_root)], [AGENT_1] )
def test_mutiple_traffic_data(create_scenario, create_history_files): Scenario.discover_traffic_histories = MagicMock( return_value=create_history_files) iterator = Scenario.variations_for_all_scenario_roots( [str(create_scenario)], [AGENT_ID], shuffle_scenarios=False) scenarios = list(iterator) assert len(scenarios) == 8 # 2 social agents x 2 missions x 2 histories traffic_history_provider = TrafficHistoryProvider() for scenario, traffic_history in zip( scenarios, [traffic_history_1, traffic_history_2]): for key in scenario.traffic_history_service.traffic_history: assert (scenario.traffic_history_service.traffic_history[key] == traffic_history[key]) traffic_history_provider.setup(scenario) assert (traffic_history_provider._traffic_history_service == scenario.traffic_history_service)
def scenarios(bubble): with temp_scenario(name="straight", map="maps/straight.net.xml") as scenario_root: traffic = t.Traffic( flows=[ t.Flow( route=t.Route( begin=("west", lane_idx, 0), end=("east", lane_idx, "max"), ), rate=50, actors={t.TrafficActor("car"): 1,}, ) for lane_idx in range(3) ] ) gen_scenario( t.Scenario(traffic={"all": traffic}, bubbles=[bubble]), output_dir=scenario_root, ) yield Scenario.variations_for_all_scenario_roots([str(scenario_root)], [])