locust 2.28.1.dev5__py3-none-any.whl → 2.28.1.dev13__py3-none-any.whl

locust/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.28.1.dev5'
-__version_tuple__ = version_tuple = (2, 28, 1, 'dev5')
+__version__ = version = '2.28.1.dev13'
+__version_tuple__ = version_tuple = (2, 28, 1, 'dev13')

locust/event.py

@@ -162,11 +162,11 @@ class Events:
 
     spawning_complete: EventHook
     """
-    Fired when all simulated users has been spawned.
+    Fired when all simulated users has been spawned. The event is fired on master first, and then distributed to workers.
 
     Event arguments:
 
-    :param user_count: Number of users that were spawned
+    :param user_count: Number of users that were spawned (in total, not per-worker)
     """
 
     quitting: EventHook

locust/runners.py

@@ -834,7 +834,10 @@ class MasterRunner(DistributedRunner):
         finally:
             timeout.cancel()
 
-        self.environment.events.spawning_complete.fire(user_count=sum(self.target_user_classes_count.values()))
+        user_count = sum(self.target_user_classes_count.values())
+        self.environment.events.spawning_complete.fire(user_count=user_count)
+        # notify workers so they can fire their own event
+        self.send_message("spawning_complete", data={"user_count": user_count})
         self.spawning_completed = True
 
         logger.info(f"{msg_prefix}: {_format_user_classes_count_for_log(self.reported_user_classes_count)}")
@@ -1110,6 +1113,7 @@ class MasterRunner(DistributedRunner):
                     logger.warning(f"Got spawning message from unknown worker {msg.node_id}. Asking worker to quit.")
                     self.server.send_to_client(Message("quit", None, msg.node_id))
             elif msg.type == "spawning_complete":
+                # a worker finished spawning (this happens multiple times during rampup)
                 self.clients[msg.node_id].state = STATE_RUNNING
                 self.clients[msg.node_id].user_classes_count = msg.data["user_classes_count"]
             elif msg.type == "quit":
@@ -1217,20 +1221,6 @@ class WorkerRunner(DistributedRunner):
         self.greenlet.spawn(self.heartbeat_timeout_checker).link_exception(greenlet_exception_handler)
         self.greenlet.spawn(self.stats_reporter).link_exception(greenlet_exception_handler)
 
-        # register listener for when all users have spawned, and report it to the master node
-        def on_spawning_complete(user_count: int) -> None:
-            assert user_count == sum(self.user_classes_count.values())
-            self.client.send(
-                Message(
-                    "spawning_complete",
-                    {"user_classes_count": self.user_classes_count, "user_count": self.user_count},
-                    self.client_id,
-                )
-            )
-            self.worker_state = STATE_RUNNING
-
-        self.environment.events.spawning_complete.add_listener(on_spawning_complete)
-
         # register listener that adds the current number of spawned users to the report that is sent to the master node
         def on_report_to_master(client_id: str, data: dict[str, Any]):
             data["user_classes_count"] = self.user_classes_count
@@ -1251,6 +1241,17 @@ class WorkerRunner(DistributedRunner):
 
         self.environment.events.user_error.add_listener(on_user_error)
 
+    def spawning_complete(self, user_count):
+        assert user_count == sum(self.user_classes_count.values())
+        self.client.send(
+            Message(
+                "spawning_complete",
+                {"user_classes_count": self.user_classes_count, "user_count": self.user_count},
+                self.client_id,
+            )
+        )
+        self.worker_state = STATE_RUNNING
+
     def start(
         self, user_count: int, spawn_rate: float, wait: bool = False, user_classes: list[type[User]] | None = None
     ) -> None:
@@ -1282,8 +1283,9 @@ class WorkerRunner(DistributedRunner):
         # can be blocking because of the stop_timeout
         self.spawn_users(user_classes_spawn_count)
         self.stop_users(user_classes_stop_count)
-
-        self.environment.events.spawning_complete.fire(user_count=sum(self.user_classes_count.values()))
+        self.spawning_complete(sum(self.user_classes_count.values()))
+        self.update_state(STATE_RUNNING)
+        self.worker_state = STATE_RUNNING
 
     def heartbeat(self) -> NoReturn:
         while True:
@@ -1394,6 +1396,9 @@ class WorkerRunner(DistributedRunner):
                 self.last_heartbeat_timestamp = time.time()
             elif msg.type == "update_user_class":
                 self.environment.update_user_class(msg.data)
