diff --git a/cts/lab/CTSlab.py.in b/cts/lab/CTSlab.py.in
index 01fbad7857..667c6fe167 100644
--- a/cts/lab/CTSlab.py.in
+++ b/cts/lab/CTSlab.py.in
@@ -1,132 +1,132 @@
 #!@PYTHON@
 """ Command-line interface to Pacemaker's Cluster Test Suite (CTS)
 """
 
 __copyright__ = "Copyright 2001-2023 the Pacemaker project contributors"
 __license__ = "GNU General Public License version 2 or later (GPLv2+) WITHOUT ANY WARRANTY"
 
 import sys, signal, os
 
 pdir = os.path.dirname(sys.path[0])
 sys.path.insert(0, pdir) # So that things work from the source directory
 
 try:
     from cts.CM_corosync  import *
 
     from pacemaker._cts.CTS import CtsLab
     from pacemaker._cts.audits import audit_list
     from pacemaker._cts.logging import LogFactory
-    from pacemaker._cts.scenarios import *
+    from pacemaker._cts.scenarios import AllOnce, Boot, BootCluster, LeaveBooted, RandomTests, Sequence
     from pacemaker._cts.tests import test_list
 except ImportError as e:
     sys.stderr.write("abort: %s\n" % e)
     sys.stderr.write("check your install and PYTHONPATH; couldn't find cts libraries in:\n%s\n" %
                      ' '.join(sys.path))
     sys.exit(1)
 
 # These are globals so they can be used by the signal handler.
 scenario = None
 LogFactory().add_stderr()
 
 
 def sig_handler(signum, frame) :
     LogFactory().log("Interrupted by signal %d"%signum)
     if scenario: scenario.summarize()
     if signum == 15 :
         if scenario: scenario.teardown()
         sys.exit(1)
 
 
 def plural_s(n, uppercase=False):
     if n == 1:
         return ""
     elif uppercase:
         return "S"
     else:
         return "s"
 
 
 if __name__ == '__main__':
 
     Environment = CtsLab(sys.argv[1:])
     NumIter = Environment["iterations"]
     Tests = []
 
     # Set the signal handler
     signal.signal(15, sig_handler)
     signal.signal(10, sig_handler)
 
     # Create the Cluster Manager object
     cm = None
     if Environment["Stack"] == "corosync 2+":
         cm = crm_corosync()
         
     else:
         LogFactory().log("Unknown stack: "+Environment["stack"])
         sys.exit(1)
 
     if Environment["TruncateLog"]:
         if Environment["OutputFile"] is None:
             LogFactory().log("Ignoring truncate request because no output file specified")
         else:
             LogFactory().log("Truncating %s" % Environment["OutputFile"])
             with open(Environment["OutputFile"], "w") as outputfile:
                 outputfile.truncate(0)
 
     Audits = audit_list(cm)
 
     if Environment["ListTests"]:
         Tests = test_list(cm, Audits)
         LogFactory().log("Total %d tests"%len(Tests))
         for test in Tests :
             LogFactory().log(str(test.name));
         sys.exit(0)
 
     elif len(Environment["tests"]) == 0:
         Tests = test_list(cm, Audits)
 
     else:
         Chosen = Environment["tests"]
         for TestCase in Chosen:
            match = None
 
            for test in test_list(cm, Audits):
                if test.name == TestCase:
                    match = test
 
            if not match:
                LogFactory().log("--choose: No applicable/valid tests chosen")
                sys.exit(1)
            else:
                Tests.append(match)
 
     # Scenario selection
     if Environment["scenario"] == "all-once":
         NumIter = len(Tests)
         scenario = AllOnce(
             cm, [ BootCluster(cm, Environment) ], Audits, Tests)
     elif Environment["scenario"] == "sequence":
         scenario = Sequence(
             cm, [ BootCluster(cm, Environment) ], Audits, Tests)
     elif Environment["scenario"] == "boot":
         scenario = Boot(cm, [ LeaveBooted(cm, Environment)], Audits, [])
     else:
         scenario = RandomTests(
             cm, [ BootCluster(cm, Environment) ], Audits, Tests)
 
     LogFactory().log(">>>>>>>>>>>>>>>> BEGINNING " + repr(NumIter) + " TEST" + plural_s(NumIter, True) + " ")
     LogFactory().log("Stack:                  %s (%s)" % (Environment["Stack"], Environment["Name"]))
     LogFactory().log("Schema:                 %s" % Environment["Schema"])
     LogFactory().log("Scenario:               %s" % scenario.__doc__)
     LogFactory().log("CTS Exerciser:          %s" % Environment["cts-exerciser"])
     LogFactory().log("CTS Logfile:            %s" % Environment["OutputFile"])
     LogFactory().log("Random Seed:            %s" % Environment["RandSeed"])
     LogFactory().log("Syslog variant:         %s" % Environment["syslogd"].strip())
     LogFactory().log("System log files:       %s" % Environment["LogFileName"])
     if "IPBase" in Environment:
         LogFactory().log("Base IP for resources:  %s" % Environment["IPBase"])
     LogFactory().log("Cluster starts at boot: %d" % Environment["at-boot"])
 
     Environment.dump()
     rc = Environment.run(scenario, NumIter)
     sys.exit(rc)