locust 2.26.1.dev48__py3-none-any.whl → 2.26.1.dev61__py3-none-any.whl

locust/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.26.1.dev48'
-__version_tuple__ = version_tuple = (2, 26, 1, 'dev48')
+__version__ = version = '2.26.1.dev61'
+__version_tuple__ = version_tuple = (2, 26, 1, 'dev61')

locust/dispatch.py

@@ -6,11 +6,12 @@ import math
 import time
 from collections import defaultdict
 from collections.abc import Generator, Iterator
+from heapq import heapify, heapreplace
+from math import log2
 from operator import attrgetter
 from typing import TYPE_CHECKING
 
 import gevent
-from roundrobin import smooth
 
 if TYPE_CHECKING:
     from locust import User
@@ -26,6 +27,33 @@ if TYPE_CHECKING:
 # profile = line_profiler.LineProfiler()
 
 
+def _kl_generator(users: list[tuple[type[User], float]]) -> Iterator[str | 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:
+        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))
+        # calculate how much choosing element i for (x + 1)th time decreases divergence
+        heapreplace(heap, (kl_diff, i))
+
+
 class UsersDispatcher(Iterator):
     """
     Iterator that dispatches the users to the workers.
@@ -319,9 +347,7 @@ class UsersDispatcher(Iterator):
 
     def _distribute_users(
         self, target_user_count: int
-    ) -> tuple[
-        dict[str, dict[str, int]], Generator[str | None, None, None], itertools.cycle, list[tuple[WorkerNode, str]]
-    ]:
+    ) -> tuple[dict[str, dict[str, int]], Iterator[str | None], itertools.cycle, list[tuple[WorkerNode, str]]]:
         """
         This function might take some time to complete if the `target_user_count` is a big number. A big number
         is typically > 50 000. However, this function is only called if a worker is added or removed while a test
@@ -350,71 +376,11 @@ class UsersDispatcher(Iterator):
 
         return users_on_workers, user_gen, worker_gen, active_users
 
-    def _user_gen(self) -> Generator[str | None, None, None]:
-        """
-        This method generates users according to their weights using
-        a smooth weighted round-robin algorithm implemented by https://github.com/linnik/roundrobin.
-
-        For example, given users A, B with weights 5 and 1 respectively, this algorithm
-        will yield AAABAAAAABAA. The smooth aspect of this algorithm is what makes it possible
-        to keep the distribution during ramp-up and ramp-down. If we were to use a normal
-        weighted round-robin algorithm, we'd get AAAAABAAAAAB which would make the distribution
-        less accurate during ramp-up/down.
-        """
-
-        def infinite_cycle_gen(users: list[tuple[type[User], int]]) -> itertools.cycle:
-            if not users:
-                return itertools.cycle([None])
-
-            def _get_order_of_magnitude(n: float) -> int:
-                """Get how many times we need to multiply `n` to get an integer-like number.
-                For example:
-                    0.1 would return 10,
-                    0.04 would return 100,
-                    0.0007 would return 10000.
-                """
-                if n <= 0:
-                    raise ValueError("To get the order of magnitude, the number must be greater than 0.")
-
-                counter = 0
-                while n < 1:
-                    n *= 10
-                    counter += 1
-                return 10**counter
-
-            # Get maximum order of magnitude to "normalize the weights".
-            # "Normalizing the weights" is to multiply all weights by the same number so that
-            # they become integers. Then we can find the largest common divisor of all the
-            # weights, divide them by it and get the smallest possible numbers with the same
-            # ratio as the numbers originally had.
-            max_order_of_magnitude = _get_order_of_magnitude(min(abs(u[1]) for u in users))
-            weights = tuple(int(u[1] * max_order_of_magnitude) for u in users)
-
-            greatest_common_divisor = math.gcd(*weights)
-            normalized_values = [
-                (
-                    user[0].__name__,
-                    normalized_weight // greatest_common_divisor,
-                )
-                for user, normalized_weight in zip(users, weights)
-            ]
-            generation_length_to_get_proper_distribution = sum(
-                normalized_val[1] for normalized_val in normalized_values
-            )
-            gen = smooth(normalized_values)
-
-            # Instead of calling `gen()` for each user, we cycle through a generator of fixed-length
-            # `generation_length_to_get_proper_distribution`. Doing so greatly improves performance because
-            # we only ever need to call `gen()` a relatively small number of times. The length of this generator
-            # is chosen as the sum of the normalized weights. So, for users A, B, C of weights 2, 5, 6, the length is
-            # 2 + 5 + 6 = 13 which would yield the distribution `CBACBCBCBCABC` that gets repeated over and over
-            # until the target user count is reached.
-            return itertools.cycle(gen() for _ in range(generation_length_to_get_proper_distribution))
-
+    def _user_gen(self) -> Iterator[str | None]:
         fixed_users = {u.__name__: u for u in self._user_classes if u.fixed_count}
 
