locust 2.35.1.dev5__tar.gz → 2.35.1.dev20__tar.gz

{locust-2.35.1.dev5 → locust-2.35.1.dev20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: locust
-Version: 2.35.1.dev5
+Version: 2.35.1.dev20
 Summary: Developer-friendly load testing framework
 Project-URL: homepage, https://locust.io/
 Project-URL: repository, https://github.com/locustio/locust

{locust-2.35.1.dev5 → locust-2.35.1.dev20}/locust/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.35.1.dev5'
-__version_tuple__ = version_tuple = (2, 35, 1, 'dev5')
+__version__ = version = '2.35.1.dev20'
+__version_tuple__ = version_tuple = (2, 35, 1, 'dev20')

{locust-2.35.1.dev5 → locust-2.35.1.dev20}/locust/html.py

@@ -5,9 +5,8 @@ from itertools import chain
 from jinja2 import Environment as JinjaEnvironment
 from jinja2 import FileSystemLoader
 
-from . import stats as stats_module
+from . import stats
 from .runners import STATE_STOPPED, STATE_STOPPING, MasterRunner
-from .stats import sort_stats, update_stats_history
 from .user.inspectuser import get_ratio
 from .util.date import format_duration, format_utc_timestamp
 
@@ -37,14 +36,14 @@ def get_html_report(
     show_download_link=True,
     theme="",
 ):
-    stats = environment.runner.stats
+    request_stats = environment.runner.stats
 
-    start_time = format_utc_timestamp(stats.start_time)
+    start_time = format_utc_timestamp(request_stats.start_time)
 
-    if end_ts := stats.last_request_timestamp:
+    if end_ts := request_stats.last_request_timestamp:
         end_time = format_utc_timestamp(end_ts)
     else:
-        end_ts = stats.start_time
+        end_ts = request_stats.start_time
         end_time = start_time
 
     host = None
@@ -55,15 +54,15 @@ def get_html_report(
         if len(all_hosts) == 1:
             host = list(all_hosts)[0]
 
-    requests_statistics = list(chain(sort_stats(stats.entries), [stats.total]))
-    failures_statistics = sort_stats(stats.errors)
+    requests_statistics = list(chain(stats.sort_stats(request_stats.entries), [request_stats.total]))
+    failures_statistics = stats.sort_stats(request_stats.errors)
     exceptions_statistics = [
         {**exc, "nodes": ", ".join(exc["nodes"])} for exc in environment.runner.exceptions.values()
     ]
 
-    if stats.history and stats.history[-1]["time"] < end_time:
-        update_stats_history(environment.runner, end_time)
-    history = stats.history
+    if request_stats.history and request_stats.history[-1]["time"] < end_time:
+        stats.update_stats_history(environment.runner, end_time)
+    history = request_stats.history
 
     is_distributed = isinstance(environment.runner, MasterRunner)
     user_spawned = (
@@ -98,13 +97,13 @@ def get_html_report(
             ],
             "start_time": start_time,
             "end_time": end_time,
-            "duration": format_duration(stats.start_time, end_ts),
+            "duration": format_duration(request_stats.start_time, end_ts),
             "host": escape(str(host)),
             "history": history,
             "show_download_link": show_download_link,
             "locustfile": escape(str(environment.locustfile)),
             "tasks": task_data,
-            "percentiles_to_chart": stats_module.PERCENTILES_TO_CHART,
+            "percentiles_to_chart": stats.PERCENTILES_TO_CHART,
             "profile": escape(str(environment.profile)) if environment.profile else None,
         },
         theme=theme,

{locust-2.35.1.dev5 → locust-2.35.1.dev20}/locust/main.py

@@ -15,6 +15,7 @@ import sys
 import time
 import traceback
 import webbrowser
+from typing import TYPE_CHECKING
 
 import gevent
 
@@ -24,16 +25,6 @@ from .env import Environment
 from .html import get_html_report, process_html_filename
 from .input_events import input_listener
 from .log import greenlet_exception_logger, setup_logging
-from .stats import (
-    StatsCSV,
-    StatsCSVFileWriter,
-    print_error_report,
-    print_percentile_stats,
-    print_stats,
-    print_stats_json,
-    stats_history,
-    stats_printer,
-)
 from .user.inspectuser import print_task_ratio, print_task_ratio_json
 from .util.load_locustfile import load_locustfile
 
@@ -52,6 +43,9 @@ except ModuleNotFoundError as e:
     if e.msg != "No module named 'locust_cloud'":
         raise
 
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
 version = locust.__version__
 
 # Options to ignore when using a custom shape class without `use_common_options=True`
@@ -93,79 +87,75 @@ def create_environment(
     )
 
 
-def main():
-    # find specified locustfile(s) and make sure it exists, using a very simplified
-    # command line parser that is only used to parse the -f option.
-    locustfiles = parse_locustfile_option()
-    locustfiles_length = len(locustfiles)
+def merge_locustfiles_content(
+    locustfiles: list[str],
+) -> tuple[
+    dict[str, type[locust.User]],
+    dict[str, locust.LoadTestShape],
+    dict[str, list[locust.TaskSet | Callable]],
+    locust.LoadTestShape | None,
+]:
+    """
+    Validate content of each locustfile in locustfiles and merge data to single objects output.
 
-    # Grabbing the Locustfile if only one was provided. Otherwise, allowing users to select the locustfile in the UI
-    # If --headless or --autostart and multiple locustfiles, all provided UserClasses will be ran
-    locustfile = locustfiles[0] if locustfiles_length == 1 else None
+    Can stop locust execution on errors.
+    """
+    available_user_classes: dict[str, type[locust.User]] = {}
+    available_shape_classes: dict[str, locust.LoadTestShape] = {}
+    # TODO: list[locust.TaskSet | Callable] should be replaced with correct type,
+    #  supported by User class task attribute. This require additional rewrite,
+    #  out of main refactoring.
+    #  Check docs for real supported task attribute signature for User\TaskSet class.
+    available_user_tasks: dict[str, list[locust.TaskSet | Callable]] = {}
 
-    # Importing Locustfile(s) - setting available UserClasses and ShapeClasses to choose from in UI
-    user_classes: dict[str, locust.User] = {}
-    available_user_classes = {}
-    available_shape_classes = {}
-    available_user_tasks = {}
-    shape_class = None
     for _locustfile in locustfiles:
-        docstring, _user_classes, shape_classes = load_locustfile(_locustfile)
+        user_classes, shape_classes = load_locustfile(_locustfile)
 
         # Setting Available Shape Classes
-        if shape_classes:
-            shape_class = shape_classes[0]
-            for shape_class in shape_classes:
-                shape_class_name = type(shape_class).__name__
-                if shape_class_name in available_shape_classes.keys():
-                    sys.stderr.write(f"Duplicate shape classes: {shape_class_name}\n")
-                    sys.exit(1)
+        for _shape_class in shape_classes:
+            shape_class_name = type(_shape_class).__name__
+            if shape_class_name in available_shape_classes.keys():
+                sys.stderr.write(f"Duplicate shape classes: {shape_class_name}\n")
+                sys.exit(1)
 
-                available_shape_classes[shape_class_name] = shape_class
+            available_shape_classes[shape_class_name] = _shape_class
 
         # Setting Available User Classes
-        for key, value in _user_classes.items():
-            if key in available_user_classes.keys():
-                previous_path = inspect.getfile(user_classes[key])
-                new_path = inspect.getfile(value)
+        for class_name, class_definition in user_classes.items():
+            if class_name in available_user_classes.keys():
+                previous_path = inspect.getfile(available_user_classes[class_name])
+                new_path = inspect.getfile(class_definition)
                 if previous_path == new_path:
                     # The same User class was defined in two locustfiles but one probably imported the other, so we just ignore it
                     continue
                 else:
                     sys.stderr.write(
-                        f"Duplicate user class names: {key} is defined in both {previous_path} and {new_path}\n"
+                        f"Duplicate user class names: {class_name} is defined in both {previous_path} and {new_path}\n"
                     )
                     sys.exit(1)
 
-            user_classes[key] = value
-            available_user_classes[key] = value
-            available_user_tasks[key] = value.tasks or {}
+            available_user_classes[class_name] = class_definition
+            available_user_tasks[class_name] = class_definition.tasks
 
-    if len(stats.PERCENTILES_TO_CHART) > 6:
-        logging.error("stats.PERCENTILES_TO_CHART parameter should be a maximum of 6 parameters \n")
-        sys.exit(1)
+    shape_class = list(available_shape_classes.values())[0] if available_shape_classes else None
 
-    def is_valid_percentile(parameter):
-        try:
-            if 0 < float(parameter) < 1:
-                return True
-            return False
-        except ValueError:
-            return False
-
-    for percentile in stats.PERCENTILES_TO_CHART:
-        if not is_valid_percentile(percentile):
-            logging.error(
-                "stats.PERCENTILES_TO_CHART parameter need to be float and value between. 0 < percentile < 1 Eg 0.95\n"
-            )
-            sys.exit(1)
+    return available_user_classes, available_shape_classes, available_user_tasks, shape_class
 
-    for percentile in stats.PERCENTILES_TO_STATISTICS:
-        if not is_valid_percentile(percentile):
-            logging.error(
-                "stats.PERCENTILES_TO_STATISTICS parameter need to be float and value between. 0 < percentile < 1 Eg 0.95\n"
-            )
-            sys.exit(1)
+
+def main():
+    # find specified locustfile(s) and make sure it exists, using a very simplified
+    # command line parser that is only used to parse the -f option.
+    locustfiles = parse_locustfile_option()
+
+    # Importing Locustfile(s) - setting available UserClasses and ShapeClasses to choose from in UI
+    (
+        available_user_classes,
+        available_shape_classes,
+        available_user_tasks,
+        shape_class,
+    ) = merge_locustfiles_content(locustfiles)
+
+    stats.validate_stats_configuration()
 
     # parse all command line options
     options = parse_options()
@@ -290,25 +280,25 @@ def main():
 
     if options.list_commands:
         print("Available Users:")
-        for name in user_classes:
+        for name in available_user_classes:
             print("    " + name)
         sys.exit(0)
 
-    if not user_classes:
+    if not available_user_classes:
         logger.error("No User class found!")
         sys.exit(1)
 
     # make sure specified User exists
     if options.user_classes:
-        if missing := set(options.user_classes) - set(user_classes.keys()):
+        if missing := set(options.user_classes) - set(available_user_classes.keys()):
             logger.error(f"Unknown User(s): {', '.join(missing)}\n")
             sys.exit(1)
         else:
-            names = set(options.user_classes) & set(user_classes.keys())
-            user_classes = [user_classes[n] for n in names]
+            names = set(options.user_classes) & set(available_user_classes.keys())
+            user_classes = [available_user_classes[n] for n in names]
     else:
         # list() call is needed to consume the dict_view object in Python 3
-        user_classes = list(user_classes.values())
+        user_classes = list(available_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])
@@ -327,7 +317,8 @@ def main():
             if soft_limit < minimum_open_file_limit:
                 # Increasing the limit to 10000 within a running process should work on at least MacOS.
                 # It does not work on all OS:es, but we should be no worse off for trying.
-                resource.setrlimit(resource.RLIMIT_NOFILE, [minimum_open_file_limit, hard_limit])
+                limits = minimum_open_file_limit, hard_limit
+                resource.setrlimit(resource.RLIMIT_NOFILE, limits)
         except BaseException:
             logger.warning(
                 f"""System open file limit '{soft_limit} is below minimum setting '{minimum_open_file_limit}'.
@@ -335,9 +326,10 @@ It's not high enough for load testing, and the OS didn't allow locust to increas
 See https://github.com/locustio/locust/wiki/Installation#increasing-maximum-number-of-open-files-limit for more info."""
             )
 
-    # create locust Environment
-    locustfile_path = None if not locustfile else os.path.basename(locustfile)
+    # At least one locust file exists, or system will exit earlier
+    locustfile_path = os.path.basename(locustfiles[0])
 
+    # create locust Environment
     environment = create_environment(
         user_classes,
         options,
@@ -422,11 +414,11 @@ See https://github.com/locustio/locust/wiki/Installation#increasing-maximum-numb
         base_csv_dir = options.csv_prefix[: -len(base_csv_file)]
         if not os.path.exists(base_csv_dir) and len(base_csv_dir) != 0:
             os.makedirs(base_csv_dir)
-        stats_csv_writer = StatsCSVFileWriter(
+        stats_csv_writer = stats.StatsCSVFileWriter(
             environment, stats.PERCENTILES_TO_REPORT, options.csv_prefix, options.stats_history_enabled
         )
     else:
-        stats_csv_writer = StatsCSV(environment, stats.PERCENTILES_TO_REPORT)
+        stats_csv_writer = stats.StatsCSV(environment, stats.PERCENTILES_TO_REPORT)
 
     # start Web UI
     if not options.headless and not options.worker:
@@ -512,10 +504,10 @@ See https://github.com/locustio/locust/wiki/Installation#increasing-maximum-numb
     stats_printer_greenlet = None
     if not options.only_summary and (options.print_stats or (options.headless and not options.worker)):
         # spawn stats printing greenlet
-        stats_printer_greenlet = gevent.spawn(stats_printer(runner.stats))
+        stats_printer_greenlet = gevent.spawn(stats.stats_printer(runner.stats))
         stats_printer_greenlet.link_exception(greenlet_exception_handler)
 
-    gevent.spawn(stats_history, runner)
+    gevent.spawn(stats.stats_history, runner)
 
     def start_automatic_run():
         if options.master:
@@ -633,11 +625,11 @@ See https://github.com/locustio/locust/wiki/Installation#increasing-maximum-numb
         if runner is not None:
             runner.quit()
         if options.json:
-            print_stats_json(runner.stats)
+            stats.print_stats_json(runner.stats)
         elif not isinstance(runner, locust.runners.WorkerRunner):
-            print_stats(runner.stats, current=False)
-            print_percentile_stats(runner.stats)
-            print_error_report(runner.stats)
+            stats.print_stats(runner.stats, current=False)
+            stats.print_percentile_stats(runner.stats)
+            stats.print_error_report(runner.stats)
         environment.events.quit.fire(exit_code=code)
         sys.exit(code)
 

{locust-2.35.1.dev5 → locust-2.35.1.dev20}/locust/stats.py

@@ -6,25 +6,28 @@ import json
 import logging
 import os
 import signal
+import sys
 import time
 from abc import abstractmethod
 from collections import OrderedDict, defaultdict, namedtuple
-from collections.abc import Callable, Iterable
 from copy import copy
 from html import escape
 from itertools import chain
-from types import FrameType
-from typing import TYPE_CHECKING, Any, NoReturn, Protocol, TypedDict, TypeVar, cast
+from typing import TYPE_CHECKING, Protocol, TypedDict, TypeVar, cast
 
 import gevent
 
-from .event import Events
 from .exception import CatchResponseError
 from .util.date import format_utc_timestamp
 from .util.rounding import proper_round
 
 if TYPE_CHECKING:
+    from collections.abc import Callable, Iterable
+    from types import FrameType
+    from typing import Any, NoReturn
+
     from .env import Environment
+    from .event import Events
     from .runners import Runner
 
 console_logger = logging.getLogger("locust.stats_logger")
@@ -1183,3 +1186,39 @@ class StatsCSVFileWriter(StatsCSV):
 
     def stats_history_file_name(self) -> str:
         return self.base_filepath + "_stats_history.csv"
+
+
+def _is_valid_percentile(parameter) -> bool:
+    """Validate single percentile value from .stats constants."""
+    try:
+        if 0 < float(parameter) < 1:
+            return True
+        return False
+    except ValueError:
+        return False
+
+
+def validate_stats_configuration() -> None:
+    """
+    This function validates .stats file's constants, that may be patched in user
+    environments.
+
+    No return in normal conditional. Stops locust execution on error.
+    """
+    if len(PERCENTILES_TO_CHART) > 6:
+        sys.stderr.write("stats.PERCENTILES_TO_CHART parameter should be a maximum of 6 parameters \n")
+        sys.exit(1)
+
+    for percentile in PERCENTILES_TO_CHART:
+        if not _is_valid_percentile(percentile):
+            sys.stderr.write(
+                "stats.PERCENTILES_TO_CHART parameter need to be float and value between. 0 < percentile < 1 Eg 0.95\n"
+            )
+            sys.exit(1)
+
+    for percentile in PERCENTILES_TO_STATISTICS:
+        if not _is_valid_percentile(percentile):
+            sys.stderr.write(
+                "stats.PERCENTILES_TO_STATISTICS parameter need to be float and value between. 0 < percentile < 1 Eg 0.95\n"
+            )
+            sys.exit(1)

{locust-2.35.1.dev5 → locust-2.35.1.dev20}/locust/util/load_locustfile.py

@@ -10,21 +10,21 @@ from ..shape import LoadTestShape
 from ..user import User
 
 
-def is_user_class(item):
+def is_user_class(item) -> bool:
     """
     Check if a variable is a runnable (non-abstract) User class
     """
     return bool(inspect.isclass(item) and issubclass(item, User) and item.abstract is False)
 
 
-def is_shape_class(item):
+def is_shape_class(item) -> bool:
     """
     Check if a class is a LoadTestShape
     """
     return bool(inspect.isclass(item) and issubclass(item, LoadTestShape) and not getattr(item, "abstract", True))
 
 
-def load_locustfile(path) -> tuple[str | None, dict[str, User], list[LoadTestShape]]:
+def load_locustfile(path) -> tuple[dict[str, type[User]], list[LoadTestShape]]:
     """
     Import given locustfile path and return (docstring, callables).
 
@@ -82,4 +82,4 @@ def load_locustfile(path) -> tuple[str | None, dict[str, User], list[LoadTestSha
     # Find shape class, if any, return it
     shape_classes = [value() for value in vars(imported).values() if is_shape_class(value)]
 
-    return imported.__doc__, user_classes, shape_classes
+    return user_classes, shape_classes

{locust-2.35.1.dev5 → locust-2.35.1.dev20}/locust/web.py

@@ -32,12 +32,10 @@ from flask_login import LoginManager, login_required
 from gevent import pywsgi
 
 from . import __version__ as version
-from . import argument_parser
-from . import stats as stats_module
+from . import argument_parser, stats
 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_safe_timestamp
@@ -126,7 +124,7 @@ class WebUI:
         web_login: bool = False,
         tls_cert: str | None = None,
         tls_key: str | None = None,
-        stats_csv_writer: StatsCSV | None = None,
+        stats_csv_writer: stats.StatsCSV | None = None,
         delayed_start=False,
         userclass_picker_is_active=False,
         build_path: str | None = None,
@@ -145,7 +143,7 @@ class WebUI:
                        allows for adding Flask routes or Blueprints before accepting requests, avoiding errors.
         """
         environment.web_ui = self
-        self.stats_csv_writer = stats_csv_writer or StatsCSV(environment, stats_module.PERCENTILES_TO_REPORT)
+        self.stats_csv_writer = stats_csv_writer or stats.StatsCSV(environment, stats.PERCENTILES_TO_REPORT)
         self.environment = environment
         self.host = host
         self.port = port
@@ -404,7 +402,11 @@ class WebUI:
         @self.auth_required_if_enabled
         def request_stats_full_history_csv() -> Response:
             options = self.environment.parsed_options
-            if options and options.stats_history_enabled and isinstance(self.stats_csv_writer, StatsCSVFileWriter):
+            if (
+                options
+                and options.stats_history_enabled
+                and isinstance(self.stats_csv_writer, stats.StatsCSVFileWriter)
+            ):
                 return send_file(
                     os.path.abspath(self.stats_csv_writer.stats_history_file_name()),
                     mimetype="text/csv",
@@ -430,12 +432,12 @@ class WebUI:
         @self.auth_required_if_enabled
         @memoize(timeout=DEFAULT_CACHE_TIME, dynamic_timeout=True)
         def request_stats() -> Response:
-            stats: list[dict[str, Any]] = []
-            errors: list[StatsErrorDict] = []
+            _stats: list[dict[str, Any]] = []
+            errors: list[stats.StatsErrorDict] = []
 
             if environment.runner is None:
                 report = {
-                    "stats": stats,
+                    "stats": _stats,
                     "errors": errors,
                     "total_rps": 0.0,
                     "total_fail_per_sec": 0.0,
@@ -451,21 +453,21 @@ class WebUI:
 
                 return jsonify(report)
 
-            for s in chain(sort_stats(environment.runner.stats.entries), [environment.runner.stats.total]):
-                stats.append(s.to_dict())
+            for s in chain(stats.sort_stats(environment.runner.stats.entries), [environment.runner.stats.total]):
+                _stats.append(s.to_dict())
 
             errors = [e.serialize() for e in environment.runner.errors.values()]
 
             # Truncate the total number of stats and errors displayed since a large number of rows will cause the app
             # to render extremely slowly. Aggregate stats should be preserved.
-            truncated_stats = stats[:500]
-            if len(stats) > 500:
-                truncated_stats += [stats[-1]]
+            truncated_stats = _stats[:500]
+            if len(_stats) > 500:
+                truncated_stats += [_stats[-1]]
 
             report = {"stats": truncated_stats, "errors": errors[:500]}
-            total_stats = stats[-1]
+            total_stats = _stats[-1]
 
-            if stats:
+            if _stats:
                 report["total_rps"] = total_stats["current_rps"]
                 report["total_fail_per_sec"] = total_stats["current_fail_per_sec"]
                 report["fail_ratio"] = environment.runner.stats.total.fail_ratio
@@ -473,7 +475,7 @@ class WebUI:
                     f"response_time_percentile_{percentile}": environment.runner.stats.total.get_current_response_time_percentile(
                         percentile
                     )
-                    for percentile in stats_module.PERCENTILES_TO_CHART
+                    for percentile in stats.PERCENTILES_TO_CHART
                 }
 
             if isinstance(environment.runner, MasterRunner):
@@ -658,7 +660,7 @@ class WebUI:
         else:
             worker_count = 0
 
-        stats = self.environment.runner.stats
+        request_stats = self.environment.runner.stats
         extra_options = argument_parser.ui_extra_args_dict()
 
         available_user_classes = None
@@ -690,7 +692,7 @@ class WebUI:
             "user_count": self.environment.runner.user_count,
             "version": version,
             "host": host if host else "",
-            "history": stats.history if stats.num_requests > 0 else [],
+            "history": request_stats.history if request_stats.num_requests > 0 else [],
             "override_host_warning": override_host_warning,
             "num_users": options and options.num_users,
             "spawn_rate": options and options.spawn_rate,
@@ -710,8 +712,8 @@ class WebUI:
             "available_shape_classes": available_shape_classes,
             "available_user_tasks": available_user_tasks,
             "users": users,
-            "percentiles_to_chart": stats_module.PERCENTILES_TO_CHART,
-            "percentiles_to_statistics": stats_module.PERCENTILES_TO_STATISTICS,
+            "percentiles_to_chart": stats.PERCENTILES_TO_CHART,
+            "percentiles_to_statistics": stats.PERCENTILES_TO_STATISTICS,
         }
 
         self.template_args = {**self.template_args, **new_template_args}