locust 2.32.2.dev44__py3-none-any.whl → 2.32.3__py3-none-any.whl

locust/_version.py

@@ -14,7 +14,7 @@ __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
 
-__version__ = "2.32.2.dev44"
+__version__ = "2.32.3"
 version = __version__
-__version_tuple__ = (2, 32, 2, "dev44")
+__version_tuple__ = (2, 32, 3)
 version_tuple = __version_tuple__

locust/argument_parser.py

@@ -59,15 +59,18 @@ class LocustArgumentParser(configargparse.ArgumentParser):
         Arguments:
             include_in_web_ui: If True (default), the argument will show in the UI.
             is_secret: If True (default is False) and include_in_web_ui is True, the argument will show in the UI with a password masked text input.
+            is_required: If True (default is False) and include_in_web_ui is True, the argument will show in the UI as a required form field.
 
         Returns:
             argparse.Action: the new argparse action
         """
         include_in_web_ui = kwargs.pop("include_in_web_ui", True)
         is_secret = kwargs.pop("is_secret", False)
+        is_required = kwargs.pop("is_required", False)
         action = super().add_argument(*args, **kwargs)
         action.include_in_web_ui = include_in_web_ui
         action.is_secret = is_secret
+        action.is_required = is_required
         return action
 
     @property
@@ -82,6 +85,14 @@ class LocustArgumentParser(configargparse.ArgumentParser):
             if a.dest in self.args_included_in_web_ui and hasattr(a, "is_secret") and a.is_secret
         }
 
+    @property
+    def required_args_included_in_web_ui(self) -> dict[str, configargparse.Action]:
+        return {
+            a.dest: a
+            for a in self._actions
+            if a.dest in self.args_included_in_web_ui and hasattr(a, "is_required") and a.is_required
+        }
+
 
 class LocustTomlConfigParser(configargparse.TomlConfigParser):
     def parse(self, stream):
@@ -151,14 +162,18 @@ def download_locustfile_from_url(url: str) -> str:
     """
     try:
         response = requests.get(url)
-        # Check if response is valid python code
-        ast.parse(response.text)
     except requests.exceptions.RequestException as e:
         sys.stderr.write(f"Failed to get locustfile from: {url}. Exception: {e}")
         sys.exit(1)
-    except SyntaxError:
-        sys.stderr.write(f"Failed to get locustfile from: {url}. Response is not valid python code.")
-        sys.exit(1)
+    else:
+        try:
+            # Check if response is valid python code
+            ast.parse(response.text)
+        except SyntaxError:
+            sys.stderr.write(
+                f"Failed to get locustfile from: {url}. Response was not valid python code: '{response.text[:100]}'"
+            )
+            sys.exit(1)
 
     with open(os.path.join(tempfile.gettempdir(), urlparse(url).path.split("/")[-1]), "w") as locustfile:
         locustfile.write(response.text)
@@ -798,6 +813,7 @@ def default_args_dict() -> dict:
 class UIExtraArgOptions(NamedTuple):
     default_value: str
     is_secret: bool
+    is_required: bool
     help_text: str
     choices: list[str] | None = None
 
@@ -813,6 +829,7 @@ def ui_extra_args_dict(args=None) -> dict[str, dict[str, Any]]:
         k: UIExtraArgOptions(
             default_value=v,
             is_secret=k in parser.secret_args_included_in_web_ui,
+            is_required=k in parser.required_args_included_in_web_ui,
             help_text=parser.args_included_in_web_ui[k].help,
             choices=parser.args_included_in_web_ui[k].choices,
         )._asdict()

locust/env.py

@@ -295,8 +295,7 @@ class Environment:
     def _validate_shape_class_instance(self):
         if self.shape_class is not None and not isinstance(self.shape_class, LoadTestShape):
             raise ValueError(
-                "shape_class should be instance of LoadTestShape or subclass LoadTestShape, but got: %s"
-                % self.shape_class
+                f"shape_class should be instance of LoadTestShape or subclass LoadTestShape, but got: {self.shape_class}"
             )
 
     @property

locust/log.py

