reqtable 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
reqtable/gui_server.py ADDED
@@ -0,0 +1,467 @@
1
+ """Local web server for the GUI: a thin, token-guarded shell over reqtable.gui."""
2
+
3
+ from __future__ import annotations
4
+
5
+ import hmac
6
+ import json
7
+ import os
8
+ import secrets
9
+ import subprocess
10
+ import threading
11
+ import webbrowser
12
+ from dataclasses import asdict
13
+ from http import HTTPStatus
14
+ from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
15
+ from pathlib import Path
16
+ from typing import Any, Callable
17
+ from urllib.parse import parse_qs, urlsplit
18
+
19
+ from . import gui_lookups
20
+ from .gui_mapping import (
21
+ build_mapping,
22
+ load_mapping,
23
+ mapping_json,
24
+ preview_mapping,
25
+ role_named,
26
+ save_mapping,
27
+ suggest_columns,
28
+ )
29
+ from .gui import (
30
+ WORKFLOWS,
31
+ BadRequest,
32
+ GuiError,
33
+ Launcher,
34
+ Workflow,
35
+ blocked_checks,
36
+ build_argv,
37
+ column_source,
38
+ launcher,
39
+ lookup_source,
40
+ ScriptStep,
41
+ posix_command,
42
+ powershell_command,
43
+ script,
44
+ table_inputs,
45
+ workflow_named,
46
+ )
47
+ from .gui_page import render_page
48
+
49
+ TOKEN_HEADER = "X-Reqtable-Token"
50
+ RUN_TIMEOUT_SECONDS = 300
51
+ MAX_BODY_BYTES = 1_000_000
52
+ # The page keeps the saved workflow in browser storage, which belongs to one address, so every launch tries the same port.
53
+ PREFERRED_PORT = 47821
54
+ SCRIPT_NAMES = {"sh": "reqtable-workflow.sh", "powershell": "reqtable-workflow.ps1"}
55
+
56
+
57
+ class Session:
58
+ """State shared by every request of one GUI process."""
59
+
60
+ def __init__(self, workdir: Path, opener: Callable[[str], object]) -> None:
61
+ self.workdir = workdir
62
+ self.token = secrets.token_urlsafe(24)
63
+ self.launcher: Launcher = launcher(workdir)
64
+ self.opener = opener
65
+ self.openable: set[Path] = set()
66
+ self.lock = threading.Lock()
67
+
68
+ def commands(self, argv: list[str]) -> dict[str, Any]:
69
+ return {
70
+ "argv": argv,
71
+ "sh": posix_command(argv, self.launcher.shown),
72
+ "powershell": powershell_command(argv, self.launcher.shown),
73
+ }
74
+
75
+ def command(self, workflow: Workflow, values: dict[str, Any]) -> dict[str, Any]:
76
+ return {
77
+ **self.commands(build_argv(workflow, values, self.workdir)),
78
+ "replaces": [
79
+ str(value)
80
+ for value in self.saved_values(workflow, values)
81
+ if (self.workdir / value).exists()
82
+ ],
83
+ }
84
+
85
+ @staticmethod
86
+ def saved_values(workflow: Workflow, values: dict[str, Any]) -> list[str]:
87
+ return [
88
+ value
89
+ for field in workflow.fields
90
+ if field.kind == "save"
91
+ and (value := str(values.get(field.name, "")).strip())
92
+ ]
93
+
94
+ def run(self, workflow: Workflow, values: dict[str, Any]) -> dict[str, Any]:
95
+ argv = build_argv(workflow, values, self.workdir)
96
+ env = {**os.environ, **self.launcher.env, "PYTHONIOENCODING": "utf-8"}
97
+ try:
98
+ done = subprocess.run(
99
+ [*self.launcher.run, *argv],
100
+ cwd=self.workdir,
101
+ env=env,
102
+ capture_output=True,
103
+ text=True,
104
+ encoding="utf-8",
105
+ errors="replace",
106
+ stdin=subprocess.DEVNULL,
107
+ timeout=RUN_TIMEOUT_SECONDS,
108
+ )
109
+ except subprocess.TimeoutExpired:
110
+ return {
111
+ **self.commands(argv),
112
+ "exit_code": None,
113
+ "stdout": "",
114
+ "stderr": f"error: stopped after {RUN_TIMEOUT_SECONDS} seconds",
115
+ "outputs": [],
116
+ "blocked": [],
117
+ }
118
+ written = [
119
+ self.workdir / value
120
+ for value in self.saved_values(workflow, values)
121
+ if done.returncode == 0 and (self.workdir / value).is_file()
122
+ ]
123
+ with self.lock:
124
+ self.openable.update(
125
+ path.resolve() for path in written if path.suffix.lower() == ".html"
126
+ )
127
+ return {
128
+ **self.commands(argv),
129
+ "exit_code": done.returncode,
130
+ "stdout": done.stdout,
131
+ "stderr": done.stderr,
132
+ "outputs": [str(p) for p in written],
133
+ "blocked": blocked_checks(done.stderr) if done.returncode == 1 else [],
134
+ }
135
+
136
+ def open_report(self, path: str) -> None:
137
+ target = Path(path).resolve()
138
+ with self.lock:
139
+ allowed = target in self.openable
140
+ if not allowed or not target.is_file():
141
+ raise BadRequest("that file was not produced by this session")
142
+ self.opener(target.as_uri())
143
+
144
+ def browse(self, path: str, extensions: tuple[str, ...]) -> dict[str, Any]:
145
+ folder = (
146
+ (self.workdir / Path(path).expanduser()).resolve() if path else self.workdir
147
+ )
148
+ try:
149
+ children = sorted(folder.iterdir(), key=lambda p: p.name.lower())
150
+ except (OSError, NotADirectoryError) as exc:
151
+ raise GuiError(
152
+ f"cannot open folder {folder}: {exc.strerror or exc}"
153
+ ) from exc
154
+ entries = []
155
+ for child in children:
156
+ if child.name.startswith("."):
157
+ continue
158
+ try:
159
+ is_dir = child.is_dir()
160
+ except OSError:
161
+ continue
162
+ if (
163
+ is_dir
164
+ or "*" in extensions
165
+ or (extensions and child.suffix.lower() in extensions)
166
+ ):
167
+ entries.append({"name": child.name, "path": str(child), "dir": is_dir})
168
+ entries.sort(key=lambda e: not e["dir"])
169
+ parent = folder.parent
170
+ return {
171
+ "path": str(folder),
172
+ "parent": str(parent) if parent != folder else None,
173
+ "entries": entries,
174
+ "places": [
175
+ {"name": "Working folder", "path": str(self.workdir)},
176
+ {"name": "Home", "path": str(Path.home())},
177
+ ],
178
+ }
179
+
180
+ def mapping_preview(self, body: dict[str, Any]) -> dict[str, Any]:
181
+ mapping = build_mapping(body.get("form")) # type: ignore[arg-type]
182
+ return {
183
+ "mapping": mapping,
184
+ **preview_mapping(self.workdir / str(body.get("path", "")), mapping),
185
+ }
186
+
187
+ def mapping_save(self, body: dict[str, Any]) -> dict[str, Any]:
188
+ mapping = build_mapping(body.get("form")) # type: ignore[arg-type]
189
+ return {
190
+ "mapping": mapping,
191
+ **save_mapping(
192
+ self.workdir,
193
+ str(body.get("path", "")),
194
+ mapping,
195
+ body.get("overwrite") is True,
196
+ ),
197
+ }
198
+
199
+ def mapping_suggest(self, query: dict[str, str]) -> dict[str, Any]:
200
+ found = gui_lookups.columns(self.workdir, query)
201
+ if "error" in found:
202
+ return {"columns": [], "id_prefix": "", "error": found["error"]}
203
+ return suggest_columns(role_named(query.get("role", "")), found["columns"])
204
+
205
+ def script(self, steps: object, shell: object) -> dict[str, Any]:
206
+ if shell not in SCRIPT_NAMES:
207
+ raise BadRequest("shell must be 'sh' or 'powershell'")
208
+ if not isinstance(steps, list):
209
+ raise BadRequest("steps must be a list")
210
+ built = []
211
+ for step in steps:
212
+ workflow, values = parse_job(step)
213
+ note = step.get("note", "") if isinstance(step, dict) else ""
214
+ if not isinstance(note, str):
215
+ raise BadRequest("note must be text")
216
+ title = f"{workflow.title} ({note})" if note else workflow.title
217
+ built.append(
218
+ ScriptStep(
219
+ title, build_argv(workflow, values, self.workdir), workflow.records
220
+ )
221
+ )
222
+ return {
223
+ "script": script(built, shell, self.workdir, self.launcher.shown),
224
+ "filename": SCRIPT_NAMES[shell],
225
+ }
226
+
227
+
228
+ def parse_job(body: object) -> tuple[Workflow, dict[str, Any]]:
229
+ if (
230
+ not isinstance(body, dict)
231
+ or not isinstance(body.get("workflow"), str)
232
+ or not isinstance(body.get("values", {}), dict)
233
+ ):
234
+ raise BadRequest("expected {workflow, values}")
235
+ return workflow_named(body["workflow"]), body.get("values", {})
236
+
237
+
238
+ class Handler(BaseHTTPRequestHandler):
239
+ server: "GuiServer"
240
+
241
+ def log_message(self, format: str, *args: object) -> None:
242
+ pass
243
+
244
+ @property
245
+ def session(self) -> Session:
246
+ return self.server.session
247
+
248
+ def send_json(self, status: int, payload: dict[str, Any]) -> None:
249
+ self.send_bytes(status, json.dumps(payload).encode("utf-8"), "application/json")
250
+
251
+ def send_bytes(self, status: int, body: bytes, content_type: str) -> None:
252
+ self.send_response(status)
253
+ self.send_header("Content-Type", content_type + "; charset=utf-8")
254
+ self.send_header("Content-Length", str(len(body)))
255
+ self.send_header("Cache-Control", "no-store")
256
+ self.send_header("X-Content-Type-Options", "nosniff")
257
+ self.send_header("Referrer-Policy", "no-referrer")
258
+ self.end_headers()
259
+ self.wfile.write(body)
260
+
261
+ def host_allowed(self) -> bool:
262
+ port = self.server.server_address[1]
263
+ return self.headers.get("Host") in (f"127.0.0.1:{port}", f"localhost:{port}")
264
+
265
+ def token_ok(self, supplied: str | None) -> bool:
266
+ return supplied is not None and hmac.compare_digest(
267
+ supplied.encode(), self.session.token.encode()
268
+ )
269
+
270
+ def refuse(self, status: HTTPStatus, message: str) -> None:
271
+ self.send_json(status, {"error": message})
272
+
273
+ def do_GET(self) -> None:
274
+ if not self.host_allowed():
275
+ return self.refuse(HTTPStatus.FORBIDDEN, "unexpected Host header")
276
+ url = urlsplit(self.path)
277
+ query = {
278
+ key: values[0]
279
+ for key, values in parse_qs(url.query, keep_blank_values=True).items()
280
+ }
281
+ if url.path == "/":
282
+ if not self.token_ok(query.get("token")):
283
+ return self.send_bytes(
284
+ HTTPStatus.FORBIDDEN,
285
+ b"Open the address that reqtable --gui printed, including ?token=...",
286
+ "text/plain",
287
+ )
288
+ return self.send_bytes(
289
+ HTTPStatus.OK,
290
+ render_page(self.session.token).encode("utf-8"),
291
+ "text/html",
292
+ )
293
+ if not url.path.startswith("/api/"):
294
+ return self.refuse(HTTPStatus.NOT_FOUND, "not found")
295
+ if not self.token_ok(self.headers.get(TOKEN_HEADER)):
296
+ return self.refuse(HTTPStatus.FORBIDDEN, "missing or wrong token")
297
+ routes: dict[str, Callable[[], dict[str, Any]]] = {
298
+ "/api/workflows": lambda: {
299
+ "workflows": workflows_json(),
300
+ "workdir": str(self.session.workdir),
301
+ "mapping": mapping_json(),
302
+ },
303
+ "/api/browse": lambda: self.session.browse(
304
+ query.get("path", ""),
305
+ tuple(e for e in query.get("ext", "").lower().split(",") if e),
306
+ ),
307
+ "/api/columns": lambda: gui_lookups.columns(self.session.workdir, query),
308
+ "/api/tables": lambda: gui_lookups.tables(self.session.workdir, query),
309
+ "/api/gates": lambda: gui_lookups.gates(self.session.workdir, query),
310
+ "/api/baselines": lambda: gui_lookups.baselines(
311
+ self.session.workdir, query
312
+ ),
313
+ "/api/systems": lambda: gui_lookups.systems(self.session.workdir, query),
314
+ "/api/mapping/suggest": lambda: self.session.mapping_suggest(query),
315
+ "/api/mapping/load": lambda: load_mapping(
316
+ self.session.workdir, query.get("path", "")
317
+ ),
318
+ }
319
+ self.dispatch(routes.get(url.path))
320
+
321
+ def do_POST(self) -> None:
322
+ if not self.host_allowed():
323
+ return self.refuse(HTTPStatus.FORBIDDEN, "unexpected Host header")
324
+ path = urlsplit(self.path).path
325
+ if not path.startswith("/api/"):
326
+ return self.refuse(HTTPStatus.NOT_FOUND, "not found")
327
+ if not self.token_ok(self.headers.get(TOKEN_HEADER)):
328
+ return self.refuse(HTTPStatus.FORBIDDEN, "missing or wrong token")
329
+ if (self.headers.get("Content-Type") or "").split(";")[
330
+ 0
331
+ ].strip() != "application/json":
332
+ return self.refuse(
333
+ HTTPStatus.BAD_REQUEST, "send JSON with Content-Type: application/json"
334
+ )
335
+ declared = (self.headers.get("Content-Length") or "").strip()
336
+ if not declared.isdigit():
337
+ return self.refuse(
338
+ HTTPStatus.BAD_REQUEST,
339
+ "send a Content-Length header with the size of the body",
340
+ )
341
+ length = int(declared)
342
+ if length > MAX_BODY_BYTES:
343
+ return self.refuse(HTTPStatus.REQUEST_ENTITY_TOO_LARGE, "request too large")
344
+ try:
345
+ body = json.loads(self.rfile.read(length) or b"null")
346
+ except (ValueError, UnicodeError):
347
+ return self.refuse(HTTPStatus.BAD_REQUEST, "body is not valid JSON")
348
+ session = self.session
349
+
350
+ def command() -> dict[str, Any]:
351
+ return session.command(*parse_job(body))
352
+
353
+ def run() -> dict[str, Any]:
354
+ return session.run(*parse_job(body))
355
+
356
+ def open_file() -> dict[str, Any]:
357
+ if not isinstance(body, dict) or not isinstance(body.get("path"), str):
358
+ raise BadRequest("expected {path}")
359
+ session.open_report(body["path"])
360
+ return {"ok": True}
361
+
362
+ def make_script() -> dict[str, Any]:
363
+ if not isinstance(body, dict):
364
+ raise BadRequest("expected {steps, shell}")
365
+ return session.script(body.get("steps"), body.get("shell"))
366
+
367
+ def mapping(
368
+ action: Callable[[dict[str, Any]], dict[str, Any]],
369
+ ) -> Callable[[], dict[str, Any]]:
370
+ def handler() -> dict[str, Any]:
371
+ if not isinstance(body, dict):
372
+ raise BadRequest("expected {path, form}")
373
+ return action(body)
374
+
375
+ return handler
376
+
377
+ routes = {
378
+ "/api/command": command,
379
+ "/api/run": run,
380
+ "/api/open": open_file,
381
+ "/api/script": make_script,
382
+ "/api/mapping/preview": mapping(session.mapping_preview),
383
+ "/api/mapping/save": mapping(session.mapping_save),
384
+ }
385
+ self.dispatch(routes.get(path))
386
+
387
+ def dispatch(self, route: Callable[[], dict[str, Any]] | None) -> None:
388
+ if route is None:
389
+ return self.refuse(HTTPStatus.NOT_FOUND, "not found")
390
+ try:
391
+ self.send_json(HTTPStatus.OK, route())
392
+ except BadRequest as exc:
393
+ self.refuse(HTTPStatus.BAD_REQUEST, str(exc))
394
+ except GuiError as exc:
395
+ self.send_json(HTTPStatus.OK, {"error": str(exc)})
396
+ except Exception as exc:
397
+ self.refuse(HTTPStatus.INTERNAL_SERVER_ERROR, f"unexpected error: {exc}")
398
+
399
+
400
+ class GuiServer(ThreadingHTTPServer):
401
+ daemon_threads = True
402
+ # On Windows this flag lets a second server take a port that is in use, so the fallback would never happen.
403
+ allow_reuse_address = os.name != "nt"
404
+
405
+ def __init__(self, session: Session, port: int) -> None:
406
+ super().__init__(("127.0.0.1", port), Handler)
407
+ self.session = session
408
+
409
+ @property
410
+ def url(self) -> str:
411
+ return f"http://127.0.0.1:{self.server_address[1]}/?token={self.session.token}"
412
+
413
+
414
+ def workflows_json() -> list[dict[str, Any]]:
415
+ result = []
416
+ for workflow in WORKFLOWS:
417
+ source = column_source(workflow)
418
+ lookup = lookup_source(workflow)
419
+ result.append(
420
+ {
421
+ **asdict(workflow),
422
+ "column_source": source.name if source else "",
423
+ "lookup_input": lookup.name if lookup else "",
424
+ "table_inputs": [f.name for f in table_inputs(workflow)],
425
+ "records": workflow.records,
426
+ }
427
+ )
428
+ return result
429
+
430
+
431
+ def make_server(
432
+ workdir: Path, port: int = 0, opener: Callable[[str], object] = webbrowser.open
433
+ ) -> GuiServer:
434
+ return GuiServer(Session(Path(workdir).resolve(), opener), port)
435
+
436
+
437
+ def open_server(
438
+ workdir: Path, opener: Callable[[str], object] = webbrowser.open
439
+ ) -> tuple[GuiServer, bool]:
440
+ """A server on the preferred port, or on any free port when that one is taken; the flag says it fell back."""
441
+ try:
442
+ return make_server(workdir, PREFERRED_PORT, opener), False
443
+ except OSError:
444
+ return make_server(workdir, 0, opener), True
445
+
446
+
447
+ def serve(workdir: Path, open_browser: bool) -> int:
448
+ server, fell_back = open_server(workdir)
449
+ print(f"reqtable GUI running at {server.url}", flush=True)
450
+ if fell_back:
451
+ print(
452
+ f"Port {PREFERRED_PORT} is in use, so this window starts with an empty workflow; "
453
+ "a workflow saved in another reqtable window stays in that window.",
454
+ flush=True,
455
+ )
456
+ print("Press Ctrl+C to stop", flush=True)
457
+ if open_browser:
458
+ threading.Thread(
459
+ target=webbrowser.open, args=(server.url,), daemon=True
460
+ ).start()
461
+ try:
462
+ server.serve_forever()
463
+ except KeyboardInterrupt:
464
+ print("\nStopped.")
465
+ finally:
466
+ server.server_close()
467
+ return 0