Can not run CARLA Simulattor while running the following script for improvised traffic manager about carla HOT 9 OPEN

import carla
import random
import time
import pandas as pd

# Connect to the client and retrieve the world object
client = carla.Client('localhost', 2000)
client.set_timeout(10.0)  # Set a timeout for client commands
client.reload_world()

world = client.get_world()

# Set up the simulator in synchronous mode
settings = world.get_settings()
settings.synchronous_mode = True  # Enables synchronous mode
# settings.fixed_delta_seconds = 0.01
world.apply_settings(settings)

# traffic_lights = world.get_actors().filter('traffic.traffic_light')

# Set up the TM in synchronous mode
traffic_manager = client.get_trafficmanager()
traffic_manager.set_synchronous_mode(True)

# # Set a seed so behaviour can be repeated if necessary
# traffic_manager.set_random_device_seed(0)
# random.seed(0)

actors = world.get_actors()


def get_traffic_lights(world):
    actors = world.get_actors()
    traffic_lights = actors.filter('traffic.traffic_light')
    return traffic_lights


def get_traffic_density(traffic_light, radius=50):
    vehicles = world.get_actors().filter('vehicle.*')
    density = 0
    for vehicle in vehicles:
        if vehicle.get_location().distance(traffic_light.get_location()) < radius:
            density += 1
    return density


# def savedata():
#     density_data = []
#     start_time = time.time()
#     for traffic_light in traffic_lights:
#         density = get_traffic_density(traffic_light)
#         elapse_time = time.time() - start_time
#         density_data.append({'Time': elapse_time, 'Traffic Light': traffic_light.id, 'Density': density})
#
#     df = pd.DataFrame(density_data)
#     df.to_excel('Traffic_light_density_data.xlsx', index=False)

# def set_traffic_light_state(traffic_light, state, green_duration=20):
#     # traffic_light.set_state(state)
#     # traffic_light.set_green_time(duration if state == carla.TrafficLightState.Green else 0)
#     # traffic_light.set_green_time(duration)
#     # traffic_light.set_yellow_time(3.0)
#     # traffic_light.set_red_time(duration if state == carla.TrafficLightState.Red else 0)
#     traffic_light.set_state(state)
#     if state == carla.TrafficLightState.Green:
#         traffic_light.set_green_time(green_duration)
#         traffic_light.set_yellow_time(3.0)
#         traffic_light.set_red_time(1.0)
#     else:
#         traffic_light.set_green_time(0)
#         traffic_light.set_yellow_time(0)
#         traffic_light.set_red_time(green_duration + 3.0)
def set_traffic_light_state(traffic_light, state, duration=20):
    traffic_light.set_state(state)
    # traffic_light.set_green_time(duration if state == carla.TrafficLightState.Green else 0)
    traffic_light.set_green_time(duration)


def savedata(density_data):
    df = pd.DataFrame(density_data)
    df.to_excel('Traffic_light_density_data.xlsx', index=False)


def control_traffic_lights(world, check_interval=20, density_threshold=5, green_duration=20):
    traffic_lights = get_traffic_lights(world)
    density_data = []
    start_time = time.time()

    try:
        while True:
            world.tick()
            for traffic_light in traffic_lights:
                density = get_traffic_density(traffic_light, radius=50)
                elapsed_time = time.time() - start_time
                density_data.append({'Time': elapsed_time, 'Traffic Light': traffic_light.id, 'Density': density})

                if density > density_threshold:
                    # if (traffic_light.)
                    set_traffic_light_state(traffic_light, carla.TrafficLightState.Green, green_duration)
                    print(
                        f"Traffic light at {traffic_light.get_location()} turned green for {green_duration} seconds due "
                        f"to high traffic density.")
                    # world.debug.draw_point(traffic_light.get_location(), 0.1)
                    # # time.sleep(green_duration + 1.0)  # Include the yellow light duration
                    # set_traffic_light_state(traffic_light, carla.TrafficLightState.Red, green_duration)
                else:
                    set_traffic_light_state(traffic_light, carla.TrafficLightState.Red, 10)
                    print(
                        f"Traffic light at {traffic_light.get_location()} turned red")
            # time.sleep(check_interval)
    except KeyboardInterrupt:
        print("Terminating the control loop")
        savedata(density_data)
        for i in vehicles:
            i.destroy()
            # world.tick()
        # time.sleep(0.02)
    # time.sleep(check_interval)


