Fix typos

Author: DimitriPapadopoulos

distributed/comm/tests/test_comms.py

@@ -1321,7 +1321,7 @@ async def check_addresses(a, b):
 
 
 @gen_test()
-async def test_tcp_adresses(tcp):
+async def test_tcp_addresses(tcp):
     a, b = await get_tcp_comm_pair()
     await check_addresses(a, b)
 
@@ -1336,13 +1336,13 @@ async def test_get_stream_address_raises_if_closed():
 
 
 @gen_test()
-async def test_tls_adresses(tcp):
+async def test_tls_addresses(tcp):
     a, b = await get_tls_comm_pair()
     await check_addresses(a, b)
 
 
 @gen_test()
-async def test_inproc_adresses():
+async def test_inproc_addresses():
     a, b = await get_inproc_comm_pair()
     await check_addresses(a, b)
 

distributed/dashboard/components/scheduler.py

@@ -2331,7 +2331,7 @@ def __init__(self, scheduler, **kwargs):
     @log_errors
     def update(self):
         # If there are too many tasks in the scheduler we'll disable this
-        # compoonents to not overload scheduler or client. Once we drop
+        # components to not overload scheduler or client. Once we drop
         # below the threshold, the data is filled up again as usual
         if len(self.scheduler.tasks) > self.max_items:
             self.subtitle.text = "Scheduler has too many tasks to display."
@@ -2863,7 +2863,7 @@ def update(self):
             # Add some status to hover
             tasks_processing = tg.states["processing"]
             tasks_memory = tg.states["memory"]
-            tasks_relased = tg.states["released"]
+            tasks_released = tg.states["released"]
             tasks_erred = tg.states["erred"]
 
             nodes_data["comp_tasks"].append(
@@ -2876,7 +2876,7 @@ def update(self):
                 f"{tasks_memory} ({tasks_memory / tot_tasks * 100:.0f} %)"
             )
             nodes_data["in_released"].append(
-                f"{tasks_relased} ({tasks_relased / tot_tasks * 100:.0f} %)"
+                f"{tasks_released} ({tasks_released / tot_tasks * 100:.0f} %)"
             )
             nodes_data["in_erred"].append(
                 f"{tasks_erred} ({tasks_erred / tot_tasks * 100:.0f} %)"
@@ -2963,7 +2963,7 @@ def _should_add_new_renderers(self) -> bool:
     def _should_update(self) -> bool:
         """
         Whether to update the ColumnDataSource. This is cheaper than redrawing,
-        but still not free, so we check whether we need it and whether the scheudler
+        but still not free, so we check whether we need it and whether the scheduler
         is busy.
         """
         return (

distributed/deploy/subprocess.py

@@ -193,7 +193,7 @@ def SubprocessCluster(
     host:
         Host address on which the scheduler will listen, defaults to localhost
     scheduler_port:
-        Port fo the scheduler, defaults to 0 to choose a random port
+        Port for the scheduler, defaults to 0 to choose a random port
     scheduler_kwargs:
             Keywords to pass on to scheduler
     dashboard_address:

distributed/protocol/tests/test_protocol_utils.py

@@ -36,17 +36,17 @@ def test_unpack_frames_partial():
     frames = [b"123", b"asdf"]
     frames.insert(0, pack_frames_prelude(frames))
 
-    frames2, missing_lenghts = unpack_frames(b"".join(frames), partial=True)
+    frames2, missing_lengths = unpack_frames(b"".join(frames), partial=True)
     assert frames2 == frames[1:]
-    assert missing_lenghts == []
+    assert missing_lengths == []
 
-    frames2, missing_lenghts = unpack_frames(b"".join(frames[:-1]), partial=True)
+    frames2, missing_lengths = unpack_frames(b"".join(frames[:-1]), partial=True)
     assert frames2 == frames[1:-1]
-    assert missing_lenghts == [4]
+    assert missing_lengths == [4]
 
-    frames2, missing_lenghts = unpack_frames(frames[0], partial=True)
+    frames2, missing_lengths = unpack_frames(frames[0], partial=True)
     assert frames2 == []
-    assert missing_lenghts == [3, 4]
+    assert missing_lengths == [3, 4]
 
     with pytest.raises(AssertionError):
         unpack_frames(b"".join(frames[:-1]))

distributed/security.py

@@ -20,7 +20,7 @@
     # https://docs.python.org/3.10/library/ssl.html#ssl.SSLContext.minimum_version
     # https://docs.python.org/3.7/library/ssl.html#ssl.SSLContext.minimum_version
 
-    # these _set_mimimun_version and _set_maximum_version depend on the validation
+    # these _set_minimum_version and _set_maximum_version depend on the validation
     # already performed in `Security._set_tls_version_field`,
     # and that they only apply to freshly created ssl.SSLContext instances in
     # _get_tls_context

distributed/shuffle/tests/test_shuffle.py

@@ -233,7 +233,7 @@ async def test_shuffle_with_array_conversion(c, s, a, b, npartitions):
         out = df.shuffle("x", npartitions=npartitions, force=True).values
 
     # See distributed#7816. TaskSpec is currently blocking linear fusion. If
-    # that was implemented, this may raise a P2PConsistencyErrro
+    # that was implemented, this may raise a P2PConsistencyError
 
     await c.compute(out)
 

distributed/tests/test_client.py

@@ -2520,7 +2520,7 @@ async def test_traceback_clean(c, s, a, b):
 
 
 @gen_cluster(client=True)
-async def test_map_differnet_lengths(c, s, a, b):
+async def test_map_different_lengths(c, s, a, b):
     assert len(c.map(add, [1, 2], [1, 2, 3])) == 2
 
 

distributed/tests/test_jupyter.py

@@ -77,11 +77,11 @@ async def test_jupyter_idle_timeout():
         # time, which is used to determine idleness. Instead of a full e2e test
         # launching a kernel and running commands on it, we'll just hook into this:
         # https://github.com/jupyter-server/jupyter_server/blob/e582e555/jupyter_server/serverapp.py#L385-L387
-        extension_last_activty = web_app.settings["last_activity_times"]
+        extension_last_activity = web_app.settings["last_activity_times"]
 
         for _ in range(10):
             last = perf_counter()
-            extension_last_activty["test"] = datetime.now(timezone.utc)
+            extension_last_activity["test"] = datetime.now(timezone.utc)
 
             await asyncio.sleep(s.idle_timeout / 2)
             if (d := perf_counter() - last) >= s.idle_timeout:
@@ -99,12 +99,12 @@ async def test_jupyter_idle_timeout_returned():
     "`check_idle` should return the last Jupyter idle time. Used in dask-kubernetes."
     async with Scheduler(jupyter=True, dashboard_address=":0") as s:
         web_app = s._jupyter_server_application.web_app
-        extension_last_activty = web_app.settings["last_activity_times"]
+        extension_last_activity = web_app.settings["last_activity_times"]
 
-        extension_last_activty["test"] = datetime.now(timezone.utc)
+        extension_last_activity["test"] = datetime.now(timezone.utc)
         last_idle = s.check_idle()
         assert last_idle is not None
-        extension_last_activty["test"] = datetime.now(timezone.utc) + timedelta(
+        extension_last_activity["test"] = datetime.now(timezone.utc) + timedelta(
             seconds=1
         )
         next_idle = s.check_idle()