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/__init__.py +3 -0
- reqtable/__main__.py +3 -0
- reqtable/baselines.py +920 -0
- reqtable/cli.py +631 -0
- reqtable/comparison.py +63 -0
- reqtable/core.py +1448 -0
- reqtable/drafts.py +166 -0
- reqtable/findings.py +605 -0
- reqtable/gate_checks.py +84 -0
- reqtable/gates.py +348 -0
- reqtable/glossary.py +162 -0
- reqtable/gui.py +952 -0
- reqtable/gui_lookups.py +192 -0
- reqtable/gui_mapping.py +789 -0
- reqtable/gui_page.py +691 -0
- reqtable/gui_page_gates.py +173 -0
- reqtable/gui_page_mapping.py +390 -0
- reqtable/gui_server.py +467 -0
- reqtable/html_report.py +2595 -0
- reqtable/markdown.py +127 -0
- reqtable/package.py +163 -0
- reqtable/quality.py +422 -0
- reqtable/review.py +318 -0
- reqtable/signoff.py +179 -0
- reqtable/traceability.py +1670 -0
- reqtable/values.py +192 -0
- reqtable/waivers.py +109 -0
- reqtable/xlsx.py +1108 -0
- reqtable-0.1.0.dist-info/METADATA +106 -0
- reqtable-0.1.0.dist-info/RECORD +33 -0
- reqtable-0.1.0.dist-info/WHEEL +4 -0
- reqtable-0.1.0.dist-info/entry_points.txt +2 -0
- reqtable-0.1.0.dist-info/licenses/LICENSE +21 -0
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
|