✨ 格式化文档

Author: SilianZ

core/__init__.py

@@ -241,12 +241,15 @@ async def main():
     os.environ["ASYNCIO_STARTUP"] = str(0)
     os.kill(os.getpid(), signal.SIGINT)
 
+
 def init():
     asyncio.run(main())
 
+
 async def close():
     await web.close()
 
+
 def kill(_, __):
     if int(os.environ["ASYNCIO_STARTUP"]) and server:
         server.close()
@@ -256,4 +259,4 @@ def kill(_, __):
 
 
 for sig in (signal.SIGINT, signal.SIGTERM):
-    signal.signal(sig, kill)
+    signal.signal(sig, kill)

core/cluster.py

@@ -33,10 +33,10 @@
     get_hash,
 )
 
-VERSION = ''
+VERSION = ""
 version_path = Path("VERSION")
 if version_path.exists():
-    with open(Path("VERSION"), 'r', encoding='utf-8') as f:
+    with open(Path("VERSION"), "r", encoding="utf-8") as f:
         VERSION = f.read()
         f.close()
 else:
@@ -512,9 +512,7 @@ async def check_files(self):
         if not miss:
             logger.success(f"Checked all files: {len(files) * len(self.storages)}!")
         else:
-            logger.info(
-                f"File missing: {unit.format_number(len(miss))}."
-            )
+            logger.info(f"File missing: {unit.format_number(len(miss))}.")
             await downloader.download(self.storages, list(miss))
         if os.path.exists("./cache/download"):
             paths = []
@@ -565,6 +563,7 @@ async def start(
         await self.check_files()
         await dashboard.set_status("启动服务")
         await self.enable()
+
     async def get(self, hash, offset: int = 0) -> File:
         storage = self.storages[0]
         stat = self.storage_stats[storage]
@@ -606,6 +605,7 @@ async def enable(self) -> None:
             },
         )
         await dashboard.set_status("巡检中")
+
     async def message(self, type, data: list[Any]):
         if len(data) == 1:
             data.append(None)
@@ -629,7 +629,9 @@ async def message(self, type, data: list[Any]):
                 f"Hosting on {CLUSTER_ID}.openbmclapi.933.moe:{PUBLIC_PORT or PORT}."
             )
             await self.start_keepalive()
-            await dashboard.set_status("正常工作" + ("" if self.trusted else "（节点信任度过低）"))
+            await dashboard.set_status(
+                "正常工作" + ("" if self.trusted else "（节点信任度过低）")
+            )
         elif type == "keep-alive":
             if err:
                 logger.error(f"Unable to keep alive! Reconnecting...")
@@ -718,21 +720,22 @@ async def disable(self):
 cluster: Optional[Cluster] = None
 last_status: str = "-"
 github_api = "https://api.github.com"
+
+
 async def check_update():
-    async with aiohttp.ClientSession(
-            base_url=github_api
-        ) as session:
-            logger.info("Checking update...")
-            try:
-                async with session.get("/repos/TTB-Network/python-openbmclapi/tags") as req:
-                    req.raise_for_status()
-                    fetched_version: str = (await req.json())[0]["name"]
-                if fetched_version != VERSION:
-                    logger.success(f"New version found: {fetched_version}!")
-                else:
-                    logger.info(f"Already up to date.")
-            except aiohttp.ClientError as e:
-                logger.error(f"An error occured whilst checking update: {e}.")
+    async with aiohttp.ClientSession(base_url=github_api) as session:
+        logger.info("Checking update...")
+        try:
+            async with session.get("/repos/TTB-Network/python-openbmclapi/tags") as req:
+                req.raise_for_status()
+                fetched_version: str = (await req.json())[0]["name"]
+            if fetched_version != VERSION:
+                logger.success(f"New version found: {fetched_version}!")
+            else:
+                logger.info(f"Already up to date.")
+        except aiohttp.ClientError as e:
+            logger.error(f"An error occured whilst checking update: {e}.")
+
 
 async def init():
     await check_update()
@@ -778,8 +781,10 @@ async def _(request: web.Request, hash: str):
         if not await cluster.exists(hash):
             return web.Response(status_code=404)
         start_bytes = 0
-        range_str = await request.get_headers('range', '')
-        range_match = re.search(r'bytes=(\d+)-(\d+)', range_str, re.S) or re.search(r'bytes=(\d+)-', range_str, re.S)
+        range_str = await request.get_headers("range", "")
+        range_match = re.search(r"bytes=(\d+)-(\d+)", range_str, re.S) or re.search(
+            r"bytes=(\d+)-", range_str, re.S
+        )
         if range_match:
             start_bytes = int(range_match.group(1)) if range_match else 0
         data = await cluster.get(hash, start_bytes)