@@ -92,10 +92,10 @@ def greenlet_exception_logger(logger, level=logging.CRITICAL):
     """
 
     def exception_handler(greenlet):
-        if greenlet.exc_info[0] == SystemExit:
+        if greenlet.exc_info[0] is SystemExit:
             logger.log(
                 min(logging.INFO, level),  # dont use higher than INFO for this, because it sounds way to urgent
-                "sys.exit(%s) called (use log level DEBUG for callstack)" % greenlet.exc_info[1],
+                f"sys.exit({greenlet.exc_info[1]}) called (use log level DEBUG for callstack)",
             )
             logger.log(logging.DEBUG, "Unhandled exception in greenlet: %s", greenlet, exc_info=greenlet.exc_info)
         else:

locust/main.py

@@ -554,7 +554,7 @@ See https://github.com/locustio/locust/wiki/Installation#increasing-maximum-numb
             logger.info("--run-time limit reached, stopping test")
             runner.stop()
             if options.autoquit != -1:
-                logger.debug("Autoquit time limit set to %s seconds" % options.autoquit)
+                logger.debug(f"Autoquit time limit set to {options.autoquit} seconds")
                 time.sleep(options.autoquit)
                 logger.info("--autoquit time reached, shutting down")
                 runner.quit()
@@ -587,11 +587,18 @@ See https://github.com/locustio/locust/wiki/Installation#increasing-maximum-numb
                     logger.error("Gave up waiting for workers to connect")
                     runner.quit()
                     sys.exit(1)
-                logging.info(
-                    "Waiting for workers to be ready, %s of %s connected",
-                    len(runner.clients.ready),
-                    options.expect_workers,
-                )
+                if time.monotonic() - start_time > 5:
+                    logging.info(
+                        "Waiting for workers to be ready, %s of %s connected",
+                        len(runner.clients.ready),
+                        options.expect_workers,
+                    )
+                else:
+                    logging.debug(
+                        "Waiting for workers to be ready, %s of %s connected",
+                        len(runner.clients.ready),
+                        options.expect_workers,
+                    )
                 # TODO: Handle KeyboardInterrupt and send quit signal to workers that are started.
                 #       Right now, if the user sends a ctrl+c, the master will not gracefully
                 #       shutdown resulting in all the already started workers to stay active.

locust/runners.py

@@ -217,7 +217,7 @@ class Runner:
                 n += 1
                 if n % 10 == 0 or n == spawn_count:
                     logger.debug("%i users spawned" % self.user_count)
-            logger.debug("All users of class %s spawned" % user_class)
+            logger.debug(f"All users of class {user_class} spawned")
             return new_users
 
         new_users: list[User] = []
@@ -248,7 +248,7 @@ class Runner:
                         "While stopping users, we encountered a user that didn't have proper args %s", user_greenlet
                     )
                     continue
-                if type(user) == self.user_classes_by_name[user_class]:
+                if type(user) is self.user_classes_by_name[user_class]:
                     to_stop.append(user)
 
             if not to_stop:
@@ -256,7 +256,7 @@ class Runner:
 
             while True:
                 user_to_stop: User = to_stop.pop()
-                logger.debug("Stopping %s" % user_to_stop.greenlet.name)
+                logger.debug(f"Stopping {user_to_stop.greenlet.name}")
                 if user_to_stop.greenlet is greenlet.getcurrent():
                     # User called runner.quit(), so don't block waiting for killing to finish
                     user_to_stop.group.killone(user_to_stop.greenlet, block=False)
@@ -272,8 +272,7 @@ class Runner:
 
         if not stop_group.join(timeout=self.environment.stop_timeout):
             logger.info(
-                "Not all users finished their tasks & terminated in %s seconds. Stopping them..."
-                % self.environment.stop_timeout
+                f"Not all users finished their tasks & terminated in {self.environment.stop_timeout} seconds. Stopping them..."
             )
             stop_group.kill(block=True)
 
@@ -495,7 +494,7 @@ class LocalRunner(Runner):
                 user_classes_spawn_count: dict[str, int] = {}
                 user_classes_stop_count: dict[str, int] = {}
                 user_classes_count = dispatched_users[self._local_worker_node.id]
-                logger.debug("Ramping to %s" % _format_user_classes_count_for_log(user_classes_count))
+                logger.debug(f"Ramping to {_format_user_classes_count_for_log(user_classes_count)}")
                 for user_class_name, user_class_count in user_classes_count.items():
                     if self.user_classes_count[user_class_name] > user_class_count:
                         user_classes_stop_count[user_class_name] = (
@@ -558,7 +557,7 @@ class LocalRunner(Runner):
         :param msg_type: The type of the message to emulate sending
         :param data: Optional data to include
         """
