locust 2.26.1.dev26__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.dev26'
-__version_tuple__ = version_tuple = (2, 26, 1, 'dev26')
+__version__ = version = '2.26.1.dev61'
+__version_tuple__ = version_tuple = (2, 26, 1, 'dev61')

locust/argument_parser.py

@@ -93,90 +93,54 @@ class LocustTomlConfigParser(configargparse.TomlConfigParser):
         return result
 
 
-def _is_package(path):
+def parse_locustfile_paths(paths: list[str]) -> list[str]:
     """
-    Is the given path a Python package?
-    """
-    return os.path.isdir(path) and os.path.exists(os.path.join(path, "__init__.py"))
-
-
-def find_locustfile(locustfile: str) -> str | None:
-    """
-    Attempt to locate a locustfile, either explicitly or by searching parent dirs.
-    """
-    # Obtain env value
-    names = [locustfile]
-    # Create .py version if necessary
-    if not names[0].endswith(".py"):
-        names.append(names[0] + ".py")
-    # Does the name contain path elements?
-    if os.path.dirname(names[0]):
-        # If so, expand home-directory markers and test for existence
-        for name in names:
-            expanded = os.path.expanduser(name)
-            if os.path.exists(expanded):
-                if name.endswith(".py") or _is_package(expanded):
-                    return os.path.abspath(expanded)
-    else:
-        # Otherwise, start in cwd and work downwards towards filesystem root
-        path = os.path.abspath(".")
-        while True:
-            for name in names:
-                joined = os.path.join(path, name)
-                if os.path.exists(joined):
-                    if name.endswith(".py") or _is_package(joined):
-                        return os.path.abspath(joined)
-            parent_path = os.path.dirname(path)
-            if parent_path == path:
-                # we've reached the root path which has been checked this iteration
-                break
-            path = parent_path
-
-    return None
-
+    Returns a list of relative file paths.
 
-def find_locustfiles(locustfiles: list[str], is_directory: bool) -> list[str]:
-    """
-    Returns a list of relative file paths for the Locustfile Picker. If is_directory is True,
-    locustfiles is expected to have a single index which is a directory that will be searched for
-    locustfiles.
+    Args:
+        paths (list[str]): paths taken from the -f command
 
-    Ignores files that start with _
+    Returns:
+        list[str]: Parsed locust file paths
     """
-    file_paths = []
-
-    if is_directory:
-        locustdir = locustfiles[0]
-
-        if len(locustfiles) != 1:
-            sys.stderr.write(f"Multiple values passed in for directory: {locustfiles}\n")
-            sys.exit(1)
-
-        if not os.path.exists(locustdir):
-            sys.stderr.write(f"Could not find directory '{locustdir}'\n")
-            sys.exit(1)
-
-        if not os.path.isdir(locustdir):
-            sys.stderr.write(f"'{locustdir} is not a directory\n")
+    # Parse each path and unpack the returned lists as a single list
+    return [parsed for path in paths for parsed in _parse_locustfile_path(path)]
+
+
+def _parse_locustfile_path(path: str) -> list[str]:
+    parsed_paths = []
+    if is_url(path):
+        # Download the file and use the new path as locustfile
+        parsed_paths.append(download_locustfile_from_url(path))
+    elif os.path.isdir(path):
+        # Find all .py files in directory tree
+        for root, _dirs, fs in os.walk(path):
+            parsed_paths.extend(
+                [
+                    os.path.abspath(os.path.join(root, f))
+                    for f in fs
+                    if os.path.isfile(os.path.join(root, f)) and f.endswith(".py") and not f.startswith("_")
+                ]
+            )
+        if not parsed_paths:
+            sys.stderr.write(f"Could not find any locustfiles in directory '{path}'")
             sys.exit(1)
-
-        for root, dirs, files in os.walk(locustdir):
-            for file in files:
-                if not file.startswith("_") and file.endswith(".py"):
-                    file_path = os.path.join(root, file)
-                    file_paths.append(file_path)
     else:
-        for file_path in locustfiles:
-            if not file_path.endswith(".py"):
-                sys.stderr.write(f"Invalid file '{file_path}'. File should have '.py' extension\n")
-                sys.exit(1)
-
-            file_paths.append(file_path)
+        # If file exists add the abspath
+        if os.path.exists(path) and path.endswith(".py"):
+            parsed_paths.append(os.path.abspath(path))
+        else:
+            note_about_file_endings = "Ensure your locustfile ends with '.py' or is a directory with locustfiles. "
+            sys.stderr.write(f"Could not find '{path}'. {note_about_file_endings}See --help for available options.\n")
+            sys.exit(1)
 
-    return file_paths
+    return parsed_paths
 
 
 def is_url(url: str) -> bool:
+    """
+    Check if path is an url
+    """
     try:
         result = urlparse(url)
         if result.scheme == "https" or result.scheme == "http":
@@ -188,6 +152,10 @@ def is_url(url: str) -> bool:
 
 
 def download_locustfile_from_url(url: str) -> str:
+    """
+    Attempt to download and save locustfile from url.
+    Returns path to downloaded file.
+    """
     try:
         response = requests.get(url)
         # Check if response is valid python code
@@ -244,7 +212,7 @@ See documentation for more details, including how to set options using a file or
         "-f",
         "--locustfile",
         metavar="<filename>",
-        default="locustfile",
+        default="locustfile.py",
         help="The Python file or module that contains your test, e.g. 'my_test.py'. Accepts multiple comma-separated .py files, a package name/directory or a url to a remote locustfile. Defaults to 'locustfile'.",
         env_var="LOCUST_LOCUSTFILE",
     )
@@ -314,7 +282,7 @@ def parse_locustfile_option(args=None) -> list[str]:
     parser
 
     Returns:
-        Locustfiles (List): List of locustfile paths
+        parsed_paths (List): List of locustfile paths
     """
     parser = get_empty_argument_parser(add_help=False)
     parser.add_argument(
@@ -354,6 +322,10 @@ def parse_locustfile_option(args=None) -> list[str]:
 
     options, _ = parser.parse_known_args(args=args)
 
+    if options.help or options.version:
+        # if --help or --version is specified we'll call parse_options which will print the help/version message
+        parse_options(args=args)
+
     if options.locustfile == "-":
         if not options.worker:
             sys.stderr.write(
@@ -364,51 +336,21 @@ def parse_locustfile_option(args=None) -> list[str]:
         filename = download_locustfile_from_master(options.master_host, options.master_port)
         return [filename]
 
-    # Comma separated string to list
-    locustfile_as_list = [
-        download_locustfile_from_url(f) if is_url(f.strip()) else f.strip() for f in options.locustfile.split(",")
-    ]
+    locustfile_list = [f.strip() for f in options.locustfile.split(",")]
+    parsed_paths = parse_locustfile_paths(locustfile_list)
 
-    # Checking if the locustfile is a single file, multiple files or a directory
-    if locustfile_is_directory(locustfile_as_list):
-        locustfiles = find_locustfiles(locustfile_as_list, is_directory=True)
-        locustfile = None
+    if not parsed_paths:
+        note_about_file_endings = ""
+        user_friendly_locustfile_name = options.locustfile
 
-        if not locustfiles:
-            sys.stderr.write(
-                f"Could not find any locustfiles in directory '{locustfile_as_list[0]}'. See --help for available options.\n"
-            )
-            sys.exit(1)
-    else:
-        if len(locustfile_as_list) > 1:
-            # Is multiple files
-            locustfiles = find_locustfiles(locustfile_as_list, is_directory=False)
-            locustfile = None
-        else:
-            # Is a single file
-            locustfile = find_locustfile(locustfile_as_list[0])
-            locustfiles = []
-
-            if not locustfile:
-                if options.help or options.version:
-                    # if --help or --version is specified we'll call parse_options which will print the help/version message
-                    parse_options(args=args)
-                note_about_file_endings = ""
-                user_friendly_locustfile_name = options.locustfile
-                if options.locustfile == "locustfile":
-                    user_friendly_locustfile_name = "locustfile.py"
-                elif not options.locustfile.endswith(".py"):
-                    note_about_file_endings = (
-                        "Ensure your locustfile ends with '.py' or is a directory with locustfiles. "
-                    )
-                sys.stderr.write(
-                    f"Could not find '{user_friendly_locustfile_name}'. {note_about_file_endings}See --help for available options.\n"
-                )
-                sys.exit(1)
-            else:
-                locustfiles.append(locustfile)
-
-    return locustfiles
+        if not options.locustfile.endswith(".py"):
+            note_about_file_endings = "Ensure your locustfile ends with '.py' or is a directory with parsed_paths. "
+        sys.stderr.write(
+            f"Could not find '{user_friendly_locustfile_name}'. {note_about_file_endings}See --help for available options.\n"
+        )
+        sys.exit(1)
+
+    return parsed_paths
 
 
 def setup_parser_arguments(parser):
@@ -857,34 +799,3 @@ def ui_extra_args_dict(args=None) -> dict[str, dict[str, Any]]:
     }
 
     return extra_args
-
-
-def locustfile_is_directory(locustfiles: list[str]) -> bool:
-    """
-    If a user passes in a locustfile without a file extension and there is a directory with the same name,
-    this function defaults to using the file and will raise a warning.
-    In this example, foobar.py will be used:
-        ├── src/
-        │   ├── foobar.py
-        ├── foobar/
-        │   ├── locustfile.py
-
-        locust -f foobar
-    """
-    if len(locustfiles) > 1:
-        return False
-
-    locustfile = locustfiles[0]
-
-    # Checking if the locustfile could be both a file and a directory
-    if not locustfile.endswith(".py"):
-        if os.path.isfile(locustfile) and os.path.isdir(locustfile):
-            msg = f"WARNING: Using {locustfile}.py instead of directory {os.path.abspath(locustfile)}\n"
-            sys.stderr.write(msg)
-
-            return False
-
-    if os.path.isdir(locustfile):
-        return True
-
-    return False

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/runners.py

@@ -1032,23 +1032,19 @@ class MasterRunner(DistributedRunner):
             elif msg.type == "locustfile":
                 logging.debug("Worker requested locust file")
                 assert self.environment.parsed_options
-                filename = (
-                    "locustfile.py"
-                    if self.environment.parsed_options.locustfile == "locustfile"
-                    else self.environment.parsed_options.locustfile
-                )
+                filename = self.environment.parsed_options.locustfile
                 try:
                     with open(filename) as f:
                         file_contents = f.read()
                 except Exception as e:
                     logger.error(
-                        f"--locustfile must be a plain filename (not a module name) for file distribution to work {e}"
+                        f"--locustfile must be a full path to a single locustfile for file distribution to work {e}"
                     )
                     self.send_message(
                         "locustfile",
                         client_id=client_id,
                         data={
-                            "error": f"locustfile parameter on master must be a plain filename (not a module name) (was '{filename}')"
+                            "error": f"locustfile must be a full path to a single locustfile for file distribution to work (was '{filename}')"
                         },
                     )
                 else:

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/test/test_main.py

@@ -1026,6 +1026,32 @@ class StandaloneIntegrationTests(ProcessIntegrationTest):
                 self.assertIn("Shutting down (exit code 0)", output)
                 self.assertEqual(0, proc.returncode)
 
+    def test_with_package_as_locustfile(self):
+        with TemporaryDirectory() as temp_dir:
+            with open(f"{temp_dir}/__init__.py", mode="w"):
+                with mock_locustfile(dir=temp_dir):
+                    proc = subprocess.Popen(
+                        [
+                            "locust",
+                            "-f",
+                            temp_dir,
+                            "--headless",
+                            "--exit-code-on-error",
+                            "0",
+                            "--run-time",
+                            "2",
+                        ],
+                        stdout=PIPE,
+                        stderr=PIPE,
+                        text=True,
+                    )
+                    stdout, stderr = proc.communicate()
+                    self.assertIn("Starting Locust", stderr)
+                    self.assertIn("All users spawned:", stderr)
+                    self.assertIn('"UserSubclass": 1', stderr)
+                    self.assertIn("Shutting down (exit code 0)", stderr)
+                    self.assertEqual(0, proc.returncode)
+
     def test_command_line_user_selection(self):
         LOCUSTFILE_CONTENT = textwrap.dedent(
             """
