locust 2.35.1.dev3__tar.gz → 2.35.1.dev11__tar.gz

{locust-2.35.1.dev3 → locust-2.35.1.dev11}/PKG-INFO

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

{locust-2.35.1.dev3 → locust-2.35.1.dev11}/locust/_version.py

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

{locust-2.35.1.dev3 → locust-2.35.1.dev11}/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.dev3 → locust-2.35.1.dev11}/locust/main.py

@@ -24,16 +24,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
 
@@ -141,31 +131,7 @@ def main():
             available_user_classes[key] = value
             available_user_tasks[key] = value.tasks or {}
 
-    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)
-
-    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)
-
-    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)
+    stats.validate_stats_configuration()
 
     # parse all command line options
     options = parse_options()
@@ -422,11 +388,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 +478,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 +599,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.dev3 → locust-2.35.1.dev11}/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.dev3 → locust-2.35.1.dev11}/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}