-        logger.debug("Running locally: sending %s message to self" % msg_type)
+        logger.debug(f"Running locally: sending {msg_type} message to self")
         if msg_type in self.custom_messages:
             listener, concurrent = self.custom_messages[msg_type]
             msg = Message(msg_type, data, "local")
@@ -877,7 +876,7 @@ class MasterRunner(DistributedRunner):
 
             if send_stop_to_client:
                 for client in self.clients.all:
-                    logger.debug("Sending stop message to worker %s" % client.id)
+                    logger.debug(f"Sending stop message to worker {client.id}")
                     self.server.send_to_client(Message("stop", None, client.id))
 
                 # Give an additional 60s for all workers to stop
@@ -987,8 +986,7 @@ class MasterRunner(DistributedRunner):
                     logger.error(f"RPCError: {e}. Will reset RPC server.")
                 else:
                     logger.debug(
-                        "RPCError when receiving from worker: %s (but no workers were expected to be connected anyway)"
-                        % (e)
+                        f"RPCError when receiving from worker: {e} (but no workers were expected to be connected anyway)"
                     )
                 self.connection_broken = True
                 gevent.sleep(FALLBACK_INTERVAL)
@@ -1027,7 +1025,9 @@ class MasterRunner(DistributedRunner):
                 # if abs(time() - msg.data["time"]) > 5.0:
                 #    warnings.warn("The worker node's clock seem to be out of sync. For the statistics to be correct the different locust servers need to have synchronized clocks.")
             elif msg.type == "locustfile":
-                if msg.data["version"][0:4] == __version__[0:4]:
+                if not msg.data["version"]:
+                    logger.error("A very old worker version requested locustfile. This probably won't work.")
+                elif msg.data["version"][0:4] == __version__[0:4]:
                     logger.debug(
                         f"A worker ({msg.node_id}) running a different patch version ({msg.data['version']}) connected, master version is {__version__}"
                     )
@@ -1410,7 +1410,7 @@ class WorkerRunner(DistributedRunner):
                 # master says we have finished spawning (happens only once during a normal rampup)
                 self.environment.events.spawning_complete.fire(user_count=msg.data["user_count"])
             elif msg.type in self.custom_messages:
-                logger.debug("Received %s message from master" % msg.type)
+                logger.debug(f"Received {msg.type} message from master")
                 listener, concurrent = self.custom_messages[msg.type]
                 if not concurrent:
                     listener(environment=self.environment, msg=msg)
@@ -1454,7 +1454,7 @@ class WorkerRunner(DistributedRunner):
         :param data: Optional data to send
         :param client_id: (unused)
         """
-        logger.debug("Sending %s message to master" % msg_type)
+        logger.debug(f"Sending {msg_type} message to master")
         self.client.send(Message(msg_type, data, self.client_id))
 
     def _send_stats(self) -> None:

locust/util/deprecation.py

@@ -12,7 +12,7 @@ def check_for_deprecated_task_set_attribute(class_dict):
         if issubclass(task_set, TaskSet) and not hasattr(task_set, "locust_task_weight"):
             warnings.warn(
                 "Usage of User.task_set is deprecated since version 1.0. Set the tasks attribute instead "
-                "(tasks = [%s])" % task_set.__name__,
+                f"(tasks = [{task_set.__name__}])",
                 DeprecationWarning,
             )
 

locust/web.py

@@ -60,6 +60,7 @@ class InputField(TypedDict, total=False):
     default_value: bool | None
     choices: list[str] | None
     is_secret: bool | None
+    is_required: bool | None
 
 
 class CustomForm(TypedDict, total=False):