locust 2.43.4.dev19__tar.gz → 2.43.4.dev31__tar.gz

{locust-2.43.4.dev19 → locust-2.43.4.dev31}/PKG-INFO

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

{locust-2.43.4.dev19 → locust-2.43.4.dev31}/locust/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '2.43.4.dev19'
-__version_tuple__ = version_tuple = (2, 43, 4, 'dev19')
+__version__ = version = '2.43.4.dev31'
+__version_tuple__ = version_tuple = (2, 43, 4, 'dev31')
 
 __commit_id__ = commit_id = None

{locust-2.43.4.dev19 → locust-2.43.4.dev31}/locust/stats.py

@@ -119,6 +119,27 @@ PERCENTILES_TO_STATISTICS = [0.95, 0.99]
 PERCENTILES_TO_CHART = [0.5, 0.95]
 
 
+def bucket_response_time(response_time: int | float) -> int:
+    """Round response time to reduce unique histogram keys.
+
+    Rounds to ~2 significant digits, so that 147 becomes 150, 3432 becomes 3400
+    and 58760 becomes 59000. This limits the dict to ~310 unique keys, which is
+    important for bandwidth in distributed mode.
+
+    This is a module-level function so it can be replaced at runtime for custom
+    bucketing, e.g. rounding to 3 significant figures or using fixed-width bins.
+    See :ref:`customizing-response-time-bucketing` in the docs.
+    """
+    if response_time < 100:
+        return round(response_time)
+    elif response_time < 1000:
+        return int(round(response_time, -1))
+    elif response_time < 10000:
+        return int(round(response_time, -2))
+    else:
+        return int(round(response_time, -3))
+
+
 class RequestStatsAdditionError(Exception):
     pass
 
@@ -381,14 +402,7 @@ class StatsEntry:
         # to avoid to much data that has to be transferred to the master node when
         # running in distributed mode, we save the response time rounded in a dict
         # so that 147 becomes 150, 3432 becomes 3400 and 58760 becomes 59000
-        if response_time < 100:
-            rounded_response_time = round(response_time)
-        elif response_time < 1000:
-            rounded_response_time = round(response_time, -1)
-        elif response_time < 10000:
-            rounded_response_time = round(response_time, -2)
-        else:
-            rounded_response_time = round(response_time, -3)
+        rounded_response_time = bucket_response_time(response_time)
 
         # increase request count for the rounded key in response time dict
         self.response_times[rounded_response_time] += 1

{locust-2.43.4.dev19 → locust-2.43.4.dev31}/locust/user/task.py

@@ -316,7 +316,8 @@ class TaskSet(metaclass=TaskSetMeta):
             self.max_wait = self.user.max_wait
         if not self.wait_function:
             self.wait_function = self.user.wait_function
-        self._cp_last_run = time()  # used by constant_pacing wait_time
+        self._cp_last_run: float = time()  # used by constant_pacing wait_time
+        self._cp_last_wait_time: float = 0  # used by constant_pacing wait_time
 
     @property
     def user(self) -> User:

{locust-2.43.4.dev19 → locust-2.43.4.dev31}/locust/user/users.py

@@ -136,7 +136,8 @@ class User(metaclass=UserMeta):
         self._greenlet: greenlet.Greenlet | None = None
         self._group: Group
         self._taskset_instance: TaskSet | None = None
-        self._cp_last_run = time.time()  # used by constant_pacing wait_time
+        self._cp_last_run: float = time.time()  # used by constant_pacing wait_time
+        self._cp_last_wait_time: float = 0  # used by constant_pacing wait_time
 
     def on_start(self) -> None:
         """

{locust-2.43.4.dev19 → locust-2.43.4.dev31}/locust/user/wait_time.py

@@ -1,8 +1,13 @@
 import random
+from collections.abc import Callable
 from time import time
+from typing import TYPE_CHECKING
 
+if TYPE_CHECKING:
+    from locust import User
 
-def between(min_wait, max_wait):
+
+def between(min_wait: float, max_wait: float) -> Callable[["User"], float]:
     """
     Returns a function that will return a random number between min_wait and max_wait.
 
@@ -15,7 +20,7 @@ def between(min_wait, max_wait):
     return lambda instance: min_wait + random.random() * (max_wait - min_wait)
 
 
-def constant(wait_time):
+def constant(wait_time: float) -> Callable[["User"], float]:
     """
     Returns a function that just returns the number specified by the wait_time argument
 
@@ -27,7 +32,7 @@ def constant(wait_time):
     return lambda instance: wait_time
 
 
-def constant_pacing(wait_time):
+def constant_pacing(wait_time: float) -> Callable[["User"], float]:
     """
     Returns a function that will track the run time of the tasks, and for each time it's
     called it will return a wait time that will try to make the total time between task
@@ -46,10 +51,8 @@ def constant_pacing(wait_time):
     the next task.
     """
 
-    def wait_time_func(self):
-        if not hasattr(self, "_cp_last_wait_time"):
-            self._cp_last_wait_time = 0
-        run_time = time() - self._cp_last_run - self._cp_last_wait_time
+    def wait_time_func(self: "User") -> float:
+        run_time: float = time() - self._cp_last_run - self._cp_last_wait_time
         self._cp_last_wait_time = max(0, wait_time - run_time)
         self._cp_last_run = time()
         return self._cp_last_wait_time
@@ -57,7 +60,7 @@ def constant_pacing(wait_time):
     return wait_time_func
 
 
-def constant_throughput(task_runs_per_second):
+def constant_throughput(task_runs_per_second: float) -> Callable[["User"], float]:
     """
     Returns a function that will track the run time of the tasks, and for each time it's
     called it will return a wait time that will try to make the number of task runs per second