@@ -797,7 +802,9 @@ async def _(request: web.Request, ws: web.WebSocket):
         auth = False
         for cookie in await request.get_cookies():
             if cookie.name == "auth" and dashboard.token_isvaild(cookie.value):
-                await ws.send(dashboard.to_bytes("auth", DASHBOARD_USERNAME).io.getbuffer())
+                await ws.send(
+                    dashboard.to_bytes("auth", DASHBOARD_USERNAME).io.getbuffer()
+                )
                 auth = True
                 break
         if not auth:
@@ -810,18 +817,29 @@ async def _(request: web.Request, ws: web.WebSocket):
             input = utils.DataInputStream(raw_data)
             type = input.readString()
             data = dashboard.deserialize(input)
-            await ws.send(dashboard.to_bytes(type, await dashboard.process(type, data)).io.getbuffer())
+            await ws.send(
+                dashboard.to_bytes(
+                    type, await dashboard.process(type, data)
+                ).io.getbuffer()
+            )
+
     @router.get("/auth")
     async def _(request: web.Request):
         auth = (await request.get_headers("Authorization")).split(" ", 1)[1]
         try:
             info = json.loads(base64.b64decode(auth))
         except:
             return web.Response(status_code=401)
-        if info["username"] != DASHBOARD_USERNAME or info["password"] != DASHBOARD_PASSWORD:
+        if (
+            info["username"] != DASHBOARD_USERNAME
+            or info["password"] != DASHBOARD_PASSWORD
+        ):
             return web.Response(status_code=401)
         token = dashboard.generate_token(request)
-        return web.Response(DASHBOARD_USERNAME, cookies=[web.Cookie("auth", token.value, expires=int(time.time() + 86400))])
+        return web.Response(
+            DASHBOARD_USERNAME,
+            cookies=[web.Cookie("auth", token.value, expires=int(time.time() + 86400))],
+        )
 
     app.mount(router)
     app.redirect("/bmcl", "/bmcl/")

core/dashboard.py

@@ -12,16 +12,20 @@
 from core.api import StatsCache
 from core.config import Config
 
+
 @dataclass
 class Token:
     value: str
     create_at: float
 
+
 BASE_URL = "https://openbmclapi.bangbang93.com/"
 CLUSTER_ID: str = Config.get("cluster.id")
 CLUSTER_SECERT: str = Config.get("cluster.secret")
 last_status = ""
 tokens: list[Token] = []
+
+
 def deserialize(data: utils.DataInputStream):
     match (data.readVarInt()):
         case 0:
@@ -35,9 +39,13 @@ def deserialize(data: utils.DataInputStream):
         case 4:
             return [deserialize(data) for _ in range(data.readVarInt())]
         case 5:
-            return {deserialize(data): deserialize(data) for _ in range(data.readVarInt())}
+            return {
+                deserialize(data): deserialize(data) for _ in range(data.readVarInt())
+            }
         case 6:
             return None
+
+
 def serialize(data: Any):
     buf = utils.DataOutputStream()
     if isinstance(data, str):
@@ -55,14 +63,23 @@ def serialize(data: Any):
     elif isinstance(data, list):
         buf.writeVarInt(4)
         buf.writeVarInt(len(data))
-        buf.write(b''.join((serialize(v).io.getvalue() for v in data)))
+        buf.write(b"".join((serialize(v).io.getvalue() for v in data)))
     elif isinstance(data, dict):
         buf.writeVarInt(5)
         buf.writeVarInt(len(data.keys()))
-        buf.write(b''.join((serialize(k).io.getvalue() + serialize(v).io.getvalue() for k, v in data.items())))
+        buf.write(
+            b"".join(
+                (
+                    serialize(k).io.getvalue() + serialize(v).io.getvalue()
+                    for k, v in data.items()
+                )
+            )
+        )
     elif data == None:
         buf.writeVarInt(6)
     return buf
+
+
 async def process(type: str, data: Any):
     if type == "runtime":
         return float(os.getenv("STARTUP") or 0)
@@ -83,31 +100,56 @@ async def process(type: str, data: Any):
             "memory": system.get_used_memory(),
             "connections": system.get_connections(),
             "cpu": system.get_cpus(),
-            "cache": asdict(await cluster.cluster.get_cache_stats()) if cluster.cluster else StatsCache()
+            "cache": (
+                asdict(await cluster.cluster.get_cache_stats())
+                if cluster.cluster
+                else StatsCache()
+            ),
         }
+
+
 async def set_status(text):