+            elif msg.type == "spawning_complete":
+                # master says we have finished spawning (happens only once during a normal rampup)
+                self.environment.events.spawning_complete.fire(user_count=msg.data["user_count"])
             elif msg.type in self.custom_messages:
                 logger.debug("Received %s message from master" % msg.type)
                 listener, concurrent = self.custom_messages[msg.type]

locust/test/test_runners.py

@@ -82,6 +82,10 @@ def mocked_rpc(raise_on_close=True):
         def send_to_client(self, message):
             self.outbox.append((message.node_id, message))
 
+        @classmethod
+        def get_messages(cls, message_type=None) -> list:
+            return [message[1] for message in cls.outbox if message_type is None or message[1].type == message_type]
+
         def recv_from_client(self):
             results = self.queue.get()
             msg = Message.unserialize(results)
@@ -1157,7 +1161,7 @@ class TestMasterWorkerRunners(LocustTestCase):
         self.assertEqual(master_env.runner.stats.total.max_response_time, 42)
         self.assertEqual(master_env.runner.stats.get("cool-string", "GET").avg_response_time, 42)
 
-    def test_test_stop_event(self):
+    def test_spawning_complete_and_test_stop_event(self):
         class TestUser(User):
             wait_time = constant(0.1)
 
@@ -1169,11 +1173,16 @@ class TestMasterWorkerRunners(LocustTestCase):
             # start a Master runner
             master_env = Environment(user_classes=[TestUser])
             test_stop_count = {"master": 0, "worker": 0}
+            spawning_complete_count = {"master": 0, "worker": 0}
 
             @master_env.events.test_stop.add_listener
             def _(*args, **kwargs):
                 test_stop_count["master"] += 1
 
+            @master_env.events.spawning_complete.add_listener
+            def _(*args, **kwargs):
+                spawning_complete_count["master"] += 1
+
             master = master_env.create_master_runner("*", 0)
             sleep(0)
             # start a Worker runner
@@ -1183,15 +1192,19 @@ class TestMasterWorkerRunners(LocustTestCase):
             def _(*args, **kwargs):
                 test_stop_count["worker"] += 1
 
+            @worker_env.events.spawning_complete.add_listener
+            def _(*args, **kwargs):
+                spawning_complete_count["worker"] += 1
+
             worker = worker_env.create_worker_runner("127.0.0.1", master.server.port)
 
             # give worker time to connect
             sleep(0.1)
             # issue start command that should trigger TestUsers to be spawned in the Workers
-            master.start(2, spawn_rate=1000)
-            sleep(0.1)
+            master.start(3, spawn_rate=1)
+            sleep(3)
             # check that worker nodes have started locusts
-            self.assertEqual(2, worker.user_count)
+            self.assertEqual(3, worker.user_count)
             # give time for users to generate stats, and stats to be sent to master
             sleep(0.1)
             master_env.events.quitting.fire(environment=master_env, reverse=True)
@@ -1200,7 +1213,7 @@ class TestMasterWorkerRunners(LocustTestCase):
             # make sure users are killed
             self.assertEqual(0, worker.user_count)
 
-        # check the test_stop event was called one time in master and one time in worker
+        # check the spwaning_complete and test_stop events were called one time in master and one time in worker
         self.assertEqual(
             1,
             test_stop_count["master"],
@@ -1211,6 +1224,16 @@ class TestMasterWorkerRunners(LocustTestCase):
             test_stop_count["worker"],
             "The test_stop event was not called exactly one time in the worker node",
         )
