locust 2.30.1.dev17__py3-none-any.whl → 2.30.1.dev25__py3-none-any.whl

locust/_version.py

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

locust/argument_parser.py

@@ -496,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/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/env.py

@@ -171,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
@@ -197,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/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/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__
 
@@ -482,6 +486,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/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")
@@ -158,7 +157,13 @@ class WebUI:
 
         @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,