locust 2.29.2.dev72__tar.gz → 2.30.1__tar.gz

{locust-2.29.2.dev72 → locust-2.30.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: locust
-Version: 2.29.2.dev72
+Version: 2.30.1
 Summary: Developer-friendly load testing framework
 Home-page: https://locust.io/
 License: MIT

{locust-2.29.2.dev72 → locust-2.30.1}/locust/_version.py

@@ -14,7 +14,7 @@ __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
 
-__version__ = "2.29.2.dev72"
+__version__ = "2.30.1"
 version = __version__
-__version_tuple__ = (2, 29, 2, "dev72")
+__version_tuple__ = (2, 30, 1)
 version_tuple = __version_tuple__

{locust-2.29.2.dev72 → locust-2.30.1}/locust/argument_parser.py

@@ -15,7 +15,6 @@ import tempfile
 import textwrap
 from collections import OrderedDict
 from typing import Any, NamedTuple
-from urllib.parse import urlparse
 from uuid import uuid4
 
 if sys.version_info >= (3, 11):
@@ -27,6 +26,9 @@ import configargparse
 import gevent
 import requests
 
+from .util.directory import get_abspaths_in
+from .util.url import is_url
+
 version = locust.__version__
 
 
@@ -125,14 +127,7 @@ def _parse_locustfile_path(path: str) -> list[str]:
         parsed_paths.append(download_locustfile_from_url(path))
     elif os.path.isdir(path):
         # Find all .py files in directory tree
-        for root, _dirs, fs in os.walk(path):
-            parsed_paths.extend(
-                [
-                    os.path.abspath(os.path.join(root, f))
-                    for f in fs
-                    if os.path.isfile(os.path.join(root, f)) and f.endswith(".py") and not f.startswith("_")
-                ]
-            )
+        parsed_paths.extend(get_abspaths_in(path, extension=".py"))
         if not parsed_paths:
             sys.stderr.write(f"Could not find any locustfiles in directory '{path}'")
             sys.exit(1)
@@ -148,20 +143,6 @@ def _parse_locustfile_path(path: str) -> list[str]:
     return parsed_paths
 
 
-def is_url(url: str) -> bool:
-    """
-    Check if path is an url
-    """
-    try:
-        result = urlparse(url)
-        if result.scheme == "https" or result.scheme == "http":
-            return True
-        else:
-            return False
-    except ValueError:
-        return False
-
-
 def download_locustfile_from_url(url: str) -> str:
     """
     Attempt to download and save locustfile from url.
@@ -238,7 +219,7 @@ def download_locustfile_from_master(master_host: str, master_port: int) -> str:
 
     def ask_for_locustfile():
         while not got_reply:
-            tempclient.send(Message("locustfile", None, client_id))
+            tempclient.send(Message("locustfile", {"version": version}, client_id))
             gevent.sleep(1)
 
     def log_warning():
@@ -271,14 +252,26 @@ def download_locustfile_from_master(master_host: str, master_port: int) -> str:
         sys.stderr.write(f"Got error from master: {msg.data['error']}\n")
         sys.exit(1)
 
-    filename = msg.data["filename"]
-    with open(os.path.join(tempfile.gettempdir(), filename), "w", encoding="utf-8") as locustfile:
-        locustfile.write(msg.data["contents"])
+    tempclient.close()
+    return msg.data.get("locustfiles", [])
 
-    atexit.register(exit_handler, locustfile.name)
 
-    tempclient.close()
-    return locustfile.name
+def parse_locustfiles_from_master(locustfile_sources) -> list[str]:
+    locustfiles = []
+
+    for source in locustfile_sources:
+        if "contents" in source:
+            filename = source["filename"]
+            file_contents = source["contents"]
+
+            with open(os.path.join(tempfile.gettempdir(), filename), "w", encoding="utf-8") as locustfile:
+                locustfile.write(file_contents)
+
+            locustfiles.append(locustfile.name)
+        else:
+            locustfiles.append(source)
+
+    return locustfiles
 
 
 def parse_locustfile_option(args=None) -> list[str]:
@@ -339,10 +332,11 @@ def parse_locustfile_option(args=None) -> list[str]:
             )
             sys.exit(1)
         # having this in argument_parser module is a bit weird, but it needs to be done early
-        filename = download_locustfile_from_master(options.master_host, options.master_port)
-        return [filename]
+        locustfile_sources = download_locustfile_from_master(options.master_host, options.master_port)
+        locustfile_list = parse_locustfiles_from_master(locustfile_sources)
+    else:
+        locustfile_list = [f.strip() for f in options.locustfile.split(",")]
 
-    locustfile_list = [f.strip() for f in options.locustfile.split(",")]
     parsed_paths = parse_locustfile_paths(locustfile_list)
 
     if not parsed_paths:
@@ -502,6 +496,13 @@ def setup_parser_arguments(parser):
         help="Enable select boxes in the web interface to choose from all available User classes and Shape classes",
         env_var="LOCUST_USERCLASS_PICKER",
     )
+    web_ui_group.add_argument(
+        "--build-path",
+        type=str,
+        default="",
+        help=configargparse.SUPPRESS,
+        env_var="LOCUST_BUILD_PATH",
+    )
     web_ui_group.add_argument(
         "--legacy-ui",
         default=False,

{locust-2.29.2.dev72 → locust-2.30.1}/locust/dispatch.py

@@ -5,7 +5,7 @@ import itertools
 import math
 import time
 from collections import defaultdict
-from collections.abc import Generator, Iterator
+from collections.abc import Iterator
 from heapq import heapify, heapreplace
 from math import log2
 from operator import attrgetter
@@ -17,41 +17,31 @@ if TYPE_CHECKING:
     from locust import User
     from locust.runners import WorkerNode
 
+    from collections.abc import Generator, Iterable
+    from typing import TypeVar
 
-# To profile line-by-line, uncomment the code below (i.e. `import line_profiler ...`) and
-# place `@profile` on the functions/methods you wish to profile. Then, in the unit test you are
-# running, use `from locust.dispatch import profile; profile.print_stats()` at the end of the unit test.
-# Placing it in a `finally` block is recommended.
-# import line_profiler
-#
-# profile = line_profiler.LineProfiler()
+    T = TypeVar("T")
 
 
-def _kl_generator(users: list[tuple[type[User], float]]) -> Iterator[str | None]:
+def _kl_generator(users: Iterable[tuple[T, float]]) -> Iterator[T | None]:
     """Generator based on Kullback-Leibler divergence
 
     For example, given users A, B with weights 5 and 1 respectively,
     this algorithm will yield AAABAAAAABAA.
     """
-    if not users:
+    heap = [(x * log2(x / (x + 1.0)), x + 1.0, x, name) for name, x in users]
+    if not heap:
         while True:
             yield None
 
-    names = [u[0].__name__ for u in users]
-    weights = [u[1] for u in users]
-    generated = weights.copy()
-
-    heap = [(x * log2(x / (x + 1.0)), i) for i, x in enumerate(generated)]
     heapify(heap)
-
     while True:
-        i = heap[0][1]  # choose element which choosing minimizes divergence the most
-        yield names[i]
-        generated[i] += 1.0
-        x = generated[i]
-        kl_diff = weights[i] * log2(x / (x + 1.0))
+        _, x, weight, name = heap[0]
+        # (divergence diff, number of generated elements + initial weight, initial weight, name) = heap[0]
+        yield name
+        kl_diff = weight * log2(x / (x + 1.0))
         # calculate how much choosing element i for (x + 1)th time decreases divergence
-        heapreplace(heap, (kl_diff, i))
+        heapreplace(heap, (kl_diff, x + 1.0, weight, name))
 
 
 class UsersDispatcher(Iterator):
@@ -378,35 +368,24 @@ class UsersDispatcher(Iterator):
         return users_on_workers, user_gen, worker_gen, active_users
 
     def _user_gen(self) -> Iterator[str | None]:
-        fixed_users = {u.__name__: u for u in self._user_classes if u.fixed_count}
-
-        fixed_users_gen = _kl_generator([(u, u.fixed_count) for u in fixed_users.values()])
-        weighted_users_gen = _kl_generator([(u, u.weight) for u in self._user_classes if not u.fixed_count])
+        weighted_users_gen = _kl_generator((u.__name__, u.weight) for u in self._user_classes if not u.fixed_count)
 
-        # Spawn users
         while True:
-            if self._try_dispatch_fixed:
+            if self._try_dispatch_fixed:  # Fixed_count users are spawned before weight users.
+                # Some peoples treat this implementation detail as a feature.
                 self._try_dispatch_fixed = False
-                current_fixed_users_count = {u: self._get_user_current_count(u) for u in fixed_users}
-                spawned_classes: set[str] = set()
-                while len(spawned_classes) != len(fixed_users):
-                    user_name: str | None = next(fixed_users_gen)
-                    if not user_name:
-                        break
-
-                    if current_fixed_users_count[user_name] < fixed_users[user_name].fixed_count:
-                        current_fixed_users_count[user_name] += 1
-                        yield user_name
-
-                        # 'self._try_dispatch_fixed' was changed outhere,  we have to recalculate current count
-                        if self._try_dispatch_fixed:
-                            current_fixed_users_count = {u: self._get_user_current_count(u) for u in fixed_users}
-                            spawned_classes.clear()
-                            self._try_dispatch_fixed = False
-                    else:
-                        spawned_classes.add(user_name)
-
-            yield next(weighted_users_gen)
+                fixed_users_missing = [
+                    (u.__name__, miss)
+                    for u in self._user_classes
+                    if u.fixed_count and (miss := u.fixed_count - self._get_user_current_count(u.__name__)) > 0
+                ]
+                total_miss = sum(miss for _, miss in fixed_users_missing)
+                fixed_users_gen = _kl_generator(fixed_users_missing)  # type: ignore[arg-type]
+                # https://mypy.readthedocs.io/en/stable/common_issues.html#variance
+                for _ in range(total_miss):
+                    yield next(fixed_users_gen)
+            else:
+                yield next(weighted_users_gen)
 
     @staticmethod
     def _fast_users_on_workers_copy(users_on_workers: dict[str, dict[str, int]]) -> dict[str, dict[str, int]]:

{locust-2.29.2.dev72 → locust-2.30.1}/locust/env.py

@@ -33,6 +33,7 @@ class Environment:
         stop_timeout: float | None = None,
         catch_exceptions=True,
         parsed_options: Namespace | None = None,
+        parsed_locustfiles: list[str] | None = None,
         available_user_classes: dict[str, User] | None = None,
         available_shape_classes: dict[str, LoadTestShape] | None = None,
         available_user_tasks: dict[str, list[TaskSet | Callable]] | None = None,
@@ -91,6 +92,8 @@ class Environment:
         """
         self.parsed_options = parsed_options
         """Reference to the parsed command line options (used to pre-populate fields in Web UI). When using Locust as a library, this should either be `None` or an object created by `argument_parser.parse_args()`"""
+        self.parsed_locustfiles = parsed_locustfiles
+        """A list of all locustfiles for the test"""
         self.available_user_classes = available_user_classes
         """List of the available User Classes to pick from in the UserClass Picker"""
         self.available_shape_classes = available_shape_classes
@@ -168,6 +171,7 @@ class Environment:
         stats_csv_writer: StatsCSV | None = None,
         delayed_start=False,
         userclass_picker_is_active=False,
+        build_path: str | None = None,
     ) -> WebUI:
         """
         Creates a :class:`WebUI <locust.web.WebUI>` instance for this Environment and start running the web server
@@ -194,6 +198,7 @@ class Environment:
             stats_csv_writer=stats_csv_writer,
             delayed_start=delayed_start,
             userclass_picker_is_active=userclass_picker_is_active,
+            build_path=build_path,
         )
         return self.web_ui
 

{locust-2.29.2.dev72 → locust-2.30.1}/locust/html.py

@@ -5,7 +5,8 @@ from html import escape
 from itertools import chain
 from json import dumps
 
-from jinja2 import Environment, FileSystemLoader
+from jinja2 import Environment as JinjaEnvironment
+from jinja2 import FileSystemLoader
 
 from . import stats as stats_module
 from .runners import STATE_STOPPED, STATE_STOPPING, MasterRunner
@@ -14,13 +15,11 @@ from .user.inspectuser import get_ratio
 from .util.date import format_utc_timestamp
 
 PERCENTILES_FOR_HTML_REPORT = [0.50, 0.6, 0.7, 0.8, 0.9, 0.95, 0.99, 1.0]
-ROOT_PATH = os.path.dirname(os.path.abspath(__file__))
-BUILD_PATH = os.path.join(ROOT_PATH, "webui", "dist")
-STATIC_PATH = os.path.join(BUILD_PATH, "assets")
+DEFAULT_BUILD_PATH = os.path.join(os.path.dirname(os.path.abspath(__file__)), "webui", "dist")
 
 
-def render_template(file, **kwargs):
-    env = Environment(loader=FileSystemLoader(BUILD_PATH), extensions=["jinja2.ext.do"])
+def render_template_from(file, build_path=DEFAULT_BUILD_PATH, **kwargs):
+    env = JinjaEnvironment(loader=FileSystemLoader(build_path))
     template = env.get_template(file)
     return template.render(**kwargs)
 
@@ -56,16 +55,6 @@ def get_html_report(
     update_stats_history(environment.runner)
     history = stats.history
 
-    static_js = []
-    js_files = [os.path.basename(filepath) for filepath in glob.glob(os.path.join(STATIC_PATH, "*.js"))]
-
-    for js_file in js_files:
-        path = os.path.join(STATIC_PATH, js_file)
-        static_js.append("// " + js_file + "\n")
-        with open(path, encoding="utf8") as f:
-            static_js.append(f.read())
-        static_js.extend(["", ""])
-
     is_distributed = isinstance(environment.runner, MasterRunner)
     user_spawned = (
         environment.runner.reported_user_classes_count if is_distributed else environment.runner.user_classes_count
@@ -79,7 +68,7 @@ def get_html_report(
         "total": get_ratio(environment.user_classes, user_spawned, True),
     }
 
-    return render_template(
+    return render_template_from(
         "report.html",
         template_args={
             "is_report": True,
@@ -107,5 +96,4 @@ def get_html_report(
             "percentiles_to_chart": stats_module.PERCENTILES_TO_CHART,
         },
         theme=theme,
-        static_js="\n".join(static_js),
     )

{locust-2.29.2.dev72 → locust-2.30.1}/locust/main.py

@@ -36,11 +36,15 @@ from .user.inspectuser import print_task_ratio, print_task_ratio_json
 from .util.load_locustfile import load_locustfile
 from .util.timespan import parse_timespan
 
+# import external plugins if  installed to allow for registering custom arguments etc
 try:
-    # import locust_plugins if it is installed, to allow it to register custom arguments etc
     import locust_plugins  # pyright: ignore[reportMissingImports]
 except ModuleNotFoundError:
     pass
+try:
+    import locust_cloud  # pyright: ignore[reportMissingImports]
+except ModuleNotFoundError:
+    pass
 
 version = locust.__version__
 
@@ -59,6 +63,7 @@ def create_environment(
     events=None,
     shape_class=None,
     locustfile=None,
+    parsed_locustfiles=None,
     available_user_classes=None,
     available_shape_classes=None,
     available_user_tasks=None,
@@ -74,6 +79,7 @@ def create_environment(
         host=options.host,
         reset_stats=options.reset_stats,
         parsed_options=options,
+        parsed_locustfiles=parsed_locustfiles,
         available_user_classes=available_user_classes,
         available_shape_classes=available_shape_classes,
         available_user_tasks=available_user_tasks,
@@ -322,6 +328,13 @@ def main():
         # list() call is needed to consume the dict_view object in Python 3
         user_classes = list(user_classes.values())
 
+    if not shape_class and options.num_users:
+        fixed_count_total = sum([user_class.fixed_count for user_class in user_classes])
+        if fixed_count_total > options.num_users:
+            logger.info(
+                f"Total fixed_count of User classes ({fixed_count_total}) is greater than the specified number of users ({options.num_users}), so not all will be spawned."
+            )
+
     if os.name != "nt" and not options.master:
         try:
             import resource
@@ -349,6 +362,7 @@ See https://github.com/locustio/locust/wiki/Installation#increasing-maximum-numb
         events=locust.events,
         shape_class=shape_class,
         locustfile=locustfile_path,
+        parsed_locustfiles=locustfiles,
         available_user_classes=available_user_classes,
         available_shape_classes=available_shape_classes,
         available_user_tasks=available_user_tasks,
@@ -479,6 +493,7 @@ See https://github.com/locustio/locust/wiki/Installation#increasing-maximum-numb
             stats_csv_writer=stats_csv_writer,
             delayed_start=True,
             userclass_picker_is_active=options.class_picker,
+            build_path=options.build_path,
         )
     else:
         web_ui = None

{locust-2.29.2.dev72 → locust-2.30.1}/locust/runners.py

@@ -32,6 +32,8 @@ from .exception import RPCError, RPCReceiveError, RPCSendError
 from .log import get_logs, greenlet_exception_logger
 from .rpc import Message, rpc
 from .stats import RequestStats, StatsError, setup_distributed_stats_event_listeners
+from .util.directory import get_abspaths_in
+from .util.url import is_url
 
 if TYPE_CHECKING:
     from . import User
@@ -1024,33 +1026,45 @@ 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]:
+                    logger.debug(
+                        f"A worker ({msg.node_id}) running a different patch version ({msg.data['version']}) connected, master version is {__version__}"
+                    )
+
                 logging.debug("Worker requested locust file")
-                assert self.environment.parsed_options
-                filename = self.environment.parsed_options.locustfile
+                assert self.environment.parsed_locustfiles
+                locustfile_options = self.environment.parsed_locustfiles
+                locustfile_list = [f.strip() for f in locustfile_options if not os.path.isdir(f)]
+
+                for locustfile_option in locustfile_options:
+                    if os.path.isdir(locustfile_option):
+                        locustfile_list.extend(get_abspaths_in(locustfile_option, extension=".py"))
+
                 try:
-                    with open(filename) as f:
-                        file_contents = f.read()
+                    locustfiles: list[str | dict[str, str]] = []
+
+                    for filename in locustfile_list:
+                        if is_url(filename):
+                            locustfiles.append(filename)
+                        else:
+                            with open(filename) as f:
+                                filename = os.path.basename(filename)
+                                file_contents = f.read()
+
+                            locustfiles.append({"filename": filename, "contents": file_contents})
                 except Exception as e:
-                    logger.error(
-                        f"--locustfile must be a full path to a single locustfile for file distribution to work {e}"
-                    )
+                    error_message = "locustfile must be a full path to a single locustfile, a comma-separated list of .py files, or a URL for file distribution to work"
+                    logger.error(f"{error_message} {e}")
                     self.send_message(
                         "locustfile",
                         client_id=client_id,
-                        data={
-                            "error": f"locustfile must be a full path to a single locustfile for file distribution to work (was '{filename}')"
-                        },
+                        data={"error": f"{error_message} (was '{filename}')"},
                     )
                 else:
-                    if getattr(self, "_old_file_contents", file_contents) != file_contents:
-                        logger.warning(
-                            "Locustfile contents changed on disk after first worker requested locustfile, sending new content. If you make any major changes (like changing User class names) you need to restart master."
-                        )
-                    self._old_file_contents = file_contents
                     self.send_message(
                         "locustfile",
                         client_id=client_id,
-                        data={"filename": os.path.basename(filename), "contents": file_contents},
+                        data={"locustfiles": locustfiles},
                     )
                 continue
             elif msg.type == "client_stopped":

{locust-2.29.2.dev72 → locust-2.30.1}/locust/stats.py

@@ -679,7 +679,10 @@ class StatsEntry:
             "max_response_time": proper_round(self.max_response_time),
             "current_rps": self.current_rps,
             "current_fail_per_sec": self.current_fail_per_sec,
+            "avg_response_time": self.avg_response_time,
             "median_response_time": self.median_response_time,
+            "total_rps": self.total_rps,
+            "total_fail_per_sec": self.total_fail_per_sec,
             **response_time_percentiles,
             "avg_content_length": self.avg_content_length,
         }

locust-2.30.1/locust/util/directory.py

@@ -0,0 +1,12 @@
+import os
+
+
+def get_abspaths_in(path, extension=None):
+    return [
+        os.path.abspath(os.path.join(root, f))
+        for root, _dirs, fs in os.walk(path)
+        for f in fs
+        if os.path.isfile(os.path.join(root, f))
+        and (f.endswith(extension) or extension is None)
+        and not f.startswith("_")
+    ]

locust-2.30.1/locust/util/url.py

@@ -0,0 +1,15 @@
+from urllib.parse import urlparse
+
+
+def is_url(url: str) -> bool:
+    """
+    Check if path is an url
+    """
+    try:
+        result = urlparse(url)
+        if result.scheme == "https" or result.scheme == "http":
+            return True
+        else:
+            return False
+    except ValueError:
+        return False

{locust-2.29.2.dev72 → locust-2.30.1}/locust/web.py

@@ -33,12 +33,13 @@ from gevent import pywsgi
 from . import __version__ as version
 from . import argument_parser
 from . import stats as stats_module
-from .html import BUILD_PATH, ROOT_PATH, STATIC_PATH, get_html_report
+from .html import DEFAULT_BUILD_PATH, get_html_report, render_template_from
 from .log import get_logs, greenlet_exception_logger
 from .runners import STATE_MISSING, STATE_RUNNING, MasterRunner
 from .stats import StatsCSV, StatsCSVFileWriter, StatsErrorDict, sort_stats
 from .user.inspectuser import get_ratio
 from .util.cache import memoize
+from .util.date import format_utc_timestamp
 from .util.timespan import parse_timespan
 
 if TYPE_CHECKING:
@@ -96,6 +97,7 @@ class WebUI:
         stats_csv_writer: StatsCSV | None = None,
         delayed_start=False,
         userclass_picker_is_active=False,
+        build_path: str | None = None,
     ):
         """
         Create WebUI instance and start running the web server in a separate greenlet (self.greenlet)