-        cycle_fixed_gen = infinite_cycle_gen([(u, u.fixed_count) for u in fixed_users.values()])
-        cycle_weighted_gen = infinite_cycle_gen([(u, u.weight) for u in self._user_classes if not 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])
 
         # Spawn users
         while True:
@@ -423,7 +389,7 @@ class UsersDispatcher(Iterator):
                 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(cycle_fixed_gen)
+                    user_name: str | None = next(fixed_users_gen)
                     if not user_name:
                         break
 
@@ -439,7 +405,7 @@ class UsersDispatcher(Iterator):
                     else:
                         spawned_classes.add(user_name)
 
-            yield next(cycle_weighted_gen)
+            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/test/test_dispatch.py

@@ -5,6 +5,7 @@ from locust.dispatch import UsersDispatcher
 from locust.runners import WorkerNode
 from locust.test.util import clear_all_functools_lru_cache
 
+import math
 import time
 import unittest
 from operator import attrgetter
@@ -3924,7 +3925,6 @@ class TestRampUpDifferentUsers(unittest.TestCase):
 
         user_dispatcher.new_dispatch(target_user_count=21, spawn_rate=21, user_classes=[User1, User2, User3])
         dispatched_users = next(user_dispatcher)
-        print(dispatched_users)
         self.assertDictEqual(
             dispatched_users,
             {
@@ -4123,6 +4123,40 @@ class TestRampUpDifferentUsers(unittest.TestCase):
         self.assertEqual(_user_count_on_worker(dispatched_users, worker_nodes[2].id), 6)
 
 
+class TestFloatWeithts(unittest.TestCase):
+    def test_float_weights(self):
+        """Final distribution should be {"User1": 3, "User2": 3, "User3": 3}"""
+
+        for ratio in (1, 1.0, 10, 2.5, 0.3, 1 / 23, math.e, math.pi):
+
+            class User1(User):
+                weight = 1 * ratio
+
+            class User2(User):
+                weight = 2 * ratio
+
+            class User3(User):
+                weight = 3 * ratio
+
+            worker_node1 = WorkerNode("1")
+            worker_node2 = WorkerNode("2")
+            worker_node3 = WorkerNode("3")
+
+            sleep_time = 0  # Speed-up test
+
+            users_dispatcher = UsersDispatcher(
+                worker_nodes=[worker_node1, worker_node2, worker_node3], user_classes=[User1, User2, User3]
+            )
+            users_dispatcher.new_dispatch(target_user_count=9, spawn_rate=0.5)
+            users_dispatcher._wait_between_dispatch = sleep_time
+
+            if ratio == 1:
+                reference = list(users_dispatcher)
+            else:
+                for x in reference:
+                    self.assertDictEqual(x, next(users_dispatcher))
+
+
 def _aggregate_dispatched_users(d: dict[str, dict[str, int]]) -> dict[str, int]:
     user_classes = list(next(iter(d.values())).keys())
     return {u: sum(d[u] for d in d.values()) for u in user_classes}

locust/user/users.py

@@ -1,21 +1,8 @@
 from __future__ import annotations
 
-import logging
-import time
-import traceback
-from typing import Callable, final
-
-from gevent import GreenletExit, greenlet
-from gevent.pool import Group
-from urllib3 import PoolManager
-
-logger = logging.getLogger(__name__)
 from locust.clients import HttpSession
 from locust.exception import LocustError, StopUser
-from locust.user.wait_time import constant
-from locust.util import deprecation
-
-from .task import (
+from locust.user.task import (
     LOCUST_STATE_RUNNING,
     LOCUST_STATE_STOPPING,
     LOCUST_STATE_WAITING,
@@ -23,6 +10,17 @@ from .task import (
     TaskSet,
     get_tasks_from_base_classes,
 )
+from locust.user.wait_time import constant
+from locust.util import deprecation
+
+import logging
+import time
+import traceback
+from typing import Callable, final
+
+from gevent import GreenletExit, greenlet
+from gevent.pool import Group
+from urllib3 import PoolManager
 
 logger = logging.getLogger(__name__)
 
@@ -105,27 +103,27 @@ class User(metaclass=UserMeta):
             tasks = {ThreadPage:15, write_post:1}
     """
 
-    weight = 1
+    weight: float = 1
     """Probability of user class being chosen. The higher the weight, the greater the chance of it being chosen."""
 
-    fixed_count = 0
+    fixed_count: int = 0
     """
     If the value > 0, the weight property will be ignored and the 'fixed_count'-instances will be spawned.
     These Users are spawned first. If the total target count (specified by the --users arg) is not enough
     to spawn all instances of each User class with the defined property, the final count of each User is undefined.
     """
 
-    abstract = True
+    abstract: bool = True
     """If abstract is True, the class is meant to be subclassed, and locust will not spawn users of this class during a test."""
 
-    def __init__(self, environment):
+    def __init__(self, environment) -> None:
         super().__init__()
         self.environment = environment
         """A reference to the :py:class:`Environment <locust.env.Environment>` in which this user is running"""
-        self._state = None
-        self._greenlet: greenlet.Greenlet = None
+        self._state: str | None = None
+        self._greenlet: greenlet.Greenlet | None = None
         self._group: Group
-        self._taskset_instance: TaskSet = None
+        self._taskset_instance: TaskSet | None = None
         self._cp_last_run = time.time()  # used by constant_pacing wait_time
 
     def on_start(self) -> None:
@@ -191,7 +189,7 @@ class User(metaclass=UserMeta):
         self._group = group
         return self._greenlet
 
-    def stop(self, force=False):
+    def stop(self, force: bool = False):
         """
         Stop the user greenlet.
 
@@ -251,7 +249,7 @@ class HttpUser(User):
     for keeping a user session between requests.
     """
 
-    abstract = True
+    abstract: bool = True
     """If abstract is True, the class is meant to be subclassed, and users will not choose this locust during a test"""
 
     pool_manager: PoolManager | None = None

{locust-2.26.1.dev48.dist-info → locust-2.26.1.dev61.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: locust
-Version: 2.26.1.dev48
+Version: 2.26.1.dev61
 Summary: Developer friendly load testing framework
 License: MIT
 Project-URL: Homepage, https://github.com/locustio/locust
@@ -37,7 +37,6 @@ Requires-Dist: ConfigArgParse >=1.5.5
 Requires-Dist: psutil >=5.9.1
 Requires-Dist: Flask-Login >=0.6.3
 Requires-Dist: Flask-Cors >=3.0.10
-Requires-Dist: roundrobin >=0.0.2
 Requires-Dist: pywin32 ; platform_system == "Windows"
 Requires-Dist: tomli >=1.1.0 ; python_version < "3.11"
 

{locust-2.26.1.dev48.dist-info → locust-2.26.1.dev61.dist-info}/RECORD

@@ -1,10 +1,10 @@
 locust/__init__.py,sha256=g6oA-Ba_hs3gLWVf5MKJ1mvfltI8MFnDWG8qslqm8yg,1402
 locust/__main__.py,sha256=vBQ82334kX06ImDbFlPFgiBRiLIinwNk3z8Khs6hd74,31
-locust/_version.py,sha256=gadSK3eqNa51B7ixflfmjSwqkQoR97QFFuc15b40Crw,428
+locust/_version.py,sha256=LEYNsmYxTmpPGy-8xPWBC-TOuPW8IR_1QcZb3AZjrPE,428
 locust/argument_parser.py,sha256=izMXLuMZWUpS6m8SrGRmOjLfPPuYWXCvQFicRmn-a90,28774
 locust/clients.py,sha256=YKuAyMAbxs8_-w7XJw0hc67KFBNNLxibsw6FwiS01Q8,14781
 locust/debug.py,sha256=We6Z9W0btkKSc7PxWmrZx-xMynvOOsKhG6jmDgQin0g,5134
-locust/dispatch.py,sha256=S2pAMOlbadOrtMTLTDkq1Pvqes3HVUdZl-K5SDss6ig,19313
+locust/dispatch.py,sha256=vYh0QEDFgJ3hY0HgSk-EiNO7IP9ffzXF_Et8wB9JvsI,16995
 locust/env.py,sha256=nd6ui1bv6n-kkLkP3r61ZkskDY627dsKOAkYHhtOW7o,12472
 locust/event.py,sha256=xgNKbcejxy1TNUfIdgV75KgD2_BOwQmvjrJ4hWuydRw,7740
 locust/exception.py,sha256=jGgJ32ubuf4pWdlaVOkbh2Y0LlG0_DHi-lv3ib8ppOE,1791
@@ -53,7 +53,7 @@ locust/test/fake_module2_for_env_test.py,sha256=dzGYWCr1SSkd8Yyo68paUNrCNW7YY_Qg
 locust/test/mock_locustfile.py,sha256=4xgoAYlhvdIBjGsLFFN0abpTNM7k12iSkrfTPUQhAMQ,1271
 locust/test/mock_logging.py,sha256=qapKrKhTdlVc8foJB2Hxjn7SB6soaLeAj3VF4A6kZtw,806
 locust/test/test_debugging.py,sha256=omQ0w5_Xh1xuTBzkd3VavEIircwtlmoOEHcMInY67vU,1053
-locust/test/test_dispatch.py,sha256=CIO10mC0FL8FjubV0jNZfd3q8EFQdZhLlm4QnN7HbPs,167754
+locust/test/test_dispatch.py,sha256=RjoncanN4FFt-aiTl4G8XRoc81n6fwfO8CacbjzpvP8,168856
 locust/test/test_env.py,sha256=l0fLl9nubdgzxwFNajmBkJvQc5cO5rOTE4p12lbCbs0,8919
 locust/test/test_fasthttp.py,sha256=jVA5wWjZxXYW6emzy-lfPC0AOabzT6rDCX0N7DPP9mc,30727
 locust/test/test_http.py,sha256=VQCVY0inLC0RS-V3E9WHL3vBLGokZjQt0zKSrTNlQmM,12536
@@ -80,7 +80,7 @@ locust/user/__init__.py,sha256=S2yvmI_AU9kXirtTIVqiV_Hs7yXzqXvaSgkNo9ig-fk,71
 locust/user/inspectuser.py,sha256=KgrWHyE5jhK6or58R7soLRf-_st42AaQrR72qbiXw9E,2641
 locust/user/sequential_taskset.py,sha256=E8yykSZBO-QMcza1frr-7l8Cv_5bbSpjRO6sbkmGpZE,2544
 locust/user/task.py,sha256=JvVVCQ1_UQSsahqaEZoFCD-cBXlOJLJ51ewXHNesSAI,16700
-locust/user/users.py,sha256=qhOW5dDmGbsukWDVb1YDs92D_vbCKRIW60jB5I2bRxs,9950
+locust/user/users.py,sha256=BsKyxzLq1lmdYBXnwHNyMH_Nxfy7QRlyLnfiE8539HY,9989
 locust/user/wait_time.py,sha256=bGRKMVx4lom75sX3POYJUa1CPeME2bEAXG6CEgxSO5U,2675
 locust/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 locust/util/cache.py,sha256=IxbpGawl0-hoWKvCrtksxjSLf2GbBBTVns06F7mFBkM,1062
@@ -95,9 +95,9 @@ locust/webui/dist/report.html,sha256=sOdZZVgZbqgu86BBCSQf3uQUYXgmgSnXF32JpnyAII8
 locust/webui/dist/assets/favicon.ico,sha256=IUl-rYqfpHdV38e-s0bkmFIeLS-n3Ug0DQxk-h202hI,8348
 locust/webui/dist/assets/index-941b6e82.js,sha256=G3n5R81Svt0HzbWaV3AV20jLWGLr4X50UZ-Adu2KcxU,1645614
 locust/webui/dist/assets/logo.png,sha256=EIVPqr6wE_yqguHaqFHIsH0ZACLSrvNWyYO7PbyIj4w,19299
-locust-2.26.1.dev48.dist-info/LICENSE,sha256=78XGpIn3fHVBfaxlPNUfjVufSN7QsdhpJMRJHv2AFpo,1095
-locust-2.26.1.dev48.dist-info/METADATA,sha256=9VQCOppNg6gNaf0Np6zUnh-1qPSGR-2gm52m8ewpeJM,7301
-locust-2.26.1.dev48.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-locust-2.26.1.dev48.dist-info/entry_points.txt,sha256=RAdt8Ku-56m7bFjmdj-MBhbF6h4NX7tVODR9QNnOg0E,44
-locust-2.26.1.dev48.dist-info/top_level.txt,sha256=XSsjgPA8Ggf9TqKVbkwSqZFuPlZ085X13M9orDycE20,7
-locust-2.26.1.dev48.dist-info/RECORD,,
+locust-2.26.1.dev61.dist-info/LICENSE,sha256=78XGpIn3fHVBfaxlPNUfjVufSN7QsdhpJMRJHv2AFpo,1095
+locust-2.26.1.dev61.dist-info/METADATA,sha256=iKcIMdLVlX5wXgc8qsYQMxWjMh5C0tLwzuSRnPSXsxA,7267
+locust-2.26.1.dev61.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+locust-2.26.1.dev61.dist-info/entry_points.txt,sha256=RAdt8Ku-56m7bFjmdj-MBhbF6h4NX7tVODR9QNnOg0E,44
+locust-2.26.1.dev61.dist-info/top_level.txt,sha256=XSsjgPA8Ggf9TqKVbkwSqZFuPlZ085X13M9orDycE20,7
+locust-2.26.1.dev61.dist-info/RECORD,,