+        self.assertEqual(
+            1,
+            spawning_complete_count["master"],
+            "The spawning_complete event was not called exactly one time in the master node",
+        )
+        self.assertEqual(
+            1,
+            spawning_complete_count["worker"],
+            "The spawning_complete event was not called exactly one time in the worker node",
+        )
 
     def test_distributed_shape(self):
         """
@@ -2565,11 +2588,10 @@ class TestMasterRunner(LocustRunnerTestCase):
             )
 
             master.start(100, 20)
-            self.assertEqual(6, len(server.outbox))
-            # First element of the outbox list is ack msg. That is why it is skipped in for loop
-            for i, (_, msg) in enumerate(server.outbox[1:].copy()):
+            self.assertEqual(7, len(server.get_messages()))
+            spawn_messages = server.get_messages("spawn")
+            for i, msg in enumerate(server.get_messages("spawn")):
                 self.assertDictEqual({"TestUser": int((i + 1) * 20)}, msg.data["user_classes_count"])
-                server.outbox.pop()
 
             # Normally, this attribute would be updated when the
             # master receives the report from the worker.
@@ -2579,11 +2601,9 @@ class TestMasterRunner(LocustRunnerTestCase):
             server.mocked_send(Message("client_ready", __version__, "zeh_fake_client2"))
             self.assertEqual(2, len(master.clients))
             sleep(0.1)  # give time for messages to be sent to clients
-            self.assertEqual(4, len(server.outbox))
-            client_id, msg = server.outbox.pop()
-            self.assertEqual({"TestUser": 50}, msg.data["user_classes_count"])
-            client_id, msg = server.outbox.pop()
-            self.assertEqual({"TestUser": 50}, msg.data["user_classes_count"])
+            spawn_messages = [message for message in server.outbox if message[1].type == "spawn"]
+            self.assertEqual({"TestUser": 50}, spawn_messages[-1][1].data["user_classes_count"])
+            self.assertEqual({"TestUser": 50}, spawn_messages[-2][1].data["user_classes_count"])
 
     def test_sends_spawn_data_to_ready_running_spawning_workers(self):
         """Sends spawn job to running, ready, or spawning workers"""
@@ -2602,8 +2622,8 @@ class TestMasterRunner(LocustRunnerTestCase):
             master.clients[2].state = STATE_SPAWNING
             master.clients[3].state = STATE_RUNNING
             master.start(user_count=5, spawn_rate=5)
-
-            self.assertEqual(3, len(server.outbox))
+            self.assertEqual(3, len(server.get_messages("spawn")))
+            self.assertEqual(3, len(server.get_messages("spawning_complete")))
 
     def test_start_event(self):
         """
@@ -2628,7 +2648,7 @@ class TestMasterRunner(LocustRunnerTestCase):
                 server.mocked_send(Message("client_ready", __version__, "fake_client%i" % i))
 
             master.start(7, 7)
-            self.assertEqual(10, len(server.outbox))
+            self.assertEqual(15, len(server.outbox))
             self.assertEqual(1, run_count[0])
 
             # change number of users and check that test_start isn't fired again
@@ -2667,7 +2687,7 @@ class TestMasterRunner(LocustRunnerTestCase):
                 server.mocked_send(Message("client_ready", __version__, "fake_client%i" % i))
 
             master.start(7, 7)
-            self.assertEqual(10, len(server.outbox))
+            self.assertEqual(15, len(server.outbox))
             master.stop()
             self.assertTrue(self.runner_stopping)
             self.assertTrue(self.runner_stopped)
@@ -2706,7 +2726,7 @@ class TestMasterRunner(LocustRunnerTestCase):
                 server.mocked_send(Message("client_ready", __version__, "fake_client%i" % i))
 
             master.start(7, 7)
-            self.assertEqual(10, len(server.outbox))
+            self.assertEqual(15, len(server.outbox))
             master.quit()
             self.assertTrue(self.runner_stopping)
             self.assertTrue(self.runner_stopped)
@@ -2753,13 +2773,10 @@ class TestMasterRunner(LocustRunnerTestCase):
                 server.mocked_send(Message("client_ready", __version__, "fake_client%i" % i))
 
             master.start(7, 7)
-            self.assertEqual(10, len(server.outbox))
-
-            num_users = sum(
-                sum(msg.data["user_classes_count"].values()) for _, msg in server.outbox if msg.type != "ack"
-            )
+            self.assertEqual(15, len(server.outbox))
 
-            self.assertEqual(7, num_users, "Total number of locusts that would have been spawned is not 7")
+            num_users = sum(sum(msg.data["user_classes_count"].values()) for msg in server.get_messages("spawn"))
+            self.assertEqual(7, num_users)
 
     def test_spawn_fewer_locusts_than_workers(self):
         class TestUser(User):
@@ -2774,11 +2791,9 @@ class TestMasterRunner(LocustRunnerTestCase):
                 server.mocked_send(Message("client_ready", __version__, "fake_client%i" % i))
 
             master.start(2, 2)
