LCOV - code coverage report
Current view: top level - src/scripts - pnginfo.ts Coverage Total Hit
Test: ComfyUI E2E Coverage Lines: 2.8 % 211 6
Test Date: 2026-11-17 04:17:53

            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              : }
        

Generated by: LCOV version 2.0-1