code: def main():
      argparser = argparse.ArgumentParser(description=__doc__)
      argparser.add_argument(
          "--host",
          metavar="H",
          default="127.0.0.1",
          help="IP of the host server (default: 127.0.0.1)",
      )
      argparser.add_argument(
          "-p",
          "--port",
          metavar="P",
          default=2000,
          type=int,
          help="TCP port to listen to (default: 2000)",
      )
      argparser.add_argument(
          "-n",
          "--number-of-vehicles",
          metavar="N",
          default=10,
          type=int,
          help="number of vehicles (default: 10)",
      )
      argparser.add_argument(
          "-d",
          "--delay",
          metavar="D",
          default=2.0,
          type=float,
          help="delay in seconds between spawns (default: 2.0)",
      )
      argparser.add_argument(
          "--safe",
          action="store_true",
          help="avoid spawning vehicles prone to accidents",
      )
      argparser.add_argument(
          "-f",
          "--recorder_filename",
          metavar="F",
          default="test1.log",
          help="recorder filename (test1.log)",
      )
      argparser.add_argument(
          "-t",
          "--recorder_time",
          metavar="T",
          default=0,
          type=int,
          help="recorder duration (auto-stop)",
      )
      args = argparser.parse_args()
  
      actor_list = []
      logging.basicConfig(
          format="%(levelname)s: %(message)s", level=logging.INFO
      )
  
      try:
          client = carla.Client(args.host, args.port)
          client.set_timeout(2.0)
          world = client.get_world()
          blueprints = world.get_blueprint_library().filter("vehicle.*")
  
          spawn_points = world.get_map().get_spawn_points()
          random.shuffle(spawn_points)
  
          print("found %d spawn points." % len(spawn_points))
  
          count = args.number_of_vehicles
  
          print(
              "Recording on file: %s"
              % client.start_recorder(args.recorder_filename)
          )
  
          if args.safe:
              blueprints = [
                  x
                  for x in blueprints
                  if int(x.get_attribute("number_of_wheels")) == 4
              ]
              blueprints = [
                  x
                  for x in blueprints
                  if not x.id.endswith("microlino")
              ]
              blueprints = [
                  x
                  for x in blueprints
                  if not x.id.endswith("carlacola")
              ]
              blueprints = [
                  x
                  for x in blueprints
                  if not x.id.endswith("cybertruck")
              ]
              blueprints = [
                  x for x in blueprints if not x.id.endswith("t2")
              ]
              blueprints = [
                  x for x in blueprints if not x.id.endswith("sprinter")
              ]
              blueprints = [
                  x
                  for x in blueprints
                  if not x.id.endswith("firetruck")
              ]
              blueprints = [
                  x
                  for x in blueprints
                  if not x.id.endswith("ambulance")
              ]
  
          spawn_points = world.get_map().get_spawn_points()
          number_of_spawn_points = len(spawn_points)
  
          if count < number_of_spawn_points:
              random.shuffle(spawn_points)
          elif count > number_of_spawn_points:
              msg = "requested %d vehicles, but could only find %d spawn points"
              logging.warning(msg, count, number_of_spawn_points)
              count = number_of_spawn_points
  
          # @todo cannot import these directly.
          SpawnActor = carla.command.SpawnActor
          SetAutopilot = carla.command.SetAutopilot
          FutureActor = carla.command.FutureActor
  
          batch = []
          for n, transform in enumerate(spawn_points):
              if n >= count:
                  break
              blueprint = random.choice(blueprints)
              if blueprint.has_attribute("color"):
                  color = random.choice(
                      blueprint.get_attribute(
                          "color"
                      ).recommended_values
                  )
                  blueprint.set_attribute("color", color)
              blueprint.set_attribute("role_name", "autopilot")
              batch.append(
                  SpawnActor(blueprint, transform).then(
                      SetAutopilot(FutureActor, True)
                  )
              )
  
          for response in client.apply_batch_sync(batch):
              if response.error:
                  logging.error(response.error)
              else:
                  actor_list.append(response.actor_id)
  
          print(
              "spawned %d vehicles, press Ctrl+C to exit."
              % len(actor_list)
          )
  
          if args.recorder_time > 0:
              time.sleep(args.recorder_time)
          else:
              while True:
                  world.wait_for_tick()
                  # time.sleep(0.1)
  
      finally:
          print("\ndestroying %d actors" % len(actor_list))
          client.apply_batch_sync(
              [carla.command.DestroyActor(x) for x in actor_list]
          )
  
          print("Stop recording")
          client.stop_recorder()
  
file_path: carla/PythonAPI/examples/start_recording.py
imports: import glob
  import os
  import sys
  import carla
  import argparse
  import random
  import time
  import logging
label_desc: Use image node_id 1 for calling a global function with example usage: main() without return types