-            self.assertEqual(10, len(server.outbox))
+            self.assertEqual(15, len(server.outbox))
 
-            num_users = sum(
-                sum(msg.data["user_classes_count"].values()) for _, msg in server.outbox if msg.type != "ack"
-            )
+            num_users = sum(sum(msg.data["user_classes_count"].values()) for msg in server.get_messages("spawn"))
 
             self.assertEqual(2, num_users, "Total number of locusts that would have been spawned is not 2")
 
@@ -2801,7 +2816,7 @@ class TestMasterRunner(LocustRunnerTestCase):
                 server.mocked_send(Message("client_ready", __version__, "fake_client%i" % i))
 
             master.start(USERS_COUNT, USERS_COUNT)
-            self.assertEqual(USERS_COUNT * 2, len(server.outbox))
+            self.assertEqual(USERS_COUNT * 3, len(server.outbox))
 
             indexes = []
             for _, msg in server.outbox:
@@ -2845,27 +2860,21 @@ class TestMasterRunner(LocustRunnerTestCase):
 
             # Wait for shape_worker to update user_count
             sleep(0.5)
-            num_users = sum(
-                sum(msg.data["user_classes_count"].values()) for _, msg in server.outbox if msg.type != "ack"
-            )
+            num_users = sum(sum(msg.data["user_classes_count"].values()) for msg in server.get_messages("spawn"))
             self.assertEqual(
                 1, num_users, "Total number of users in first stage of shape test is not 1: %i" % num_users
             )
 
             # Wait for shape_worker to update user_count again
             sleep(1.5)
-            num_users = sum(
-                sum(msg.data["user_classes_count"].values()) for _, msg in server.outbox if msg.type != "ack"
-            )
+            num_users = sum(sum(msg.data["user_classes_count"].values()) for msg in server.get_messages("spawn"))
             self.assertEqual(
                 1, num_users, "Total number of users in second stage of shape test is not 1: %i" % num_users
             )
 
             # Wait for shape_worker to update user_count few times but not reach the end yet
             sleep(2.5)
-            num_users = sum(
-                sum(msg.data["user_classes_count"].values()) for _, msg in server.outbox if msg.type != "ack"
-            )
+            num_users = sum(sum(msg.data["user_classes_count"].values()) for msg in server.get_messages("spawn"))
             self.assertEqual(
                 3, num_users, "Total number of users in second stage of shape test is not 3: %i" % num_users
             )
@@ -2903,18 +2912,14 @@ class TestMasterRunner(LocustRunnerTestCase):
             sleep(0.5)
 
             # Wait for shape_worker to update user_count
-            num_users = sum(
-                sum(msg.data["user_classes_count"].values()) for _, msg in server.outbox if msg.type != "ack"
-            )
+            num_users = sum(sum(msg.data["user_classes_count"].values()) for msg in server.get_messages("spawn"))
             self.assertEqual(
                 1, num_users, "Total number of users in first stage of shape test is not 1: %i" % num_users
             )
 
             # Wait for shape_worker to update user_count again
             sleep(2)
-            num_users = sum(
-                sum(msg.data["user_classes_count"].values()) for _, msg in server.outbox if msg.type != "ack"
-            )
+            num_users = sum(sum(msg.data["user_classes_count"].values()) for msg in server.get_messages("spawn"))
             self.assertEqual(
                 3, num_users, "Total number of users in second stage of shape test is not 3: %i" % num_users
             )
@@ -2952,9 +2957,7 @@ class TestMasterRunner(LocustRunnerTestCase):
             sleep(0.5)
 
             # Wait for shape_worker to update user_count
-            num_users = sum(
-                sum(msg.data["user_classes_count"].values()) for _, msg in server.outbox if msg.type != "ack"
-            )
+            num_users = sum(sum(msg.data["user_classes_count"].values()) for msg in server.get_messages("spawn"))
             self.assertEqual(
                 5, num_users, "Total number of users in first stage of shape test is not 5: %i" % num_users
             )
@@ -2962,9 +2965,7 @@ class TestMasterRunner(LocustRunnerTestCase):
             # Wait for shape_worker to update user_count again
             sleep(2)
             msgs = defaultdict(dict)
-            for _, msg in server.outbox:
-                if msg.type == "ack":
-                    continue
+            for msg in server.get_messages("spawn"):
                 msgs[msg.node_id][msg.data["timestamp"]] = sum(msg.data["user_classes_count"].values())
             # Count users for the last received messages
             num_users = sum(v[max(v.keys())] for v in msgs.values())
@@ -3223,11 +3224,11 @@ class TestMasterRunner(LocustRunnerTestCase):
             master.start(10, 10)
             sleep(0.1)
             server.mocked_send(Message("stats", BAD_MESSAGE, "zeh_fake_client1"))
-            self.assertEqual(4, len(server.outbox))
+            self.assertEqual(5, len(server.outbox))
 
             # Expected message order in outbox: ack, spawn, reconnect, ack
             self.assertEqual(
-                "reconnect", server.outbox[2][1].type, "Master didn't send worker reconnect message when expected."
+                "reconnect", server.outbox[3][1].type, "Master didn't send worker reconnect message when expected."
             )
 
     def test_worker_sends_unrecognized_message_to_master(self):
@@ -3251,7 +3252,7 @@ class TestMasterRunner(LocustRunnerTestCase):
             master.start(10, 10)
             sleep(0.1)
             server.mocked_send(Message("stats", UNRECOGNIZED_MESSAGE, "zeh_fake_client1"))
