gradio

1
import { spawn } from "node:child_process";
2
import { join, basename } from "path";
3
import { fileURLToPath } from "url";
4
import { readdirSync, writeFileSync } from "fs";
5
import net from "net";
6

7
import kl from "kleur";
8

9
const __dirname = fileURLToPath(new URL(".", import.meta.url));
10
const TEST_APP_PATH = join(__dirname, "./test.py");
11
const TEST_FILES_PATH = join(__dirname, "..", "js", "app", "test");
12
const ROOT = join(__dirname, "..");
13

14
const test_files = readdirSync(TEST_FILES_PATH)
15
	.filter(
16
		(f) =>
17
			f.endsWith("spec.ts") &&
18
			!f.endsWith(".skip.spec.ts") &&
19
			!f.endsWith(".component.spec.ts")
20
	)
21
	.map((f) => basename(f, ".spec.ts"));
22

23
export default async function global_setup() {
24
	const verbose = process.env.GRADIO_TEST_VERBOSE;
25

26
	const port = await find_free_port(7860, 8860);
27
	process.env.GRADIO_E2E_TEST_PORT = port;
28

29
	process.stdout.write(kl.yellow("\nCreating test gradio app.\n\n"));
30

31
	const test_app = make_app(test_files, port);
32
	process.stdout.write(kl.yellow("App created. Starting test server.\n\n"));
33

34
	process.stdout.write(kl.bgBlue(" =========================== \n"));
35
	process.stdout.write(kl.bgBlue(" === PYTHON STARTUP LOGS === \n"));
36
	process.stdout.write(kl.bgBlue(" =========================== \n\n"));
37

38
	writeFileSync(TEST_APP_PATH, test_app);
39

40
	const app = await spawn_gradio_app(TEST_APP_PATH, port, verbose);
41

42
	process.stdout.write(
43
		kl.green(`\n\nServer started. Running tests on port ${port}.\n`)
44
	);
45

46
	return () => {
47
		process.stdout.write(kl.green(`\nTests complete, cleaning up!\n`));
48

49
		kill_process(app);
50
	};
51
}
52
const INFO_RE = /^INFO:/;
53

54
function spawn_gradio_app(app, port, verbose) {
55
	const PORT_RE = new RegExp(`:${port}`);
56

57
	return new Promise((res, rej) => {
58
		const _process = spawn(`python`, [app], {
59
			shell: true,
60
			stdio: "pipe",
61
			cwd: ROOT,
62
			env: {
63
				...process.env,
64
				GRADIO_SERVER_PORT: `7879`,
65
				PYTHONUNBUFFERED: "true",
66
				GRADIO_ANALYTICS_ENABLED: "False"
67
			}
68
		});
69
		_process.stdout.setEncoding("utf8");
70

71
		function std_out(data) {
72
			const _data = data.toString();
73
			const is_info = INFO_RE.test(_data);
74

75
			if (is_info) {
76
				process.stdout.write(kl.yellow(_data));
77
			}
78

79
			if (!is_info) {
80
				process.stdout.write(`${_data}\n`);
81
			}
82

83
			if (PORT_RE.test(_data)) {
84
				process.stdout.write(kl.bgBlue("\n =========== END =========== "));
85

86
				res(_process);
87

88
				if (!verbose) {
89
					_process.stdout.off("data", std_out);
90
					_process.stderr.off("data", std_out);
91
				}
92
			}
93
		}
94

95
		_process.stdout.on("data", std_out);
96
		_process.stderr.on("data", std_out);
97
		_process.on("exit", () => kill_process(_process));
98
		_process.on("close", () => kill_process(_process));
99
		_process.on("disconnect", () => kill_process(_process));
100
	});
101
}
102

103
function kill_process(process) {
104
	process.kill("SIGKILL");
105
}
106

107
function make_app(demos, port) {
108
	return `import gradio as gr
109
import uvicorn
110
from fastapi import FastAPI
111
import gradio as gr
112
${demos.map((d) => `from demo.${d}.run import demo as ${d}`).join("\n")}
113

114
app = FastAPI()
115
${demos
116
	.map((d) => `app = gr.mount_gradio_app(app, ${d}, path="/${d}")`)
117
	.join("\n")}
118

119
config = uvicorn.Config(app, port=${port}, log_level="info")
120
server = uvicorn.Server(config=config)
121
server.run()`;
122
}
123

124
export async function find_free_port(start_port, end_port) {
125
	for (let port = start_port; port < end_port; port++) {
126
		if (await is_free_port(port)) {
127
			return port;
128
		}
129
	}
130

131
	throw new Error(
132
		`Could not find free ports: there were not enough ports available.`
133
	);
134
}
135

136
export function is_free_port(port) {
137
	return new Promise((accept, reject) => {
138
		const sock = net.createConnection(port, "127.0.0.1");
139
		sock.once("connect", () => {
140
			sock.end();
141
			accept(false);
142
		});
143
		sock.once("error", (e) => {
144
			sock.destroy();
145
			if (e.code === "ECONNREFUSED") {
146
				accept(true);
147
			} else {
148
				reject(e);
149
			}
150
		});
151
	});
152
}
153