Update artworks.yaml

artworks.yaml

@@ -5,13 +5,1298 @@ title: en=ArtWorks AI;ru=Узлы ArtWorks AI
 url: https://huggingface.co/PiperMy/Node-Packages/resolve/main/artworks.yaml
 version: 2
 nodes:
-  remove_background_artworks:
-    _id: remove_background_artworks
+  inpaint_image_artworks:
+    _id: inpaint_image_artworks
     arrange:
-      x: 500
-      y: 110
+      x: 440
+      y: 60
     category:
-      id: analyze_images
+      id: generate_images
+      title: en=Generate images;ru=Генерация изображений
+    groups:
+      inputs:
+        mask:
+          order: 2
+          title: en=Mask;ru=Маска
+        SDXL:
+          order: 4
+          title: SDXL checkpoints
+          description: Only for SDXL checkpoints
+        base:
+          order: 1
+          title: en=Base;ru=Базовые параметры
+        special:
+          order: 3
+          title: en=Special;ru=Специальные возможности
+    inputs:
+      image:
+        order: 1
+        title: en=Image;ru=Изображение
+        group: base
+        type: image
+        required: true
+        extensions:
+          - id: draw-mask
+            params:
+              mask: mask
+      prompt:
+        order: 2
+        title: en=Prompt;ru=Подсказка
+        group: base
+        type: string
+        required: true
+        multiline: true
+      negativePrompt:
+        order: 4
+        title: en=Negative prompt;ru=Негативная подсказка
+        group: base
+        type: string
+        multiline: true
+      checkpoint:
+        order: 3
+        title: en=Checkpoint;ru=Модель
+        group: base
+        type: string
+        required: true
+        default: juggernautXL_v9Rundiffusionphoto2.safetensors
+        enum:
+          - raemuXL_v40.safetensors|Raemu XL <SDXL>
+          - aamXLAnimeMix_v10.safetensors|AAM XL (Anime Mix) <SDXL> <Fantasy>
+          - dreamweaverPony25D.1erv.safetensors|DreamWeaver - Pony 2.5D Mix <SDXL>
+          - mixGEMAdam8witQegoow.NeWz.safetensors|MyMIX-G/Jem <SDXL> <Realistic>
+          - mfcgPDXL_v10.safetensors|MFCG PDXL <SDXL>
+          - aniku_0.2.fp16.safetensors|Anime Desire <SDXL> <Fantasy>
+          - flux1DevHyperNF4Flux1DevBNB_flux1DevHyperNF4.safetensors|Hyper NF4 Flux 1 <Flux>
+          - STOIQONewrealityFLUXSD_F1DPreAlpha.safetensors|New Reality Flux <Flux>
+          - juggernautXL_v9Rundiffusionphoto2.safetensors|Juggernaut XL <SDXL>
+          - animaPencilXL_v260.safetensors|Anima Pencil XL <SDXL> <Fantasy>
+          - bluePencilXL_v401.safetensors|Blue Pencil XL <SDXL> <Fantasy>
+          - pixelArtDiffusionXL_spriteShaper.safetensors|Pixel Art Diffusion XL <SDXL> <Fantasy>
+          - albedobaseXL_v20.safetensors|AlbedoBase XL <SDXL>
+          - leosamsHelloworldXL_helloworldXL50GPT4V.safetensors|Helloworld XL <SDXL>
+          - dynavisionXLAllInOneStylized_releaseV0610Bakedvae.safetensors|DynaVision XL All In One <SDXL>
+          - photon_v1.safetensors|Photon <SD 1.5>
+          - afroditexlNudePeople_20Bkdvae.safetensors|Nude People <NSFW>
+          - nosft-float8-e4m3fn.safetensors|Flux Nude People <NSFW>
+          - asdf_0.4a_lorapov_0.2_lust_0.4.fp16.safetensors|Real Porn <NSFW>
+          - Sexy_Aesthetic_SDXL_0.4x0.2.fp16.safetensors|Sexy & Beauty <NSFW>
+          - aniku_0.2.fp16.safetensors|Anime Desire <NSFW>
+          - anikurender_0.4b.fp16.safetensors|Hardcore Fantasy <NSFW>
+      denoisingStrength:
+        order: 6
+        title: en=Denoising strength;ru=Степень изменения
+        group: base
+        type: float
+        required: true
+        min: 0.1
+        max: 1
+        step: 0.05
+        default: 0.5
+      cfgScale:
+        order: 7
+        title: en=CFG scale;ru=Креативность
+        group: base
+        type: integer
+        required: true
+        min: 1
+        max: 20
+        step: 1
+        default: 7
+      imageSize:
+        order: 5
+        title: en=Image size;ru=Размер изображения
+        group: base
+        type: string
+        placeholder: auto:auto
+        default: auto:auto
+        enum:
+          - auto:1024
+          - 1024:auto
+          - auto:auto
+      performance:
+        order: 8
+        title: en=Performance;ru=Производительность
+        group: base
+        type: string
+        default: speed
+        enum:
+          - express|⚡ Express
+          - speed|🚅 Speed
+          - quality|💎 Quality
+      controlNets:
+        order: 1
+        title: en=Control nets;ru=Контрольные сети
+        group: special
+        type: json
+        schema:
+          id: control-nets
+      seed:
+        order: 10
+        title: en=Seed;ru=Начальный шум
+        group: base
+        type: integer
+      batchSize:
+        order: 9
+        title: en=Batch size;ru=Кол-во
+        group: base
+        type: integer
+        min: 1
+        max: 4
+        step: 1
+        default: 1
+      mask:
+        order: 1
+        title: en=Mask;ru=Маска
+        group: mask
+        type: image
+        required: true
+      invertMask:
+        order: 1
+        title: en=Invert mask;ru=Инвертировать маску
+        group: SDXL
+        type: boolean
+        default: false
+      maskMargin:
+        order: 2
+        title: en=Mask margin;ru=Отступ от маски
+        group: mask
+        type: integer
+        default: 10
+    outputs:
+      image1:
+        title: en=Image 1;ru=Изображение 1
+        type: image
+      images:
+        title: en=Images;ru=Изображения
+        type: image[]
+      image2:
+        title: en=Image 2;ru=Изображение 2
+        type: image
+      image3:
+        title: en=Image 3;ru=Изображение 3
+        type: image
+      image4:
+        title: en=Image 4;ru=Изображение 4
+        type: image
+    package: artworks
+    script: |
+      const CHECK_TASK_INTERVAL = 3000;
+      const MAX_ATTEMPTS = 100;
+
+      export async function run({ inputs, state }) {
+
+          const { FatalError, TimeoutError, RepeatNode, NextNode } = DEFINITIONS;
+          const { ArtWorks, fitSize, FatalError: ArtWorksError } = require('artworks');
+          const sharp = require('sharp/lib/index.js');
+
+          const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL');
+          if (!PAAS_BASE_URL) {
+              throw new FatalError('Please, set PAAS_BASE_URL in environment');
+          }
+          const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER');
+          if (!OPEN_PAAS_USER) {
+              throw new FatalError('Please, set OPEN_PAAS_USER in environment');
+          }
+          const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD');
+          if (!OPEN_PAAS_PASSWORD) {
+              throw new FatalError('Please, set OPEN_PAAS_PASSWORD in environment');
+          }
+
+          const artworks = new ArtWorks({
+              baseUrl: PAAS_BASE_URL,
+              username: OPEN_PAAS_USER,
+              password: OPEN_PAAS_PASSWORD
+          });
+
+          if (!state) {
+              const {
+                  image,
+                  prompt,
+                  checkpoint,
+                  negativePrompt,
+                  imageSize,
+                  denoisingStrength,
+                  cfgScale,
+                  performance,
+                  batchSize,
+                  seed,
+                  // mask
+                  mask,
+                  maskMargin,
+                  // special
+                  controlNets,
+                  // SDXL
+                  invertMask,
+              } = inputs;
+              const payload = {
+                  type: "inpaint-on-image",
+                  isFast: true,
+                  payload: {
+                      base64: false,
+                      image,
+                      prompt,
+                      checkpoint,
+                      negativePrompt,
+                      ...(!!imageSize
+                          ? await (async () => {
+                              const { data } = await download(image);
+                              const buffer = sharp(data);
+                              const { width, height } = await buffer.metadata();
+                              if (imageSize !== "auto:auto") {
+                                  const { width: w, height: h } = fitSize(imageSize, height / width);
+                                  return { size: `${w}x${h}` };
+                              }
+
+                              return {};
+                          })()
+                          : {}),
+                      denoisingStrength,
+                      cfgScale,
+                      performance,
+                      ...(batchSize > 1 ? { batchSize } : {}),
+                      seed,
+                      // mask
+                      mask,
+                      maskMargin,
+                      // special
+                      controlNets,
+                      // SDXL
+                      invertMask
+                  },
+              };
+              try {
+                  const task = await artworks.createTask(payload);
+                  console.log(`Task created ${task}`);
+                  return RepeatNode.from({
+                      state: {
+                          payload,
+                          task,
+                          attempt: 0,
+                          startedAt: new Date()
+                      },
+                      progress: {
+                          total: MAX_ATTEMPTS,
+                          processed: 0
+                      },
+                      delay: 2000
+                  });
+              } catch (e) {
+                  if (e instanceof ArtWorksError) {
+                      throw new FatalError(e.message);
+                  }
+                  throw e;
+              }
+          } else {
+              const {
+                  payload,
+                  task,
+                  attempt,
+                  startedAt
+              } = state;
+
+              if (attempt > MAX_ATTEMPTS) {
+                  try {
+                      await artworks.cancelTask(task);
+                  } catch (e) { }
+
+                  const now = new Date();
+                  const time = (now - new Date(startedAt)) / 1000;
+                  throw new TimeoutError(`PaaS task for text to image ${task} timeout in ${time} sec`);
+              }
+
+              console.log(`Check task ${attempt} ${task}`);
+
+              try {
+                  const results = await artworks.checkState(task);
+                  if (!results) {
+                      return RepeatNode.from({
+                          delay: CHECK_TASK_INTERVAL,
+                          state: {
+                              payload,
+                              task,
+                              attempt: attempt + 1,
+                              startedAt,
+                          },
+                          progress: {
+                              total: MAX_ATTEMPTS,
+                              processed: attempt
+                          },
+                      });
+                  }
+                  let images = results.images.map((i) => i.url);
+                  const [image1, image2, image3, image4] = images;
+                  return NextNode.from({
+                      outputs: {
+                          images,
+                          image1,
+                          image2,
+                          image3,
+                          image4
+                      }
+                  });
+              } catch (e) {
+                  if (e instanceof ArtWorksError) {
+                      throw new FatalError(e.message);
+                  }
+                  throw e;
+              }
+          }
+      }
+    source: catalog
+    title: en=Inpaint on image;ru=Улучшить изображение
+    version: 1
+    environment:
+      OPEN_PAAS_USER:
+        title: PaaS user
+        type: string
+        scope: global
+      OPEN_PAAS_PASSWORD:
+        title: PaaS password
+        type: string
+        scope: global
+      PAAS_BASE_URL:
+        title: PaaS base url
+        type: string
+        scope: global
+  face_swap_on_image:
+    _id: face_swap_on_image
+    arrange:
+      x: 760
+      y: 180
+    category:
+      id: deep_swap
+      title: en=Deep swap;ru=Глубокая замена
+    environment:
+      OPEN_PAAS_USER:
+        title: PaaS user
+        type: string
+        scope: global
+      OPEN_PAAS_PASSWORD:
+        title: PaaS password
+        type: string
+        scope: global
+      PAAS_BASE_URL:
+        title: PaaS base url
+        type: string
+        scope: global
+    inputs:
+      face:
+        order: 1
+        title: en=Face;ru=Лицо
+        type: image
+        required: true
+      image:
+        order: 2
+        title: en=Image;ru=Изображение
+        type: image
+        required: true
+    outputs:
+      image:
+        title: en=Image;ru=Изображение
+        type: image
+    package: artworks
+    script: |
+      const CHECK_TASK_INTERVAL = 3000;
+      const MAX_ATTEMPTS = 20;
+
+      export async function run({ inputs, state }) {
+
+          const { FatalError, TimeoutError, RepeatNode, NextNode } = DEFINITIONS;
+          const { ArtWorks, FatalError: ArtWorksError } = require('artworks');
+
+          const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL');
+          if (!PAAS_BASE_URL) {
+              throw new FatalError('Please, set PAAS_BASE_URL in environment');
+          }
+          const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER');
+          if (!OPEN_PAAS_USER) {
+              throw new FatalError('Please, set OPEN_PAAS_USER in environment');
+          }
+          const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD');
+          if (!OPEN_PAAS_PASSWORD) {
+              throw new FatalError('Please, set OPEN_PAAS_PASSWORD in environment');
+          }
+
+          const artworks = new ArtWorks({
+              baseUrl: PAAS_BASE_URL,
+              username: OPEN_PAAS_USER,
+              password: OPEN_PAAS_PASSWORD
+          });
+
+          if (!state) {
+              const {
+                  face,
+                  image
+              } = inputs;
+
+              const payload = {
+                  type: "faceswap-on-image",
+                  isFast: true,
+                  payload: {
+                      base64: false,
+                      face,
+                      image,
+                  }
+              };
+              try {
+                  const task = await artworks.createTask(payload);
+                  console.log(`Task created ${task}`);
+                  return RepeatNode.from({
+                      state: {
+                          payload,
+                          task,
+                          attempt: 0,
+                          startedAt: new Date()
+                      },
+                      progress: {
+                          total: MAX_ATTEMPTS,
+                          processed: 0
+                      },
+                      delay: 2000
+                  });
+              } catch (e) {
+                  if (e instanceof ArtWorksError) {
+                      throw new FatalError(e.message);
+                  }
+                  throw e;
+              }
+          } else {
+              const {
+                  payload,
+                  task,
+                  attempt,
+                  startedAt
+              } = state;
+
+              if (attempt > MAX_ATTEMPTS) {
+                  try {
+                      await artworks.cancelTask(task);
+                  } catch (e) { }
+
+                  const now = new Date();
+                  const time = (now - new Date(startedAt)) / 1000;
+                  throw new TimeoutError(`PaaS task for text to image ${task} timeout in ${time} sec`);
+              }
+
+              console.log(`Check task ${attempt} ${task}`);
+
+              try {
+                  const results = await artworks.checkState(task);
+                  if (!results) {
+                      return RepeatNode.from({
+                          delay: CHECK_TASK_INTERVAL,
+                          state: {
+                              payload,
+                              task,
+                              attempt: attempt + 1,
+                              startedAt,
+                          },
+                          progress: {
+                              total: MAX_ATTEMPTS,
+                              processed: attempt
+                          },
+                      });
+                  }
+                  let { images: [{ url: image }] } = results;
+                  return NextNode.from({
+                      outputs: {
+                          image
+                      }
+                  });
+              } catch (e) {
+                  if (e instanceof ArtWorksError) {
+                      throw new FatalError(e.message);
+                  }
+                  throw e;
+              }
+          }
+      }
+    source: catalog
+    title: en=Face swap on image;ru=Замена лица на изображении
+    version: 1
+  translate_text:
+    _id: translate_text
+    arrange:
+      x: 770
+      y: 370
+    category:
+      id: process_text
+      title: en=Process text;ru=Обработка текста
+    inputs:
+      source:
+        order: 1
+        title: Source language
+        type: string
+        required: true
+        default: auto
+        enum:
+          - auto|Auto
+          - en|English
+          - de|German
+          - ru|Russian
+          - es|Spanish
+          - fr|French
+          - it|Italian
+          - pt|Portuguese
+          - ja|Japanese
+          - ko|Korean
+          - hi|Hindi
+          - tr|Turkish
+          - zh|Chinese Simplified
+      target:
+        order: 2
+        title: Target
+        description: github://generative-core/piper/main/docs/nodes/translate-text/target.md
+        type: string
+        required: true
+        default: de
+        enum:
+          - en|English
+          - de|German
+          - ru|Russian
+          - es|Spanish
+          - fr|French
+          - it|Italian
+          - pt|Portuguese
+          - ja|Japanese
+          - ko|Korean
+          - hi|Hindi
+          - tr|Turkish
+          - zh|Chinese Simplified
+      text:
+        order: 3
+        title: Text
+        type: string
+        required: true
+        multiline: true
+    outputs:
+      text:
+        title: Text
+        type: string
+      alternatives:
+        title: Alternatives
+        type: string[]
+      detectedLanguage:
+        title: Detected language
+        type: json
+        schema: detected-languages
+    package: artworks
+    source: catalog
+    title: en=Translate text;ru=Перевести текст
+    version: 1
+    environment:
+      OPEN_PAAS_USER:
+        title: PaaS user
+        type: string
+        scope: global
+      OPEN_PAAS_PASSWORD:
+        title: PaaS password
+        type: string
+        scope: global
+      PAAS_BASE_URL:
+        title: PaaS base url
+        type: string
+        scope: global
+    script: |
+      const CHECK_TASK_INTERVAL = 3000;
+      const MAX_ATTEMPTS = 10;
+
+      export async function run({ inputs, state }) {
+
+          const { FatalError, TimeoutError, RepeatNode, NextNode } = DEFINITIONS;
+          const { ArtWorks, FatalError: ArtWorksError } = require('artworks');
+
+          const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL');
+          if (!PAAS_BASE_URL) {
+              throw new FatalError('Please, set PAAS_BASE_URL in environment');
+          }
+          const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER');
+          if (!OPEN_PAAS_USER) {
+              throw new FatalError('Please, set OPEN_PAAS_USER in environment');
+          }
+          const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD');
+          if (!OPEN_PAAS_PASSWORD) {
+              throw new FatalError('Please, set OPEN_PAAS_PASSWORD in environment');
+          }
+
+          const artworks = new ArtWorks({
+              baseUrl: PAAS_BASE_URL,
+              username: OPEN_PAAS_USER,
+              password: OPEN_PAAS_PASSWORD
+          });
+
+          if (!state) {
+              const { source, target, text } = inputs;
+
+              const payload = {
+                  type: "translate-text",
+                  isFast: true,
+                  payload: {
+                      source,
+                      target,
+                      text,
+                  },
+              };
+              try {
+                  const task = await artworks.createTask(payload);
+                  console.log(`Task created ${task}`);
+                  return RepeatNode.from({
+                      state: {
+                          payload,
+                          task,
+                          attempt: 0,
+                          startedAt: new Date()
+                      },
+                      progress: {
+                          total: MAX_ATTEMPTS,
+                          processed: 0
+                      },
+                      delay: 2000
+                  });
+              } catch (e) {
+                  if (e instanceof ArtWorksError) {
+                      throw new FatalError(e.message);
+                  }
+                  throw e;
+              }
+          } else {
+              const {
+                  payload,
+                  task,
+                  attempt,
+                  startedAt
+              } = state;
+
+              if (attempt > MAX_ATTEMPTS) {
+                  try {
+                      await artworks.cancelTask(task);
+                  } catch (e) { }
+
+                  const now = new Date();
+                  const time = (now - new Date(startedAt)) / 1000;
+                  throw new TimeoutError(`PaaS task for text to image ${task} timeout in ${time} sec`);
+              }
+
+              console.log(`Check task ${attempt} ${task}`);
+
+              try {
+                  const results = await artworks.checkState(task);
+                  if (!results) {
+                      return RepeatNode.from({
+                          delay: CHECK_TASK_INTERVAL,
+                          state: {
+                              payload,
+                              task,
+                              attempt: attempt + 1,
+                              startedAt,
+                          },
+                          progress: {
+                              total: MAX_ATTEMPTS,
+                              processed: attempt
+                          },
+                      });
+                  }
+                  console.log(results);
+                  const { alternatives, detectedLanguage, text } = results;
+                  return NextNode.from({
+                      outputs: {
+                          alternatives,
+                          detectedLanguage,
+                          text
+                      }
+                  });
+              } catch (e) {
+                  if (e instanceof ArtWorksError) {
+                      throw new FatalError(e.message);
+                  }
+                  throw e;
+              }
+          }
+      }
+  upscale_image:
+    _id: upscale_image
+    arrange:
+      x: 100
+      y: 410
+    category:
+      id: generate_images
+      title: en=Generate images;ru=Генерация изображений
+    environment:
+      OPEN_PAAS_USER:
+        title: PaaS user
+        type: string
+        scope: global
+      OPEN_PAAS_PASSWORD:
+        title: PaaS password
+        type: string
+        scope: global
+      PAAS_BASE_URL:
+        title: PaaS base url
+        type: string
+        scope: global
+    inputs:
+      image:
+        order: 1
+        title: Image
+        type: image
+        required: true
+      upscalingResize:
+        order: 2
+        title: Resize
+        type: float
+        required: true
+        min: 0.1
+        max: 4
+        step: 0.1
+        default: 2
+    outputs:
+      image:
+        title: Image
+        type: image
+    package: artworks
+    source: catalog
+    title: en=Upscale image;ru=Увеличить изображение
+    version: 1
+    script: |-
+      const CHECK_TASK_INTERVAL = 3000;
+      const MAX_ATTEMPTS = 20;
+
+      export async function run({ inputs, state }) {
+
+          const { FatalError, TimeoutError, RepeatNode, NextNode } = DEFINITIONS;
+          const { ArtWorks, FatalError: ArtWorksError } = require('artworks');
+
+          const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL');
+          if (!PAAS_BASE_URL) {
+              throw new FatalError('Please, set PAAS_BASE_URL in environment');
+          }
+          const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER');
+          if (!OPEN_PAAS_USER) {
+              throw new FatalError('Please, set OPEN_PAAS_USER in environment');
+          }
+          const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD');
+          if (!OPEN_PAAS_PASSWORD) {
+              throw new FatalError('Please, set OPEN_PAAS_PASSWORD in environment');
+          }
+
+          const artworks = new ArtWorks({
+              baseUrl: PAAS_BASE_URL,
+              username: OPEN_PAAS_USER,
+              password: OPEN_PAAS_PASSWORD
+          });
+
+          if (!state) {
+              const {
+                  image,
+                  upscalingResize,
+              } = inputs;
+
+              const payload = {
+                  type: "upscale-image",
+                  isFast: true,
+                  payload: {
+                      base64: false,
+                      image,
+                      upscalingResize,
+                  },
+              };
+              try {
+                  const task = await artworks.createTask(payload);
+                  console.log(`Task created ${task}`);
+                  return RepeatNode.from({
+                      state: {
+                          payload,
+                          task,
+                          attempt: 0,
+                          startedAt: new Date()
+                      },
+                      progress: {
+                          total: MAX_ATTEMPTS,
+                          processed: 0
+                      },
+                      delay: 5000
+                  });
+              } catch (e) {
+                  if (e instanceof ArtWorksError) {
+                      throw new FatalError(e.message);
+                  }
+                  throw e;
+              }
+          } else {
+              const {
+                  payload,
+                  task,
+                  attempt,
+                  startedAt
+              } = state;
+
+              if (attempt > MAX_ATTEMPTS) {
+                  try {
+                      await artworks.cancelTask(task);
+                  } catch (e) { }
+
+                  const now = new Date();
+                  const time = (now - new Date(startedAt)) / 1000;
+                  throw new TimeoutError(`PaaS task for text to image ${task} timeout in ${time} sec`);
+              }
+
+              console.log(`Check task ${attempt} ${task}`);
+
+              try {
+                  const results = await artworks.checkState(task);
+                  if (!results) {
+                      return RepeatNode.from({
+                          delay: CHECK_TASK_INTERVAL,
+                          state: {
+                              payload,
+                              task,
+                              attempt: attempt + 1,
+                              startedAt,
+                          },
+                          progress: {
+                              total: MAX_ATTEMPTS,
+                              processed: attempt
+                          },
+                      });
+                  }
+                  let { image: { url: image } } = results;
+                  return NextNode.from({
+                      outputs: {
+                          image
+                      }
+                  });
+              } catch (e) {
+                  if (e instanceof ArtWorksError) {
+                      throw new FatalError(e.message);
+                  }
+                  throw e;
+              }
+          }
+      }
+  exctract_mask_on_image:
+    _id: exctract_mask_on_image
+    arrange:
+      x: 900
+      y: 50
+    category:
+      id: image_analysis
+      title: en=Image analysis;ru=Анализ изображений
+    environment:
+      OPEN_PAAS_USER:
+        title: PaaS user
+        type: string
+        scope: global
+      OPEN_PAAS_PASSWORD:
+        title: PaaS password
+        type: string
+        scope: global
+      PAAS_BASE_URL:
+        title: PaaS base url
+        type: string
+        scope: global
+    inputs:
+      image:
+        order: 1
+        title: Image
+        type: image
+        required: true
+      type:
+        order: 2
+        title: Type
+        type: string
+        required: true
+        default: yolo
+        enum:
+          - yolo|Yolo
+          - default|Prompt
+      prompt:
+        order: 4
+        title: Prompt
+        type: string
+        required: false
+        multiline: true
+      model:
+        order: 3
+        title: Yolo model
+        type: string
+        required: false
+        default: deepfashion2_yolov8s-seg.pt
+        enum:
+          - deepfashion2_yolov8s-seg.pt
+          - face_yolov8m.pt
+          - face_yolov8n.pt
+          - face_yolov8s.pt
+          - female_breast_v3.2.pt
+          - hand_yolov8n.pt
+          - hand_yolov8s.pt
+          - penisV2.pt
+          - person_yolov8m-seg.pt
+          - person_yolov8n-seg.pt
+          - person_yolov8s-seg.pt
+          - vagina-v2.6.pt
+      threshold:
+        order: 5
+        title: Threshold
+        type: float
+        required: true
+        min: 0.1
+        max: 0.69
+        step: 0.1
+        default: 0.5
+      confidence:
+        order: 6
+        title: Confidence
+        type: float
+        required: true
+        min: 0.1
+        max: 0.99
+        step: 0.1
+        default: 0.5
+      applyConvexHull:
+        order: 8
+        title: Apply convex hull
+        type: boolean
+        default: false
+    outputs:
+      merged:
+        title: Merged
+        type: image
+      masks:
+        title: Masks
+        type: json
+        schema: image-masks
+    package: artworks
+    script: |-
+      const CHECK_TASK_INTERVAL = 3000;
+      const MAX_ATTEMPTS = 20;
+
+      export async function run({ inputs, state }) {
+
+          const { FatalError, TimeoutError, RepeatNode, NextNode } = DEFINITIONS;
+          const { ArtWorks, FatalError: ArtWorksError } = require('artworks');
+          const sharp = require('sharp/lib/index.js');
+
+          const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL');
+          if (!PAAS_BASE_URL) {
+              throw new FatalError('Please, set PAAS_BASE_URL in environment');
+          }
+          const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER');
+          if (!OPEN_PAAS_USER) {
+              throw new FatalError('Please, set OPEN_PAAS_USER in environment');
+          }
+          const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD');
+          if (!OPEN_PAAS_PASSWORD) {
+              throw new FatalError('Please, set OPEN_PAAS_PASSWORD in environment');
+          }
+
+          const artworks = new ArtWorks({
+              baseUrl: PAAS_BASE_URL,
+              username: OPEN_PAAS_USER,
+              password: OPEN_PAAS_PASSWORD
+          });
+
+          if (!state) {
+              const { image, type, model, prompt, threshold, applyConvexHull } = inputs;
+
+              const payload = {
+                  type: "image-to-mask",
+                  isFast: true,
+                  payload: {
+                      base64: false,
+                      image,
+                      type,
+                      model,
+                      prompt,
+                      threshold,
+                      applyConvexHull,
+                  },
+              };
+              try {
+                  const task = await artworks.createTask(payload);
+                  console.log(`Task created ${task}`);
+                  return RepeatNode.from({
+                      state: {
+                          payload,
+                          task,
+                          attempt: 0,
+                          startedAt: new Date()
+                      },
+                      progress: {
+                          total: MAX_ATTEMPTS,
+                          processed: 0
+                      },
+                      delay: 5000
+                  });
+              } catch (e) {
+                  if (e instanceof ArtWorksError) {
+                      throw new FatalError(e.message);
+                  }
+                  throw e;
+              }
+          } else {
+              const {
+                  payload,
+                  task,
+                  attempt,
+                  startedAt
+              } = state;
+
+              if (attempt > MAX_ATTEMPTS) {
+                  try {
+                      await artworks.cancelTask(task);
+                  } catch (e) { }
+
+                  const now = new Date();
+                  const time = (now - new Date(startedAt)) / 1000;
+                  throw new TimeoutError(`PaaS task for text to image ${task} timeout in ${time} sec`);
+              }
+
+              console.log(`Check task ${attempt} ${task}`);
+
+              try {
+                  const results = await artworks.checkState(task);
+                  if (!results) {
+                      return RepeatNode.from({
+                          delay: CHECK_TASK_INTERVAL,
+                          state: {
+                              payload,
+                              task,
+                              attempt: attempt + 1,
+                              startedAt,
+                          },
+                          progress: {
+                              total: MAX_ATTEMPTS,
+                              processed: attempt
+                          },
+                      });
+                  }
+                  const { masks: detected } = results;
+                  const { image } = inputs;
+                  const { data } = await download(image);
+                  const { width, height } = await sharp(data).metadata();
+
+                  const areas = [];
+                  const masks = [];
+                  for (const m of detected) {
+                      const {
+                          mask,
+                          confidence,
+                          className,
+                          coordinates: [left, top],
+                      } = m;
+
+                      const buffer = Buffer.from(mask, "base64");
+
+                      areas.push({
+                          input: buffer,
+                          top,
+                          left,
+                      });
+
+                      const { width, height } = await sharp(buffer).metadata();
+                      masks.push({
+                          top,
+                          left,
+                          width,
+                          height,
+                          className,
+                          confidence,
+                      });
+                  }
+
+                  let merged = await sharp({
+                      create: {
+                          width,
+                          height,
+                          channels: 3,
+                          background: { r: 0, g: 0, b: 0 },
+                      },
+                  }).composite(areas);
+                  return NextNode.from({
+                      outputs: {
+                          masks,
+                          merged: await merged.png().toBuffer()
+                      }
+                  });
+              } catch (e) {
+                  if (e instanceof ArtWorksError) {
+                      throw new FatalError(e.message);
+                  }
+                  throw e;
+              }
+          }
+      }
+    source: catalog
+    title: en=Extract mask on image;ru=Выделить маску
+    version: 1
+  classify_image:
+    _id: classify_image
+    arrange:
+      x: 1080
+      y: 460
+    category:
+      id: image_analysis
+      title: en=Image analysis;ru=Анализ изображений
+    environment:
+      OPEN_PAAS_USER:
+        title: PaaS user
+        type: string
+        scope: global
+      OPEN_PAAS_PASSWORD:
+        title: PaaS password
+        type: string
+        scope: global
+      PAAS_BASE_URL:
+        title: PaaS base url
+        type: string
+        scope: global
+    inputs:
+      image:
+        order: 1
+        title: Image
+        type: image
+        required: true
+      labels:
+        order: 2
+        title: Labels
+        type: json
+        required: true
+        default: '{ "girl": "girl on photo", "male": "male on photo" }'
+        schema:
+          id: image-labels
+    outputs:
+      labels:
+        title: Labels
+        type: json
+    package: artworks
+    script: |-
+      const CHECK_TASK_INTERVAL = 1000;
+      const MAX_ATTEMPTS = 20;
+
+      export async function run({ inputs, state }) {
+
+          const { FatalError, TimeoutError, RepeatNode, NextNode } = DEFINITIONS;
+          const { ArtWorks, FatalError: ArtWorksError } = require('artworks');
+
+          const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL');
+          if (!PAAS_BASE_URL) {
+              throw new FatalError('Please, set PAAS_BASE_URL in environment');
+          }
+          const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER');
+          if (!OPEN_PAAS_USER) {
+              throw new FatalError('Please, set OPEN_PAAS_USER in environment');
+          }
+          const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD');
+          if (!OPEN_PAAS_PASSWORD) {
+              throw new FatalError('Please, set OPEN_PAAS_PASSWORD in environment');
+          }
+
+          const artworks = new ArtWorks({
+              baseUrl: PAAS_BASE_URL,
+              username: OPEN_PAAS_USER,
+              password: OPEN_PAAS_PASSWORD
+          });
+
+          if (!state) {
+              const { image, labels } = inputs;
+
+              const payload = {
+                  type: "classify-image",
+                  isFast: true,
+                  payload: {
+                      base64: false,
+                      image,
+                      labels: Object.values(labels),
+                  },
+              };
+              try {
+                  const task = await artworks.createTask(payload);
+                  console.log(`Task created ${task}`);
+                  return RepeatNode.from({
+                      state: {
+                          payload,
+                          task,
+                          attempt: 0,
+                          startedAt: new Date()
+                      },
+                      progress: {
+                          total: MAX_ATTEMPTS,
+                          processed: 0
+                      },
+                      delay: 2000
+                  });
+              } catch (e) {
+                  if (e instanceof ArtWorksError) {
+                      throw new FatalError(e.message);
+                  }
+                  throw e;
+              }
+          } else {
+              const {
+                  payload,
+                  task,
+                  attempt,
+                  startedAt
+              } = state;
+
+              if (attempt > MAX_ATTEMPTS) {
+                  try {
+                      await artworks.cancelTask(task);
+                  } catch (e) { }
+
+                  const now = new Date();
+                  const time = (now - new Date(startedAt)) / 1000;
+                  throw new TimeoutError(`PaaS task for text to image ${task} timeout in ${time} sec`);
+              }
+
+              console.log(`Check task ${attempt} ${task}`);
+
+              try {
+                  const results = await artworks.checkState(task);
+                  if (!results) {
+                      return RepeatNode.from({
+                          delay: CHECK_TASK_INTERVAL,
+                          state: {
+                              payload,
+                              task,
+                              attempt: attempt + 1,
+                              startedAt,
+                          },
+                          progress: {
+                              total: MAX_ATTEMPTS,
+                              processed: attempt
+                          },
+                      });
+                  }
+                  let { probs } = results;
+                  const { labels } = inputs;
+                  const tags = {};
+                  for (const key of Object.keys(labels)) {
+                      tags[key] = probs[labels[key]];
+                  }
+                  return NextNode.from({
+                      outputs: {
+                          labels: tags
+                      }
+                  });
+              } catch (e) {
+                  if (e instanceof ArtWorksError) {
+                      throw new FatalError(e.message);
+                  }
+                  throw e;
+              }
+          }
+      }
+    source: catalog
+    title: en=Classify image;ru=Тегировать изображение
+    version: 1
+  detect_face_on_image:
+    _id: detect_face_on_image
+    arrange:
+      x: 900
+      y: 330
+    category:
+      id: image_analysis
       title: en=Image analysis;ru=Анализ изображений
     environment:
       OPEN_PAAS_USER:
@@ -32,155 +1317,147 @@ nodes:
         title: en=Image;ru=Изображение
         type: image
         required: true
-      model:
+      index:
         order: 2
-        title: en=Model;ru=Модель
-        type: string
+        title: en=Index;ru=Индекс
+        type: integer
         required: true
-        default: isnet-general-use
-        enum:
-          - isnet-general-use|IsNet
-          - u2net|U2Net
+        default: 0
     outputs:
-      image:
-        title: en=Image;ru=Изображение
+      face:
+        title: en=Face;ru=Лицо
         type: image
+      features:
+        title: en=Features;ru=Характеристики
+        type: json
+        schema: face-features
     package: artworks
-    script: |-
-      const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL');
-      if(!PAAS_BASE_URL) {
-          error.fatal('Please, set PAAS_BASE_URL in environment');
-      }
-      const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER');
-      if(!OPEN_PAAS_USER) {
-          error.fatal('Please, set OPEN_PAAS_USER in environment');
-      }
-      const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD');
-      if(!OPEN_PAAS_PASSWORD) {
-          error.fatal('Please, set OPEN_PAAS_PASSWORD in environment');
-      }
-      const PAAS_AUTH = {
-          username: OPEN_PAAS_USER,
-          password: OPEN_PAAS_PASSWORD
-      };
+    script: |
       const CHECK_TASK_INTERVAL = 3000;
