locust 2.46.6.dev12__tar.gz → 2.46.7__tar.gz

{locust-2.46.6.dev12 → locust-2.46.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: locust
-Version: 2.46.6.dev12
+Version: 2.46.7
 Summary: Developer-friendly load testing framework
 Project-URL: Homepage, https://locust.cloud/
 Project-URL: Repository, https://github.com/locustio/locust
@@ -38,7 +38,7 @@ Requires-Dist: python-engineio>=4.12.2
 Requires-Dist: python-socketio[client]>=5.13.0
 Requires-Dist: pywin32; sys_platform == 'win32'
 Requires-Dist: pyzmq>=25.0.0
-Requires-Dist: requests>=2.32.2
+Requires-Dist: requests>=2.33.1
 Requires-Dist: typing-extensions>=4.6.0; python_version < '3.12'
 Requires-Dist: werkzeug>=2.0.0
 Provides-Extra: dns
@@ -83,11 +83,12 @@ If you want your users to loop, perform some conditional behaviour or do some ca
 ```python
 from locust import HttpUser, task, between
 
+
 class QuickstartUser(HttpUser):
     wait_time = between(1, 2)
 
     def on_start(self):
-        self.client.post("/login", json={"username":"foo", "password":"bar"})
+        self.client.post("/login", json={"username": "foo", "password": "bar"})
 
     @task
     def hello_world(self):

{locust-2.46.6.dev12 → locust-2.46.7}/README.md

@@ -24,11 +24,12 @@ If you want your users to loop, perform some conditional behaviour or do some ca
 ```python
 from locust import HttpUser, task, between
 
+
 class QuickstartUser(HttpUser):
     wait_time = between(1, 2)
 
     def on_start(self):
-        self.client.post("/login", json={"username":"foo", "password":"bar"})
+        self.client.post("/login", json={"username": "foo", "password": "bar"})
 
     @task
     def hello_world(self):

{locust-2.46.6.dev12 → locust-2.46.7}/locust/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.46.6.dev12'
-__version_tuple__ = version_tuple = (2, 46, 6, 'dev12')
+__version__ = version = '2.46.7'
+__version_tuple__ = version_tuple = (2, 46, 7)
 
 __commit_id__ = commit_id = None

{locust-2.46.6.dev12 → locust-2.46.7}/locust/clients.py

@@ -8,10 +8,9 @@ import sys
 import time
 from contextlib import contextmanager
 from typing import TYPE_CHECKING, cast
-from urllib.parse import urlparse, urlunparse
+from urllib.parse import unquote, urlparse, urlunparse
 
 import requests
-from packaging.version import Version
 from requests import Response
 from requests.adapters import HTTPAdapter
 from requests.auth import HTTPBasicAuth
@@ -28,8 +27,6 @@ if sys.version_info >= (3, 12):
 else:
     from typing_extensions import override
 
-requests_version = Version(requests.__version__).release
-
 if TYPE_CHECKING:
     from collections.abc import Callable, Generator, Iterable, Mapping, MutableMapping
     from typing import Any, TypedDict, Unpack
@@ -45,7 +42,7 @@ if TYPE_CHECKING:
         cookies: RequestsCookieJar | MutableMapping[str, str] | None
         files: Any  # simplified signature
         auth: Any  # simplified signature
-        timeout: float | tuple[float, float] | tuple[float, None] | None
+        timeout: float | tuple[float | None, float | None] | None
         allow_redirects: bool
         proxies: MutableMapping[str, str] | None
         hooks: Mapping[str, Iterable[Callable[[Response], Any]] | Callable[[Response], Any]] | None
@@ -61,9 +58,8 @@ if TYPE_CHECKING:
 
 absolute_http_url_regexp = re.compile(r"^https?://", re.IGNORECASE)
 
-if requests_version >= (2, 32, 5):
-    _preloaded_ssl_context = create_urllib3_context()
-    _preloaded_ssl_context.load_verify_locations(extract_zipped_paths(DEFAULT_CA_BUNDLE_PATH))
+_preloaded_ssl_context = create_urllib3_context()
+_preloaded_ssl_context.load_verify_locations(extract_zipped_paths(DEFAULT_CA_BUNDLE_PATH))
 
 
 class HttpSession(requests.Session):
@@ -104,16 +100,13 @@ class HttpSession(requests.Session):
         # Check for basic authentication
         parsed_url = urlparse(self.base_url)
         if parsed_url.username and parsed_url.password:
-            netloc = parsed_url.hostname
-            if parsed_url.port:
-                netloc += ":%d" % parsed_url.port
-
-            # remove username and password from the base_url
+            # remove username and password from the base_url (keeping e.g. the brackets of an IPv6 host)
+            netloc = parsed_url.netloc.rpartition("@")[2]
             self.base_url = urlunparse(
                 (parsed_url.scheme, netloc, parsed_url.path, parsed_url.params, parsed_url.query, parsed_url.fragment)
             )
-            # configure requests to use basic auth
-            self.auth = HTTPBasicAuth(parsed_url.username, parsed_url.password)
+            # configure requests to use basic auth (credentials in a URL are percent-encoded)
+            self.auth = HTTPBasicAuth(unquote(parsed_url.username), unquote(parsed_url.password))
 
         self.mount("https://", LocustHttpAdapter(pool_manager=pool_manager))
         self.mount("http://", LocustHttpAdapter(pool_manager=pool_manager))
@@ -198,7 +191,7 @@ class HttpSession(requests.Session):
         response = self._send_request_safe_mode(method, complete_url, data=data, json=json, **kwargs)
         response_time = (time.perf_counter() - start_perf_counter) * 1000
 
-        if request_before_redirect := (response.history and response.history[0] or response).request:
+        if request_before_redirect := ((response.history and response.history[0]) or response).request:
             complete_url = str(request_before_redirect.url)
             if not name:
                 name = request_before_redirect.path_url
@@ -491,14 +484,10 @@ class LocustHttpAdapter(HTTPAdapter):
         if self.poolmanager is None:
             super().init_poolmanager(*args, **kwargs)
 
-    # In python requests version 2.32.5 they reverted
-    # https://github.com/psf/requests/pull/6667
-    # Without this change the root CA certificates are loaded on every request
-    # We re-implement this change to increase the performance
+    # requests reverted https://github.com/psf/requests/pull/6667 in 2.32.5, so without
+    # re-implementing it here the root CA certificates are loaded on every request.
+    # We re-implement it to increase performance (see _preloaded_ssl_context above).
     def cert_verify(self, conn, url, verify, cert):
-        if requests_version < (2, 32, 5):
-            return super().cert_verify(conn, url, verify, cert)
-
         if url.lower().startswith("https") and verify:
             conn.cert_reqs = "CERT_REQUIRED"
 
@@ -532,7 +521,7 @@ class LocustHttpAdapter(HTTPAdapter):
     def build_connection_pool_key_attributes(self, request, verify, cert=None):
         host_params, pool_kwargs = super().build_connection_pool_key_attributes(request, verify, cert)
 
-        if requests_version >= (2, 32, 5) and verify is True:
+        if verify is True:
             pool_kwargs["ssl_context"] = _preloaded_ssl_context
 
         return host_params, pool_kwargs

{locust-2.46.6.dev12 → locust-2.46.7}/locust/contrib/fasthttp.py

@@ -12,10 +12,11 @@ import socket
 import time
 import zlib
 from base64 import b64encode
+from contextlib import contextmanager
 from http.cookiejar import CookieJar
 from ssl import SSLError
 from typing import TYPE_CHECKING
-from urllib.parse import urlparse, urlunparse
+from urllib.parse import unquote, urlparse, urlunparse
 
 import gevent
 from charset_normalizer import detect
@@ -111,6 +112,11 @@ class FastHttpSession:
         self.request_event = request_event
         self.cookiejar = CookieJar()
         self.user = user
+
+        # Requests can be grouped under a common name by setting request_name, or by using the rename_request context manager
+        # This is an alternative to passing in the "name" parameter to the requests function
+        self.request_name: str | None = None
+
         if not ssl_context_factory:
             if insecure:
                 ssl_context_factory = insecure_ssl_context_factory
@@ -128,11 +134,8 @@ class FastHttpSession:
         if self.base_url:
             parsed_url = urlparse(self.base_url)
             if parsed_url.username and parsed_url.password:
-                netloc = parsed_url.hostname or ""
-                if parsed_url.port:
-                    netloc += ":%d" % parsed_url.port
-
-                # remove username and password from the base_url
+                # remove username and password from the base_url (keeping e.g. the brackets of an IPv6 host)
+                netloc = parsed_url.netloc.rpartition("@")[2]
                 self.base_url = str(
                     urlunparse(
                         (
@@ -146,7 +149,8 @@ class FastHttpSession:
                     )
                 )
                 # store authentication header (we construct this by using _basic_auth_str() function from requests.auth)
-                self.auth_header = _construct_basic_auth_str(parsed_url.username, parsed_url.password)
+                # (credentials in a URL are percent-encoded)
+                self.auth_header = _construct_basic_auth_str(unquote(parsed_url.username), unquote(parsed_url.password))
 
     def _build_url(self, path: str) -> str:
         """prepend url with hostname unless it's already an absolute URL"""
@@ -155,6 +159,16 @@ class FastHttpSession:
         else:
             return f"{self.base_url}{path}"
 
+    @contextmanager
+    def rename_request(self, name: str) -> Generator[None]:
+        """Group requests using the "with" keyword"""
+
+        self.request_name = name
+        try:
+            yield
+        finally:
+            self.request_name = None
+
     def _send_request_safe_mode(self, method: str, url: str, **kwargs) -> FastResponse:
         """
         Send an HTTP request, and catch any exception that might occur due to either
@@ -223,6 +237,10 @@ class FastHttpSession:
         :return: A :py:class:`FastResponse <locust.contrib.fasthttp.FastResponse>` object if catch_response is False, and
             :py:class:`ResponseContextManager <locust.contrib.fasthttp.ResponseContextManager>` if True.
         """
+        # if group name has been set and no name parameter has been passed in; set the name parameter to group_name
+        if self.request_name and not name:
+            name = self.request_name
+
         # prepend url with hostname unless it's already an absolute URL
         built_url = self._build_url(url)
 
@@ -231,7 +249,7 @@ class FastHttpSession:
         if self.user:
             context = {**self.user.context(), **context}
 
-        headers = headers or {}
+        headers = dict(headers) if headers else {}
         if auth:
             headers["Authorization"] = _construct_basic_auth_str(auth[0], auth[1])
         elif self.auth_header:
@@ -248,7 +266,7 @@ class FastHttpSession:
 
         if not allow_redirects:
             old_redirect_resonse_codes = self.client.redirect_resonse_codes
-            self.client.redirect_resonse_codes = frozenset()
+            self.client.redirect_resonse_codes = self.client.redirect_response_codes = frozenset()
 
         start_perf_counter = time.perf_counter()
         # send request, and catch any exceptions
@@ -264,7 +282,7 @@ class FastHttpSession:
         }
 
         if not allow_redirects:
-            self.client.redirect_resonse_codes = old_redirect_resonse_codes
+            self.client.redirect_resonse_codes = self.client.redirect_response_codes = old_redirect_resonse_codes
 
         request_meta["response_length"] = 0  # default value, if length cannot be determined
 
@@ -605,6 +623,7 @@ class LocustUserAgent(UserAgent):
     request_type = FastRequest
     valid_response_codes = frozenset([200, 201, 202, 203, 204, 205, 206, 207, 208, 226, 301, 302, 303, 304, 307, 308])
     redirect_resonse_codes = frozenset([301, 302, 303, 307, 308])
+    redirect_response_codes = redirect_resonse_codes  # geventhttpclient 2.5+ spelling
 
     def __init__(self, client_pool: HTTPClientPool | None = None, **kwargs):
         super().__init__(**kwargs)

{locust-2.46.6.dev12 → locust-2.46.7}/locust/dispatch.py

@@ -192,6 +192,12 @@ class UsersDispatcher(Iterator):
         :param spawn_rate: The spawn rate
         :param user_classes: The user classes to be used for the new dispatch
         """
+        if target_user_count < 0:
+            raise ValueError(f"target_user_count must be >= 0, got {target_user_count}")
+
+        if spawn_rate <= 0:
+            raise ValueError(f"spawn_rate must be > 0, got {spawn_rate}")
+
         if user_classes is not None and self._user_classes != sorted(user_classes, key=attrgetter("__name__")):
             self._user_classes = sorted(user_classes, key=attrgetter("__name__"))
             self._user_generator = self._user_gen()

{locust-2.46.6.dev12 → locust-2.46.7}/locust/runners.py

@@ -917,10 +917,8 @@ class MasterRunner(DistributedRunner):
         self.greenlet.kill(block=True)
 
     def check_stopped(self) -> None:
-        if (
-            self.state == STATE_STOPPING
-            and all(x.state == STATE_INIT for x in self.clients.all)
-            or all(x.state not in (STATE_RUNNING, STATE_SPAWNING, STATE_INIT) for x in self.clients.all)
+        if (self.state == STATE_STOPPING and all(x.state == STATE_INIT for x in self.clients.all)) or all(
+            x.state not in (STATE_RUNNING, STATE_SPAWNING, STATE_INIT) for x in self.clients.all
         ):
             self.update_state(STATE_STOPPED)
 
@@ -938,7 +936,7 @@ class MasterRunner(DistributedRunner):
                     missing_clients_to_be_removed.append(client.id)
 
                 if client.heartbeat < 0 and client.state != STATE_MISSING:
-                    logger.info(f"Worker {str(client.id)} failed to send heartbeat, setting state to missing.")
+                    logger.info(f"Worker {client.id!s} failed to send heartbeat, setting state to missing.")
                     client.state = STATE_MISSING
                     client.user_classes_count = {}
                     if self._users_dispatcher is not None:
@@ -1023,7 +1021,7 @@ class MasterRunner(DistributedRunner):
                 elif msg.data != __version__ and msg.data != -1:
                     if msg.data[0:4] == __version__[0:4]:
                         logger.debug(
-                            f"A worker ({client_id}) running a different patch version ({repr(msg.data)}) connected, master version is {repr(__version__)}"
+                            f"A worker ({client_id}) running a different patch version ({msg.data!r}) connected, master version is {__version__!r}"
                         )
                     else:
                         logger.warning(
@@ -1113,7 +1111,7 @@ class MasterRunner(DistributedRunner):
                     c.heartbeat = HEARTBEAT_LIVENESS
                     client_state = msg.data["state"]
                     if c.state == STATE_MISSING:
-                        logger.info(f"Worker {str(c.id)} self-healed with heartbeat, setting state to {client_state}.")
+                        logger.info(f"Worker {c.id!s} self-healed with heartbeat, setting state to {client_state}.")
                         if self._users_dispatcher is not None:
                             self._users_dispatcher.add_worker(worker_node=c)
                             if not self._users_dispatcher.dispatch_in_progress and self.state == STATE_RUNNING:

{locust-2.46.6.dev12 → locust-2.46.7}/locust/stats.py

@@ -539,7 +539,7 @@ class StatsEntry:
             # (which is what the response times cache is used for) uses an approximation of the
             # last 10 seconds anyway, it should be fine to ignore this.
             last_time = int(self.last_request_timestamp) if self.last_request_timestamp else None
-            if last_time and last_time > (old_last_request_timestamp and int(old_last_request_timestamp) or 0):
+            if last_time and last_time > ((old_last_request_timestamp and int(old_last_request_timestamp)) or 0):
                 self._cache_response_times(last_time)
 
     def serialize(self) -> StatsEntryDict:
@@ -585,7 +585,7 @@ class StatsEntry:
             + str((STATS_NAME_WIDTH - STATS_TYPE_WIDTH) + 4)
             + "s %7d %12s |%7d %7d %7d%7d | %7.2f %11.2f"
         ) % (
-            (self.method and self.method + " " or ""),
+            ((self.method and self.method + " ") or ""),
             self.name,
             self.num_requests,
             "%d(%.2f%%)" % (self.num_failures, self.fail_ratio * 100),
@@ -661,12 +661,15 @@ class StatsEntry:
         if not self.num_requests:
             raise ValueError("Can't calculate percentile on url with no successful requests")
 
-        tpl = f"%-{str(STATS_TYPE_WIDTH)}s %-{str(STATS_NAME_WIDTH)}s %8d {' '.join(['%6d'] * len(PERCENTILES_TO_REPORT))}"
+        tpl = f"%-{STATS_TYPE_WIDTH!s}s %-{STATS_NAME_WIDTH!s}s %8d {' '.join(['%6d'] * len(PERCENTILES_TO_REPORT))}"
 
         return tpl % (
-            (self.method or "", self.name)
-            + tuple(self.get_response_time_percentile(p) for p in PERCENTILES_TO_REPORT)
-            + (self.num_requests,)
+            (
+                self.method or "",
+                self.name,
+                *tuple(self.get_response_time_percentile(p) for p in PERCENTILES_TO_REPORT),
+                self.num_requests,
+            )
         )
 
     def _cache_response_times(self, t: int) -> None:
@@ -897,9 +900,9 @@ def get_percentile_stats_summary(stats: RequestStats) -> list[str]:
     Percentile stats summary will be returned as list of string
     """
     summary = ["Response time percentiles (approximated)"]
-    headers = ("Type", "Name") + tuple(get_readable_percentiles(PERCENTILES_TO_REPORT)) + ("# reqs",)
+    headers = ("Type", "Name", *tuple(get_readable_percentiles(PERCENTILES_TO_REPORT)), "# reqs")
     summary.append(
-        (f"%-{str(STATS_TYPE_WIDTH)}s %-{str(STATS_NAME_WIDTH)}s %8s {' '.join(['%6s'] * len(PERCENTILES_TO_REPORT))}")
+        f"%-{STATS_TYPE_WIDTH!s}s %-{STATS_NAME_WIDTH!s}s %8s {' '.join(['%6s'] * len(PERCENTILES_TO_REPORT))}"
         % headers
     )
     separator = (
@@ -1008,7 +1011,8 @@ class StatsCSV:
             "Average Content Size",
             "Requests/s",
             "Failures/s",
-        ] + get_readable_percentiles(self.percentiles_to_report)
+            *get_readable_percentiles(self.percentiles_to_report),
+        ]
 
         self.failures_columns = [
             "Method",
@@ -1190,8 +1194,8 @@ class StatsCSVFileWriter(StatsCSV):
 
     def _stats_history_data_rows(self, csv_writer: CSVWriter, now: float) -> None:
         """
-        Write CSV rows with the *current* stats. By default only includes the
-        Aggregated stats entry, but if self.full_history is set to True, a row for each entry will
+        Write CSV rows with the *current* stats. By default, only includes the
+        Aggregated stats entry, but if self.full_history is set to True, a row for each entry
         will be included.
 
         Note that this method differs from the other methods as it appends time-stamped data to the file, whereas the other methods overwrites the data.

{locust-2.46.6.dev12 → locust-2.46.7}/locust/user/task.py

@@ -14,7 +14,7 @@ import random
 import traceback
 from collections import deque
 from collections.abc import Callable
-from time import time
+from time import perf_counter, time
 from typing import (
     TYPE_CHECKING,
     Protocol,
@@ -316,7 +316,7 @@ class TaskSet(metaclass=TaskSetMeta):
             self.max_wait = self.user.max_wait
         if not self.wait_function:
             self.wait_function = self.user.wait_function
-        self._cp_last_run: float = time()  # used by constant_pacing wait_time
+        self._cp_last_run: float = perf_counter()  # used by constant_pacing wait_time
         self._cp_last_wait_time: float = 0  # used by constant_pacing wait_time
 
     @property

{locust-2.46.6.dev12 → locust-2.46.7}/locust/user/users.py

@@ -141,7 +141,7 @@ class User(metaclass=UserMeta):
         self._greenlet: greenlet.Greenlet | None = None
         self._group: Group
         self._taskset_instance: TaskSet | None = None
-        self._cp_last_run: float = time.time()  # used by constant_pacing wait_time
+        self._cp_last_run: float = time.perf_counter()  # used by constant_pacing wait_time
         self._cp_last_wait_time: float = 0  # used by constant_pacing wait_time
 
     def on_start(self) -> None:
@@ -275,7 +275,7 @@ class RestMixin(Generic[RestResponseT]):
         * Sets ``catch_response=True`` (so always use a :ref:`with-block <catch-response>`)
         * Catches any unhandled exceptions thrown inside your with-block, marking the sample as failed (instead of exiting the task immediately without even firing the request event)
         """
-        headers = headers or {}
+        headers = dict(headers) if headers else {}
         if not ("Content-Type" in headers or "content-type" in headers):
             headers["Content-Type"] = "application/json"
         if not ("Accept" in headers or "accept" in headers):

{locust-2.46.6.dev12 → locust-2.46.7}/locust/user/wait_time.py

@@ -1,6 +1,6 @@
 import random
 from collections.abc import Callable
-from time import time
+from time import perf_counter
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -52,9 +52,9 @@ def constant_pacing(wait_time: float) -> Callable[["User"], float]:
     """
 
     def wait_time_func(self: "User") -> float:
-        run_time: float = time() - self._cp_last_run - self._cp_last_wait_time
+        run_time: float = perf_counter() - self._cp_last_run - self._cp_last_wait_time
         self._cp_last_wait_time = max(0, wait_time - run_time)
-        self._cp_last_run = time()
+        self._cp_last_run = perf_counter()
         return self._cp_last_wait_time
 
     return wait_time_func
@@ -83,6 +83,8 @@ def constant_throughput(task_runs_per_second: float) -> Callable[["User"], float
     If a task execution exceeds the specified wait_time, the wait will be 0 before starting
     the next task.
     """
+    if task_runs_per_second <= 0:
+        raise ValueError(f"constant_throughput() requires a positive rate, got: {task_runs_per_second}")
     return constant_pacing(1 / task_runs_per_second)
 
 

{locust-2.46.6.dev12 → locust-2.46.7}/locust/util/cache.py

@@ -24,10 +24,8 @@ def memoize(timeout, dynamic_timeout=False):
             return cache["result"]
 
         def clear_cache():
-            if "time" in cache:
-                del cache["time"]
-            if "result" in cache:
-                del cache["result"]
+            cache.pop("time", None)
+            cache.pop("result", None)
 
         wrapper.clear_cache = clear_cache
         return wrapper

{locust-2.46.6.dev12 → locust-2.46.7}/locust/util/date.py

@@ -10,7 +10,7 @@ def format_safe_timestamp(unix_timestamp):
 
 
 def format_duration(start_time, end_time):
-    seconds = int(end_time) - int(start_time)
+    seconds = int(end_time - start_time)
     days = seconds // 86400
     hours = (seconds % 86400) // 3600
     minutes = (seconds % 3600) // 60
@@ -20,4 +20,4 @@ def format_duration(start_time, end_time):
 
     parts = [f"{value} {label}{'s' if value != 1 else ''}" for value, label in time_parts if value > 0]
 
-    return " and ".join(filter(None, [", ".join(parts[:-1])] + parts[-1:])) if parts else "0 seconds"
+    return " and ".join(filter(None, [", ".join(parts[:-1]), *parts[-1:]])) if parts else "0 seconds"

{locust-2.46.6.dev12 → locust-2.46.7}/locust/util/exception_handler.py

@@ -8,7 +8,7 @@ def retry(delays=(1, 3, 5), exception=Exception):
     def decorator(function):
         def wrapper(*args, **kwargs):
             cnt = 0
-            for delay in delays + (None,):
+            for delay in (*delays, None):
                 try:
                     return function(*args, **kwargs)
                 except exception as e:

{locust-2.46.6.dev12 → locust-2.46.7}/locust/web.py

@@ -274,7 +274,7 @@ class WebUI:
                             err_msg = f"Invalid user_count value: {value!r} (must be an integer)"
                             logger.error(err_msg)
                             return jsonify({"success": False, "message": err_msg, "host": environment.host})
-                        parsed_options_dict["users"] = user_count
+                        parsed_options_dict["num_users"] = user_count
                     case "spawn_rate":
                         try:
                             spawn_rate = float(value)
@@ -338,8 +338,8 @@ class WebUI:
                 self._swarm_greenlet = None
 
             if environment.runner is not None:
-                if user_count is None or not spawn_rate:
-                    err_msg = "Missing user_count or spawn_rate from /swarm request"
+                if user_count is None or user_count < 0 or spawn_rate is None or spawn_rate <= 0:
+                    err_msg = "Missing or invalid user_count or spawn_rate from /swarm request"
                     logger.error(err_msg)
                     return jsonify({"success": False, "message": err_msg, "host": environment.host})
                 self._swarm_greenlet = gevent.spawn(environment.runner.start, user_count, spawn_rate)

{locust-2.46.6.dev12 → locust-2.46.7}/pyproject.toml

@@ -35,7 +35,7 @@ classifiers = [
 dependencies = [
     "flask>=2.0.0",
     "Werkzeug>=2.0.0",
-    "requests>=2.32.2",
+    "requests>=2.33.1",
     "msgpack>=1.0.0",
     "pyzmq>=25.0.0",
     "geventhttpclient>=2.3.1",
@@ -81,9 +81,9 @@ test = [
 ]
 lint = [
     "pre-commit>=4.5.0,<5.0.0",
-    "ruff==0.15.12",
+    "ruff==0.16.8",
     "mypy>=1.13.0,<1.15.0",
-    "types-requests==2.32.4.20250809",
+    "types-requests==2.33.0.20260906",
     "typos>=1.50.1"
 ]
 release = ["twine>=5.1.1,<6.0.0"]
@@ -159,8 +159,8 @@ extend-exclude = [
     "src/readthedocs-sphinx-search/",
     "examples/grpc/hello_pb2*.py",
 ]
-lint.ignore = ["E402", "E501", "E713", "E731", "E741", "UP031", "PERF203"]
-lint.select = ["E", "F", "W", "UP", "FA102", "I001", "FURB", "PERF"]
+lint.ignore = ["E402", "E501", "E713", "E731", "E741", "UP031", "PERF203", "RUF012", "RUF059", "RUF015"]
+lint.select = ["E", "F", "W", "UP", "FA102", "I001", "FURB", "PERF", "RUF"]
 lint.dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?)|resp)$"
 
 [tool.ruff.lint.per-file-ignores]

{locust-2.46.6.dev12 → locust-2.46.7}/locust/__init__.py

@@ -36,28 +36,28 @@ from .user.wait_time import between, constant, constant_pacing, constant_through
 events = Events()
 
 __all__ = (
-    "SequentialTaskSet",
+    "FastHttpUser",
+    "HttpLocust",
+    "HttpUser",
+    "LoadTestShape",
+    "Locust",
     "MarkovTaskSet",
-    "transition",
-    "transitions",
-    "wait_time",
-    "task",
-    "tag",
+    "SequentialTaskSet",
     "TaskSet",
-    "HttpUser",
-    "FastHttpUser",
     "User",
+    "__version__",
     "between",
     "constant",
     "constant_pacing",
     "constant_throughput",
-    "poisson",
     "events",
-    "LoadTestShape",
+    "poisson",
     "run_single_user",
-    "HttpLocust",
-    "Locust",
-    "__version__",
+    "tag",
+    "task",
+    "transition",
+    "transitions",
+    "wait_time",
 )
 
 # Used for raising a DeprecationWarning if old Locust/HttpLocust is used

{locust-2.46.6.dev12 → locust-2.46.7}/locust/user/__init__.py

@@ -1,9 +1,9 @@
 __all__ = (
     "HttpUser",
-    "tag",
-    "task",
     "TaskSet",
     "User",
+    "tag",
+    "task",
 )
 from .task import TaskSet, tag, task
 from .users import HttpUser, User