Line data Source code
1 : import type { LGraph, LGraphNode } from '@/lib/litegraph/src/litegraph'
2 : import { withGraphIntentSource } from '@/lib/litegraph/src/graphIntents'
3 : import { LiteGraph } from '@/lib/litegraph/src/litegraph'
4 : import type { IBaseWidget } from '@comfyorg/graph-model/widgets'
5 :
6 : import { api } from './api'
7 : import { getFromAvifFile } from './metadata/avif'
8 : import { getFromFlacFile } from './metadata/flac'
9 : import { getFromLatentFile } from './metadata/latent'
10 : import { getFromPngFile } from './metadata/png'
11 : import { getFromWebpFile } from './metadata/webp'
12 :
13 2356 : export const getAvifMetadata = getFromAvifFile
14 2356 : export const getFlacMetadata = getFromFlacFile
15 2356 : export const getLatentMetadata = getFromLatentFile
16 2356 : export const getPngMetadata = getFromPngFile
17 2356 : export const getWebpMetadata = getFromWebpFile
18 :
19 : interface NodeConnection {
20 : node: LGraphNode
21 : index: number
22 : }
23 :
24 : interface LoraEntry {
25 : name: string
26 : weight: number
27 : }
28 :
29 2356 : const A1111_NEGATIVE_PROMPT_PREFIX = '\nNegative prompt:'
30 :
31 0 : function normalizeA1111Parameters(parameters: string): string {
32 0 : const stepsIndex = parameters.lastIndexOf('\nSteps:')
33 0 : if (
34 : stepsIndex === -1 ||
35 : parameters.lastIndexOf(A1111_NEGATIVE_PROMPT_PREFIX, stepsIndex) > -1
36 : ) {
37 0 : return parameters
38 : }
39 :
40 0 : return `${parameters.slice(0, stepsIndex)}${A1111_NEGATIVE_PROMPT_PREFIX}${parameters.slice(stepsIndex)}`
41 : }
42 :
43 : export type A1111ImportOutcome =
44 : | 'imported'
45 : | 'imported-without-embeddings'
46 : | 'not-a1111'
47 : | 'core-nodes-unavailable'
48 :
49 0 : export async function importA1111(
50 : graph: LGraph,
51 : parameters: string,
52 : beforeGraphClear?: () => void | Promise<void>
53 : ): Promise<A1111ImportOutcome> {
54 0 : const normalizedParameters = normalizeA1111Parameters(parameters)
55 0 : const p = normalizedParameters.lastIndexOf('\nSteps:')
56 0 : if (p > -1) {
57 0 : const matchResult = normalizedParameters
58 : .substr(p)
59 : .split('\n')[1]
60 : .match(
61 : new RegExp('\\s*([^:]+:\\s*([^"\\{].*?|".*?"|\\{.*?\\}))\\s*(,|$)', 'g')
62 : )
63 0 : if (!matchResult) return 'not-a1111'
64 :
65 0 : const opts: Partial<Record<string, string>> = matchResult.reduce(
66 : (acc: Record<string, string>, n: string) => {
67 0 : const s = n.split(':')
68 0 : if (s[1].endsWith(',')) {
69 0 : s[1] = s[1].substr(0, s[1].length - 1)
70 : }
71 0 : acc[s[0].trim().toLowerCase()] = s[1].trim()
72 0 : return acc
73 : },
74 : {}
75 : )
76 0 : const p2 = normalizedParameters.lastIndexOf(A1111_NEGATIVE_PROMPT_PREFIX, p)
77 0 : if (p2 > -1) {
78 0 : let positive = normalizedParameters.substr(0, p2).trim()
79 0 : let negative = normalizedParameters
80 : .substring(p2 + A1111_NEGATIVE_PROMPT_PREFIX.length, p)
81 : .trim()
82 :
83 0 : const ckptNode = LiteGraph.createNode('CheckpointLoaderSimple')
84 0 : const clipSkipNode = LiteGraph.createNode('CLIPSetLastLayer')
85 0 : const positiveNode = LiteGraph.createNode('CLIPTextEncode')
86 0 : const negativeNode = LiteGraph.createNode('CLIPTextEncode')
87 0 : const samplerNode = LiteGraph.createNode('KSampler')
88 0 : const imageNode = LiteGraph.createNode('EmptyLatentImage')
89 0 : const vaeNode = LiteGraph.createNode('VAEDecode')
90 0 : const saveNode = LiteGraph.createNode('SaveImage')
91 :
92 0 : if (
93 : !ckptNode ||
94 : !clipSkipNode ||
95 : !positiveNode ||
96 : !negativeNode ||
97 : !samplerNode ||
98 : !imageNode ||
99 : !vaeNode ||
100 : !saveNode
101 : ) {
102 0 : console.error('Failed to create required nodes for A1111 import')
103 0 : return 'core-nodes-unavailable'
104 : }
105 :
106 0 : const hires: { samplerNode: LGraphNode | null; steps?: string } = {
107 : samplerNode: null
108 : }
109 :
110 0 : const ceil64 = (v: number) => Math.ceil(v / 64) * 64
111 :
112 0 : function getWidget(
113 : node: LGraphNode | null,
114 : name: string
115 : ): IBaseWidget | undefined {
116 0 : return node?.widgets?.find((w) => w.name === name)
117 : }
118 :
119 0 : function setWidgetValue(
120 : node: LGraphNode | null,
121 : name: string,
122 : value: string | number,
123 : isOptionPrefix?: boolean
124 : ): void {
125 0 : const w = getWidget(node, name)
126 0 : if (!w) return
127 :
128 0 : if (isOptionPrefix) {
129 : const values = w.options.values as string[] | undefined
130 0 : const o = values?.find((v) => v.startsWith(String(value)))
131 0 : if (o) {
132 0 : w.value = o
133 : } else {
134 0 : console.warn(`Unknown value '${value}' for widget '${name}'`, node)
135 0 : w.value = value
136 : }
137 : } else {
138 0 : w.value = value
139 : }
140 : }
141 :
142 0 : function createLoraNodes(
143 : clipNode: LGraphNode,
144 : text: string,
145 : prevClip: NodeConnection,
146 : prevModel: NodeConnection,
147 : targetSamplerNode: LGraphNode
148 : ): { text: string; prevModel: NodeConnection; prevClip: NodeConnection } {
149 0 : const loras: LoraEntry[] = []
150 0 : text = text.replace(/<lora:([^:]+:[^>]+)>/g, (_m, c: string) => {
151 0 : const s = c.split(':')
152 0 : const weight = parseFloat(s[1])
153 0 : if (isNaN(weight)) {
154 0 : console.warn('Invalid LORA', _m)
155 : } else {
156 0 : loras.push({ name: s[0], weight })
157 : }
158 0 : return ''
159 : })
160 :
161 0 : for (const l of loras) {
162 0 : const loraNode = LiteGraph.createNode('LoraLoader')
163 0 : if (!loraNode) continue
164 0 : graph.add(loraNode)
165 0 : setWidgetValue(loraNode, 'lora_name', l.name, true)
166 0 : setWidgetValue(loraNode, 'strength_model', l.weight)
167 0 : setWidgetValue(loraNode, 'strength_clip', l.weight)
168 0 : prevModel.node.connect(prevModel.index, loraNode, 0)
169 0 : prevClip.node.connect(prevClip.index, loraNode, 1)
170 0 : prevModel = { node: loraNode, index: 0 }
171 0 : prevClip = { node: loraNode, index: 1 }
172 : }
173 :
174 0 : prevClip.node.connect(1, clipNode, 0)
175 0 : prevModel.node.connect(0, targetSamplerNode, 0)
176 0 : if (hires.samplerNode) {
177 0 : prevModel.node.connect(0, hires.samplerNode, 0)
178 : }
179 :
180 0 : return { text, prevModel, prevClip }
181 : }
182 :
183 0 : function replaceEmbeddings(text: string): string {
184 0 : if (!embeddings.length) return text
185 0 : return text.replaceAll(
186 : new RegExp(
187 : '\\b(' +
188 : embeddings
189 : .map((e) => e.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'))
190 : .join('\\b|\\b') +
191 : ')\\b',
192 : 'ig'
193 : ),
194 : 'embedding:$1'
195 : )
196 : }
197 :
198 0 : function popOpt(name: string): string | undefined {
199 0 : const v = opts[name]
200 0 : delete opts[name]
201 0 : return v
202 : }
203 :
204 0 : const { embeddings, embeddingsLoaded } = await api
205 : .getEmbeddings()
206 : .then((embeddings) => ({ embeddings, embeddingsLoaded: true }))
207 : .catch((error: unknown) => {
208 0 : console.error('Failed to load embeddings for A1111 import:', error)
209 0 : return { embeddings: [], embeddingsLoaded: false }
210 : })
211 :
212 0 : await beforeGraphClear?.()
213 0 : withGraphIntentSource('load', () => {
214 0 : graph.clear()
215 0 : graph.add(ckptNode)
216 0 : graph.add(clipSkipNode)
217 0 : graph.add(positiveNode)
218 0 : graph.add(negativeNode)
219 0 : graph.add(samplerNode)
220 0 : graph.add(imageNode)
221 0 : graph.add(vaeNode)
222 0 : graph.add(saveNode)
223 :
224 0 : ckptNode.connect(1, clipSkipNode, 0)
225 0 : clipSkipNode.connect(0, positiveNode, 0)
226 0 : clipSkipNode.connect(0, negativeNode, 0)
227 0 : ckptNode.connect(0, samplerNode, 0)
228 0 : positiveNode.connect(0, samplerNode, 1)
229 0 : negativeNode.connect(0, samplerNode, 2)
230 0 : imageNode.connect(0, samplerNode, 3)
231 0 : vaeNode.connect(0, saveNode, 0)
232 0 : samplerNode.connect(0, vaeNode, 0)
233 0 : ckptNode.connect(2, vaeNode, 1)
234 :
235 0 : const handlers: Partial<Record<string, (v: string) => void>> = {
236 : model(v: string) {
237 0 : setWidgetValue(ckptNode, 'ckpt_name', v, true)
238 : },
239 : vae() {},
240 : 'cfg scale'(v: string) {
241 0 : setWidgetValue(samplerNode, 'cfg', +v)
242 : },
243 : 'clip skip'(v: string) {
244 0 : setWidgetValue(clipSkipNode, 'stop_at_clip_layer', -Number(v))
245 : },
246 : sampler(v: string) {
247 0 : let name = v.toLowerCase().replace('++', 'pp').replaceAll(' ', '_')
248 0 : if (name.includes('karras')) {
249 0 : name = name.replace('karras', '').replace(/_+$/, '')
250 0 : setWidgetValue(samplerNode, 'scheduler', 'karras')
251 : } else {
252 0 : setWidgetValue(samplerNode, 'scheduler', 'normal')
253 : }
254 : const w = getWidget(samplerNode, 'sampler_name')
255 : const values = w?.options.values as string[] | undefined
256 0 : const o = values?.find((v) => v === name || v === 'sample_' + name)
257 0 : if (o) {
258 0 : setWidgetValue(samplerNode, 'sampler_name', o)
259 : }
260 : },
261 : // fallow-ignore-next-line complexity -- legacy A1111 size/hires importer; this PR only scopes its existing branches under load provenance.
262 : size(v: string) {
263 0 : const wxh = v.split('x')
264 0 : const w = ceil64(+wxh[0])
265 0 : const h = ceil64(+wxh[1])
266 0 : const hrUp = popOpt('hires upscale')
267 0 : const hrSz = popOpt('hires resize')
268 0 : hires.steps = popOpt('hires steps')
269 0 : let hrMethod = popOpt('hires upscaler')
270 :
271 0 : setWidgetValue(imageNode, 'width', w)
272 0 : setWidgetValue(imageNode, 'height', h)
273 :
274 0 : if (hrUp || hrSz) {
275 0 : let uw: number, uh: number
276 0 : if (hrUp) {
277 0 : uw = w * Number(hrUp)
278 0 : uh = h * Number(hrUp)
279 0 : } else if (hrSz) {
280 0 : const s = hrSz.split('x')
281 0 : uw = +s[0]
282 0 : uh = +s[1]
283 : } else {
284 0 : return
285 : }
286 :
287 0 : let upscaleNode: LGraphNode | null
288 0 : let latentNode: LGraphNode | null
289 :
290 0 : if (hrMethod?.startsWith('Latent')) {
291 0 : latentNode = upscaleNode = LiteGraph.createNode('LatentUpscale')
292 0 : if (!upscaleNode) return
293 0 : graph.add(upscaleNode)
294 0 : samplerNode.connect(0, upscaleNode, 0)
295 :
296 0 : switch (hrMethod) {
297 : case 'Latent (nearest-exact)':
298 0 : hrMethod = 'nearest-exact'
299 : break
300 : }
301 0 : setWidgetValue(upscaleNode, 'upscale_method', hrMethod, true)
302 : } else {
303 0 : const decode = LiteGraph.createNode('VAEDecodeTiled')
304 0 : if (!decode) return
305 0 : graph.add(decode)
306 0 : samplerNode.connect(0, decode, 0)
307 0 : ckptNode.connect(2, decode, 1)
308 :
309 0 : const upscaleLoaderNode =
310 : LiteGraph.createNode('UpscaleModelLoader')
311 0 : if (!upscaleLoaderNode) return
312 0 : graph.add(upscaleLoaderNode)
313 0 : setWidgetValue(
314 : upscaleLoaderNode,
315 : 'model_name',
316 : hrMethod ?? '',
317 : true
318 : )
319 :
320 0 : const modelUpscaleNode = LiteGraph.createNode(
321 : 'ImageUpscaleWithModel'
322 : )
323 0 : if (!modelUpscaleNode) return
324 0 : graph.add(modelUpscaleNode)
325 0 : decode.connect(0, modelUpscaleNode, 1)
326 0 : upscaleLoaderNode.connect(0, modelUpscaleNode, 0)
327 :
328 0 : upscaleNode = LiteGraph.createNode('ImageScale')
329 0 : if (!upscaleNode) return
330 0 : graph.add(upscaleNode)
331 0 : modelUpscaleNode.connect(0, upscaleNode, 0)
332 :
333 0 : const vaeEncodeNode = LiteGraph.createNode('VAEEncodeTiled')
334 0 : if (!vaeEncodeNode) return
335 0 : latentNode = vaeEncodeNode
336 0 : graph.add(vaeEncodeNode)
337 0 : upscaleNode.connect(0, vaeEncodeNode, 0)
338 0 : ckptNode.connect(2, vaeEncodeNode, 1)
339 : }
340 :
341 0 : setWidgetValue(upscaleNode, 'width', ceil64(uw))
342 0 : setWidgetValue(upscaleNode, 'height', ceil64(uh))
343 :
344 0 : const hrSamplerNode = LiteGraph.createNode('KSampler')
345 0 : if (!hrSamplerNode || !latentNode) return
346 0 : hires.samplerNode = hrSamplerNode
347 0 : graph.add(hrSamplerNode)
348 0 : ckptNode.connect(0, hrSamplerNode, 0)
349 0 : positiveNode.connect(0, hrSamplerNode, 1)
350 0 : negativeNode.connect(0, hrSamplerNode, 2)
351 0 : latentNode.connect(0, hrSamplerNode, 3)
352 0 : hrSamplerNode.connect(0, vaeNode, 0)
353 : }
354 : },
355 : steps(v: string) {
356 0 : setWidgetValue(samplerNode, 'steps', +v)
357 : },
358 : seed(v: string) {
359 0 : setWidgetValue(samplerNode, 'seed', +v)
360 : }
361 : }
362 :
363 0 : for (const opt in opts) {
364 0 : const handler = handlers[opt]
365 0 : if (handler) {
366 0 : const value = popOpt(opt)
367 0 : if (value !== undefined) handler(value)
368 : }
369 : }
370 :
371 0 : const { samplerNode: hrSamplerNode, steps: hrSteps } = hires
372 0 : if (hrSamplerNode) {
373 0 : setWidgetValue(
374 : hrSamplerNode,
375 : 'steps',
376 : hrSteps
377 : ? +hrSteps
378 : : (getWidget(samplerNode, 'steps')?.value as number)
379 : )
380 0 : setWidgetValue(
381 : hrSamplerNode,
382 : 'cfg',
383 : getWidget(samplerNode, 'cfg')?.value as number
384 : )
385 0 : setWidgetValue(
386 : hrSamplerNode,
387 : 'scheduler',
388 : getWidget(samplerNode, 'scheduler')?.value as string
389 : )
390 0 : setWidgetValue(
391 : hrSamplerNode,
392 : 'sampler_name',
393 : getWidget(samplerNode, 'sampler_name')?.value as string
394 : )
395 0 : setWidgetValue(
396 : hrSamplerNode,
397 : 'denoise',
398 : +(popOpt('denoising strength') ?? '1')
399 : )
400 : }
401 :
402 0 : let n = createLoraNodes(
403 : positiveNode,
404 : positive,
405 : { node: clipSkipNode, index: 0 },
406 : { node: ckptNode, index: 0 },
407 : samplerNode
408 : )
409 0 : positive = n.text
410 0 : n = createLoraNodes(
411 : negativeNode,
412 : negative,
413 : n.prevClip,
414 : n.prevModel,
415 : samplerNode
416 : )
417 0 : negative = n.text
418 :
419 0 : setWidgetValue(positiveNode, 'text', replaceEmbeddings(positive))
420 0 : setWidgetValue(negativeNode, 'text', replaceEmbeddings(negative))
421 :
422 0 : graph.arrange()
423 : })
424 :
425 0 : for (const opt of [
426 : 'model hash',
427 : 'ensd',
428 : 'version',
429 : 'vae hash',
430 : 'ti hashes',
431 : 'lora hashes',
432 : 'hashes'
433 : ]) {
434 0 : delete opts[opt]
435 : }
436 :
437 0 : if (Object.keys(opts).length) {
438 0 : console.warn('Unhandled parameters:', opts)
439 : }
440 0 : return embeddingsLoaded ? 'imported' : 'imported-without-embeddings'
441 : }
442 : }
443 0 : return 'not-a1111'
444 : }
|