@@ -124,14 +126,11 @@ class WebUI:
         self.app = app
         app.jinja_env.add_extension("jinja2.ext.do")
         app.debug = True
-        app.root_path = ROOT_PATH
-        self.webui_build_path = BUILD_PATH
         self.greenlet: gevent.Greenlet | None = None
         self._swarm_greenlet: gevent.Greenlet | None = None
         self.template_args = {}
         self.auth_args = {}
-        self.app.template_folder = BUILD_PATH
-        self.app.static_folder = STATIC_PATH
+        self.app.template_folder = build_path or DEFAULT_BUILD_PATH
         self.app.static_url_path = "/assets/"
         # ensures static js files work on Windows
         mimetypes.add_type("application/javascript", ".js")
@@ -152,13 +151,19 @@ class WebUI:
             error_code = getattr(error, "code", 500)
             logger.log(
                 logging.INFO if error_code <= 404 else logging.ERROR,
-                f"UI got request for {request.path}, but it resulted in a {error.code}: {error.name}",
+                f"UI got request for {request.path}, but it resulted in a {error_code}: {error.name}",
             )
             return make_response(error_message, error_code)
 
         @app.route("/assets/<path:path>")
         def send_assets(path):
-            return send_from_directory(os.path.join(self.webui_build_path, "assets"), path)
+            directory = (
+                os.path.join(self.app.template_folder, "assets")
+                if os.path.exists(os.path.join(app.template_folder, "assets", path))
+                else os.path.join(DEFAULT_BUILD_PATH, "assets")
+            )
+
+            return send_from_directory(directory, path)
 
         @app.route("/")
         @self.auth_required_if_enabled
@@ -499,7 +504,7 @@ class WebUI:
             if not self.web_login:
                 return redirect(url_for("index"))
 
-            return render_template(
+            return render_template_from(
                 "auth.html",
                 auth_args=self.auth_args,
             )
@@ -613,6 +618,8 @@ class WebUI:
             else None
         )
 
+        start_time = format_utc_timestamp(stats.start_time)
+
         self.template_args = {
             "locustfile": self.environment.locustfile,
             "state": self.environment.runner.state,
@@ -630,6 +637,7 @@ class WebUI:
                 and not (self.userclass_picker_is_active or self.environment.shape_class.use_common_options)
             ),
             "stats_history_enabled": options and options.stats_history_enabled,
+            "start_time": start_time,
             "tasks": dumps({}),
             "extra_options": extra_options,
             "run_time": options and options.run_time,

{locust-2.29.2.dev72 → locust-2.30.1}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "poetry_dynamic_versioning.backend"
 [tool.poetry]
 name = "locust"
 description = "Developer-friendly load testing framework"
-version = "2.29.2.dev72"
+version = "2.30.1"
 license = "MIT"
 readme = "README.md"
 authors = ["Jonatan Heyman", "Lars Holmberg"]