locust 2.29.2.dev26__tar.gz → 2.29.2.dev34__tar.gz

{locust-2.29.2.dev26 → locust-2.29.2.dev34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: locust
-Version: 2.29.2.dev26
+Version: 2.29.2.dev34
 Summary: Developer-friendly load testing framework
 License: MIT
 Project-URL: Homepage, https://github.com/locustio/locust

{locust-2.29.2.dev26 → locust-2.29.2.dev34}/docs/tasksets.rst

@@ -148,7 +148,8 @@ SequentialTaskSet class
 =======================
 
 :py:class:`SequentialTaskSet <locust.SequentialTaskSet>` is a TaskSet whose tasks will be executed 
-in the order that they are declared. It is possible to nest SequentialTaskSets 
+in the order that they are declared. If the  *<Task : int>* dictionary is used, each task will be repeated by the amount
+given by the integer at the point of declaration. It is possible to nest SequentialTaskSets
 within a TaskSet and vice versa.
 
 For example, the following code will request URLs /1-/4 in order, and then repeat.
@@ -164,8 +165,9 @@ For example, the following code will request URLs /1-/4 in order, and then repea
             self.client.get("/1")
             self.client.get("/2")
         
-        # you can still use the tasks attribute to specify a list of tasks
+        # you can still use the tasks attribute to specify a list or dict of tasks
         tasks = [function_task]
+        # tasks = {function_task: 1}
         
         @task
         def last_task(self):

{locust-2.29.2.dev26 → locust-2.29.2.dev34}/locust/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.29.2.dev26'
-__version_tuple__ = version_tuple = (2, 29, 2, 'dev26')
+__version__ = version = '2.29.2.dev34'
+__version_tuple__ = version_tuple = (2, 29, 2, 'dev34')

{locust-2.29.2.dev26 → locust-2.29.2.dev34}/locust/stats.py

@@ -9,25 +9,12 @@ import signal
 import time
 from abc import abstractmethod
 from collections import OrderedDict, defaultdict, namedtuple
-from collections import (
-    OrderedDict as OrderedDictType,
-)
 from collections.abc import Iterable
 from copy import copy
 from html import escape
 from itertools import chain
-from tempfile import NamedTemporaryFile
 from types import FrameType
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Callable,
-    NoReturn,
-    Protocol,
-    TypedDict,
-    TypeVar,
-    cast,
-)
+from typing import TYPE_CHECKING, Any, Callable, NoReturn, Protocol, TypedDict, TypeVar, cast
 
 import gevent
 
@@ -319,12 +306,12 @@ class StatsEntry:
         A {response_time => count} dict that holds the response time distribution of all
         the requests.
 
-        The keys (the response time in ms) are rounded to store 1, 2, ... 9, 10, 20. .. 90,
-        100, 200 .. 900, 1000, 2000 ... 9000, in order to save memory.
+        The keys (the response time in ms) are rounded to store 1, 2, ... 98, 99, 100, 110, 120, ... 980, 990, 1000,
+        1100, 1200, ... 9800, 9900, 10_000, 11_000, 12_000 ... in order to save memory.
 
         This dict is used to calculate the median and percentile response times.
         """
-        self.response_times_cache: OrderedDictType[int, CachedResponseTimes] | None = None
+        self.response_times_cache: OrderedDict[int, CachedResponseTimes] | None = None
         """
         If use_response_times_cache is set to True, this will be a {timestamp => CachedResponseTimes()}
         OrderedDict that holds a copy of the response_times dict for each of the last 20 seconds.

{locust-2.29.2.dev26 → locust-2.29.2.dev34}/locust/test/test_sequential_taskset.py

@@ -34,6 +34,26 @@ class TestTaskSet(LocustTestCase):
         self.assertRaises(RescheduleTask, lambda: l.run())
         self.assertEqual([1, 2, 3], log)
 
+    def test_task_sequence_with_dictionary(self):
+        log = []
+
+        def t1(self):
+            log.append(1)
+
+        def t2(self):
+            log.append(2)
+
+        def t3(self):
+            log.append(3)
+            self.interrupt(reschedule=False)
+
+        class MyTaskSequence(SequentialTaskSet):
+            tasks = {t1: 3, t2: 2, t3: 1}
+
+        l = MyTaskSequence(self.locust)
+        self.assertRaises(RescheduleTask, lambda: l.run())
+        self.assertEqual([1, 1, 1, 2, 2, 3], log)
+
     def test_task_sequence_with_methods(self):
         log = []
 

{locust-2.29.2.dev26 → locust-2.29.2.dev34}/locust/user/sequential_taskset.py

@@ -1,6 +1,6 @@
 from locust.exception import LocustError
 
-import logging
+from itertools import cycle
 
 from .task import TaskSet, TaskSetMeta
 
@@ -26,8 +26,12 @@ class SequentialTaskSetMeta(TaskSetMeta):
                 # compared to methods declared with @task
                 if isinstance(value, list):
                     new_tasks.extend(value)
+                elif isinstance(value, dict):
+                    for task, weight in value.items():
+                        for _ in range(weight):
+                            new_tasks.append(task)
                 else:
-                    raise ValueError("On SequentialTaskSet the task attribute can only be set to a list")
+                    raise ValueError("The 'tasks' attribute can only be set to list or dict")
 
             if "locust_task_weight" in dir(value):
                 # method decorated with @task
@@ -52,13 +56,11 @@ class SequentialTaskSet(TaskSet, metaclass=SequentialTaskSetMeta):
 
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
-        self._task_index = 0
+        self._task_cycle = cycle(self.tasks)
 
     def get_next_task(self):
         if not self.tasks:
             raise LocustError(
                 "No tasks defined. Use the @task decorator or set the 'tasks' attribute of the SequentialTaskSet"
             )
-        task = self.tasks[self._task_index % len(self.tasks)]
-        self._task_index += 1
-        return task
+        return next(self._task_cycle)