locust 2.26.1.dev26__tar.gz → 2.26.1.dev48__tar.gz

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

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

{locust-2.26.1.dev26 → locust-2.26.1.dev48}/docs/configuration.rst

@@ -114,8 +114,7 @@ See :ref:`running-without-web-ui`
 Using multiple Locustfiles at once
 ==================================
 
-The ``-f/--locustfile`` option accepts a single directory of locustfiles as an option. Locust will recursively
-search the directory for ``*.py`` files, ignoring files that start with "_".
+``-f/--locustfile`` accepts multiple, comma-separated locustfiles.
 
 Example:
 
@@ -132,20 +131,23 @@ With the following file structure:
 
 .. code-block:: console
 
-    $ locust -f locustfiles
+    $ locust -f locustfiles/locustfile1.py,locustfiles/locustfile2.py,locustfiles/more_files/locustfile3.py
 
 Locust will use ``locustfile1.py``, ``locustfile2.py`` & ``more_files/locustfile3.py``
 
-Additionally, ``-f/--locustfile`` accepts multiple, comma-separated locustfiles.
+Additionally, ``-f/--locustfile`` accepts directories as an option. Locust will recursively
+search specified directories for ``*.py`` files, ignoring files that start with "_".
 
 Example:
 
 .. code-block:: console
 
-    $ locust -f locustfiles/locustfile1.py,locustfiles/locustfile2.py,locustfiles/more_files/locustfile3.py
+    $ locust -f locustfiles
 
 Locust will use ``locustfile1.py``, ``locustfile2.py`` & ``more_files/locustfile3.py``
 
+
+
 You can also use ``-f/--locustfile`` for web urls. This will download the file and use it as any normal locustfile.
 
 Example:

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

{locust-2.26.1.dev26 → locust-2.26.1.dev48}/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-2.26.1.dev26 → locust-2.26.1.dev48}/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-2.26.1.dev26 → locust-2.26.1.dev48}/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-2.26.1.dev26 → locust-2.26.1.dev48}/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-2.26.1.dev26 → locust-2.26.1.dev48/locust.egg-info}/PKG-INFO

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