Hugging Face's logo

Spaces:
flatcherlee
/
ioatol2
Runtime error

App Files Community
ioatol2
File size: 3,326 Bytes 
ac6acf2
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
 
const { mockApi } = require("./setup");
const { Ez } = require("./ezgraph");
const lg = require("./litegraph");
const fs = require("fs");
const path = require("path");

const html = fs.readFileSync(path.resolve(__dirname, "../../web/index.html"))

/**

 *

 * @param { Parameters<typeof mockApi>[0] & { 

 * 	resetEnv?: boolean, 

 * 	preSetup?(app): Promise<void>,

 *  localStorage?: Record<string, string> 

 * } } config

 * @returns

 */
export async function start(config = {}) {
	if(config.resetEnv) {
		jest.resetModules();
		jest.resetAllMocks();
        lg.setup(global);
		localStorage.clear();
		sessionStorage.clear();
	}

	Object.assign(localStorage, config.localStorage ?? {});
	document.body.innerHTML = html;

	mockApi(config);
	const { app } = require("../../web/scripts/app");
	config.preSetup?.(app);
	await app.setup();

	return { ...Ez.graph(app, global["LiteGraph"], global["LGraphCanvas"]), app };
}

/**

 * @param { ReturnType<Ez["graph"]>["graph"] } graph

 * @param { (hasReloaded: boolean) => (Promise<void> | void) } cb

 */
export async function checkBeforeAndAfterReload(graph, cb) {
	await cb(false);
	await graph.reload();
	await cb(true);
}

/**

 * @param { string } name

 * @param { Record<string, string | [string | string[], any]> } input

 * @param { (string | string[])[] | Record<string, string | string[]> } output

 * @returns { Record<string, import("../../web/types/comfy").ComfyObjectInfo> }

 */
export function makeNodeDef(name, input, output = {}) {
	const nodeDef = {
		name,
		category: "test",
		output: [],
		output_name: [],
		output_is_list: [],
		input: {
			required: {},
		},
	};
	for (const k in input) {
		nodeDef.input.required[k] = typeof input[k] === "string" ? [input[k], {}] : [...input[k]];
	}
	if (output instanceof Array) {
		output = output.reduce((p, c) => {
			p[c] = c;
			return p;
		}, {});
	}
	for (const k in output) {
		nodeDef.output.push(output[k]);
		nodeDef.output_name.push(k);
		nodeDef.output_is_list.push(false);
	}

	return { [name]: nodeDef };
}

/**

/**

 * @template { any } T

 * @param { T } x

 * @returns { x is Exclude<T, null | undefined> }

 */
export function assertNotNullOrUndefined(x) {
	expect(x).not.toEqual(null);
	expect(x).not.toEqual(undefined);
	return true;
}

/**

 *

 * @param { ReturnType<Ez["graph"]>["ez"] } ez

 * @param { ReturnType<Ez["graph"]>["graph"] } graph

 */
export function createDefaultWorkflow(ez, graph) {
	graph.clear();
	const ckpt = ez.CheckpointLoaderSimple();

	const pos = ez.CLIPTextEncode(ckpt.outputs.CLIP, { text: "positive" });
	const neg = ez.CLIPTextEncode(ckpt.outputs.CLIP, { text: "negative" });

	const empty = ez.EmptyLatentImage();
	const sampler = ez.KSampler(
		ckpt.outputs.MODEL,
		pos.outputs.CONDITIONING,
		neg.outputs.CONDITIONING,
		empty.outputs.LATENT
	);

	const decode = ez.VAEDecode(sampler.outputs.LATENT, ckpt.outputs.VAE);
	const save = ez.SaveImage(decode.outputs.IMAGE);
	graph.arrange();

	return { ckpt, pos, neg, empty, sampler, decode, save };
}

export async function getNodeDefs() {
	const { api } = require("../../web/scripts/api");
	return api.getNodeDefs();
}

export async function getNodeDef(nodeId) {
	return (await getNodeDefs())[nodeId];
}