dbgr-server 1.1.0.dev1__py3-none-any.whl

dbgr_server/__init__.py

@@ -0,0 +1 @@
+__version__ = "1.1.0-dev1"

dbgr_server/__main__.py

@@ -0,0 +1,61 @@
+# Stdlib:
+import asyncio
+import argparse
+from logging import DEBUG, INFO, WARNING, getLogger
+
+# Thirdparty:
+import uvicorn
+
+# Firstparty:
+from dbgr_server.app import init_app
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--debug", action="store_true")
+    parser.add_argument("--extra-search-path", action="store_true")
+    parser.add_argument("--more", action="store_true")
+    parser.add_argument("--detached_session", action="store_true")
+    parser.add_argument("--show-filename", action="store_true")
+    parser.add_argument("--server-host", type=str, default="localhost")
+    parser.add_argument("--server-port", type=int, default=1984)
+    parser.add_argument("--socket-host", type=str, default="localhost")
+    parser.add_argument("--socket-port", type=int, default=19840)
+    args = parser.parse_args()
+
+    log = getLogger("dbgr_server")
+    if args.debug:
+        log.setLevel(INFO)
+        if args.more:
+            log.setLevel(DEBUG)
+    else:
+        log.setLevel(WARNING)
+
+    try:
+        import uvloop  # pylint: disable=import-outside-toplevel
+        uvloop.install()
+    except ImportError:  # pragma: no cover
+        pass
+
+    settings = {
+        "debug": args.debug,
+        "extra_search_path": args.extra_search_path,
+        "more": args.more,
+        "detached_session": args.detached_session,
+        "show_filename": args.show_filename,
+        "socket_host": args.socket_host,
+        "socket_port": args.socket_port,
+    }
+
+    app = asyncio.run(init_app(settings))
+
+    uvicorn.run(
+        app,
+        host=args.server_host,
+        port=args.server_port,
+        loop="none",  # event loop already configured
+    )
+
+
+if __name__ == "__main__":
+    main()

dbgr_server/app.py