-            self.assertEqual(2, len(server.outbox))
+            self.assertEqual(3, len(server.outbox))
 
     def test_unknown_host_sends_message_to_master(self):
         """
@@ -3274,7 +3275,7 @@ class TestMasterRunner(LocustRunnerTestCase):
             master.start(10, 10)
             sleep(0.1)
             server.mocked_send(Message("stats", UNRECOGNIZED_HOST_MESSAGE, "unknown_host"))
-            self.assertEqual(2, len(server.outbox))
+            self.assertEqual(3, len(server.outbox))
 
 
 class TestWorkerRunner(LocustTestCase):

{locust-2.28.1.dev5.dist-info → locust-2.28.1.dev13.dist-info}/METADATA

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

{locust-2.28.1.dev5.dist-info → locust-2.28.1.dev13.dist-info}/RECORD

@@ -1,19 +1,19 @@
 locust/__init__.py,sha256=g6oA-Ba_hs3gLWVf5MKJ1mvfltI8MFnDWG8qslqm8yg,1402
 locust/__main__.py,sha256=vBQ82334kX06ImDbFlPFgiBRiLIinwNk3z8Khs6hd74,31
-locust/_version.py,sha256=qMWDhIpQqlRPvupt6JirBlvLKSD860__bom6YB9_htI,426
+locust/_version.py,sha256=Q1TWGd4oNv3QSU1p6QqsAkYKTrQr8ThKLvEBRf3l2H0,428
 locust/argument_parser.py,sha256=VVhInNMKaisjiywQ7H43ooONpHe1Ve1JmftHgnQnRfY,28715
 locust/clients.py,sha256=YKuAyMAbxs8_-w7XJw0hc67KFBNNLxibsw6FwiS01Q8,14781
 locust/debug.py,sha256=We6Z9W0btkKSc7PxWmrZx-xMynvOOsKhG6jmDgQin0g,5134
 locust/dispatch.py,sha256=vYh0QEDFgJ3hY0HgSk-EiNO7IP9ffzXF_Et8wB9JvsI,16995
 locust/env.py,sha256=SLtUQCYaiv_oq_Nz1xaB0OD8RkTdESt2b71vz_qohpo,12452
-locust/event.py,sha256=xgNKbcejxy1TNUfIdgV75KgD2_BOwQmvjrJ4hWuydRw,7740
+locust/event.py,sha256=m-egSPfOEd1Q6HEXx5lB0LlXOuEdzeS7B1XSFIDgRy0,7836
 locust/exception.py,sha256=jGgJ32ubuf4pWdlaVOkbh2Y0LlG0_DHi-lv3ib8ppOE,1791
 locust/html.py,sha256=C-RvShjgRRqzzYGdOGCelobm_SlEGjp8TutvHou1er0,4050
 locust/input_events.py,sha256=ZIyePyAMuA_YFYWg18g_pE4kwuQV3RbEB250MzXRwjY,3314
 locust/log.py,sha256=cqLt7nnxnQuM4vWFB5EpJpNUTxGBVEkUJuaJPI1S7_Y,3186
 locust/main.py,sha256=NGjL5QqakU5aeyUzwu2Fh00xVZfC3eoBE3DtfOmRtcM,27854
 locust/py.typed,sha256=gkWLl8yD4mIZnNYYAIRM8g9VarLvWmTAFeUfEbxJLBw,65
-locust/runners.py,sha256=kbEJtHVbDyQnd4IFo0GogasiZKWGXqFgiOiKt3aMjxw,68083
+locust/runners.py,sha256=Xc_cyRig7nL5Rtuk4hfH029JoQZP4U_yXGGK7t-h-SE,68406
 locust/shape.py,sha256=t-lwBS8LOjWcKXNL7j2U3zroIXJ1b0fazUwpRYQOKXw,1973
 locust/stats.py,sha256=IXhOtYJ_B863kyrHysNQmuFHv2Vd57vE3Rnerwp3bzs,45859
 locust/web.py,sha256=5Zj8nTa3Kr0aLhC1bXjZ5bissSOddYFQnIw8NOFUdPI,26976
@@ -39,7 +39,7 @@ locust/test/test_log.py,sha256=YPY6vgTAy1KaNU2qoVvQrTH5x_mzRrljEHrkSBy3yxs,7553
 locust/test/test_main.py,sha256=7OuH2-7noD_rbeoKJD9hIZsylSugu7ze3XFIrU1u0HI,85016
 locust/test/test_old_wait_api.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 locust/test/test_parser.py,sha256=-2VO5Dopg-VoWvIgXrmr7GN40cqrnjUoctBHmVlyewg,17826
-locust/test/test_runners.py,sha256=UWHmQW59QV1ZQzHRZjFIZiSW8ROUIVCuUgU-VAwOpH8,160110
+locust/test/test_runners.py,sha256=pUqxY9IvlDXbYlkEZGX3PZIo25upBdPsDwt3g1dPqbA,160681
 locust/test/test_sequential_taskset.py,sha256=QjVMWWfGHn9hU5AvPxRDU7Vo5DcVW1VkMVfDA0k9OPE,3398
 locust/test/test_stats.py,sha256=F51VkL3k3y4OhYBlRyV6vWzisenSAOmSWKy2IPVrnWM,33929
 locust/test/test_tags.py,sha256=mzhGLPMizSnSItTHLHizYvloxDfuIDAOgelwInyrf28,13138
@@ -70,9 +70,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-e569e7ff.js,sha256=Oq8fMAMNzgRmzBEFzrQTarNoTm5AENM0lIegSwnYMUM,1645744
 locust/webui/dist/assets/logo.png,sha256=EIVPqr6wE_yqguHaqFHIsH0ZACLSrvNWyYO7PbyIj4w,19299
-locust-2.28.1.dev5.dist-info/LICENSE,sha256=78XGpIn3fHVBfaxlPNUfjVufSN7QsdhpJMRJHv2AFpo,1095
-locust-2.28.1.dev5.dist-info/METADATA,sha256=vg1XisoLZJAJzC8NkzbrVI-daoTpc9OH20H6gDMKHO8,7263
-locust-2.28.1.dev5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-locust-2.28.1.dev5.dist-info/entry_points.txt,sha256=RAdt8Ku-56m7bFjmdj-MBhbF6h4NX7tVODR9QNnOg0E,44
-locust-2.28.1.dev5.dist-info/top_level.txt,sha256=XSsjgPA8Ggf9TqKVbkwSqZFuPlZ085X13M9orDycE20,7
-locust-2.28.1.dev5.dist-info/RECORD,,
+locust-2.28.1.dev13.dist-info/LICENSE,sha256=78XGpIn3fHVBfaxlPNUfjVufSN7QsdhpJMRJHv2AFpo,1095
+locust-2.28.1.dev13.dist-info/METADATA,sha256=S2zcEtf4B_NZB4HbybXzfoV78kEtowsCzcsDnqfhegM,7264
+locust-2.28.1.dev13.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+locust-2.28.1.dev13.dist-info/entry_points.txt,sha256=RAdt8Ku-56m7bFjmdj-MBhbF6h4NX7tVODR9QNnOg0E,44
+locust-2.28.1.dev13.dist-info/top_level.txt,sha256=XSsjgPA8Ggf9TqKVbkwSqZFuPlZ085X13M9orDycE20,7
+locust-2.28.1.dev13.dist-info/RECORD,,