-    global last_status 
+    global last_status
     if last_status != text:
         app = web.app
         output = to_bytes("status", text)
         for ws in app.get_websockets("/bmcl/"):
             await ws.send(output.io.getvalue())
     last_status = text
 
+
 def to_bytes(type: str, data: Any):
     output = utils.DataOutputStream()
     output.writeString(type)
     output.write(serialize(data).io.getvalue())
     return output
 
-def generate_token(request: 'web.Request') -> Token:
+
+def generate_token(request: "web.Request") -> Token:
     global tokens
-    token = Token(hashlib.sha256(zlib.compress(hashlib.sha512((request.get_ip() + request.get_user_agent() + request.get_url() + CLUSTER_ID + CLUSTER_SECERT + str(time.time())).encode("utf-8")).digest())).hexdigest(), time.time())
+    token = Token(
+        hashlib.sha256(
+            zlib.compress(
+                hashlib.sha512(
+                    (
+                        request.get_ip()
+                        + request.get_user_agent()
+                        + request.get_url()
+                        + CLUSTER_ID
+                        + CLUSTER_SECERT
+                        + str(time.time())
+                    ).encode("utf-8")
+                ).digest()
+            )
+        ).hexdigest(),
+        time.time(),
+    )
     tokens.append(token)
     return token
 
+
 def token_isvaild(value) -> bool:
     for token in tokens:
         if token.value == value and token.create_at + 86400 > time.time():
             return True
-    return False
+    return False

core/logger.py

@@ -5,54 +5,54 @@
 basic_logger_format = "<green>[{time:YYYY-MM-DD HH:mm:ss}]</green> <level>[{level}] <yellow>[{name}:{function}:{line}]</yellow>: {message}</level>"
 
 
-def log(*values):  
-    data = []  
-    for v in values:  
-        try:  
-            data.append(str(v))  
-        except:  
-            data.append(repr(v))  
-    return " ".join(data)  
-  
-  
-class LoggingLogger:  
-    def __init__(self):  
+def log(*values):
+    data = []
+    for v in values:
+        try:
+            data.append(str(v))
+        except:
+            data.append(repr(v))
+    return " ".join(data)
+
+
+class LoggingLogger:
+    def __init__(self):
         self.log = Logger.opt(depth=2)
-        self.log.remove()  
-        self.log.add(  
-            sys.stderr,  
-            format=basic_logger_format,  
-            level="DEBUG",  
-            colorize=True,  
-        )  
-        self.log.add(  
-            Path("./logs/{time:YYYY-MM-DD}.log"),  
-            format=basic_logger_format,  
-            retention="10 days",  
-            encoding="utf-8",  
-        )  
-  
-    def _log_with_args(self, level, *args, **kwargs):  
-        message = log(*args) if args else ""  
-        self.log.log(level, message, **kwargs)  
-  
-    def info(self, *args, **kwargs):  
-        self._log_with_args("INFO", *args, **kwargs)  
-  
-    def error(self, *args, **kwargs):  
-        self._log_with_args("ERROR", *args, **kwargs)  
-  
-    def debug(self, *args, **kwargs):  
-        self._log_with_args("DEBUG", *args, **kwargs)  
-  
-    def warn(self, *args, **kwargs):  
-        self._log_with_args("WARNING", *args, **kwargs)  
-  
-    def exception(self, *args, **kwargs):  
-        self._log_with_args("EXCEPTION", *args, **kwargs) 
-
-    def success(self, *args, **kwargs):  
-        self._log_with_args("SUCCESS", *args, **kwargs) 
+        self.log.remove()
+        self.log.add(
+            sys.stderr,
+            format=basic_logger_format,
+            level="DEBUG",
+            colorize=True,
+        )
+        self.log.add(
+            Path("./logs/{time:YYYY-MM-DD}.log"),
+            format=basic_logger_format,
+            retention="10 days",
+            encoding="utf-8",
+        )
+
+    def _log_with_args(self, level, *args, **kwargs):
+        message = log(*args) if args else ""
+        self.log.log(level, message, **kwargs)
+
+    def info(self, *args, **kwargs):
+        self._log_with_args("INFO", *args, **kwargs)
+
+    def error(self, *args, **kwargs):
+        self._log_with_args("ERROR", *args, **kwargs)
+
+    def debug(self, *args, **kwargs):
+        self._log_with_args("DEBUG", *args, **kwargs)
+
+    def warn(self, *args, **kwargs):
+        self._log_with_args("WARNING", *args, **kwargs)
+
+    def exception(self, *args, **kwargs):
+        self._log_with_args("EXCEPTION", *args, **kwargs)
+
+    def success(self, *args, **kwargs):
+        self._log_with_args("SUCCESS", *args, **kwargs)
 
 
 logger = LoggingLogger()