# We will also set up the spectator
spectator = world.get_spectator()

spawn_points = world.get_map().get_spawn_points()

# Select some models from the blueprint library
models = ['dodge', 'audi', 'model3', 'mini', 'mustang', 'lincoln', 'prius', 'nissan', 'crown', 'impala']
blueprints = []
# blueprints = world.get_blueprint_library().filter('vehicle.*')
for vehicle in world.get_blueprint_library().filter('vehicle.*'):
    if any(model in vehicle.id for model in models):
        blueprints.append(vehicle)

# Routes with their respective spawn points and indices
routes = [
    ([32], [129, 28, 137, 101, 57, 58, 154, 147]),
    ([149], [21, 105, 134, 52, 86, 120, 4, 121]),
    ([147], [72, 146, 126, 99, 108, 68, 24]),
    ([106], [85, 1, 104, 67, 140, 10, 143])
]

# Assign vehicle counts to each route
route_vehicle_counts = [30, 25, 20, 15]
total_vehicles = sum(route_vehicle_counts)

# Set a max number of vehicles and prepare a list for those we spawn
# max_vehicles = total_vehicles
max_vehicles = min([total_vehicles, len(spawn_points)])
vehicles = []

# Take a random sample of the spawn points and spawn some vehicles
for i, spawn_point in enumerate(random.sample(spawn_points, max_vehicles)):
    temp = world.try_spawn_actor(random.choice(blueprints), spawn_point)
    if temp is not None:
        vehicles.append(temp)

route_1 = []
route_2 = []
route_3 = []
route_4 = []

# Prepare route locations
# route_locations = []
count = 0
for spawn_point, indices in routes:
    if count == 0:
        route_1.append(spawn_points[spawn_point[0]].location)
        # route = [spawn_points[spawn_point[0]].location]
        for ind in indices:
            route_1.append(spawn_points[ind].location)
    if count == 1:
        route_2.append(spawn_points[spawn_point[0]].location)
        # route = [spawn_points[spawn_point[0]].location]
        for ind in indices:
            route_2.append(spawn_points[ind].location)
    if count == 2:
        route_3.append(spawn_points[spawn_point[0]].location)
        # route = [spawn_points[spawn_point[0]].location]
        for ind in indices:
            route_3.append(spawn_points[ind].location)
    if count == 3:
        route_4.append(spawn_points[spawn_point[0]].location)
        # route = [spawn_points[spawn_point[0]].location]
        for ind in indices:
            route_4.append(spawn_points[ind].location)
    count += 1
    # route_locations.append(route)

# Assign vehicles to routes
assigned_vehicles = {
    0: [],  # Vehicles for route 1
    1: [],  # Vehicles for route 2
    2: [],  # Vehicles for route 3
    3: []  # Vehicles for route 4
}

vehicle_idx = 0
for route_idx, count in enumerate(route_vehicle_counts):
    for _ in range(count):
        if vehicle_idx < len(vehicles):
            assigned_vehicles[route_idx].append(vehicles[vehicle_idx])
            vehicle_idx += 1
    vehicle_idx = 0

print(route_1)

# Assign routes to vehicles
for route_idx, vehicle_list in assigned_vehicles.items():
    if route_idx == 0:
        for vehicle in vehicle_list:
            traffic_manager.set_path(vehicle, route_1)
            vehicle.set_autopilot(True)
            # Randomly set the probability that a vehicle will ignore traffic lights
            # traffic_manager.ignore_lights_percentage(vehicle, random.randint(0, 50))
    elif route_idx == 1:
        for vehicle in vehicle_list:
            traffic_manager.set_path(vehicle, route_2)
            vehicle.set_autopilot(True)
    elif route_idx == 2:
        for vehicle in vehicle_list:
            traffic_manager.set_path(vehicle, route_3)
            vehicle.set_autopilot(True)
    elif route_idx == 3:
        for vehicle in vehicle_list:
            traffic_manager.set_path(vehicle, route_4)
            vehicle.set_autopilot(True)
# while True:
#     world.tick()  # Advance the simulation by one tick

# if __name__ == '__main__':
#     main()
# try:
#     control_traffic_lights(traffic_lights, density_threshold=5, green_duration=20)
# except KeyboardInterrupt:
#     for i in vehicles:
#         i.destroy()

control_traffic_lights(world)