locust 2.26.1.dev48__tar.gz → 2.26.1.dev65__tar.gz

{locust-2.26.1.dev48/locust.egg-info → locust-2.26.1.dev65}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: locust
-Version: 2.26.1.dev48
+Version: 2.26.1.dev65
 Summary: Developer friendly load testing framework
 License: MIT
 Project-URL: Homepage, https://github.com/locustio/locust
@@ -38,7 +38,6 @@ Requires-Dist: tomli>=1.1.0; python_version < "3.11"
 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"
 
 # Locust

{locust-2.26.1.dev48 → locust-2.26.1.dev65}/benchmarks/dispatch.py

@@ -15,509 +15,48 @@ import time
 
 from prettytable import PrettyTable
 
-
-class User1(User):
-    weight = 5
-
-
-class User2(User):
-    weight = 55
-
-
-class User3(User):
-    weight = 37
-
-
-class User4(User):
-    weight = 2
-
-
-class User5(User):
-    weight = 97
-
-
-class User6(User):
-    weight = 41
-
-
-class User7(User):
-    weight = 33
-
-
-class User8(User):
-    weight = 19
-
-
-class User9(User):
-    weight = 19
-
-
-class User10(User):
-    weight = 34
-
-
-class User11(User):
-    weight = 78
-
-
-class User12(User):
-    weight = 76
-
-
-class User13(User):
-    weight = 28
-
-
-class User14(User):
-    weight = 62
-
-
-class User15(User):
-    weight = 69
-
-
-class User16(User):
-    weight = 5
-
-
-class User17(User):
-    weight = 55
-
-
-class User18(User):
-    weight = 37
-
-
-class User19(User):
-    weight = 2
-
-
-class User20(User):
-    weight = 97
-
-
-class User21(User):
-    weight = 41
-
-
-class User22(User):
-    weight = 33
-
-
-class User23(User):
-    weight = 19
-
-
-class User24(User):
-    weight = 19
-
-
-class User25(User):
-    weight = 34
-
-
-class User26(User):
-    weight = 78
-
-
-class User27(User):
-    weight = 76
-
-
-class User28(User):
-    weight = 28
-
-
-class User29(User):
-    weight = 62
-
-
-class User30(User):
-    weight = 69
-
-
-class User31(User):
-    weight = 41
-
-
-class User32(User):
-    weight = 33
-
-
-class User33(User):
-    weight = 19
-
-
-class User34(User):
-    weight = 19
-
-
-class User35(User):
-    weight = 34
-
-
-class User36(User):
-    weight = 78
-
-
-class User37(User):
-    weight = 76
-
-
-class User38(User):
-    weight = 28
-
-
-class User39(User):
-    weight = 62
-
-
-class User40(User):
-    weight = 69
-
-
-class User41(User):
-    weight = 41
-
-
-class User42(User):
-    weight = 33
-
-
-class User43(User):
-    weight = 19
-
-
-class User44(User):
-    weight = 19
-
-
-class User45(User):
-    weight = 34
-
-
-class User46(User):
-    weight = 78
-
-
-class User47(User):
-    weight = 76
-
-
-class User48(User):
-    weight = 28
-
-
-class User49(User):
-    weight = 62
-
-
-class User50(User):
-    weight = 69
-
-
-class User51(User):
-    weight = 5
-
-
-class User52(User):
-    weight = 55
-
-
-class User53(User):
-    weight = 37
-
-
-class User54(User):
-    weight = 2
-
-
-class User55(User):
-    weight = 97
-
-
-class User56(User):
-    weight = 41
-
-
-class User57(User):
-    weight = 33
-
-
-class User58(User):
-    weight = 19
-
-
-class User59(User):
-    weight = 19
-
-
-class User60(User):
-    weight = 34
-
-
-class User61(User):
-    weight = 78
-
-
-class User62(User):
-    weight = 76
-
-
-class User63(User):
-    weight = 28
-
-
-class User64(User):
-    weight = 62
-
-
-class User65(User):
-    weight = 69
-
-
-class User66(User):
-    weight = 5
-
-
-class User67(User):
-    weight = 55
-
-
-class User68(User):
-    weight = 37
-
-
-class User69(User):
-    weight = 2
-
-
-class User70(User):
-    weight = 97
-
-
-class User71(User):
-    weight = 41
-
-
-class User72(User):
-    weight = 33
-
-
-class User73(User):
-    weight = 19
-
-
-class User74(User):
-    weight = 19
-
-
-class User75(User):
-    weight = 34
-
-
-class User76(User):
-    weight = 78
-
-
-class User77(User):
-    weight = 76
-
-
-class User78(User):
-    weight = 28
-
-
-class User79(User):
-    weight = 62
-
-
-class User80(User):
-    weight = 69
-
-
-class User81(User):
-    weight = 41
-
-
-class User82(User):
-    weight = 33
-
-
-class User83(User):
-    weight = 19
-
-
-class User84(User):
-    weight = 19
-
-
-class User85(User):
-    weight = 34
-
-
-class User86(User):
-    weight = 78
-
-
-class User87(User):
-    weight = 76
-
-
-class User88(User):
-    weight = 28
-
-
-class User89(User):
-    weight = 62
-
-
-class User90(User):
-    weight = 69
-
-
-class User91(User):
-    weight = 41
-
-
-class User92(User):
-    weight = 33
-
-
-class User93(User):
-    weight = 19
-
-
-class User94(User):
-    weight = 19
-
-
-class User95(User):
-    weight = 34
-
-
-class User96(User):
-    weight = 78
-
-
-class User97(User):
-    weight = 76
-
-
-class User98(User):
-    weight = 28
-
-
-class User99(User):
-    weight = 62
-
-
-class User100(User):
-    weight = 69
-
-
-USER_CLASSES = [
-    User1,
-    User2,
-    User3,
-    User4,
-    User5,
-    User6,
-    User7,
-    User8,
-    User9,
-    User10,
-    User11,
-    User12,
-    User13,
-    User14,
-    User15,
-    User16,
-    User17,
-    User18,
-    User19,
-    User20,
-    User21,
-    User22,
-    User23,
-    User24,
-    User25,
-    User26,
-    User27,
-    User28,
-    User29,
-    User30,
-    User31,
-    User32,
-    User33,
-    User34,
-    User35,
-    User36,
-    User37,
-    User38,
-    User39,
-    User40,
-    User41,
-    User42,
-    User43,
-    User44,
-    User45,
-    User46,
-    User47,
-    User48,
-    User49,
-    User50,
-    User51,
-    User52,
-    User53,
-    User54,
-    User55,
-    User56,
-    User57,
-    User58,
-    User59,
-    User60,
-    User61,
-    User62,
-    User63,
-    User64,
-    User65,
-    User66,
-    User67,
-    User68,
-    User69,
-    User70,
-    User71,
-    User72,
-    User73,
-    User74,
-    User75,
-    User76,
-    User77,
-    User78,
-    User79,
-    User80,
-    User81,
-    User82,
-    User83,
-    User84,
-    User85,
-    User86,
-    User87,
-    User88,
-    User89,
-    User90,
-    User91,
-    User92,
-    User93,
-    User94,
-    User95,
-    User96,
-    User97,
-    User98,
-    User99,
-    User100,
+# fmt: off
+WEIGHTS = [
+     5, 55, 37,  2, 97, 41, 33, 19, 19, 34,
+    78, 76, 28, 62, 69,  5, 55, 37,  2, 97,
+    41, 33, 19, 19, 34, 78, 76, 28, 62, 69,
+    41, 33, 19, 19, 34, 78, 76, 28, 62, 69,
+    41, 33, 19, 19, 34, 78, 76, 28, 62, 69,
+     5, 55, 37,  2, 97, 41, 33, 19, 19, 34,
+    78, 76, 28, 62, 69,  5, 55, 37,  2, 97,
+    41, 33, 19, 19, 34, 78, 76, 28, 62, 69,
+    41, 33, 19, 19, 34, 78, 76, 28, 62, 69,
+    41, 33, 19, 19, 34, 78, 76, 28, 62, 69,
 ]
+# fmt: on
+
+for i, x in enumerate(WEIGHTS):
+    exec(f"class User{i+1}(User): weight = {x}")
+
+# Equivalent to:
+#
+# class User1(User):
+#     weight = 5
+#
+# class User2(User):
+#     weight = 55
+# .
+# .
+# .
+# class User100(User):
+#     weight = 69
+
+exec("USER_CLASSES = [" + ",".join(f"User{i+1}" for i in range(len(WEIGHTS))) + "]")
+# Equivalent to:
+#
+# USER_CLASSES = [
+#     User1,
+#     User2,
+#     .
+#     .
+#     .
+#     User100,
+# ]
 
 
 if __name__ == "__main__":
@@ -545,7 +84,10 @@ if __name__ == "__main__":
             workers = [WorkerNode(str(i + 1)) for i in range(worker_count)]
 
             ts = time.perf_counter()
-            users_dispatcher = UsersDispatcher(worker_nodes=workers, user_classes=USER_CLASSES[:number_of_user_classes])
+            users_dispatcher = UsersDispatcher(
+                worker_nodes=workers,
+                user_classes=USER_CLASSES[:number_of_user_classes],  # noqa: F821 (Undefined name `USER_CLASSES`) -> It's created inside "exec"
+            )
             instantiate_duration = time.perf_counter() - ts
 
             # Ramp-up

{locust-2.26.1.dev48 → locust-2.26.1.dev65}/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.dev65'
+__version_tuple__ = version_tuple = (2, 26, 1, 'dev65')

{locust-2.26.1.dev48 → locust-2.26.1.dev65}/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]]: