code: def parse_prompt_attention(text):
      """
      Parses a string with attention tokens and returns a list of pairs: text and its associated weight.
      Accepted tokens are:
        (abc) - increases attention to abc by a multiplier of 1.1
        (abc:3.12) - increases attention to abc by a multiplier of 3.12
        [abc] - decreases attention to abc by a multiplier of 1.1
        \\( - literal character '('
        \\[ - literal character '['
        \\) - literal character ')'
        \\] - literal character ']'
        \\ - literal character '\'
        anything else - just text
  
      >>> parse_prompt_attention('normal text')
      [['normal text', 1.0]]
      >>> parse_prompt_attention('an (important) word')
      [['an ', 1.0], ['important', 1.1], [' word', 1.0]]
      >>> parse_prompt_attention('(unbalanced')
      [['unbalanced', 1.1]]
      >>> parse_prompt_attention('\\(literal\\]')
      [['(literal]', 1.0]]
      >>> parse_prompt_attention('(unnecessary)(parens)')
      [['unnecessaryparens', 1.1]]
      >>> parse_prompt_attention('a (((house:1.3)) [on] a (hill:0.5), sun, (((sky))).')
      [['a ', 1.0],
       ['house', 1.5730000000000004],
       [' ', 1.1],
       ['on', 1.0],
       [' a ', 1.1],
       ['hill', 0.55],
       [', sun, ', 1.1],
       ['sky', 1.4641000000000006],
       ['.', 1.1]]
      """
      import re
  
      re_attention = re.compile(
          r"""
              \\\(|\\\)|\\\[|\\]|\\\\|\\|\(|\[|:([+-]?[.\d]+)\)|
              \)|]|[^\\()\[\]:]+|:
          """,
          re.X,
      )
  
      re_break = re.compile(r"\s*\bBREAK\b\s*", re.S)
  
      res = []
      round_brackets = []
      square_brackets = []
  
      round_bracket_multiplier = 1.1
      square_bracket_multiplier = 1 / 1.1
  
      def multiply_range(start_position, multiplier):
          for p in range(start_position, len(res)):
              res[p][1] *= multiplier
  
      for m in re_attention.finditer(text):
          text = m.group(0)
          weight = m.group(1)
  
          if text.startswith("\\"):
              res.append([text[1:], 1.0])
          elif text == "(":
              round_brackets.append(len(res))
          elif text == "[":
              square_brackets.append(len(res))
          elif weight is not None and len(round_brackets) > 0:
              multiply_range(round_brackets.pop(), float(weight))
          elif text == ")" and len(round_brackets) > 0:
              multiply_range(
                  round_brackets.pop(), round_bracket_multiplier
              )
          elif text == "]" and len(square_brackets) > 0:
              multiply_range(
                  square_brackets.pop(), square_bracket_multiplier
              )
          else:
              parts = re.split(re_break, text)
              for i, part in enumerate(parts):
                  if i > 0:
                      res.append(["BREAK", -1])
                  res.append([part, 1.0])
  
      for pos in round_brackets:
          multiply_range(pos, round_bracket_multiplier)
  
      for pos in square_brackets:
          multiply_range(pos, square_bracket_multiplier)
  
      if len(res) == 0:
          res = [["", 1.0]]
  
      # merge runs of identical weights
      i = 0
      while i + 1 < len(res):
          if res[i][1] == res[i + 1][1]:
              res[i][0] += res[i + 1][0]
              res.pop(i + 1)
          else:
              i += 1
  
      return res
  
imports: import inspect
  import os
  from typing import Any, Callable, Dict, List, Optional, Tuple, Union
  import torch
  from PIL import Image
  from transformers import CLIPImageProcessor, CLIPTextModel, CLIPTextModelWithProjection, CLIPTokenizer, CLIPVisionModelWithProjection
  from diffusers import DiffusionPipeline, StableDiffusionXLPipeline
  from diffusers.image_processor import PipelineImageInput, VaeImageProcessor
  from diffusers.loaders import FromSingleFileMixin, IPAdapterMixin, LoraLoaderMixin, TextualInversionLoaderMixin
  from diffusers.models import AutoencoderKL, ImageProjection, UNet2DConditionModel
  from diffusers.models.attention_processor import AttnProcessor2_0, FusedAttnProcessor2_0, LoRAAttnProcessor2_0, LoRAXFormersAttnProcessor, XFormersAttnProcessor
  from diffusers.pipelines.stable_diffusion_xl.pipeline_output import StableDiffusionXLPipelineOutput
  from diffusers.schedulers import KarrasDiffusionSchedulers
  from diffusers.utils import deprecate, is_accelerate_available, is_accelerate_version, is_invisible_watermark_available, logging, replace_example_docstring
  from diffusers.utils.torch_utils import randn_tensor
label_desc: Use image node_id 1 for calling a global function with example usage: parse_prompt_attention(text) and returns: res