@@ -1132,7 +1158,7 @@ class StandaloneIntegrationTests(ProcessIntegrationTest):
                     stderr=PIPE,
                     text=True,
                 )
-                gevent.sleep(1)
+                gevent.sleep(2)
                 proc.send_signal(signal.SIGTERM)
                 stdout, stderr = proc.communicate()
 
@@ -1801,34 +1827,49 @@ class SecondUser(HttpUser):
             """
         )
         with mock_locustfile(content=LOCUSTFILE_CONTENT) as mocked:
-            proc = subprocess.Popen(
-                [
-                    "locust",
-                    "-f",
-                    mocked.file_path[:-3],  # remove ".py"
-                    "--headless",
-                    "--master",
-                ],
-                stderr=STDOUT,
-                stdout=PIPE,
-                text=True,
-            )
-            proc_worker = subprocess.Popen(
-                [
-                    "locust",
-                    "-f",
-                    "-",
-                    "--worker",
-                ],
-                stderr=STDOUT,
-                stdout=PIPE,
-                text=True,
-            )
-            stdout = proc_worker.communicate()[0]
-            self.assertIn("Got error from master: locustfile parameter on master must be a plain filename", stdout)
-            proc.kill()
-            master_stdout = proc.communicate()[0]
-            self.assertIn("--locustfile must be a plain filename (not a module name) for file distribut", master_stdout)
+            with mock_locustfile() as mocked2:
+                proc = subprocess.Popen(
+                    [
+                        "locust",
+                        "-f",
+                        f"{mocked.file_path}, {mocked2.file_path}",
+                        "--headless",
+                        "--master",
+                        "-L",
+                        "debug",
+                    ],
+                    stderr=STDOUT,
+                    stdout=PIPE,
+                    text=True,
+                )
+                proc_worker = subprocess.Popen(
+                    [
+                        "locust",
+                        "-f",
+                        "-",
+                        "--worker",
+                    ],
+                    stderr=STDOUT,
+                    stdout=PIPE,
+                    text=True,
+                )
+
+                try:
+                    stdout = proc_worker.communicate(timeout=5)[0]
+                    self.assertIn(
+                        "Got error from master: locustfile must be a full path to a single locustfile for file distribution to work",
+                        stdout,
+                    )
+                    proc.kill()
+                    master_stdout = proc.communicate()[0]
+                    self.assertIn(
+                        "--locustfile must be a full path to a single locustfile for file distribution", master_stdout
+                    )
+                except Exception:
+                    proc.kill()
+                    proc_worker.kill()
+                    stdout, worker_stderr = proc_worker.communicate()
+                    assert False, f"worker never finished: {stdout}"
 
     def test_json_schema(self):
         LOCUSTFILE_CONTENT = textwrap.dedent(

locust/test/test_parser.py

@@ -1,9 +1,8 @@
 import locust
 from locust.argument_parser import (
-    find_locustfiles,
     get_parser,
-    locustfile_is_directory,
     parse_locustfile_option,
+    parse_locustfile_paths,
     parse_options,
     ui_extra_args_dict,
 )
@@ -91,6 +90,7 @@ class TestArgumentParser(LocustTestCase):
         super().setUp()
         self.parent_dir = TemporaryDirectory()
         self.child_dir = TemporaryDirectory(dir=self.parent_dir.name)
+        self.child_dir2 = TemporaryDirectory(dir=self.parent_dir.name)
 
     def tearDown(self):
         super().tearDown()
@@ -257,6 +257,33 @@ class TestArgumentParser(LocustTestCase):
                     ]
                 )
 
+    def test_parse_locustfile_and_directory(self):
+        with mock_locustfile(filename_prefix="mock_locustfile1", dir=self.parent_dir.name) as mock_locustfile1:
+            with mock_locustfile(filename_prefix="mock_locustfile2", dir=self.parent_dir.name) as mock_locustfile2:
+                with mock_locustfile(filename_prefix="mock_locustfile3", dir=self.child_dir.name) as mock_locustfile3:
+                    locustfiles = parse_locustfile_option(
+                        args=[
+                            "-f",
+                            f"{mock_locustfile1.file_path},{self.child_dir.name}",
+                        ]
+                    )
+                    self.assertIn(mock_locustfile1.file_path, locustfiles)
+                    self.assertNotIn(mock_locustfile2.file_path, locustfiles)
+                    self.assertIn(mock_locustfile3.file_path, locustfiles)
+
+    def test_parse_multiple_directories(self):
+        with mock_locustfile(filename_prefix="mock_locustfile1", dir=self.child_dir.name) as mock_locustfile1:
+            with mock_locustfile(filename_prefix="mock_locustfile2", dir=self.child_dir2.name) as mock_locustfile2:
+                locustfiles = parse_locustfile_option(
+                    args=[
+                        "-f",
+                        f"{self.child_dir.name},{self.child_dir2.name}",
+                    ]
+                )
+
+                self.assertIn(mock_locustfile1.file_path, locustfiles)
+                self.assertIn(mock_locustfile2.file_path, locustfiles)
+
     def test_parse_locustfile_invalid_directory_error(self):
         with mock.patch("sys.stderr", new=StringIO()):
             with self.assertRaises(SystemExit):
@@ -377,7 +404,7 @@ class TestFindLocustfiles(LocustTestCase):
         with mock_locustfile(dir=self.parent_dir1.name) as mocked1:
             with mock_locustfile(dir=self.child_dir.name) as mocked2:
                 with mock_locustfile(dir=self.child_dir.name) as mocked3:
-                    locustfiles = find_locustfiles([self.parent_dir1.name], True)
+                    locustfiles = parse_locustfile_paths([self.parent_dir1.name])
 
                     self.assertIn(mocked1.file_path, locustfiles)
                     self.assertIn(mocked2.file_path, locustfiles)
@@ -387,13 +414,13 @@ class TestFindLocustfiles(LocustTestCase):
     def test_find_locustfiles_error_if_directory_doesnt_exist(self):
         with mock.patch("sys.stderr", new=StringIO()):
             with self.assertRaises(SystemExit):
-                find_locustfiles(["some_directory"], True)
+                parse_locustfile_paths(["some_directory"])
 
     def test_find_locustfiles_ignores_invalid_files_in_directory(self):
         with NamedTemporaryFile(suffix=".py", prefix="_", dir=self.parent_dir1.name) as invalid_file1:
             with NamedTemporaryFile(suffix=".txt", prefix="", dir=self.parent_dir1.name) as invalid_file2:
                 with mock_locustfile(filename_prefix="mock_locustfile1", dir=self.parent_dir1.name) as mock_locustfile1:
-                    locustfiles = find_locustfiles([self.parent_dir1.name], True)
+                    locustfiles = parse_locustfile_paths([self.parent_dir1.name])
 
                     self.assertIn(mock_locustfile1.file_path, locustfiles)
                     self.assertNotIn(invalid_file1.name, locustfiles)
@@ -403,7 +430,7 @@ class TestFindLocustfiles(LocustTestCase):
     def test_find_locustfiles_with_multiple_locustfiles(self):
         with mock_locustfile() as mocked1:
             with mock_locustfile() as mocked2:
-                locustfiles = find_locustfiles([mocked1.file_path, mocked2.file_path], False)
+                locustfiles = parse_locustfile_paths([mocked1.file_path, mocked2.file_path])
 
                 self.assertIn(mocked1.file_path, locustfiles)
                 self.assertIn(mocked2.file_path, locustfiles)
@@ -415,58 +442,9 @@ class TestFindLocustfiles(LocustTestCase):
             with mock_locustfile() as valid_file:
                 with self.assertRaises(SystemExit):
                     invalid_file = NamedTemporaryFile(suffix=".txt")
-                    find_locustfiles([valid_file.file_path, invalid_file.name], False)
-
-    def test_find_locustfiles_error_if_invalid_directory(self):
-        with mock.patch("sys.stderr", new=StringIO()):
-            with mock_locustfile() as valid_file:
-                with self.assertRaises(SystemExit):
-                    find_locustfiles([valid_file.file_path], True)
+                    parse_locustfile_paths([valid_file.file_path, invalid_file.name])
 
     def test_find_locustfiles_error_if_multiple_values_for_directory(self):
         with mock.patch("sys.stderr", new=StringIO()):
             with self.assertRaises(SystemExit):
-                find_locustfiles([self.parent_dir1.name, self.parent_dir2.name], True)
-
-
-class TestLocustfileIsDirectory(LocustTestCase):
-    def setUp(self):
-        super().setUp()
-        self.random_prefix = "locust/test/foobar_" + str(randint(1000, 9999))
-        self.mock_filename = self.random_prefix + ".py"
-
-        self.mock_locustfile = open(self.mock_filename, "w")
-        self.mock_locustfile.close()
-        self.mock_dir = os.mkdir(self.random_prefix)
-
-    def tearDown(self):
-        super().tearDown()
-        os.remove(self.mock_filename)
-        os.rmdir(self.random_prefix)
-
-    def test_locustfile_is_directory_single_locustfile(self):
-        with mock_locustfile() as mocked:
-            is_dir = locustfile_is_directory([mocked.file_path])
-            assert not is_dir
-
-    def test_locustfile_is_directory_single_locustfile_without_file_extension(self):
-        prefix_name = "foobar"
-        with NamedTemporaryFile(prefix=prefix_name, suffix=".py"):
-            is_dir = locustfile_is_directory([prefix_name])
-            assert not is_dir
-
-    def test_locustfile_is_directory_multiple_locustfiles(self):
-        with mock_locustfile() as mocked1:
-            with mock_locustfile() as mocked2:
-                is_dir = locustfile_is_directory([mocked1.file_path, mocked2.file_path])
-                assert not is_dir
-
-    def test_locustfile_is_directory_true_if_directory(self):
-        with TemporaryDirectory() as mocked_dir:
-            is_dir = locustfile_is_directory([mocked_dir])
-            assert is_dir
-
-    def test_locustfile_is_directory_false_if_file_and_directory_share_the_same_name(self):
-        """See locustfile_is_directory docstring of an example of this usecase"""
-        is_dir = locustfile_is_directory([self.random_prefix, self.mock_filename])
-        assert not is_dir
+                parse_locustfile_paths([self.parent_dir1.name, self.parent_dir2.name])

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.dev26.dist-info → locust-2.26.1.dev61.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: locust
-Version: 2.26.1.dev26
+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.dev26.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=UzMj119kATOoBBjWI2c9qaMddMD8HTQOomwHL55-fso,428
-locust/argument_parser.py,sha256=gOyB1rqEEFNVkhGa-oAuCxf573aB_lATSY9w6FlCbHk,32008
+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
@@ -13,7 +13,7 @@ locust/input_events.py,sha256=VQIrgXaoph3JgLo6REKtPBThEPUXYXG5Kcedly5aRYc,3272
 locust/log.py,sha256=2IVp9YL4ZPfWdj3sBFuOHfgneg3g7m7tUGR-sy2s3E8,3155
 locust/main.py,sha256=Un9THvATWEOewIeeoLkecxBluxQcoC7BkFhmk_UgTxM,28150
 locust/py.typed,sha256=gkWLl8yD4mIZnNYYAIRM8g9VarLvWmTAFeUfEbxJLBw,65
-locust/runners.py,sha256=7qJE6cHETFEOo7kr0vo_PN3bdfOIw-fbKrc2aPPrjKw,67954
+locust/runners.py,sha256=MGgzDU6_hhZ58Myn6bAWY92NQJKuwV9NyP4B9SdN9ek,67797
 locust/shape.py,sha256=t-lwBS8LOjWcKXNL7j2U3zroIXJ1b0fazUwpRYQOKXw,1973
 locust/stats.py,sha256=l2cxxVre8dvA4MIOD_ZKNj_fYySz5gTGC2f9Rc4-CL0,46134
 locust/web.py,sha256=zj0Lm3tQq0MhbeJ1oKROnvauNibwUSBXsTehw2q2nAA,28251
@@ -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
@@ -61,9 +61,9 @@ locust/test/test_interruptable_task.py,sha256=LZKSV-aJNnwfvAxguz6SckBEuGEnfGimoI
 locust/test/test_load_locustfile.py,sha256=v-muHoM-CYu8t7DXm4AQtFP2q8RYfnTTUBqj7uVqhig,8494
 locust/test/test_locust_class.py,sha256=oGhhOX848jHRQnIfFlhLlW-kHGYLyYsfDX8hM07Ro7g,25506
 locust/test/test_log.py,sha256=YPY6vgTAy1KaNU2qoVvQrTH5x_mzRrljEHrkSBy3yxs,7553
-locust/test/test_main.py,sha256=LOVES_hyNs9kftr9WYRIn6SrfeonAZC7lK4WWJHZOyM,83554
+locust/test/test_main.py,sha256=Ae3F8KTj65YakX_S8eckhJNbqKrRsivoPkFoZaHeyWI,85344
 locust/test/test_old_wait_api.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-locust/test/test_parser.py,sha256=R2RATAHVC1n4gRYZyRD3yO5P9QMFbruZ3A4dwaw8Up0,18287
+locust/test/test_parser.py,sha256=-2VO5Dopg-VoWvIgXrmr7GN40cqrnjUoctBHmVlyewg,17826
 locust/test/test_runners.py,sha256=6FPd-3Glp5_xtVIE8yCHDonM0aYJ0A6He5KSxuWOk34,159381
 locust/test/test_sequential_taskset.py,sha256=QjVMWWfGHn9hU5AvPxRDU7Vo5DcVW1VkMVfDA0k9OPE,3398
 locust/test/test_stats.py,sha256=F51VkL3k3y4OhYBlRyV6vWzisenSAOmSWKy2IPVrnWM,33929
@@ -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.dev26.dist-info/LICENSE,sha256=78XGpIn3fHVBfaxlPNUfjVufSN7QsdhpJMRJHv2AFpo,1095
-locust-2.26.1.dev26.dist-info/METADATA,sha256=7B0ufqAm8D1nKYfoLhSPeJS7TtJe0o5gIUvszDV2JOY,7301
-locust-2.26.1.dev26.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-locust-2.26.1.dev26.dist-info/entry_points.txt,sha256=RAdt8Ku-56m7bFjmdj-MBhbF6h4NX7tVODR9QNnOg0E,44
-locust-2.26.1.dev26.dist-info/top_level.txt,sha256=XSsjgPA8Ggf9TqKVbkwSqZFuPlZ085X13M9orDycE20,7
-locust-2.26.1.dev26.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,,