+      const MAX_ATTEMPTS = 10;
 
-      function getUrl(path) {
-          return `${PAAS_BASE_URL}/api/v3/${path}`;
-      }
+      const FIT_FACE_SIZE = 512;
 
-      async function createTask(payload) {
-          try {
-              const response = await httpClient({
-                  method: "post",
-                  url: getUrl("tasks"),
-                  headers: {
-                      "Content-type": "application/json",
-                  },
-                  auth: PAAS_AUTH,
-                  data: JSON.stringify(payload),
-              });
-              const {
-                  id
-              } = response.data;
-              return id;
-          } catch (e) {
-              const {
-                  errors
-              } = e.response?.data || {};
-              if (errors?.length > 0) {
-                  error.fatal(errors.join(", "));
-              }
-              error.fatal(e.statusText);
-          }
-      }
+      export async function fit(image, { maxWidth, maxHeight }) {
+          const { width, height } = await image.metadata();
+          const orientation = width >= height ? "-" : "|";
 
-      async function cancelTask(id) {
-          log(`Cancel task ${id}`);
-          try {
-              await httpClient({
-                  method: "post",
-                  url: getUrl(`tasks/${id}/cancel`),
-                  headers: {
-                      "Content-type": "application/json",
-                  },
-                  auth: PAAS_AUTH,
-              });
-              logger.debug(`Cancel task ${id}`);
-          } catch (e) {
-              const {
-                  errors
-              } = e.response?.data;
-              if (errors?.length > 0) {
-                  error.fatal(errors.join(", "));
-              }
-              error.fatal(e.statusText);
+          const sharp = require('sharp/lib/index.js');
+
+          switch (orientation) {
+              case "-":
+                  if (width > maxWidth) {
+                      return sharp(await image.resize({ width: maxWidth }).toBuffer());
+                  }
+                  break;
+              case "|":
+                  if (height > maxHeight) {
+                      return sharp(await image.resize({ height: maxHeight }).toBuffer());
+                  }
+                  break;
           }
+
+          return image;
       }
 
-      async function checkState(id) {
-          const {
-              data
-          } = await httpClient({
-              method: "get",
-              url: getUrl(`tasks/${id}`),
-              headers: {
-                  "Content-type": "application/json",
-              },
-              auth: PAAS_AUTH,
+      export async function crop(source, face) {
+          const sharp = require('sharp/lib/index.js');
+
+          const image = await sharp(source);
+          const metadata = await image.metadata();
+
+          const UNCROP = 0.6;
+
+          let { x, y, width, height } = face;
+
+          const uncropX = width * UNCROP;
+          const uncropY = height * UNCROP;
+
+          width = Math.round(width + uncropX);
+          height = Math.round(height + uncropY);
+          x = Math.round(x - uncropX / 2);
+          y = Math.round(y - uncropY / 2);
+
+          const [left, top] = [Math.max(x, 0), Math.max(y, 0)];
+          [width, height] = [
+              Math.min(width, metadata.width - left),
+              Math.min(height, metadata.height - top),
+          ];
+          const size = Math.min(width, height);
+
+          const crop = {
+              left,
+              top,
+              width: size,
+              height: size,
+          };
+
+          const area = await fit(await image.clone().extract(crop).webp(), {
+              maxWidth: FIT_FACE_SIZE,
+              maxHeight: FIT_FACE_SIZE,
           });
 
-          const {
-              status,
-              results
-          } = data;
-          switch (status) {
-              case "preparing":
-              case "scheduling":
-              case "scheduled":
-              case "pending":
-              case "processing":
-                  return null;
-              case "completed":
-                  const {
-                      data
-                  } = results;
-                  return data;
-              case "failed":
-                  error.fatal(results.error);
-              default:
-                  error.fatal("Wrong task status");
-          }
+          return area.toBuffer();
       }
 
-      (async () => {
+      export async function run({ inputs, state }) {
+
+          const { FatalError, TimeoutError, RepeatNode, NextNode } = DEFINITIONS;
+          const { ArtWorks, FatalError: ArtWorksError } = require('artworks');
+
+          const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL');
+          if (!PAAS_BASE_URL) {
+              throw new FatalError('Please, set PAAS_BASE_URL in environment');
+          }
+          const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER');
+          if (!OPEN_PAAS_USER) {
+              throw new FatalError('Please, set OPEN_PAAS_USER in environment');
+          }
+          const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD');
+          if (!OPEN_PAAS_PASSWORD) {
+              throw new FatalError('Please, set OPEN_PAAS_PASSWORD in environment');
+          }
 
-          const {
-              image,
-              model,
-          } = inputs;
+          const artworks = new ArtWorks({
+              baseUrl: PAAS_BASE_URL,
+              username: OPEN_PAAS_USER,
+              password: OPEN_PAAS_PASSWORD
+          });
 
           if (!state) {
+              const { image, index } = inputs;
+
               const payload = {
-                  type: "remove-image-background",
+                  type: "detect-faces",
                   isFast: true,
                   payload: {
                       base64: false,
-                      model,
                       image,
+                      features: ["age", "gender", "race", "emotion"],
                   },
               };
-              const task = await createTask(payload);
-              log(`Task created ${task}`);
-              return repeat({
-                  state: {
-                      payload,
-                      task,
-                      attempt: 0,
-                      startedAt: new Date()
-                  },
-                  delay: 5000
-              });
+              try {
+                  const task = await artworks.createTask(payload);
+                  console.log(`Task created ${task}`);
+                  return RepeatNode.from({
+                      state: {
+                          payload,
+                          task,
+                          attempt: 0,
+                          startedAt: new Date()
+                      },
+                      progress: {
+                          total: MAX_ATTEMPTS,
+                          processed: 0
+                      },
+                      delay: 2000
+                  });
+              } catch (e) {
+                  if (e instanceof ArtWorksError) {
+                      throw new FatalError(e.message);
+                  }
+                  throw e;
+              }
           } else {
               const {
                   payload,
@@ -188,53 +1465,80 @@ nodes:
                   attempt,
                   startedAt
               } = state;
-              if (attempt > 200) {
-                  await cancelTask(task);
+
+              if (attempt > MAX_ATTEMPTS) {
+                  try {
+                      await artworks.cancelTask(task);
+                  } catch (e) { }
 
                   const now = new Date();
                   const time = (now - new Date(startedAt)) / 1000;
-                  error.timeout(`PaaS task for text to image ${task} timeout in ${time} sec`);
+                  throw new TimeoutError(`PaaS task for text to image ${task} timeout in ${time} sec`);
               }
 
-              log(`Check task ${attempt} ${task}`);
-              const results = await checkState(task);
-              if (!results) {
-                  return repeat({
-                      delay: CHECK_TASK_INTERVAL,
-                      state: {
-                          payload,
-                          task,
-                          attempt: attempt + 1,
-                          startedAt,
+              console.log(`Check task ${attempt} ${task}`);
+
+              try {
+                  const results = await artworks.checkState(task);
+                  if (!results) {
+                      return RepeatNode.from({
+                          delay: CHECK_TASK_INTERVAL,
+                          state: {
+                              payload,
+                              task,
+                              attempt: attempt + 1,
+                              startedAt,
+                          },
+                          progress: {
+                              total: MAX_ATTEMPTS,
+                              processed: attempt
+                          },
+                      });
+                  }
+                  const { faces } = results;
+                  const { image, index } = inputs;
+                  const face = faces[index];
+                  if (!face) {
+                      throw new FatalError("Face with such index was not found");
+                  }
+                  const { x, y, width, height, ageFrom, ageTo, gender, race, emotion } = face;
+                  const { data } = await download(image);
+                  return NextNode.from({
+                      outputs: {
+                          face: await crop(data, {
+                              x,
+                              y,
+                              width,
+                              height,
+                          }),
+                          features: {
+                              ageFrom,
+                              ageTo,
+                              gender,
+                              race,
+                              emotion,
+                          },
                       },
                   });
-              }
-              let { image: {url: image} } = results;
-              return next({
-                  outputs: {
-                      image
+              } catch (e) {
+                  if (e instanceof ArtWorksError) {
+                      throw new FatalError(e.message);
                   }
-              });
+                  throw e;
+              }
           }
-
-      })();
+      }
     source: catalog
-    title: en=Remove background;ru=Удалить фон
+    title: en=Detect face;ru=Определить лицо
     version: 1
-  generate_image_artworks:
-    _id: generate_image_artworks
+  remove_background:
+    _id: remove_background
     arrange:
-      x: 170
-      y: 110
+      x: 750
+      y: 630
     category:
-      id: generate_images
-      title: en=Generate images;ru=Генерация изображений
-    costs: |-
-      const COST_PER_IMAGE = 0.02;
-      (() => {
-          const { batchSize } = inputs;
-          return batchSize * COST_PER_IMAGE;
-      })()
+      id: image_processing
+      title: en=Work with images;ru=Работа с изображениями
     environment:
       OPEN_PAAS_USER:
         title: PaaS user
@@ -248,607 +1552,91 @@ nodes:
         title: PaaS base url
         type: string
         scope: global
-    groups:
-      inputs:
-        SDXL:
-          order: 2
-          title: SDXL checkpoints
-          description: Only for SDXL checkpoints
-        base:
-          order: 1
-          title: en=Base parameters;ru=Базовые параметры
     inputs:
-      checkpoint:
-        order: 2
-        title: Checkpoint
-        group: base
-        type: string
-        required: true
-        default: juggernautXL_v9Rundiffusionphoto2.safetensors
-        enum:
-          - raemuXL_v40.safetensors|Raemu XL <SDXL>
-          - aamXLAnimeMix_v10.safetensors|AAM XL (Anime Mix) <SDXL> <Fantasy>
-          - dreamweaverPony25D.1erv.safetensors|DreamWeaver - Pony 2.5D Mix <SDXL>
-          - mixGEMAdam8witQegoow.NeWz.safetensors|MyMIX-G/Jem <SDXL> <Realistic>
-          - mfcgPDXL_v10.safetensors|MFCG PDXL <SDXL>
-          - aniku_0.2.fp16.safetensors|Anime Desire <SDXL> <Fantasy>
-          - flux1DevHyperNF4Flux1DevBNB_flux1DevHyperNF4.safetensors|Hyper NF4 Flux 1 <Flux>
-          - STOIQONewrealityFLUXSD_F1DPreAlpha.safetensors|New Reality Flux <Flux>
-          - juggernautXL_v9Rundiffusionphoto2.safetensors|Juggernaut XL <SDXL>
-          - animaPencilXL_v260.safetensors|Anima Pencil XL <SDXL> <Fantasy>
-          - bluePencilXL_v401.safetensors|Blue Pencil XL <SDXL> <Fantasy>
-          - pixelArtDiffusionXL_spriteShaper.safetensors|Pixel Art Diffusion XL <SDXL> <Fantasy>
-          - albedobaseXL_v20.safetensors|AlbedoBase XL <SDXL>
-          - leosamsHelloworldXL_helloworldXL50GPT4V.safetensors|Helloworld XL <SDXL>
-          - dynavisionXLAllInOneStylized_releaseV0610Bakedvae.safetensors|DynaVision XL All In One <SDXL>
-          - photon_v1.safetensors|Photon <SD 1.5>
-          - afroditexlNudePeople_20Bkdvae.safetensors|Nude People <NSFW>
-          - nosft-float8-e4m3fn.safetensors|Flux Nude People <NSFW>
-          - asdf_0.4a_lorapov_0.2_lust_0.4.fp16.safetensors|Real Porn <NSFW>
-          - Sexy_Aesthetic_SDXL_0.4x0.2.fp16.safetensors|Sexy & Beauty <NSFW>
-          - aniku_0.2.fp16.safetensors|Anime Desire <NSFW>
-          - anikurender_0.4b.fp16.safetensors|Hardcore Fantasy <NSFW>
-      prompt:
+      image:
         order: 1
-        title: Prompt
-        group: base
-        type: string
-        required: true
-        multiline: true
-        default: cat walking on the moon
-      imageSize:
-        order: 4
-        title: Size
-        group: base
-        type: string
+        title: en=Image;ru=Изображение
+        type: image
         required: true
-        default: 1024x1024
-        enum:
-          - 512x512|512x512 <SD 1.5>
-          - 512x768|512x768 <SD 1.5>
-          - 512x912|512x912 <SD 1.5>
-          - 576x768|576x768 <SD 1.5>
-          - 704x1344|704x1344 <SD 1.5>
-          - 704x1408|704x1408 <SD 1.5>
-          - 768x512|768x512 <SD 1.5>
-          - 768x576|768x576 <SD 1.5>
-          - 768x768|768x768 <SD 1.5>
-          - 768x1280|768x1280 <SD 1.5>
-          - 768x1344|768x1344 <SD 1.5>
-          - 832x1152|832x1152 <SD 1.5>
-          - 832x1216|832x1216 <SD 1.5>
-          - 896x1088|896x1088 <SD 1.5>
-          - 896x1152|896x1152 <SD 1.5>
-          - 912x512|912x512 <SD 1.5>
-          - 960x1024|960x1024 <SDXL> <Flux> <SD 1.5>
-          - 960x1088|960x1088 <SDXL> <Flux> <SD 1.5>
-          - 1024x1024|1024x1024 <SDXL> <Flux> <SD 1.5>
-          - 1024x960|1024x960 <SDXL> <Flux> <SD 1.5>
-          - 1088x896|1088x896 <SDXL> <Flux> <SD 1.5>
-          - 1088x960|1088x960 <SDXL> <Flux> <SD 1.5>
-          - 1152x832|1152x832 <SDXL> <Flux> <SD 1.5>
-          - 1152x896|1152x896 <SDXL> <Flux> <SD 1.5>
-          - 1216x832|1216x832 <SDXL> <Flux>
-          - 1280x768|1280x768 <SDXL> <Flux>
-          - 1344x704|1344x704 <SDXL> <Flux>
-          - 1344x768|1344x768 <SDXL> <Flux>
-          - 1408x704|1408x704 <SDXL> <Flux>
-          - 1472x704|1472x704 <SDXL> <Flux>
-          - 1536x640|1536x640 <SDXL> <Flux>
-          - 1600x640|1600x640 <SDXL> <Flux>
-          - 1664x576|1664x576 <SDXL> <Flux>
-          - 1728x576|1728x576 <SDXL> <Flux>
-      batchSize:
-        order: 7
-        title: Batch size
-        group: base
-        type: integer
-        min: 1
-        max: 4
-        step: 1
-        default: 1
-      negativePrompt:
-        order: 3
-        title: Negative prompt
-        group: base
+      model:
+        order: 2
+        title: en=Model;ru=Модель
         type: string
-        multiline: true
-      cfgScale:
-        order: 5
-        title: CFG scale
-        group: base
-        type: float
         required: true
-        min: 1
-        max: 20
-        step: 1
-        default: 7
-      performance:
-        order: 6
-        title: Performance
-        group: base
-        type: string
-        default: speed
-        enum:
-          - express|⚡ Express
-          - speed|🚅 Speed
-          - quality|💎 Quality
-      styles:
-        order: 2
-        title: Styles
-        group: SDXL
-        type: string[]
+        default: isnet-general-use
         enum:
-          - Abstract Expressionism
-          - Academia
-          - Action Figure
-          - Adorable 3D Character
-          - Adorable Kawaii
-          - Ads Advertising
-          - Ads Automotive
-          - Ads Corporate
-          - Ads Fashion Editorial
-          - Ads Food Photography
-          - Ads Gourmet Food Photography
-          - Ads Luxury
-          - Ads Real Estate
-          - Ads Retail
-          - Art Deco
-          - Art Nouveau
-          - Artstyle Abstract
-          - Artstyle Abstract Expressionism
-          - Artstyle Art Deco
-          - Artstyle Art Nouveau
-          - Artstyle Constructivist
-          - Artstyle Cubist
-          - Artstyle Expressionist
-          - Artstyle Graffiti
-          - Artstyle Hyperrealism
-          - Artstyle Impressionist
-          - Artstyle Pointillism
-          - Artstyle Pop Art
-          - Artstyle Psychedelic
-          - Artstyle Renaissance
-          - Artstyle Steampunk
-          - Artstyle Surrealist
-          - Artstyle Typography
-          - Artstyle Watercolor
-          - Astral Aura
-          - Avant Garde
-          - Baroque
-          - Bauhaus Style Poster
-          - Blueprint Schematic Drawing
-          - Caricature
-          - Cel Shaded Art
-          - Character Design Sheet
-          - Cinematic Diva
-          - Classicism Art
-          - Color Field Painting
-          - Colored Pencil Art
-          - Conceptual Art
-          - Constructivism
-          - Cubism
-          - Dadaism
-          - Dark Fantasy
-          - Dark Moody Atmosphere
-          - Dmt Art Style
-          - Doodle Art
-          - Double Exposure
-          - Dripping Paint Splatter Art
-          - Expressionism
-          - Faded Polaroid Photo
-          - Fauvism
-          - Flat 2d Art
-          - Fooocus Cinematic
-          - Fooocus Enhance
-          - Fooocus Masterpiece
-          - Fooocus Negative
-          - Fooocus Photograph
-          - Fooocus Semi Realistic
-          - Fooocus Sharp
-          - Fooocus V2
-          - Fortnite Art Style
-          - Futurism
-          - Futuristic Biomechanical
-          - Futuristic Biomechanical Cyberpunk
-          - Futuristic Cybernetic
-          - Futuristic Cybernetic Robot
-          - Futuristic Cyberpunk Cityscape
-          - Futuristic Futuristic
-          - Futuristic Retro Cyberpunk
-          - Futuristic Retro Futurism
-          - Futuristic Sci Fi
-          - Futuristic Vaporwave
-          - Game Bubble Bobble
-          - Game Cyberpunk Game
-          - Game Fighting Game
-          - Game Gta
-          - Game Mario
-          - Game Minecraft
-          - Game Pokemon
-          - Game Retro Arcade
-          - Game Retro Game
-          - Game Rpg Fantasy Game
-          - Game Strategy Game
-          - Game Streetfighter
-          - Game Zelda
-          - Glitchcore
-          - Glo Fi
-          - Googie Art Style
-          - Graffiti Art
-          - Harlem Renaissance Art
-          - High Fashion
-          - Idyllic
-          - Impressionism
-          - Infographic Drawing
-          - Ink Dripping Drawing
-          - Japanese Ink Drawing
-          - Knolling Photography
-          - Light Cheery Atmosphere
-          - Logo Design
-          - Luxurious Elegance
-          - MRE Ancient Illustration
-          - MRE Anime
-          - MRE Artistic Vision
-          - MRE Bad Dream
-          - MRE Brave Art
-          - MRE Cinematic Dynamic
-          - MRE Comic
-          - MRE Dark Cyberpunk
-          - MRE Dark Dream
-          - MRE Dynamic Illustration
-          - MRE Elemental Art
-          - MRE Gloomy Art
-          - MRE Heroic Fantasy
-          - MRE Lyrical Geometry
-          - MRE Manga
-          - MRE Space Art
-          - MRE Spontaneous Picture
-          - MRE Sumi E Detailed
-          - MRE Sumi E Symbolic
-          - MRE Surreal Painting
-          - MRE Undead Art
-          - MRE Underground
-          - Macro Photography
-          - Mandola Art
-          - Marker Drawing
-          - Medievalism
-          - Minimalism
-          - Misc Architectural
-          - Misc Disco
-          - Misc Dreamscape
-          - Misc Dystopian
-          - Misc Fairy Tale
-          - Misc Gothic
-          - Misc Grunge
-          - Misc Horror
-          - Misc Kawaii
-          - Misc Lovecraftian
-          - Misc Macabre
-          - Misc Manga
-          - Misc Metropolis
-          - Misc Minimalist
-          - Misc Monochrome
-          - Misc Nautical
-          - Misc Space
-          - Misc Stained Glass
-          - Misc Techwear Fashion
-          - Misc Tribal
-          - Misc Zentangle
-          - Mk Adnate Style
-          - Mk Afrofuturism
-          - Mk Albumen Print
-          - Mk Alcohol Ink Art
-          - Mk Andy Warhol
-          - Mk Anthotype Print
-          - Mk Aquatint Print
-          - Mk Atompunk
-          - Mk Basquiat
-          - Mk Bauhaus Style
-          - Mk Blacklight Paint
-          - Mk Bromoil Print
-          - Mk Calotype Print
-          - Mk Carnival Glass
-          - Mk Chicano Art
-          - Mk Chromolithography
-          - Mk Cibulak Porcelain
-          - Mk Color Sketchnote
-          - Mk Coloring Book
-          - Mk Constructivism
-          - Mk Cross Processing Print
-          - Mk Cross Stitching
-          - Mk Cyanotype Print
-          - Mk Dayak Art
-          - Mk De Stijl
-          - Mk Dufaycolor Photograph
-          - Mk Embroidery
-          - Mk Encaustic Paint
-          - Mk Fayum Portrait
-          - Mk Gond Painting
-          - Mk Gyotaku
-          - Mk Halftone Print
-          - Mk Herbarium
-          - Mk Illuminated Manuscript
-          - Mk Inuit Carving
-          - Mk Kalighat Painting
-          - Mk Lite Brite Art
-          - Mk Luminogram
-          - Mk Madhubani Painting
-          - Mk Mokume Gane
-          - Mk Mosaic
-          - Mk One Line Art
-          - Mk Palekh
-          - Mk Patachitra Painting
-          - Mk Pichwai Painting
-          - Mk Pictorialism
-          - Mk Pollock
-          - Mk Punk Collage
-          - Mk Ron English Style
-          - Mk Samoan Art Inspired
-          - Mk Scrimshaw
-          - Mk Shepard Fairey Style
-          - Mk Shibori
-          - Mk Singer Sargent
-          - Mk Suminagashi
-          - Mk Tlingit Art
-          - Mk Ukiyo E
-          - Mk Van Gogh
-          - Mk Vintage Airline Poster
-          - Mk Vintage Travel Poster
-          - Mk Vitreous Enamel
-          - Neo Baroque
-          - Neo Byzantine
-          - Neo Futurism
-          - Neo Impressionism
-          - Neo Rococo
-          - Neoclassicism
-          - Op Art
-          - Ornate And Intricate
-          - Papercraft Collage
-          - Papercraft Flat Papercut
-          - Papercraft Kirigami
-          - Papercraft Paper Mache
-          - Papercraft Paper Quilling
-          - Papercraft Papercut Collage
-          - Papercraft Papercut Shadow Box
-          - Papercraft Stacked Papercut
-          - Papercraft Thick Layered Papercut
-          - Pebble Art
-          - Pencil Sketch Drawing
-          - Photo Alien
-          - Photo Film Noir
-          - Photo Glamour
-          - Photo Hdr
-          - Photo Iphone Photographic
-          - Photo Long Exposure
-          - Photo Neon Noir
-          - Photo Silhouette
-          - Photo Tilt Shift
-          - Pop Art 2
-          - Random Style
-          - Rococo
-          - SAI 3D Model
-          - SAI Analog Film
-          - SAI Anime
-          - SAI Cinematic
-          - SAI Comic Book
-          - SAI Craft Clay
-          - SAI Digital Art
-          - SAI Enhance
-          - SAI Fantasy Art
-          - SAI Isometric
-          - SAI Line Art
-          - SAI Lowpoly
-          - SAI Neonpunk
-          - SAI Origami
-          - SAI Photographic
-          - SAI Pixel Art
-          - SAI Texture
-          - Silhouette Art
-          - Simple Vector Art
-          - Sketchup
-          - Steampunk 2
-          - Sticker Designs
-          - Suprematism
-          - Surrealism
-          - Terragen
-          - Tranquil Relaxing Atmosphere
-          - Vibrant Rim Light
-          - Volumetric Lighting
-          - Watercolor 2
-          - Whimsical And Playful
-      sharpness:
-        order: 1
-        title: Sharpness
-        group: SDXL
-        type: integer
-        min: 0
-        max: 30
-        step: 1
-        default: 2
-      seed:
-        order: 8
-        title: Seed
-        group: base
-        type: integer
-        placeholder: no seed
+          - isnet-general-use|IsNet
+          - u2net|U2Net
     outputs:
       image:
-        title: Image
+        title: en=Image;ru=Изображение
         type: image
-      images:
-        title: Images
-        type: image[]
     package: artworks
     script: |-
-      const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL');
-      if(!PAAS_BASE_URL) {
-          error.fatal('Please, set PAAS_BASE_URL in environment');
-      }
-      const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER');
-      if(!OPEN_PAAS_USER) {
-          error.fatal('Please, set OPEN_PAAS_USER in environment');
-      }
-      const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD');
-      if(!OPEN_PAAS_PASSWORD) {
-          error.fatal('Please, set OPEN_PAAS_PASSWORD in environment');
-      }
-      const PAAS_AUTH = {
-          username: OPEN_PAAS_USER,
-          password: OPEN_PAAS_PASSWORD
-      };
       const CHECK_TASK_INTERVAL = 3000;
+      const MAX_ATTEMPTS = 20;
 
-      function getUrl(path) {
-          return `${PAAS_BASE_URL}/api/v3/${path}`;
-      }
+      export async function run({ inputs, state }) {
 
-      async function createTask(payload) {
+          const { FatalError, TimeoutError, RepeatNode, NextNode } = DEFINITIONS;
+          const { ArtWorks, FatalError: ArtWorksError } = require('artworks');
 
-          try {
-              const response = await httpClient({
-                  method: "post",
-                  url: getUrl("tasks"),
-                  headers: {
-                      "Content-type": "application/json",
-                  },
-                  auth: PAAS_AUTH,
-                  data: JSON.stringify(payload),
-              });
-              const {
-                  id
-              } = response.data;
-              return id;
-          } catch (e) {
-              const {
-                  errors
-              } = e.response?.data;
-              if (errors?.length > 0) {
-                  error.data(errors.join(", "));
-              }
-              error.fatal(e.statusText);
+          const PAAS_BASE_URL = env.variables.get('PAAS_BASE_URL');
+          if (!PAAS_BASE_URL) {
+              throw new FatalError('Please, set PAAS_BASE_URL in environment');
           }
-      }
-
-      async function cancelTask(id) {
-          log(`Cancel task ${id}`);
-          try {
-              await httpClient({
-                  method: "post",
-                  url: getUrl(`tasks/${id}/cancel`),
-                  headers: {
-                      "Content-type": "application/json",
-                  },
-                  auth: PAAS_AUTH,
-              });
-          } catch (e) {
-              const {
-                  errors
-              } = e.response?.data;
-              if (errors?.length > 0) {
-                  logger.error(errors.join(", "));
-                  error.data(errors.join(", "));
-              }
-              error.fatal(e.statusText);
+          const OPEN_PAAS_USER = env.variables.get('OPEN_PAAS_USER');
+          if (!OPEN_PAAS_USER) {
+              throw new FatalError('Please, set OPEN_PAAS_USER in environment');
           }
-      }
-
-      async function checkState(id) {
-          const {
-              data
-          } = await httpClient({
-              method: "get",
-              url: getUrl(`tasks/${id}`),
-              headers: {
-                  "Content-type": "application/json",
-              },
-              auth: PAAS_AUTH,
-          });
-
-          const {
-              status,
-              results
-          } = data;
-          switch (status) {
-              case "preparing":
-              case "scheduling":
-              case "scheduled":
-              case "pending":
-              case "processing":
-                  return null;
-              case "completed":
-                  const {
-                      data
-                  } = results;
-                  return data;
-              case "failed":
-                  const {
-                      error
-                  } = results;
-                  error.fatal(error);
-              default:
-                  error.fatal("Wrong task status");
+          const OPEN_PAAS_PASSWORD = env.variables.get('OPEN_PAAS_PASSWORD');
+          if (!OPEN_PAAS_PASSWORD) {
+              throw new FatalError('Please, set OPEN_PAAS_PASSWORD in environment');
           }
-      }
 
-      (async () => {
-
-          const {
-              prompt,
-              negativePrompt,
-              checkpoint,
-              cfgScale,
-              imageSize: size,
-              performance,
-              sharpness,
-              seed,
-              batchSize,
-              // SDXL
-              styles,
-          } = inputs;
+          const artworks = new ArtWorks({
+              baseUrl: PAAS_BASE_URL,
+              username: OPEN_PAAS_USER,
+              password: OPEN_PAAS_PASSWORD
+          });
 
           if (!state) {
+              const {
+                  image,
+                  model,
+              } = inputs;
+
               const payload = {
-                  type: "text-to-image",
+                  type: "remove-image-background",
                   isFast: true,
                   payload: {
                       base64: false,
-                      prompt,
-                      ...(!!negativePrompt ? {
-                          negativePrompt
-                      } : {}),
-                      checkpoint,
-                      cfgScale,
-                      size,
-                      ...(performance !== "speed" ? {
-                          performance
-                      } : {}),
-                      ...(seed > 0 ? {
-                          seed
-                      } : {}),
-                      ...(batchSize > 1 ? {
-                          batchSize
-                      } : {}),
-                      // SDXL
-                      ...(styles?.length > 0 ? {
-                          styles
-                      } : {}),
-                      ...(sharpness > 2 ? {
-                          sharpness
-                      } : {}),
+                      model,
+                      image,
                   },
               };
-              const task = await createTask(payload);
-              log(`Task created ${task}`);
-              return repeat({
-                  state: {
-                      payload,
-                      task,
-                      attempt: 0,
-                      startedAt: new Date()
-                  },
-                  delay: 5000
-              });
+              try {
+                  const task = await artworks.createTask(payload);
+                  console.log(`Task created ${task}`);
+                  return RepeatNode.from({
+                      state: {
+                          payload,
+                          task,
+                          attempt: 0,
+                          startedAt: new Date()
+                      },
+                      progress: {
+                          total: MAX_ATTEMPTS,
+                          processed: 0
+                      },
+                      delay: 5000
+                  });
+              } catch (e) {
+                  if (e instanceof ArtWorksError) {
+                      throw new FatalError(e.message);
+                  }
+                  throw e;
+              }
           } else {
               const {
                   payload,
@@ -856,38 +1644,50 @@ nodes:
                   attempt,
                   startedAt
               } = state;
-              if (attempt > 200) {
-                  await cancelTask(task);
+              
+              if (attempt > MAX_ATTEMPTS) {
+                  try {
+                      await artworks.cancelTask(task);
+                  } catch (e) { }
 
                   const now = new Date();
                   const time = (now - new Date(startedAt)) / 1000;
-                  error.timeout(`PaaS task for text to image ${task} timeout in ${time} sec`);
+                  throw new TimeoutError(`PaaS task for text to image ${task} timeout in ${time} sec`);
               }
 
-              log(`Check task ${attempt} ${task}`);
-              const results = await checkState(task);
-              if (!results) {
-                  return repeat({
-                      delay: CHECK_TASK_INTERVAL,
-                      state: {
-                          payload,
-                          task,
-                          attempt: attempt + 1,
-                          startedAt,
-                      },
+              console.log(`Check task ${attempt} ${task}`);
+
+              try {
+                  const results = await artworks.checkState(task);
+                  if (!results) {
+                      return RepeatNode.from({
+                          delay: CHECK_TASK_INTERVAL,
+                          state: {
+                              payload,
+                              task,
+                              attempt: attempt + 1,
+                              startedAt,
+                          },
+                          progress: {
+                              total: MAX_ATTEMPTS,
+                              processed: attempt
+                          },
+                      });
+                  }
+                  let { image: { url: image } } = results;
+                  return NextNode.from({
+                      outputs: {
+                          image
+                      }
                   });
-              }
-              let images = results.images.map((i) => i.url);
-              const [image] = images;
-              return next({
-                  outputs: {
-                      images,
-                      image: image
+              } catch (e) {
+                  if (e instanceof ArtWorksError) {
+                      throw new FatalError(e.message);
                   }
-              });
+                  throw e;
+              }
           }
-
-      })();
+      }
     source: catalog
-    title: en=Generate image;ru=Генерация изображения
+    title: en=Remove background;ru=Удалить фон
     version: 1