locust 2.46.5.dev8__tar.gz → 2.46.6__tar.gz

{locust-2.46.5.dev8 → locust-2.46.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: locust
-Version: 2.46.5.dev8
+Version: 2.46.6
 Summary: Developer-friendly load testing framework
 Project-URL: Homepage, https://locust.cloud/
 Project-URL: Repository, https://github.com/locustio/locust

{locust-2.46.5.dev8 → locust-2.46.6}/locust/__init__.py

@@ -31,7 +31,7 @@ from .user.markov_taskset import MarkovTaskSet, transition, transitions
 from .user.sequential_taskset import SequentialTaskSet
 from .user.task import TaskSet, tag, task
 from .user.users import HttpUser, User
-from .user.wait_time import between, constant, constant_pacing, constant_throughput
+from .user.wait_time import between, constant, constant_pacing, constant_throughput, poisson
 
 events = Events()
 
@@ -51,6 +51,7 @@ __all__ = (
     "constant",
     "constant_pacing",
     "constant_throughput",
+    "poisson",
     "events",
     "LoadTestShape",
     "run_single_user",

{locust-2.46.5.dev8 → locust-2.46.6}/locust/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.46.5.dev8'
-__version_tuple__ = version_tuple = (2, 46, 5, 'dev8')
+__version__ = version = '2.46.6'
+__version_tuple__ = version_tuple = (2, 46, 6)
 
 __commit_id__ = commit_id = None

{locust-2.46.5.dev8 → locust-2.46.6}/locust/clients.py

@@ -478,6 +478,10 @@ class ResponseContextManager(Response):
         self._manual_result = exc
 
 
+class RestResponseContextManager(ResponseContextManager):
+    js: dict  # This is technically an Optional, but I dont want to force everyone to check it
+
+
 class LocustHttpAdapter(HTTPAdapter):
     def __init__(self, pool_manager: PoolManager | None, *args, **kwargs):
         self.poolmanager = pool_manager

{locust-2.46.5.dev8 → locust-2.46.6}/locust/contrib/fasthttp.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from locust.exception import CatchResponseError, LocustError, ResponseError, StopTest
 from locust.user import User
+from locust.user.users import RestMixin
 from locust.util.deprecation import DeprecatedFastHttpLocustClass as FastHttpLocust  # noqa: F401
 
 import json
@@ -9,14 +10,11 @@ import json as unshadowed_json  # some methods take a named parameter called jso
 import re
 import socket
 import time
-import traceback
 import zlib
 from base64 import b64encode
-from contextlib import contextmanager
 from http.cookiejar import CookieJar
-from json.decoder import JSONDecodeError
 from ssl import SSLError
-from typing import TYPE_CHECKING, cast
+from typing import TYPE_CHECKING
 from urllib.parse import urlparse, urlunparse
 
 import gevent
@@ -249,7 +247,7 @@ class FastHttpSession:
                 headers["Accept"] = "application/json"
 
         if not allow_redirects:
-            old_redirect_response_codes = self.client.redirect_resonse_codes
+            old_redirect_resonse_codes = self.client.redirect_resonse_codes
             self.client.redirect_resonse_codes = frozenset()
 
         start_perf_counter = time.perf_counter()
@@ -266,7 +264,7 @@ class FastHttpSession:
         }
 
         if not allow_redirects:
-            self.client.redirect_resonse_codes = old_redirect_response_codes
+            self.client.redirect_resonse_codes = old_redirect_resonse_codes
 
         request_meta["response_length"] = 0  # default value, if length cannot be determined
 
@@ -355,7 +353,7 @@ class FastHttpSession:
         return self.request("PUT", url, data=data, **kwargs)
 
 
-class FastHttpUser(User):
+class FastHttpUser(User, RestMixin["RestResponseContextManager"]):
     """
     FastHttpUser provides the same API as HttpUser, but uses geventhttpclient instead of python-requests
     as its underlying client. It uses considerably less CPU on the load generator, and should work
@@ -413,8 +411,6 @@ class FastHttpUser(User):
     abstract = True
     """Dont register this as a User class that can be run by itself"""
 
-    _callstack_regex = re.compile(r'  File "(\/.[^"]*)", line (\d*),(.*)')
-
     def __init__(self, environment) -> None:
         super().__init__(environment)
         if self.host is None:
@@ -443,66 +439,6 @@ class FastHttpUser(User):
         The client support cookies, and therefore keeps the session between HTTP requests.
         """
 
-    @contextmanager
-    def rest(self, method, url, headers: dict | None = None, **kwargs) -> Generator[RestResponseContextManager]:
-        """
-        A wrapper for self.client.request that:
-
-        * Parses the JSON response to a dict called ``js`` in the response object. Marks the request as failed if the response was not valid JSON.
-        * Defaults ``Content-Type`` and ``Accept`` headers to ``application/json``
-        * Sets ``catch_response=True`` (so always use a :ref:`with-block <catch-response>`)
-        * Catches any unhandled exceptions thrown inside your with-block, marking the sample as failed (instead of exiting the task immediately without even firing the request event)
-        """
-        headers = headers or {}
-        if not ("Content-Type" in headers or "content-type" in headers):
-            headers["Content-Type"] = "application/json"
-        if not ("Accept" in headers or "accept" in headers):
-            headers["Accept"] = "application/json"
-        with self.client.request(method, url, catch_response=True, headers=headers, **kwargs) as r:
-            resp = cast(RestResponseContextManager, r)
-            resp.js = None  # type: ignore
-            if resp.content is None:
-                resp.failure(str(resp.error))
-            elif resp.text:
-                try:
-                    resp.js = resp.json()
-                except JSONDecodeError as e:
-                    resp.failure(
-                        f"Could not parse response as JSON. {resp.text[:250]}, response code {resp.status_code}, error {e}"
-                    )
-            try:
-                yield resp
-            except AssertionError as e:
-                if e.args:
-                    if e.args[0].endswith(","):
-                        short_resp = resp.text[:200] if resp.text else resp.text
-                        resp.failure(f"{e.args[0][:-1]}, response was {short_resp}")
-                    else:
-                        resp.failure(e.args[0])
-                else:
-                    resp.failure("Assertion failed")
-
-            except Exception as e:
-                error_lines = []
-                for l in traceback.format_exc().split("\n"):
-                    if m := self._callstack_regex.match(l):
-                        filename = re.sub(r"/((home|Users)/\w*)/", "~/", m.group(1))
-                        error_lines.append(filename + ":" + m.group(2) + m.group(3))
-                    short_resp = resp.text[:200] if resp.text else resp.text
-                    resp.failure(f"{e.__class__.__name__}: {e} at {', '.join(error_lines)}. Response was {short_resp}")
-
-    @contextmanager
-    def rest_(self, method, url, name=None, **kwargs) -> Generator[RestResponseContextManager]:
-        """
-        Some REST api:s use a timestamp as part of their query string (mainly to break through caches).
-        This is a convenience method for that, appending a _=<timestamp> parameter automatically
-        """
-        separator = "&" if "?" in url else "?"
-        if name is None:
-            name = url + separator + "_=..."
-        with self.rest(method, f"{url}{separator}_={int(time.time() * 1000)}", name=name, **kwargs) as resp:
-            yield resp
-
 
 class FastRequest(CompatRequest):
     payload: str | None = None

{locust-2.46.5.dev8 → locust-2.46.6}/locust/runners.py

@@ -1143,8 +1143,14 @@ class MasterRunner(DistributedRunner):
                     self.server.send_to_client(Message("quit", None, msg.node_id))
             case "spawning_complete":
                 # a worker finished spawning (this happens multiple times during rampup)
-                self.clients[msg.node_id].state = STATE_RUNNING
-                self.clients[msg.node_id].user_classes_count = msg.data["user_classes_count"]
+                try:
+                    self.clients[msg.node_id].state = STATE_RUNNING
+                    self.clients[msg.node_id].user_classes_count = msg.data["user_classes_count"]
+                except KeyError:
+                    logger.warning(
+                        f"Got spawning_complete message from unknown worker {msg.node_id}. Asking worker to quit."
+                    )
+                    self.server.send_to_client(Message("quit", None, msg.node_id))
             case "logs":
                 self.environment.update_worker_logs(msg.data)
             case "quit":

{locust-2.46.5.dev8 → locust-2.46.6}/locust/stats.py

@@ -435,7 +435,10 @@ class StatsEntry:
     def median_response_time(self) -> int:
         if not self.response_times:
             return 0
-        median = median_from_dict(self.num_requests - self.num_none_requests, self.response_times) or 0
+        median = (
+            calculate_response_time_percentile(self.response_times, self.num_requests - self.num_none_requests, 0.5)
+            or 0
+        )
 
         # Since we only use two digits of precision when calculating the median response time
         # while still using the exact values for min and max response times, the following checks
@@ -812,20 +815,6 @@ def avg(values: list[float | int]) -> float:
     return sum(values, 0.0) / max(len(values), 1)
 
 
-def median_from_dict(total: int, count: dict[int, int]) -> int:
-    """
-    total is the number of requests made
-    count is a dict {response_time: count}
-    """
-    pos = (total - 1) / 2
-    for k in sorted(count.keys()):
-        if pos < count[k]:
-            return k
-        pos -= count[k]
-
-    return k
-
-
 def setup_distributed_stats_event_listeners(events: Events, stats: RequestStats) -> None:
     def on_report_to_master(client_id: str, data: dict[str, Any]) -> None:
         data["stats"] = stats.serialize_stats()

{locust-2.46.5.dev8 → locust-2.46.6}/locust/user/users.py

@@ -1,6 +1,6 @@
 from __future__ import annotations
 
-from locust.clients import HttpSession
+from locust.clients import HttpSession, RestResponseContextManager
 from locust.exception import CatchResponseError, StopTest, StopUser
 from locust.user.task import (
     LOCUST_STATE_RUNNING,
@@ -14,11 +14,14 @@ from locust.user.wait_time import constant
 from locust.util import deprecation
 
 import logging
+import re
 import sys
 import time
 import traceback
 from collections.abc import Callable
-from typing import TYPE_CHECKING, final
+from contextlib import contextmanager
+from json.decoder import JSONDecodeError
+from typing import TYPE_CHECKING, Any, Generic, TypeVar, final
 
 from gevent import GreenletExit, greenlet
 from gevent.pool import Group
@@ -32,6 +35,8 @@ else:
     from typing_extensions import override
 
 if TYPE_CHECKING:
+    from collections.abc import Generator
+
     import pytest
 
 logger = logging.getLogger(__name__)
@@ -250,7 +255,78 @@ class User(metaclass=UserMeta):
         return ".".join(filter(lambda x: x != "<locals>", (cls.__module__ + "." + cls.__qualname__).split(".")))
 
 
-class HttpUser(User):
+RestResponseT = TypeVar("RestResponseT")
+
+
+class RestMixin(Generic[RestResponseT]):
+    """
+    Provides the ``rest`` and ``rest_`` methods for User classes that have an HTTP ``client`` (HttpUser and FastHttpUser)
+    """
+
+    _callstack_regex = re.compile(r'  File "(\/.[^"]*)", line (\d*),(.*)')
+
+    @contextmanager
+    def rest(self, method, url, headers: dict | None = None, **kwargs) -> Generator[RestResponseT]:
+        """
+        A wrapper for self.client.request that:
+
+        * Parses the JSON response to a dict called ``js`` in the response object. Marks the request as failed if the response was not valid JSON.
+        * Defaults ``Content-Type`` and ``Accept`` headers to ``application/json``
+        * Sets ``catch_response=True`` (so always use a :ref:`with-block <catch-response>`)
+        * Catches any unhandled exceptions thrown inside your with-block, marking the sample as failed (instead of exiting the task immediately without even firing the request event)
+        """
+        headers = headers or {}
+        if not ("Content-Type" in headers or "content-type" in headers):
+            headers["Content-Type"] = "application/json"
+        if not ("Accept" in headers or "accept" in headers):
+            headers["Accept"] = "application/json"
+        with self.client.request(method, url, catch_response=True, headers=headers, **kwargs) as r:  # type: ignore[attr-defined]
+            resp: Any = r
+            resp.js = None
+            if resp.content is None:
+                resp.failure(str(resp.error))
+            elif resp.text:
+                try:
+                    resp.js = resp.json()
+                except JSONDecodeError as e:
+                    resp.failure(
+                        f"Could not parse response as JSON. {resp.text[:250]}, response code {resp.status_code}, error {e}"
+                    )
+            try:
+                yield resp
+            except AssertionError as e:
+                if e.args:
+                    if e.args[0].endswith(","):
+                        short_resp = resp.text[:200] if resp.text else resp.text
+                        resp.failure(f"{e.args[0][:-1]}, response was {short_resp}")
+                    else:
+                        resp.failure(e.args[0])
+                else:
+                    resp.failure("Assertion failed")
+
+            except Exception as e:
+                error_lines = []
+                for l in traceback.format_exc().split("\n"):
+                    if m := self._callstack_regex.match(l):
+                        filename = re.sub(r"/((home|Users)/\w*)/", "~/", m.group(1))
+                        error_lines.append(filename + ":" + m.group(2) + m.group(3))
+                    short_resp = resp.text[:200] if resp.text else resp.text
+                    resp.failure(f"{e.__class__.__name__}: {e} at {', '.join(error_lines)}. Response was {short_resp}")
+
+    @contextmanager
+    def rest_(self, method, url, name=None, **kwargs) -> Generator[RestResponseT]:
+        """
+        Some REST api:s use a timestamp as part of their query string (mainly to break through caches).
+        This is a convenience method for that, appending a _=<timestamp> parameter automatically
+        """
+        separator = "&" if "?" in url else "?"
+        if name is None:
+            name = url + separator + "_=..."
+        with self.rest(method, f"{url}{separator}_={int(time.time() * 1000)}", name=name, **kwargs) as resp:
+            yield resp
+
+
+class HttpUser(User, RestMixin[RestResponseContextManager]):
     """
     Represents an HTTP "user" which is to be spawned and attack the system that is to be load tested.
 

{locust-2.46.5.dev8 → locust-2.46.6}/locust/user/wait_time.py

@@ -84,3 +84,30 @@ def constant_throughput(task_runs_per_second: float) -> Callable[["User"], float
     the next task.
     """
     return constant_pacing(1 / task_runs_per_second)
+
+
+def poisson(rate: float) -> Callable[["User"], float]:
+    """
+    Returns a function that will return a random wait time sampled from an exponential
+    distribution with mean ``1/rate`` seconds. Tasks will therefore arrive according to a
+    Poisson process with mean rate ``rate`` tasks per second, which is a good approximation
+    of how real users arrive.
+
+    The average number of task runs per second will be ``rate``, but unlike
+    :py:func:`constant_throughput <locust.wait_time.constant_throughput>` the individual
+    intervals vary randomly, so bursts and quiet periods occur naturally.
+
+    Example::
+
+        class MyUser(User):
+            wait_time = poisson(2)  # on average, each user runs 2 tasks per second
+            @task
+            def my_task(self):
+                ...
+
+    If you have multiple requests in a task your RPS will of course be higher than the
+    specified throughput.
+    """
+    if rate <= 0:
+        raise ValueError(f"poisson() requires a positive rate, got: {rate}")
+    return lambda instance: random.expovariate(rate)

{locust-2.46.5.dev8 → locust-2.46.6}/locust/web.py

@@ -29,6 +29,7 @@ from flask import (
 from flask_cors import CORS
 from flask_login import LoginManager, login_required
 from gevent import pywsgi
+from jinja2 import TemplateNotFound
 
 from . import __version__ as version
 from . import argument_parser, stats
@@ -206,8 +207,14 @@ class WebUI:
             if not environment.runner:
                 return make_response("Error: Locust Environment does not have any runner", 500)
             self.update_template_args()
-
-            return render_template("index.html", template_args=self.template_args)
+            try:
+                return render_template("index.html", template_args=self.template_args)
+            except TemplateNotFound:
+                return make_response(
+                    "Web UI assets are missing. If running Locust from source, "
+                    "please refer to docs/developing-locust.rst for instructions on building the Web UI.",
+                    500,
+                )
 
         @app_blueprint.route("/swarm", methods=["POST"])
         @self.auth_required_if_enabled

{locust-2.46.5.dev8 → locust-2.46.6}/pyproject.toml

@@ -84,6 +84,7 @@ lint = [
     "ruff==0.15.12",
     "mypy>=1.13.0,<1.15.0",
     "types-requests==2.32.4.20250809",
+    "typos>=1.50.1"
 ]
 release = ["twine>=5.1.1,<6.0.0"]
 docs = [
@@ -273,6 +274,7 @@ python = ["3.12"]
 all = [""]
 types = ["mypy locust/"]
 format = ["ruff check .", "ruff format --check"]
+spelling = ["typos ."]
 
 
 ## Hatch docs building environment
@@ -294,7 +296,7 @@ filterwarnings = [
     # but that isn't always possible
     "ignore::gevent.monkey.MonkeyPatchWarning",
     # "This process is multi-threaded, use of fork() may lead to deadlocks in the child." started happening in Python 3.12
-    # It could potentially be a real issue, but I dont think
+    # It could potentially be a real issue, but I don't think
     "ignore::DeprecationWarning:gevent",
 
 ]