@@ -0,0 +1,139 @@
+# Stdlib:
+import asyncio
+import logging
+import mimetypes
+import sys
+from contextlib import asynccontextmanager
+from json import JSONDecodeError
+from typing import Any, Dict, Optional
+
+# Register font MIME types missing from some system mimetypes databases
+mimetypes.add_type("font/woff2", ".woff2")
+mimetypes.add_type("font/woff", ".woff")
+mimetypes.add_type("font/ttf", ".ttf")
+mimetypes.add_type("font/eot", ".eot")
+
+# Thirdparty:
+import httpx
+from fastapi import FastAPI
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+
+# Firstparty:
+import dbgr_server
+from dbgr_server.constants import PROJECT_DIR, THEME
+from dbgr_server.routes import router
+from dbgr_server.utils.state import settings as settings_store
+from dbgr_server.utils.technical import LibPythonWatcher
+
+
+async def init_versions(app: FastAPI) -> None:
+    async with httpx.AsyncClient(timeout=1) as client:
+        try:
+            resp = await client.get("https://pypi.org/pypi/dbgr-server/json")
+            info = resp.json()
+            pypi_version = info["info"]["version"]
+            app.state.pypi_version = pypi_version
+        except httpx.TimeoutException:
+            app.state.pypi_version = "pypi_error"
+        except (JSONDecodeError, KeyError):
+            app.state.pypi_version = "parsing_error"
+        except Exception:  # pylint: disable=broad-except
+            app.state.pypi_version = "unknown_error"
+
+    app.state.version = dbgr_server.__version__
+    new_version: Any = False
+    if app.state.pypi_version not in (
+        "pypi_error",
+        "parsing_error",
+        "unknown_error",
+        app.state.version,
+    ):
+        new_version = app.state.pypi_version
+    app.state.new_version = new_version
+
+
+def create_templates() -> Jinja2Templates:
+    templates = Jinja2Templates(directory=str(PROJECT_DIR / "templates"))
+
+    def asset(path: str) -> str:
+        """Static URL with a mtime query string so browsers refetch after a rebuild."""
+        rel = path.lstrip("/")
+        try:
+            version = int((PROJECT_DIR / "static" / rel).stat().st_mtime)
+        except OSError:
+            version = 0
+        return f"/static/{rel}?v={version}"
+
+    templates.env.globals.update(
+        static=lambda path: f"/static{path}",
+        asset=asset,
+        url=lambda route, **kwargs: (
+            f"/static/{kwargs.get('filename', '')}"
+            if route == "static"
+            else "/"
+        ),
+    )
+    return templates
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):  # type: ignore[type-arg]
+    socket_host: str = getattr(app.state, "socket_host", "localhost")
+    socket_port: Optional[int] = getattr(app.state, "socket_port", None)
+
+    if not socket_port:
+        yield
+        return
+
+    from dbgr_server.utils.streams import handle_tcp_connection  # pylint: disable=import-outside-toplevel
+
+    tcp_server = await asyncio.start_server(
+        handle_tcp_connection, socket_host, socket_port
+    )
+    async with tcp_server:
+        tcp_server_task = asyncio.ensure_future(tcp_server.serve_forever())
+        try:
+            yield
+        finally:
+            tcp_server_task.cancel()
+            try:
+                await tcp_server_task
+            except asyncio.CancelledError:
+                pass
+
+
+async def init_app(settings: Optional[Dict[str, Any]] = None) -> FastAPI:
+    if settings is None:
+        settings = {}
+
+    if LibPythonWatcher:  # pragma: no cover
+        LibPythonWatcher(
+            sys.base_prefix if settings.get("extra_search_path") else None
+        )
+
+    app = FastAPI(lifespan=lifespan)
+
+    settings_store.update(**{
+        k: v for k, v in settings.items()
+        if k in ("debug", "extra_search_path", "more", "detached_session", "show_filename")
+    })
+    app.state.settings = settings_store
+    app.state.socket_host = settings.get("socket_host", "localhost")
+    app.state.socket_port = settings.get("socket_port", None)
+
+    logging.basicConfig(level=logging.DEBUG)
+    await init_versions(app)
+    app.state.theme = THEME
+
+    templates = create_templates()
+    app.state.templates = templates
+
+    app.include_router(router)
+    app.mount(
+        "/static",
+        StaticFiles(directory=str(PROJECT_DIR / "static")),
+        name="static",
+    )
+
+    return app

dbgr_server/constants.py

@@ -0,0 +1,10 @@
+# Stdlib:
+import pathlib
+
+PROJECT_DIR = pathlib.Path(__file__).parent
+THEME = "indigo-red"
+DBGR_TYPES = ("home", "pm", "shell", "debug")
+UUID_REGEXP = (
+    "[a-f0-9]{8}-[a-f0-9]{4}-[1-5][a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}"
+)
+UNKNOWN_UUID = "UNKNOWN_UUID"

dbgr_server/routes.py

@@ -0,0 +1,22 @@
+# Thirdparty:
+from fastapi import APIRouter
+
+# Firstparty:
+from dbgr_server.views import (
+    debug_get,
+    debug_post_form,
+    home_get,
+    main_get,
+    status_ws,
+    websocket_ws,
+)
+
+router = APIRouter()
+
+router.add_api_route("/", home_get, methods=["GET"])
+router.add_api_route("/{type_}/session/{uuid}", main_get, methods=["GET"])
+router.add_api_route("/debug/file/{fn:path}", debug_get, methods=["GET"])
+router.add_api_route("/debug/file/{fn:path}", debug_post_form, methods=["POST"])
+router.add_api_route("/debug/file/", debug_post_form, methods=["POST"])
+router.add_api_websocket_route("/websocket/{uuid}", websocket_ws)
+router.add_api_websocket_route("/status", status_ws)