[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

simulate.py

@@ -1,27 +1,29 @@
 from __future__ import annotations
-import random
+
 import argparse
 import asyncio
-from enum import Enum
 import json
 import os
+import random
 import secrets
+import time
 from dataclasses import dataclass
 from datetime import datetime
 from functools import partial
-import time
 from typing import Any, Coroutine, List
 
 import aiohttp
 import aiometer
 from playwright.async_api import Browser, async_playwright
 from yarl import URL
 
+
 @dataclass
 class TimedResult[T]:
     duration: float
     result: T
 
+
 @dataclass
 class HubAccess:
     """
@@ -63,6 +65,7 @@ class FailedServer(Server):
     start_failure_time: datetime
     startup_events: List[dict]
 
+
 @dataclass
 class NBGitpullerURL:
     repo: str
@@ -74,7 +77,7 @@ def make_fullpath(self, server_url: URL, targetpath: str) -> URL:
             "repo": self.repo,
             "branch": self.ref,
             "targetPath": targetpath,
-            "urlPath": os.path.join("tree", targetpath, self.open_path)
+            "urlPath": os.path.join("tree", targetpath, self.open_path),
         }
 
         return (server_url / "git-pull").with_query(query_params)
@@ -101,14 +104,19 @@ async def load_nbgitpuller_url(
     targetpath = secrets.token_hex(8)
     going_to = nbgitpuller_url.make_fullpath(server.server_url, targetpath)
     await page.goto(str(going_to))
-    expected_final_full_url = str(nbgitpuller_url.make_expectedpath(server.server_url, targetpath))
+    expected_final_full_url = str(
+        nbgitpuller_url.make_expectedpath(server.server_url, targetpath)
+    )
     await page.wait_for_url(expected_final_full_url, timeout=120 * 10 * 1000)
     await page.wait_for_load_state("networkidle")
     await page.screenshot(path=screenshot_name)
     return TimedResult(time.perf_counter() - start_time, None)
 
+
 async def start_named_server(
-    session: aiohttp.ClientSession, server: Server, profile_options: dict[str, str] | None = None,
+    session: aiohttp.ClientSession,
+    server: Server,
+    profile_options: dict[str, str] | None = None,
 ) -> TimedResult[RunningServer | None]:
     """
     Try to start a named server as defined
@@ -124,11 +132,15 @@ async def start_named_server(
         / server.servername
     )
     events = []
-    async with session.post(server_api_url, headers=headers, json=profile_options) as resp:
+    async with session.post(
+        server_api_url, headers=headers, json=profile_options
+    ) as resp:
         if resp.status == 202:
             # we are awaiting start, let's look for events
             async with session.get(
-                server_api_url / "progress", headers=headers, timeout=aiohttp.ClientTimeout(10 * 60)
+                server_api_url / "progress",
+                headers=headers,
+                timeout=aiohttp.ClientTimeout(10 * 60),
             ) as progress_resp:
                 async for line in progress_resp.content:
                     if line.decode().strip() == "":
@@ -145,9 +157,11 @@ async def start_named_server(
                                 hub_access=server.hub_access,
                                 startup_events=events,
                                 server_url=URL(
-                                    server.hub_access.url.joinpath(progress_event["url"].lstrip("/"), encoded=True)
+                                    server.hub_access.url.joinpath(
+                                        progress_event["url"].lstrip("/"), encoded=True
+                                    )
                                 ),
-                            )
+                            ),
                         )
         elif resp.status == 429:
             # Sleep for upto roughly 2s and try again
@@ -161,14 +175,16 @@ async def start_named_server(
             # Some kinda error
             resp.raise_for_status()
 
+
 def poisson_distribution_wait_times(rate: float, count: int) -> list[float]:
     wait_times = []
     t = 0
-    while(len(wait_times) < count):
+    while len(wait_times) < count:
         t += random.expovariate(rate)
         wait_times.append(t)
     return wait_times
 
+
 async def payload(
     session: aiohttp.ClientSession,
     browser: Browser,
@@ -195,23 +211,31 @@ async def payload(
                         server.servername + ".png",
                     )
                     timing_info["nbgitpuller"] = result.duration
-                    print(f"nbgitpuller completed for {server.servername} in {result.duration:0.2f}s")
+                    print(
+                        f"nbgitpuller completed for {server.servername} in {result.duration:0.2f}s"
+                    )
                 case None:
                     print("Server startup failed")
 
     print(f"{server.servername}: {timing_info}")
 
+
 async def delay(duration: float, callable: Coroutine) -> Any:
     await asyncio.sleep(duration)
     return await callable
 
+
 async def main():
     argparser = argparse.ArgumentParser()
     argparser.add_argument("hub_url", help="Full URL to the JupyterHub to test against")
-    argparser.add_argument("server_prefix", help="Prefix used for named servers started in this run")
+    argparser.add_argument(
+        "server_prefix", help="Prefix used for named servers started in this run"
+    )
     argparser.add_argument("username", help="Name of the user")
     argparser.add_argument("servers_count", type=int, help="Number of servers to start")
-    argparser.add_argument("server_startup_rate", type=int, help="Number of servers to start per minute")
+    argparser.add_argument(
+        "server_startup_rate", type=int, help="Number of servers to start per minute"
+    )
     # FIXME: This shouldn't be here.
     argparser.add_argument(
         "--max-concurrency",
@@ -220,36 +244,55 @@ async def main():
         help="Max Numbers of Servers to start at the same time",
     )
     argparser.add_argument(
-        '--profile-option',
+        "--profile-option",
         help="Additional profile option to specify when starting the server (of key=value form)",
-        nargs="*"
+        nargs="*",
     )
 
     args = argparser.parse_args()
 
-    nbgitpuller_url = NBGitpullerURL("https://github.com/mspass-team/mspass_tutorial/", "master", "Earthscope2025")
+    nbgitpuller_url = NBGitpullerURL(
+        "https://github.com/mspass-team/mspass_tutorial/", "master", "Earthscope2025"
+    )
     token = os.environ["JUPYTERHUB_TOKEN"]
 
     profile_options = None
     if args.profile_option:
         profile_options = {}
         for po in args.profile_option:
-            key, value = po.split('=', 2)
+            key, value = po.split("=", 2)
             profile_options[key] = value
 
     hub_url = URL(args.hub_url)
     async with async_playwright() as p:
         browser = await p.firefox.launch(headless=False)
         async with aiohttp.ClientSession() as session:
             servers_to_start = [
-                Server(f"{args.server_prefix}-{i}", args.username, HubAccess(hub_url, token))
+                Server(
+                    f"{args.server_prefix}-{i}",
+                    args.username,
+                    HubAccess(hub_url, token),
+                )
                 for i in range(args.servers_count)
             ]
-            delays = poisson_distribution_wait_times(args.server_startup_rate / 60, args.servers_count)
+            delays = poisson_distribution_wait_times(
+                args.server_startup_rate / 60, args.servers_count
+            )
             print(delays)
             await aiometer.run_all(
                 [
-                    partial(delay, duration, payload(session, browser, token, nbgitpuller_url, profile_options, server))
+                    partial(
+                        delay,
+                        duration,
+                        payload(
+                            session,
+                            browser,
+                            token,
+                            nbgitpuller_url,
+                            profile_options,
+                            server,
+                        ),
+                    )
                     for server, duration in zip(servers_to_start, delays)
                 ],
                 max_at_once=args.max_concurrency,