docs: def new(cls, ns_path, script, campaign_dir, runner_type='Auto',
              overwrite=False, optimized=True, check_repo=True):
          """
          Create a new campaign from an ns-3 installation and a campaign
          directory.
  
          This method will create a DatabaseManager, which will install a
          database in the specified campaign_dir. If a database is already
          available at the ns_path described in the specified campaign_dir and
          its configuration matches config, this instance is used instead. If the
          overwrite argument is set to True instead, the specified directory is
          wiped and a new campaign is created in its place.
  
          Furthermore, this method will initialize a SimulationRunner, of type
          specified by the runner_type parameter, which will be locked on the
          ns-3 installation at ns_path and set up to run the desired script.
  
          Finally, note that creation of a campaign requires a git repository to
          be initialized at the specified ns_path. This will allow SEM to save
          the commit at which the simulations are run, enforce reproducibility
          and avoid mixing results coming from different versions of ns-3 and its
          libraries.
  
          Args:
              ns_path (str): path to the ns-3 installation to employ in this
                  campaign.
              script (str): ns-3 script that will be executed to run simulations.
              campaign_dir (str): path to the directory in which to save the
                  simulation campaign database.
              runner_type (str): implementation of the SimulationRunner to use.
                  Value can be: SimulationRunner (for running sequential
                  simulations locally), ParallelRunner (for running parallel
                  simulations locally), GridRunner (for running simulations using
                  a DRMAA-compatible parallel task scheduler). Use Auto to
                  automatically pick the best runner.
              overwrite (bool): whether to overwrite already existing
                  campaign_dir folders. This deletes the directory if and only if
                  it only contains files that were detected to be created by sem.
              optimized (bool): whether to configure the runner to employ an
                  optimized ns-3 build.
          """
          # Convert paths to be absolute
          ns_path = os.path.abspath(ns_path)
          campaign_dir = os.path.abspath(campaign_dir)
  
          # Verify if the specified campaign is already available
          if Path(campaign_dir).exists() and not overwrite:
              # Try loading
              manager = CampaignManager.load(campaign_dir, ns_path,
                                             runner_type=runner_type,
                                             optimized=optimized,
                                             check_repo=check_repo)
  
              if manager.db.get_script() == script:
                  return manager
              else:
                  del manager
  
          # Initialize runner
          runner = CampaignManager.create_runner(ns_path, script,
                                                 runner_type=runner_type,
                                                 optimized=optimized)
  
          # Get list of parameters to save in the DB
          params = runner.get_available_parameters()
  
          # Get current commit
          commit = ""
          if check_repo:
              from git import Repo, exc
              commit = Repo(ns_path).head.commit.hexsha
  
          # Create a database manager from the configuration
          db = DatabaseManager.new(script=script,
                                   params=params,
                                   commit=commit,
                                   campaign_dir=campaign_dir,
                                   overwrite=overwrite)
  
          return cls(db, runner, check_repo)